feat(no-unnecessary-act): detect edge and mixed cases

Author: Belco90

lib/create-testing-library-rule/detect-testing-library-utils.ts

@@ -689,14 +689,10 @@ export function detectTestingLibraryUtils<
           return false;
         }
 
-        const originalNodeName =
-          isImportSpecifier(importedUtilSpecifier) &&
-          importedUtilSpecifier.local.name !==
-            importedUtilSpecifier.imported.name
-            ? importedUtilSpecifier.imported.name
-            : undefined;
-
-        return [node.name, originalNodeName].filter(Boolean).includes('act');
+        return hasImportMatch(
+          importedUtilSpecifier,
+          referenceNodeIdentifier.name
+        );
       })();
 
       return isTestingLibraryAct || isReactDomTestUtilsAct;
@@ -832,6 +828,12 @@ export function detectTestingLibraryUtils<
         return false;
       }
 
+      const referenceNode = getReferenceNode(node);
+      const referenceNodeIdentifier = getPropertyIdentifierNode(referenceNode);
+      if (!referenceNodeIdentifier) {
+        return false;
+      }
+
       const importDeclaration = (() => {
         if (isImportDeclaration(importNode.parent)) {
           return importNode.parent;

lib/rules/no-unnecessary-act.ts

@@ -2,7 +2,6 @@ import { TSESTree } from '@typescript-eslint/experimental-utils';
 import { createTestingLibraryRule } from '../create-testing-library-rule';
 import {
   getDeepestIdentifierNode,
-  getPropertyIdentifierNode,
   getStatementCallExpression,
   isEmptyFunction,
 } from '../node-utils';
@@ -75,26 +74,23 @@ export default createTestingLibraryRule<[], MessageIds>({
         return;
       }
 
-      const callExpressionIdentifier = getPropertyIdentifierNode(
-        callExpressionNode
-      );
-
-      if (!callExpressionIdentifier) {
+      const identifierNode = getDeepestIdentifierNode(callExpressionNode);
+      if (!identifierNode) {
         return;
       }
 
-      if (!helpers.isActUtil(callExpressionIdentifier)) {
+      if (!helpers.isActUtil(identifierNode)) {
         return;
       }
 
       if (isEmptyFunction(functionNode)) {
         context.report({
-          node: callExpressionIdentifier,
+          node: identifierNode,
           messageId: 'noUnnecessaryActEmptyFunction',
         });
       } else if (!hasSomeNonTestingLibraryCall(blockStatementNode.body)) {
         context.report({
-          node: callExpressionIdentifier,
+          node: identifierNode,
           messageId: 'noUnnecessaryActTestingLibraryUtil',
         });
       }
@@ -117,15 +113,12 @@ export default createTestingLibraryRule<[], MessageIds>({
         return;
       }
 
-      const parentCallExpressionIdentifier = getPropertyIdentifierNode(
-        parentCallExpression
-      );
-
-      if (!parentCallExpressionIdentifier) {
+      const identifierNode = getDeepestIdentifierNode(parentCallExpression);
+      if (!identifierNode) {
         return;
       }
 
-      if (!helpers.isActUtil(parentCallExpressionIdentifier)) {
+      if (!helpers.isActUtil(identifierNode)) {
         return;
       }
 
@@ -134,7 +127,7 @@ export default createTestingLibraryRule<[], MessageIds>({
       }
 
       context.report({
-        node: parentCallExpressionIdentifier,
+        node: identifierNode,
         messageId: 'noUnnecessaryActTestingLibraryUtil',
       });
     }

tests/lib/rules/no-unnecessary-act.test.ts

@@ -735,6 +735,48 @@ ruleTester.run(RULE_NAME, rule, {
       ],
     },
 
-    // TODO case: mixed scenarios - AGR disabled
+    {
+      settings: {
+        'testing-library/utils-module': 'custom-testing-module',
+        'testing-library/custom-renders': 'off',
+      },
+      code: `// case: mixed scenarios - AGR disabled
+      import * as ReactTestUtils from 'react-dom/test-utils';
+      import { act as renamedAct, fireEvent, screen as renamedScreen, render, waitFor } from 'custom-testing-module'
+      import userEvent from '@testing-library/user-event'
+      import { act, waitForElementToBeRemoved } from 'somewhere-else'
+
+      test('invalid case', async () => {
+        ReactTestUtils.act(() => {})
+        await ReactTestUtils.act(() => render())
+        await renamedAct(async () => waitFor())
+        renamedAct(function() { renamedScreen.findByRole('button') })
+
+        // these are valid
+        await renamedAct(() => waitForElementToBeRemoved(element))
+        act(() => {})
+        await act(async () => { userEvent.click(element) })
+        act(function() { return renamedScreen.getByText('foo') })
+      });
+      `,
+      errors: [
+        { messageId: 'noUnnecessaryActEmptyFunction', line: 8, column: 24 },
+        {
+          messageId: 'noUnnecessaryActTestingLibraryUtil',
+          line: 9,
+          column: 30,
+        },
+        {
+          messageId: 'noUnnecessaryActTestingLibraryUtil',
+          line: 10,
+          column: 15,
+        },
+        {
+          messageId: 'noUnnecessaryActTestingLibraryUtil',
+          line: 11,
+          column: 9,
+        },
+      ],
+    },
   ],
 });