feat(require-hook): support global checking

Author: G-Rath

src/rules/__tests__/require-hook.test.ts

@@ -17,6 +17,22 @@ ruleTester.run('require-hook', rule, {
         //
       });
     `,
+    dedent`
+      const { myFn } = require('../functions');
+
+      test('myFn', () => {
+        expect(myFn()).toBe(1);
+      });
+    `,
+    dedent`
+      const { myFn } = require('../functions');
+
+      describe('myFn', () => {
+        it('returns one', () => {
+          expect(myFn()).toBe(1);
+        });
+      });
+    `,
     dedent`
       describe('some tests', () => {
         it('is true', () => {
@@ -97,6 +113,16 @@ ruleTester.run('require-hook', rule, {
     `,
   ],
   invalid: [
+    {
+      code: 'setup();',
+      errors: [
+        {
+          messageId: 'useHook',
+          line: 1,
+          column: 1,
+        },
+      ],
+    },
     {
       code: dedent`
         describe('some tests', () => {
@@ -142,5 +168,82 @@ ruleTester.run('require-hook', rule, {
         },
       ],
     },
+    {
+      code: dedent`
+        import { database, isCity } from '../database';
+        import { loadCities } from '../api';
+
+        jest.mock('../api');
+
+        const initializeCityDatabase = () => {
+          database.addCity('Vienna');
+          database.addCity('San Juan');
+          database.addCity('Wellington');
+        };
+
+        const clearCityDatabase = () => {
+          database.clear();
+        };
+
+        initializeCityDatabase();
+
+        test('that persists cities', () => {
+          expect(database.cities.length).toHaveLength(3);
+        });
+
+        test('city database has Vienna', () => {
+          expect(isCity('Vienna')).toBeTruthy();
+        });
+
+        test('city database has San Juan', () => {
+          expect(isCity('San Juan')).toBeTruthy();
+        });
+
+        describe('when loading cities from the api', () => {
+          let consoleWarnSpy = jest.spyOn(console, 'warn');
+
+          loadCities.mockResolvedValue(['Wellington', 'London']);
+
+          it('does not duplicate cities', async () => {
+            await database.loadCities();
+
+            expect(database.cities).toHaveLength(4);
+          });
+
+          it('logs any duplicates', async () => {
+            await database.loadCities();
+
+            expect(consoleWarnSpy).toHaveBeenCalledWith(
+              'Ignored duplicate cities: Wellington',
+            );
+          });
+        });
+
+        clearCityDatabase();
+      `,
+      parserOptions: { sourceType: 'module' },
+      errors: [
+        {
+          messageId: 'useHook',
+          line: 4,
+          column: 1,
+        },
+        {
+          messageId: 'useHook',
+          line: 16,
+          column: 1,
+        },
+        {
+          messageId: 'useHook',
+          line: 33,
+          column: 3,
+        },
+        {
+          messageId: 'useHook',
+          line: 50,
+          column: 1,
+        },
+      ],
+    },
   ],
 });

src/rules/require-hook.ts

@@ -1,4 +1,7 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/experimental-utils';
+import {
+  AST_NODE_TYPES,
+  TSESTree,
+} from '@typescript-eslint/experimental-utils';
 import {
   createRule,
   isDescribeCall,
@@ -7,6 +10,18 @@ import {
   isTestCaseCall,
 } from './utils';
 
+const shouldBeInHook = (node: TSESTree.Node): boolean => {
+  switch (node.type) {
+    case AST_NODE_TYPES.ExpressionStatement:
+      return shouldBeInHook(node.expression);
+    case AST_NODE_TYPES.CallExpression:
+      return !(isDescribeCall(node) || isTestCaseCall(node) || isHook(node));
+
+    default:
+      return false;
+  }
+};
+
 export default createRule({
   name: __filename,
   meta: {
@@ -23,7 +38,21 @@ export default createRule({
   },
   defaultOptions: [],
   create(context) {
+    const checkBlockBody = (body: TSESTree.BlockStatement['body']) => {
+      for (const statement of body) {
+        if (shouldBeInHook(statement)) {
+          context.report({
+            node: statement,
+            messageId: 'useHook',
+          });
+        }
+      }
+    };
+
     return {
+      Program(program) {
+        checkBlockBody(program.body);
+      },
       CallExpression(node) {
         if (!isDescribeCall(node) || node.arguments.length < 2) {
           return;
@@ -38,25 +67,7 @@ export default createRule({
           return;
         }
 
-        for (const nod of testFn.body.body) {
-          if (
-            nod.type === AST_NODE_TYPES.ExpressionStatement &&
-            nod.expression.type === AST_NODE_TYPES.CallExpression
-          ) {
-            if (
-              isDescribeCall(nod.expression) ||
-              isTestCaseCall(nod.expression) ||
-              isHook(nod.expression)
-            ) {
-              return;
-            }
-
-            context.report({
-              node: nod.expression,
-              messageId: 'useHook',
-            });
-          }
-        }
+        checkBlockBody(testFn.body.body);
       },
     };
   },