require-hook.ts

import {
  AST_NODE_TYPES,
  TSESTree,
} from '@typescript-eslint/experimental-utils';
import {
  createRule,
  getNodeName,
  isDescribeCall,
  isFunction,
  isHook,
  isIdentifier,
  isTestCaseCall,
} from './utils';

interface RequireHooksOptions {
  excludedFunctions?: readonly string[];
  allowedHooks?: readonly string[];
}

const isExcludedFnCall = (
  node: TSESTree.CallExpression,
  options: RequireHooksOptions,
): boolean => {
  const [firstArgument] = node.arguments;

  if (firstArgument === undefined) {
    return false;
  }

  const nodeName = getNodeName(node);
  const argumentNodeName = getNodeName(firstArgument);

  if (nodeName === null || argumentNodeName === null) {
    return false;
  }

  return (
    !!options.excludedFunctions?.includes(nodeName) &&
    !!options.allowedHooks?.includes(argumentNodeName)
  );
};

const isJestFnCall = (node: TSESTree.CallExpression): boolean => {
  if (isDescribeCall(node) || isTestCaseCall(node) || isHook(node)) {
    return true;
  }

  return !!getNodeName(node)?.startsWith('jest.');
};

const isNullOrUndefined = (node: TSESTree.Expression): boolean => {
  return (
    (node.type === AST_NODE_TYPES.Literal && node.value === null) ||
    isIdentifier(node, 'undefined')
  );
};

const shouldBeInHook = (
  node: TSESTree.Node,
  options: RequireHooksOptions,
): boolean => {
  switch (node.type) {
    case AST_NODE_TYPES.ExpressionStatement:
      return shouldBeInHook(node.expression, options);
    case AST_NODE_TYPES.CallExpression:
      return !(isJestFnCall(node) || isExcludedFnCall(node, options));
    case AST_NODE_TYPES.VariableDeclaration: {
      if (node.kind === 'const') {
        return false;
      }

      return node.declarations.some(
        ({ init }) => init !== null && !isNullOrUndefined(init),
      );
    }

    default:
      return false;
  }
};

const defaultAllowedHooks = [
  'beforeAll',
  'beforeEach',
  'afterAll',
  'afterEach',
];

export default createRule<[RequireHooksOptions], 'useHook'>({
  name: __filename,
  meta: {
    docs: {
      category: 'Best Practices',
      description: 'Require setup and teardown code to be within a hook',
      recommended: false,
    },
    messages: {
      useHook: 'This should be done within a hook',
    },
    type: 'suggestion',
    schema: [
      {
        type: 'object',
        properties: {
          excludedFunctions: {
            type: 'array',
            items: { type: 'string' },
          },
          allowedHooks: {
            type: 'array',
            items: { type: 'string' },
            default: defaultAllowedHooks,
          },
        },
        additionalProperties: false,
      },
    ],
  },
  defaultOptions: [
    {
      excludedFunctions: [],
    },
  ],
  create(context) {
    const { allowedHooks = defaultAllowedHooks, excludedFunctions = [] } =
      context.options[0] ?? {};

    const checkBlockBody = (body: TSESTree.BlockStatement['body']) => {
      for (const statement of body) {
        if (shouldBeInHook(statement, { allowedHooks, excludedFunctions })) {
          context.report({
            node: statement,
            messageId: 'useHook',
          });
        }
      }
    };

    return {
      Program(program) {
        checkBlockBody(program.body);
      },
      CallExpression(node) {
        if (!isDescribeCall(node) || node.arguments.length < 2) {
          return;
        }

        const [, testFn] = node.arguments;

        if (
          !isFunction(testFn) ||
          testFn.body.type !== AST_NODE_TYPES.BlockStatement
        ) {
          return;
        }

        checkBlockBody(testFn.body.body);
      },
    };
  },
});