prefer-explicit-assert.ts

import { TSESTree, ASTUtils } from '@typescript-eslint/experimental-utils';

import { createTestingLibraryRule } from '../create-testing-library-rule';
import {
  findClosestCallNode,
  isCallExpression,
  isMemberExpression,
} from '../node-utils';
import { PRESENCE_MATCHERS, ABSENCE_MATCHERS } from '../utils';

export const RULE_NAME = 'prefer-explicit-assert';
export type MessageIds =
  | 'preferExplicitAssert'
  | 'preferExplicitAssertAssertion';
type Options = [
  {
    assertion?: string;
    includeFindQueries?: boolean;
  }
];

const isAtTopLevel = (node: TSESTree.Node) =>
  (!!node.parent?.parent &&
    node.parent.parent.type === 'ExpressionStatement') ||
  (node.parent?.parent?.type === 'AwaitExpression' &&
    !!node.parent.parent.parent &&
    node.parent.parent.parent.type === 'ExpressionStatement');

const isVariableDeclaration = (node: TSESTree.Node) => {
  if (
    isCallExpression(node.parent) &&
    ASTUtils.isAwaitExpression(node.parent.parent) &&
    ASTUtils.isVariableDeclarator(node.parent.parent.parent)
  ) {
    return true; // const quxElement = await findByLabelText('qux')
  }

  if (
    isCallExpression(node.parent) &&
    ASTUtils.isVariableDeclarator(node.parent.parent)
  ) {
    return true; // const quxElement = findByLabelText('qux')
  }

  if (
    isMemberExpression(node.parent) &&
    isCallExpression(node.parent.parent) &&
    ASTUtils.isAwaitExpression(node.parent.parent.parent) &&
    ASTUtils.isVariableDeclarator(node.parent.parent.parent.parent)
  ) {
    return true; // const quxElement = await screen.findByLabelText('qux')
  }

  if (
    isMemberExpression(node.parent) &&
    isCallExpression(node.parent.parent) &&
    ASTUtils.isVariableDeclarator(node.parent.parent.parent)
  ) {
    return true; // const quxElement = screen.findByLabelText('qux')
  }

  return false;
};

export default createTestingLibraryRule<Options, MessageIds>({
  name: RULE_NAME,
  meta: {
    type: 'suggestion',
    docs: {
      description:
        'Suggest using explicit assertions rather than standalone queries',
      recommendedConfig: {
        dom: false,
        angular: false,
        react: false,
        vue: false,
      },
    },
    messages: {
      preferExplicitAssert:
        'Wrap stand-alone `{{queryType}}` query with `expect` function for better explicit assertion',
      preferExplicitAssertAssertion:
        '`getBy*` queries must be asserted with `{{assertion}}`', // TODO: support findBy* queries as well
    },
    schema: [
      {
        type: 'object',
        additionalProperties: false,
        properties: {
          assertion: {
            type: 'string',
            enum: PRESENCE_MATCHERS,
          },
          includeFindQueries: { type: 'boolean' },
        },
      },
    ],
  },
  defaultOptions: [{ includeFindQueries: true }],
  create(context, [options], helpers) {
    const { assertion, includeFindQueries } = options;
    const getQueryCalls: TSESTree.Identifier[] = [];
    const findQueryCalls: TSESTree.Identifier[] = [];

    return {
      'CallExpression Identifier'(node: TSESTree.Identifier) {
        if (helpers.isGetQueryVariant(node)) {
          getQueryCalls.push(node);
        }

        if (helpers.isFindQueryVariant(node)) {
          findQueryCalls.push(node);
        }
      },
      'Program:exit'() {
        if (includeFindQueries) {
          findQueryCalls.forEach((queryCall) => {
            const memberExpression = isMemberExpression(queryCall.parent)
              ? queryCall.parent
              : queryCall;

            if (
              isVariableDeclaration(queryCall) ||
              !isAtTopLevel(memberExpression)
            ) {
              return;
            }

            context.report({
              node: queryCall,
              messageId: 'preferExplicitAssert',
              data: {
                queryType: 'findBy*',
              },
            });
          });
        }

        getQueryCalls.forEach((queryCall) => {
          const node = isMemberExpression(queryCall.parent)
            ? queryCall.parent
            : queryCall;

          if (isAtTopLevel(node)) {
            context.report({
              node: queryCall,
              messageId: 'preferExplicitAssert',
              data: {
                queryType: 'getBy*',
              },
            });
          }

          if (assertion) {
            const expectCallNode = findClosestCallNode(node, 'expect');
            if (!expectCallNode) return;

            const expectStatement =
              expectCallNode.parent as TSESTree.MemberExpression;
            const property = expectStatement.property as TSESTree.Identifier;
            let matcher = property.name;
            let isNegatedMatcher = false;

            if (
              matcher === 'not' &&
              isMemberExpression(expectStatement.parent) &&
              ASTUtils.isIdentifier(expectStatement.parent.property)
            ) {
              isNegatedMatcher = true;
              matcher = expectStatement.parent.property.name;
            }

            const shouldEnforceAssertion =
              (!isNegatedMatcher && PRESENCE_MATCHERS.includes(matcher)) ||
              (isNegatedMatcher && ABSENCE_MATCHERS.includes(matcher));

            if (shouldEnforceAssertion && matcher !== assertion) {
              context.report({
                node: property,
                messageId: 'preferExplicitAssertAssertion',
                data: {
                  assertion,
                },
              });
            }
          }
        });
      },
    };
  },
});