feat(no-unnecessary-act): detect error for empty callbacks

Author: Belco90

lib/rules/no-unnecessary-act.ts

@@ -4,6 +4,7 @@ import {
   getDeepestIdentifierNode,
   getPropertyIdentifierNode,
   getStatementCallExpression,
+  isEmptyFunction,
 } from '../node-utils';
 
 export const RULE_NAME = 'no-unnecessary-act';
@@ -64,11 +65,15 @@ export default createTestingLibraryRule<[], MessageIds>({
     function checkNoUnnecessaryActFromBlockStatement(
       blockStatementNode: TSESTree.BlockStatement
     ) {
-      const callExpressionNode = blockStatementNode?.parent?.parent as
+      const functionNode = blockStatementNode?.parent as
+        | TSESTree.FunctionExpression
+        | TSESTree.ArrowFunctionExpression
+        | undefined;
+      const callExpressionNode = functionNode?.parent as
         | TSESTree.CallExpression
         | undefined;
 
-      if (!callExpressionNode) {
+      if (!callExpressionNode || !functionNode) {
         return;
       }
 
@@ -84,7 +89,14 @@ export default createTestingLibraryRule<[], MessageIds>({
         return;
       }
 
-      // TODO: check if empty function body
+      if (isEmptyFunction(functionNode)) {
+        context.report({
+          node: callExpressionIdentifier,
+          messageId: 'noUnnecessaryActEmptyFunction',
+        });
+
+        return;
+      }
 
       if (hasNonTestingLibraryCall(blockStatementNode.body)) {
         return;

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

@@ -96,7 +96,7 @@ ruleTester.run(RULE_NAME, rule, {
 
       test('valid case', async () => {
         act(() => {
-          render(<Foo />);
+          render(element);
           stuffThatDoesNotUseRTL();
         });
         
@@ -112,6 +112,39 @@ ruleTester.run(RULE_NAME, rule, {
       });
       `,
     },
+    {
+      settings: {
+        'testing-library/utils-module': 'test-utils',
+      },
+      code: `// case: non-RTL act wrapping RTL - AGR disabled
+      import { act } from 'somewhere-else'
+      import { waitFor } from '@testing-library/react'
+
+      test('valid case', async () => {
+        act(() => {
+          waitFor();
+        });
+        
+        await act(async () => {
+          waitFor();
+        });
+        
+        act(function() {
+          waitFor();
+        });
+        
+        act(function() {
+          return waitFor();
+        });
+        
+        act(() => waitFor());
+
+        act(() => {})
+        await act(async () => {})
+        act(function() {})
+      });
+      `,
+    },
   ],
   invalid: [
     {
@@ -317,8 +350,25 @@ ruleTester.run(RULE_NAME, rule, {
         },
       ],
     },
+    {
+      code: `// case: RTL act wrapping empty callback
+      import { act } from '@testing-library/react'
+
+      test('invalid case', async () => {
+        await act(async () => {})
+        act(() => {})
+        await act(async function () {})
+        act(function () {})
+      })
+      `,
+      errors: [
+        { messageId: 'noUnnecessaryActEmptyFunction', line: 5, column: 15 },
+        { messageId: 'noUnnecessaryActEmptyFunction', line: 6, column: 9 },
+        { messageId: 'noUnnecessaryActEmptyFunction', line: 7, column: 15 },
+        { messageId: 'noUnnecessaryActEmptyFunction', line: 8, column: 9 },
+      ],
+    },
 
-    // TODO case: RTL act wrapping empty callback
     // TODO case: RTU act wrapping RTL calls - callbacks with body (BlockStatement)
     // TODO case: RTU act wrapping RTL calls - callbacks with return
     // TODO case: RTU act wrapping empty callback