Feat/custom method name for enforce close testing module

.vscode/eslint-plugin.code-workspace

@@ -4,7 +4,4 @@
       "path": ".."
     }
   ],
-  "settings": {
-    "prettier.prettierPath": ".yarn/unplugged/prettier-npm-3.1.0-708d6027b1/node_modules/prettier"
-  }
 }

src/rules/enforce-close-testing-module.rule.ts

@@ -18,7 +18,24 @@ function typeOfHook(hookName: TestBeforeHooks | TestAfterHooks): HookType {
   return hookName.includes('All') ? 'all' : 'each';
 }
 
-export default createRule({
+export type Options = [
+  {
+    closeAliases?: {
+      kind: string;
+      name: string;
+    }[];
+  },
+];
+
+const defaultOptions: Options = [
+  {
+    closeAliases: [],
+  },
+];
+
+export type MessageIds = 'testModuleNotClosed' | 'testModuleClosedInWrongHook';
+
+export default createRule<Options, MessageIds>({
   name: 'enforce-close-testing-module',
   meta: {
     type: 'problem',
@@ -27,15 +44,35 @@ export default createRule({
       recommended: 'recommended',
     },
     fixable: undefined,
-    schema: [], // no options
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          closeAliases: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                kind: {
+                  type: 'string',
+                },
+                name: {
+                  type: 'string',
+                },
+              },
+            },
+          },
+        },
+      },
+    ], // no options
     messages: {
       testModuleNotClosed:
         'A Testing Module was created but not closed, which can cause memory leaks',
       testModuleClosedInWrongHook:
         'A Testing Module was created in {{ created }} but was closed in the wrong hook {{ closed }}',
     },
   },
-  defaultOptions: [],
+  defaultOptions,
   create(context) {
     let testModuleCreated = false;
     let testModuleClosed = false;
@@ -120,18 +157,7 @@ export default createRule({
         }
 
         // Logic to check if module.close() is called in the wrong hook
-        const callExpressions = traverser.getAllParentCallExpressions(node);
-        const callExpressionWithHook = callExpressions.find(
-          (expression) =>
-            ASTUtils.isIdentifier(expression.callee) &&
-            ['afterAll', 'afterEach'].includes(expression.callee.name)
-        );
-        if (
-          callExpressionWithHook &&
-          ASTUtils.isIdentifier(callExpressionWithHook.callee)
-        ) {
-          closedInHook = callExpressionWithHook.callee.name as TestAfterHooks;
-        }
+        closedInHook = afterHookContainingNode(node);
 
         if (
           closedInHook &&
@@ -149,6 +175,19 @@ export default createRule({
           });
         }
       },
+      'CallExpression[callee.type="Identifier"]': (
+        node: TSESTree.CallExpression
+      ) => {
+        const calleeName = (node.callee as TSESTree.Identifier).name;
+        const functionAliases = context.options[0]?.closeAliases?.filter(
+          (alias) => alias.kind === 'function'
+        );
+
+        if (functionAliases?.some((alias) => alias.name === calleeName)) {
+          testModuleClosed = true;
+          closedInHook = afterHookContainingNode(node);
+        }
+      },
       'Program:exit': (node) => {
         if (testModuleCreated && !testModuleClosed && !appModuleClosed) {
           context.report({
@@ -161,3 +200,23 @@ export default createRule({
     };
   },
 });
+
+function afterHookContainingNode(
+  node: TSESTree.CallExpression | TSESTree.MemberExpression
+): TestAfterHooks | undefined {
+  let result: TestAfterHooks | undefined;
+  const callExpressions = traverser.getAllParentCallExpressions(node);
+  const callExpressionWithHook = callExpressions.find(
+    (expression) =>
+      ASTUtils.isIdentifier(expression.callee) &&
+      ['afterAll', 'afterEach'].includes(expression.callee.name)
+  );
+  if (
+    callExpressionWithHook &&
+    ASTUtils.isIdentifier(callExpressionWithHook.callee)
+  ) {
+    result = callExpressionWithHook.callee.name as TestAfterHooks;
+  }
+  return result;
+}
+

tests/rules/enforce-close-testing-module.spec.ts

@@ -87,6 +87,34 @@ ruleTester.run('enforce-close-testing-module', enforceCloseTestingModuleRule, {
         });
       `,
     },
+    {
+      code: `
+        describe('Closes the testingModule using a custom function', () => {
+          let testingModule: TestingModule;
+          beforeEach(async () => {
+            testingModule = await Test.createTestingModule({
+              imports: [AppModule],
+            }).compile();
+          });
+          it('should be defined', () => {
+            expect(testingModule).toBeDefined();
+          });
+        });
+        afterEach(async () => {
+          await customClose();
+        });
+      `,
+      options: [
+        {
+          closeAliases: [
+            {
+              kind: 'function',
+              name: 'customClose',
+            },
+          ],
+        },
+      ],
+    },
   ],
   invalid: [
     {