refactor(extract helpers for detecting presence/absence assets): add fake rule tests for queries

Author: Belco90

lib/detect-testing-library-utils.ts

@@ -1,5 +1,11 @@
 import { TSESLint, TSESTree } from '@typescript-eslint/experimental-utils';
-import { getImportModuleName, ImportModuleNode, isLiteral } from './node-utils';
+import {
+  getAssertNodeInfo,
+  getImportModuleName,
+  ImportModuleNode,
+  isLiteral,
+} from './node-utils';
+import { ABSENCE_MATCHERS, PRESENCE_MATCHERS } from './utils';
 
 export type TestingLibrarySettings = {
   'testing-library/module'?: string;
@@ -35,6 +41,8 @@ export type DetectionHelpers = {
   isGetByQuery: (node: TSESTree.Identifier) => boolean;
   isQueryByQuery: (node: TSESTree.Identifier) => boolean;
   isSyncQuery: (node: TSESTree.Identifier) => boolean;
+  isPresenceAssert: (node: TSESTree.MemberExpression) => boolean;
+  isAbsenceAssert: (node: TSESTree.MemberExpression) => boolean;
   canReportErrors: () => boolean;
 };
 
@@ -126,6 +134,30 @@ export function detectTestingLibraryUtils<
         return this.isGetByQuery(node) || this.isQueryByQuery(node);
       },
 
+      isPresenceAssert(node) {
+        const { matcher, isNegated } = getAssertNodeInfo(node);
+
+        if (!matcher) {
+          return false;
+        }
+
+        return isNegated
+          ? ABSENCE_MATCHERS.includes(matcher)
+          : PRESENCE_MATCHERS.includes(matcher);
+      },
+
+      isAbsenceAssert(node) {
+        const { matcher, isNegated } = getAssertNodeInfo(node);
+
+        if (!matcher) {
+          return false;
+        }
+
+        return isNegated
+          ? PRESENCE_MATCHERS.includes(matcher)
+          : ABSENCE_MATCHERS.includes(matcher);
+      },
+
       /**
        * Determines if file inspected meets all conditions to be reported by rules or not.
        */

lib/node-utils.ts

@@ -1,5 +1,6 @@
 import {
   AST_NODE_TYPES,
+  ASTUtils,
   TSESLint,
   TSESTree,
 } from '@typescript-eslint/experimental-utils';
@@ -253,3 +254,42 @@ export function getImportModuleName(
     return node.arguments[0].value;
   }
 }
+
+type AssertNodeInfo = {
+  matcher: string | null;
+  isNegated: boolean;
+};
+/**
+ * Extracts matcher info from MemberExpression node representing an assert.
+ */
+export function getAssertNodeInfo(
+  node: TSESTree.MemberExpression
+): AssertNodeInfo {
+  const emptyInfo = { matcher: null, isNegated: false } as AssertNodeInfo;
+
+  if (
+    !isCallExpression(node.object) ||
+    !ASTUtils.isIdentifier(node.object.callee)
+  ) {
+    return emptyInfo;
+  }
+
+  if (node.object.callee.name !== 'expect') {
+    return emptyInfo;
+  }
+
+  let matcher = ASTUtils.getPropertyName(node);
+  let isNegated = false;
+  if (matcher === 'not') {
+    matcher = isMemberExpression(node.parent)
+      ? ASTUtils.getPropertyName(node.parent)
+      : null;
+    isNegated = true;
+  }
+
+  if (!matcher) {
+    return emptyInfo;
+  }
+
+  return { matcher, isNegated };
+}

tests/create-testing-library-rule.test.ts

