refactor: split checks for import matching node name in different methods

Author: Belco90

lib/detect-testing-library-utils.ts

@@ -8,6 +8,7 @@ import {
   getImportModuleName,
   getPropertyIdentifierNode,
   getReferenceNode,
+  hasImportMatch,
   ImportModuleNode,
   isImportDeclaration,
   isImportNamespaceSpecifier,
@@ -127,6 +128,12 @@ export function detectTestingLibraryUtils<
     /**
      * Small method to extract common checks to determine whether a node is
      * related to Testing Library or not.
+     *
+     * To determine whether a node is a valid Testing Library util, there are
+     * two conditions to match:
+     * - it's named in a particular way (decided by given callback)
+     * - it's imported from valid Testing Library module (depends on aggressive
+     *    reporting)
      */
     function isTestingLibraryUtil(
       node: TSESTree.Identifier,
@@ -136,28 +143,14 @@ export function detectTestingLibraryUtils<
         return false;
       }
 
-      const referenceNode = getReferenceNode(node);
-      const referenceNodeIdentifier = getPropertyIdentifierNode(referenceNode);
-
       if (isAggressiveModuleReportingEnabled()) {
         return true;
       }
 
-      // TODO: extract this into function, combined with logic from isFireEventMethod
-      // TODO: include some tests create-testing-library-rule
-      const importNode = findImportedUtilSpecifier(
-        referenceNodeIdentifier.name
-      );
-
-      if (!importNode) {
-        return false;
-      }
-
-      if (ASTUtils.isIdentifier(importNode)) {
-        return importNode.name === referenceNodeIdentifier.name;
-      }
+      const referenceNode = getReferenceNode(node);
+      const referenceNodeIdentifier = getPropertyIdentifierNode(referenceNode);
 
-      return importNode.local.name === referenceNodeIdentifier.name;
+      return isNodeComingFromTestingLibrary(referenceNodeIdentifier);
     }
 
     /**
@@ -454,17 +447,26 @@ export function detectTestingLibraryUtils<
     const canReportErrors: CanReportErrorsFn = () => {
       return isTestingLibraryImported() && isValidFilename();
     };
+
     /**
-     * Takes a MemberExpression or an Identifier and verifies if its name comes from the import in TL
-     * @param node a MemberExpression (in "foo.property" it would be property) or an Identifier
+     * Determines whether a node is imported from a valid Testing Library module
+     *
+     * This method will try to find any import matching the given node name,
+     * and also make sure the name is a valid match in case it's been renamed.
      */
     const isNodeComingFromTestingLibrary: IsNodeComingFromTestingLibraryFn = (
       node
     ) => {
       const identifierName: string | undefined = getPropertyIdentifierNode(node)
         .name;
 
-      return !!findImportedUtilSpecifier(identifierName);
+      const importNode = findImportedUtilSpecifier(identifierName);
+
+      if (!importNode) {
+        return false;
+      }
+
+      return hasImportMatch(importNode, identifierName);
     };
 
     const helpers: DetectionHelpers = {

lib/node-utils.ts

@@ -620,3 +620,14 @@ export function getInnermostReturningFunction(
 
   return functionScope.block;
 }
+
+export function hasImportMatch(
+  importNode: TSESTree.ImportClause | TSESTree.Identifier,
+  identifierName: string
+): boolean {
+  if (ASTUtils.isIdentifier(importNode)) {
+    return importNode.name === identifierName;
+  }
+
+  return importNode.local.name === identifierName;
+}

tests/create-testing-library-rule.test.ts

@@ -126,6 +126,19 @@ ruleTester.run(RULE_NAME, rule, {
       const utils = render()
       `,
     },
+    {
+      settings: {
+        'testing-library/utils-module': 'test-utils',
+      },
+      code: `
+      // case (render util): aggressive reporting disabled - method with same name
+      // as TL method but not coming from TL module is valid
+      import { render as testingLibraryRender } from 'test-utils'
+      import { render } from 'somewhere-else'
+
+      const utils = render()
+      `,
+    },
 
     // Test Cases for presence/absence assertions
     // cases: asserts not related to presence/absence
@@ -287,6 +300,21 @@ ruleTester.run(RULE_NAME, rule, {
       waitFor()
       `,
     },
+    {
+      settings: {
+        'testing-library/utils-module': 'test-utils',
+      },
+      code: `
+      // case (async util): aggressive reporting disabled - method with same name
+      // as TL method but not coming from TL module is valid
+      import { waitFor as testingLibraryWaitFor } from 'test-utils'
+      import { waitFor } from 'somewhere-else'
+
+        test('this should not be reported', () => {
+        waitFor()
+      });
+      `,
+    },
 
     // Test Cases for all settings mixed
     {

tests/lib/rules/prefer-wait-for.test.ts

@@ -218,6 +218,21 @@ ruleTester.run(RULE_NAME, rule, {
       cy.wait();
       `,
     },
+    {
+      settings: {
+        'testing-library/utils-module': 'test-utils',
+      },
+      code: `
+      // case: aggressive reporting disabled - method named same as invalid method
+      // but not coming from Testing Library is valid
+      import { wait as testingLibraryWait } from 'test-utils'
+      import { wait } from 'somewhere-else'
+      
+      async () => {
+        await wait();
+      }
+      `,
+    },
     {
       // https://github.com/testing-library/eslint-plugin-testing-library/issues/145
       code: `import * as foo from 'imNoTestingLibrary';