chore(no-hooks): convert to typescript (#322)

Author: G-Rath

src/rules/__tests__/no-hooks.test.js

@@ -0,0 +1,60 @@
+import { TSESLint } from '@typescript-eslint/experimental-utils';
+import rule from '../no-hooks';
+import { HookName } from '../tsUtils';
+
+const ruleTester = new TSESLint.RuleTester({
+  parserOptions: {
+    ecmaVersion: 6,
+  },
+});
+
+ruleTester.run('no-hooks', rule, {
+  valid: [
+    'test("foo")',
+    'describe("foo", () => { it("bar") })',
+    'test("foo", () => { expect(subject.beforeEach()).toBe(true) })',
+    {
+      code: 'afterEach(() => {}); afterAll(() => {});',
+      options: [{ allow: [HookName.afterEach, HookName.afterAll] }],
+    },
+  ],
+  invalid: [
+    {
+      code: 'beforeAll(() => {})',
+      errors: [
+        { messageId: 'unexpectedHook', data: { hookName: HookName.beforeAll } },
+      ],
+    },
+    {
+      code: 'beforeEach(() => {})',
+      errors: [
+        {
+          messageId: 'unexpectedHook',
+          data: { hookName: HookName.beforeEach },
+        },
+      ],
+    },
+    {
+      code: 'afterAll(() => {})',
+      errors: [
+        { messageId: 'unexpectedHook', data: { hookName: HookName.afterAll } },
+      ],
+    },
+    {
+      code: 'afterEach(() => {})',
+      errors: [
+        { messageId: 'unexpectedHook', data: { hookName: HookName.afterEach } },
+      ],
+    },
+    {
+      code: 'beforeEach(() => {}); afterEach(() => { jest.resetModules() });',
+      options: [{ allow: [HookName.afterEach] }],
+      errors: [
+        {
+          messageId: 'unexpectedHook',
+          data: { hookName: HookName.beforeEach },
+        },
+      ],
+    },
+  ],
+});

src/rules/__tests__/no-hooks.test.ts

@@ -0,0 +1,50 @@
+import { HookName, createRule, isHook } from './tsUtils';
+
+export default createRule({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Disallow setup and teardown hooks',
+      recommended: false,
+    },
+    messages: {
+      unexpectedHook: "Unexpected '{{ hookName }}' hook",
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allow: {
+            type: 'array',
+            contains: ['beforeAll', 'beforeEach', 'afterAll', 'afterEach'],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    type: 'suggestion',
+  },
+  defaultOptions: [{ allow: [] } as { allow: readonly HookName[] }],
+  create(context, [{ allow }]) {
+    const whitelistedHookNames = allow.reduce((hashMap, value) => {
+      hashMap[value] = true;
+      return hashMap;
+    }, Object.create(null));
+
+    const isWhitelisted = (node: { callee: { name: string } }) =>
+      whitelistedHookNames[node.callee.name];
+
+    return {
+      CallExpression(node) {
+        if (isHook(node) && !isWhitelisted(node)) {
+          context.report({
+            node,
+            messageId: 'unexpectedHook',
+            data: { hookName: node.callee.name },
+          });
+        }
+      },
+    };
+  },
+});

src/rules/no-hooks.js

@@ -95,7 +95,6 @@ export const isFunction = (node: TSESTree.Node): node is FunctionExpression =>
   node.type === AST_NODE_TYPES.FunctionExpression ||
   node.type === AST_NODE_TYPES.ArrowFunctionExpression;
 
-/* istanbul ignore next */
 export const isHook = (
   node: TSESTree.CallExpression,
 ): node is JestFunctionCallExpressionWithIdentifierCallee<HookName> => {

src/rules/no-hooks.ts

@@ -101,13 +101,6 @@ const describeAliases = new Set(['describe', 'fdescribe', 'xdescribe']);
 
 const testCaseNames = new Set(['fit', 'it', 'test', 'xit', 'xtest']);
 
-const testHookNames = new Set([
-  'beforeAll',
-  'beforeEach',
-  'afterAll',
-  'afterEach',
-]);
-
 export const getNodeName = node => {
   function joinNames(a, b) {
     return a && b ? `${a}.${b}` : null;
@@ -128,12 +121,6 @@ export const getNodeName = node => {
   return null;
 };
 
-export const isHook = node =>
-  node &&
-  node.type === 'CallExpression' &&
-  node.callee.type === 'Identifier' &&
-  testHookNames.has(node.callee.name);
-
 export const isTestCase = node =>
   node &&
   node.type === 'CallExpression' &&