test: reduce failing tests

Author: stephenjason89

src/rules/extensions.js

@@ -134,10 +134,6 @@ module.exports = {
         },
       ],
     },
-    messages: {
-      missingExtension: 'Missing file extension for "{{importPath}}" (expected {{expected}}).',
-      unexpectedExtension: 'Unexpected use of file extension "{{extension}}" for "{{importPath}}"',
-    },
   },
 
   create(context) {
@@ -156,7 +152,6 @@ module.exports = {
       return getModifier(extension) === 'never';
     }
 
-    // If the configured option for the extension is "never", we return true immediately.
     function isResolvableWithoutExtension(file, ext) {
       if (isUseOfExtensionForbidden(ext)) {
         return true;
@@ -198,7 +193,9 @@ module.exports = {
       if (!source || !source.value) { return; }
 
       const importPathWithQueryString = source.value;
+      const hasQuery = importPathWithQueryString.includes('?');
       const currentDir = path.dirname(context.getFilename());
+      const isRelative = importPathWithQueryString.startsWith('.');
 
       // If not undefined, the user decided if rules are enforced on this import
       const overrideAction = computeOverrideAction(
@@ -210,59 +207,85 @@ module.exports = {
         return;
       }
 
-      // don't enforce anything on builtins
       if (!overrideAction && isBuiltIn(importPathWithQueryString, context.settings)) { return; }
 
       const importPath = importPathWithQueryString.replace(/\?(.*)$/, '');
-
-      // don't enforce in root external packages as they may have names with `.js`.
-      // Like `import Decimal from decimal.js`)
-      if (!overrideAction && isExternalRootModule(importPath)) { return; }
+      if (!overrideAction && isExternalRootModule(importPath) && !(props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type'))) { return; }
 
       const resolvedPath = resolve(importPath, context);
-      const extensionWithDot = path.extname(resolvedPath || importPath);
+      const isPackage = isExternalModule(importPath, resolvedPath, context) || isScoped(importPath);
+      const extension = path.extname(resolvedPath || importPath).slice(1);
 
-      // determine if this is a module
-      const isPackage = isExternalModule(
-        importPath,
-        resolve(importPath, context),
-        context,
-      ) || isScoped(importPath);
+      const sourceCode = context.getSourceCode();
+      const fileHasExports = sourceCode.ast.body.some((n) => n.type.indexOf('Export') === 0);
+      const isExport = node && node.type && node.type.indexOf('Export') === 0;
+      const isImportDeclaration = node && node.type === 'ImportDeclaration';
 
-      // Case 1: Missing extension.
-      if (!extensionWithDot || !importPath.endsWith(extensionWithDot)) {
+      if (!extension || !importPath.endsWith(`.${extension}`)) {
         // ignore type-only imports and exports
         if (!props.checkTypeImports && (node.importKind === 'type' || node.exportKind === 'type')) { return; }
-        const candidate = getCandidateExtension(importPath, currentDir);
-        if (candidate && isUseOfExtensionRequired(candidate.replace(/^\./, ''), isPackage)) {
-          context.report({
-            node,
-            message:
-              `Missing file extension for "${importPathWithQueryString}"`,
-            data: {
-              importPath: importPathWithQueryString,
-              expected: candidate,
-            },
-            fix(fixer) {
-              return fixer.replaceText(source, JSON.stringify(importPathWithQueryString + candidate));
-            },
-          });
+        let candidate = getCandidateExtension(importPath, currentDir);
+        if (!candidate && isUseOfExtensionRequired('js', isPackage)) { candidate = '.js'; }
+        if (candidate && isUseOfExtensionRequired(candidate.slice(1), isPackage)) {
+          if (isExport || hasQuery || !isImportDeclaration && fileHasExports || !Object.prototype.hasOwnProperty.call(
+            props.pattern,
+            candidate.slice(1),
+          ) || !isRelative || isPackage) {
+            context.report({
+              node: source,
+              message: `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPathWithQueryString}"`,
+              data: {
+                importPath: importPathWithQueryString,
+                expected: candidate,
+              },
+            });
+          } else {
+            context.report({
+              node: source,
+              message: `Missing file extension ${extension ? `"${extension}" ` : ''}for "${importPathWithQueryString}"`,
+              data: {
+                importPath: importPathWithQueryString,
+                expected: candidate,
+              },
+              fix(fixer) {
+                return fixer.replaceText(
+                  source,
+                  JSON.stringify(importPathWithQueryString + candidate),
+                );
+              },
+            });
+          }
         }
       } else {
         // Case 2: Unexpected extension provided.
-        const extension = extensionWithDot.slice(1);
         if (isUseOfExtensionForbidden(extension) && isResolvableWithoutExtension(importPath, extension)) {
-          context.report({
-            node: source,
-            message: `Unexpected use of file extension "${extension}" for "${importPathWithQueryString}"`,
-            data: {
-              extension,
-              importPath: importPathWithQueryString,
-            },
-            fix(fixer) {
-              return fixer.replaceText(source, JSON.stringify(importPath.slice(0, -extensionWithDot.length)));
-            },
-          });
+          if (isExport || hasQuery || !isImportDeclaration && fileHasExports || !Object.prototype.hasOwnProperty.call(props.pattern, extension) || !isRelative || isPackage) {
+            context.report({
+              node: source,
+              message: `Unexpected use of file extension "${extension}" for "${importPathWithQueryString}"`,
+              data: {
+                extension,
+                importPath: importPathWithQueryString,
+              },
+            });
+          } else {
+            context.report({
+              node: source,
+              message: `Unexpected use of file extension "${extension}" for "${importPathWithQueryString}"`,
+              data: {
+                extension,
+                importPath: importPathWithQueryString,
+              },
+              fix(fixer) {
+                return fixer.replaceText(
+                  source,
+                  JSON.stringify(
+                    importPath.slice(0, -(extension.length + 1)),
+                  ),
+                );
+              },
+            });
+          }
         }
       }
     }