feat(no-unnecessary-act): first approach for the rule

Author: Belco90

docs/rules/no-unnecessary-act.md

@@ -96,6 +96,7 @@ export interface DetectionHelpers {
   getTestingLibraryImportName: GetTestingLibraryImportNameFn;
   getCustomModuleImportName: GetCustomModuleImportNameFn;
   isTestingLibraryImported: IsTestingLibraryImportedFn;
+  isTestingLibraryUtil: (node: TSESTree.Identifier) => boolean;
   isGetQueryVariant: IsGetQueryVariantFn;
   isQueryQueryVariant: IsQueryQueryVariantFn;
   isFindQueryVariant: IsFindQueryVariantFn;
@@ -112,6 +113,7 @@ export interface DetectionHelpers {
   isRenderUtil: IsRenderUtilFn;
   isRenderVariableDeclarator: IsRenderVariableDeclaratorFn;
   isDebugUtil: IsDebugUtilFn;
+  isActUtil: (node: TSESTree.Identifier) => boolean;
   isPresenceAssert: IsPresenceAssertFn;
   isAbsenceAssert: IsAbsenceAssertFn;
   canReportErrors: CanReportErrorsFn;
@@ -618,6 +620,30 @@ export function detectTestingLibraryUtils<
       );
     };
 
+    const isActUtil = (node: TSESTree.Identifier): boolean => {
+      return isPotentialTestingLibraryFunction(
+        node,
+        (identifierNodeName, originalNodeName) => {
+          return [identifierNodeName, originalNodeName]
+            .filter(Boolean)
+            .includes('act');
+        }
+      );
+
+      // TODO: check if `act` coming from 'react-dom/test-utils'
+    };
+
+    const isTestingLibraryUtil = (node: TSESTree.Identifier): boolean => {
+      return (
+        isAsyncUtil(node) ||
+        isQuery(node) ||
+        isRenderUtil(node) ||
+        isFireEventMethod(node) ||
+        isUserEventMethod(node) ||
+        isActUtil(node)
+      );
+    };
+
     /**
      * Determines whether a given MemberExpression node is a presence assert
      *
@@ -795,6 +821,7 @@ export function detectTestingLibraryUtils<
       getTestingLibraryImportName,
       getCustomModuleImportName,
       isTestingLibraryImported,
+      isTestingLibraryUtil,
       isGetQueryVariant,
       isQueryQueryVariant,
       isFindQueryVariant,
@@ -811,6 +838,7 @@ export function detectTestingLibraryUtils<
       isRenderUtil,
       isRenderVariableDeclarator,
       isDebugUtil,
+      isActUtil,
       isPresenceAssert,
       isAbsenceAssert,
       canReportErrors,

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

@@ -0,0 +1,99 @@
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+import { createTestingLibraryRule } from '../create-testing-library-rule';
+import {
+  getDeepestIdentifierNode,
+  getPropertyIdentifierNode,
+  isCallExpression,
+  isExpressionStatement,
+} from '../node-utils';
+
+export const RULE_NAME = 'no-unnecessary-act';
+export type MessageIds =
+  | 'noUnnecessaryActTestingLibraryUtil'
+  | 'noUnnecessaryActEmptyFunction';
+
+export default createTestingLibraryRule<[], MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow the use of `act` when wrapping Testing Library utils or empty functions',
+      category: 'Possible Errors',
+      recommended: false,
+    },
+    messages: {
+      noUnnecessaryActTestingLibraryUtil:
+        'Avoid wrapping Testing Library util calls in `act`',
+      noUnnecessaryActEmptyFunction: 'Avoid wrapping empty function in `act`',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+
+  create(context, _, helpers) {
+    function hasNonTestingLibraryCall(
+      statements: TSESTree.Statement[]
+    ): boolean {
+      for (const statement of statements) {
+        if (!isExpressionStatement(statement)) {
+          continue;
+        }
+
+        if (!isCallExpression(statement.expression)) {
+          continue;
+        }
+
+        const identifier = getDeepestIdentifierNode(statement.expression);
+
+        if (!identifier) {
+          continue;
+        }
+
+        if (helpers.isTestingLibraryUtil(identifier)) {
+          continue;
+        }
+
+        // at this point the statement is a non testing library call
+        return true;
+      }
+      return false;
+    }
+
+    function checkNoUnnecessaryAct(
+      blockStatementNode: TSESTree.BlockStatement
+    ) {
+      const callExpressionNode = blockStatementNode?.parent?.parent as
+        | TSESTree.CallExpression
+        | undefined;
+
+      if (!callExpressionNode) {
+        return;
+      }
+
+      const callExpressionIdentifier = getPropertyIdentifierNode(
+        callExpressionNode
+      );
+
+      if (!callExpressionIdentifier) {
+        return;
+      }
+
+      if (!helpers.isActUtil(callExpressionIdentifier)) {
+        return;
+      }
+
+      // TODO: check if empty function body
+
+      if (hasNonTestingLibraryCall(blockStatementNode.body)) {
+        return;
+      }
+    }
+
+    return {
+      'CallExpression > ArrowFunctionExpression > BlockStatement': checkNoUnnecessaryAct,
+      'CallExpression > FunctionExpression > BlockStatement': checkNoUnnecessaryAct,
+      // TODO: add selector for call expression > arrow function > implicit return
+    };
+  },
+});