no-if.ts

import {
  AST_NODE_TYPES,
  TSESTree,
} from '@typescript-eslint/experimental-utils';
import {
  TestCaseName,
  createRule,
  getNodeName,
  getTestCallExpressionsFromDeclaredVariables,
  isTestCase,
} from './utils';

const testCaseNames = new Set<string | null>([
  ...Object.keys(TestCaseName),
  'it.only',
  'it.concurrent.only',
  'it.skip',
  'it.concurrent.skip',
  'test.only',
  'test.concurrent.only',
  'test.skip',
  'test.concurrent.skip',
  'fit.concurrent',
]);

const isTestArrowFunction = (node: TSESTree.ArrowFunctionExpression) =>
  node.parent !== undefined &&
  node.parent.type === AST_NODE_TYPES.CallExpression &&
  testCaseNames.has(getNodeName(node.parent.callee));

const conditionName = {
  [AST_NODE_TYPES.ConditionalExpression]: 'conditional',
  [AST_NODE_TYPES.SwitchStatement]: 'switch',
  [AST_NODE_TYPES.IfStatement]: 'if',
};

export default createRule({
  name: __filename,
  meta: {
    docs: {
      description: 'Disallow conditional logic',
      category: 'Best Practices',
      recommended: false,
    },
    messages: {
      conditionalInTest: 'Test should not contain {{ condition }} statements.',
    },
    schema: [],
    type: 'suggestion',
  },
  defaultOptions: [],
  create(context) {
    const stack: boolean[] = [];

    function validate(
      node:
        | TSESTree.ConditionalExpression
        | TSESTree.SwitchStatement
        | TSESTree.IfStatement,
    ) {
      const lastElementInStack = stack[stack.length - 1];

      if (stack.length === 0 || !lastElementInStack) {
        return;
      }

      context.report({
        data: { condition: conditionName[node.type] },
        messageId: 'conditionalInTest',
        node,
      });
    }

    return {
      CallExpression(node) {
        if (isTestCase(node)) {
          stack.push(true);
        }
      },
      FunctionExpression() {
        stack.push(false);
      },
      FunctionDeclaration(node) {
        const declaredVariables = context.getDeclaredVariables(node);
        const testCallExpressions = getTestCallExpressionsFromDeclaredVariables(
          declaredVariables,
        );

        stack.push(testCallExpressions.length > 0);
      },
      ArrowFunctionExpression(node) {
        stack.push(isTestArrowFunction(node));
      },
      IfStatement: validate,
      SwitchStatement: validate,
      ConditionalExpression: validate,
      'CallExpression:exit'() {
        stack.pop();
      },
      'FunctionExpression:exit'() {
        stack.pop();
      },
      'FunctionDeclaration:exit'() {
        stack.pop();
      },
      'ArrowFunctionExpression:exit'() {
        stack.pop();
      },
    };
  },
});