@@ -121,6 +121,19 @@ ruleTester.run(RULE_NAME, rule, {
       `,
     },
 
+    // Test Cases for presence/absence assertions
+    // cases: asserts not related to presence/absence
+    'expect(element).toBeDisabled()',
+    'expect(element).toBeEnabled()',
+
+    // cases: presence/absence matcher not related to assert
+    'element.toBeInTheDocument()',
+    'element.not.toBeInTheDocument()',
+
+    // cases: weird scenarios to check guard against parent nodes
+    'expect(element).not()',
+    'expect(element).not()',
+
     // Test Cases for Queries and Aggressive Queries Reporting
     {
       code: `
@@ -362,6 +375,36 @@ ruleTester.run(RULE_NAME, rule, {
       errors: [{ line: 7, column: 21, messageId: 'fakeError' }],
     },
 
+    // Test Cases for presence/absence assertions
+    {
+      code: `
+      // case: presence matcher .toBeInTheDocument forced to be reported
+      expect(element).toBeInTheDocument()
+      `,
+      errors: [{ line: 3, column: 7, messageId: 'presenceAssertError' }],
+    },
+    {
+      code: `
+      // case: absence matcher .not.toBeInTheDocument forced to be reported
+      expect(element).not.toBeInTheDocument()
+      `,
+      errors: [{ line: 3, column: 7, messageId: 'absenceAssertError' }],
+    },
+    {
+      code: `
+      // case: presence matcher .not.toBeNull forced to be reported
+      expect(element).not.toBeNull()
+      `,
+      errors: [{ line: 3, column: 7, messageId: 'presenceAssertError' }],
+    },
+    {
+      code: `
+      // case: absence matcher .toBeNull forced to be reported
+      expect(element).toBeNull()
+      `,
+      errors: [{ line: 3, column: 7, messageId: 'absenceAssertError' }],
+    },
+
     // Test Cases for Queries and Aggressive Queries Reporting
     {
       code: `

tests/fake-rule.ts

@@ -7,7 +7,12 @@ import { createTestingLibraryRule } from '../lib/create-testing-library-rule';
 
 export const RULE_NAME = 'fake-rule';
 type Options = [];
-type MessageIds = 'fakeError' | 'getByError' | 'queryByError';
+type MessageIds =
+  | 'fakeError'
+  | 'getByError'
+  | 'queryByError'
+  | 'presenceAssertError'
+  | 'absenceAssertError';
 
 export default createTestingLibraryRule<Options, MessageIds>({
   name: RULE_NAME,
@@ -22,6 +27,8 @@ export default createTestingLibraryRule<Options, MessageIds>({
       fakeError: 'fake error reported',
       getByError: 'some error related to getBy reported',
       queryByError: 'some error related to queryBy reported',
+      presenceAssertError: 'some error related to presence assert reported',
+      absenceAssertError: 'some error related to absence assert reported',
     },
     fixable: null,
     schema: [],
@@ -44,7 +51,17 @@ export default createTestingLibraryRule<Options, MessageIds>({
       }
     };
 
-    const checkImportDeclaration = (node: TSESTree.ImportDeclaration) => {
+    const reportMemberExpression = (node: TSESTree.MemberExpression) => {
+      if (helpers.isPresenceAssert(node)) {
+        return context.report({ node, messageId: 'presenceAssertError' });
+      }
+
+      if (helpers.isAbsenceAssert(node)) {
+        return context.report({ node, messageId: 'absenceAssertError' });
+      }
+    };
+
+    const reportImportDeclaration = (node: TSESTree.ImportDeclaration) => {
       // This is just to check that defining an `ImportDeclaration` doesn't
       // override `ImportDeclaration` from `detectTestingLibraryUtils`
 
@@ -55,7 +72,8 @@ export default createTestingLibraryRule<Options, MessageIds>({
 
     return {
       'CallExpression Identifier': reportCallExpressionIdentifier,
-      ImportDeclaration: checkImportDeclaration,
+      MemberExpression: reportMemberExpression,
+      ImportDeclaration: reportImportDeclaration,
       'Program:exit'() {
         const importNode = helpers.getCustomModuleImportNode();
         const importName = helpers.getCustomModuleImportName();

tests/lib/rules/prefer-presence-queries.test.ts

@@ -362,9 +362,6 @@ ruleTester.run(RULE_NAME, rule, {
      // right after clicking submit button it disappears
      expect(submitButton).not.toBeInTheDocument()
     `,
-    // some weird examples after here to check guard against parent nodes
-    'expect(getByText("button")).not()',
-    'expect(queryByText("button")).not()',
   ],
   invalid: [
     // cases: asserting absence incorrectly with `getBy*` queries