refactor(no-wait-for-empty-callback): use new rule creator and helpers

Author: Belco90

lib/detect-testing-library-utils.ts

@@ -22,6 +22,7 @@ import {
   ASYNC_UTILS,
   PRESENCE_MATCHERS,
   ALL_QUERIES_COMBINATIONS,
+  VALID_ASYNC_UTILS,
 } from './utils';
 
 export type TestingLibrarySettings = {
@@ -62,7 +63,10 @@ type IsFindQueryVariantFn = (node: TSESTree.Identifier) => boolean;
 type IsSyncQueryFn = (node: TSESTree.Identifier) => boolean;
 type IsAsyncQueryFn = (node: TSESTree.Identifier) => boolean;
 type IsCustomQueryFn = (node: TSESTree.Identifier) => boolean;
-type IsAsyncUtilFn = (node: TSESTree.Identifier) => boolean;
+type IsAsyncUtilFn = (
+  node: TSESTree.Identifier,
+  validNames?: VALID_ASYNC_UTILS[]
+) => boolean;
 type IsFireEventMethodFn = (node: TSESTree.Identifier) => boolean;
 type IsRenderUtilFn = (node: TSESTree.Identifier) => boolean;
 type IsPresenceAssertFn = (node: TSESTree.MemberExpression) => boolean;
@@ -291,10 +295,13 @@ export function detectTestingLibraryUtils<
      * Otherwise, it means `custom-module` has been set up, so only those nodes
      * coming from Testing Library will be considered as valid.
      */
-    const isAsyncUtil: IsAsyncUtilFn = (node) => {
-      return isTestingLibraryUtil(node, (identifierNodeName) =>
-        ASYNC_UTILS.includes(identifierNodeName)
-      );
+    const isAsyncUtil: IsAsyncUtilFn = (node, validNames) => {
+      return isTestingLibraryUtil(node, (identifierNodeName) => {
+        if (validNames && validNames.length > 0) {
+          return (validNames as string[]).includes(identifierNodeName);
+        }
+        return ASYNC_UTILS.includes(identifierNodeName);
+      });
     };
 
     /**

lib/rules/no-wait-for-empty-callback.ts

@@ -1,19 +1,16 @@
+import { ASTUtils, TSESTree } from '@typescript-eslint/experimental-utils';
 import {
-  ESLintUtils,
-  TSESTree,
-  ASTUtils,
-} from '@typescript-eslint/experimental-utils';
-import { getDocsUrl } from '../utils';
-import { isBlockStatement, isCallExpression } from '../node-utils';
+  getPropertyIdentifierNode,
+  isBlockStatement,
+  isCallExpression,
+} from '../node-utils';
+import { createTestingLibraryRule } from '../create-testing-library-rule';
 
 export const RULE_NAME = 'no-wait-for-empty-callback';
 export type MessageIds = 'noWaitForEmptyCallback';
 type Options = [];
 
-const WAIT_EXPRESSION_QUERY =
-  'CallExpression[callee.name=/^(waitFor|waitForElementToBeRemoved)$/]';
-
-export default ESLintUtils.RuleCreator(getDocsUrl)<Options, MessageIds>({
+export default createTestingLibraryRule<Options, MessageIds>({
   name: RULE_NAME,
   meta: {
     type: 'suggestion',
@@ -33,11 +30,24 @@ export default ESLintUtils.RuleCreator(getDocsUrl)<Options, MessageIds>({
   defaultOptions: [],
 
   // trimmed down implementation of https://github.com/eslint/eslint/blob/master/lib/rules/no-empty-function.js
-  // TODO: var referencing any of previously mentioned?
-  create: function (context) {
+  create(context, _, helpers) {
+    function isValidWaitFor(node: TSESTree.Node): boolean {
+      const parentCallExpression = node.parent as TSESTree.CallExpression;
+      const parentIdentifier = getPropertyIdentifierNode(parentCallExpression);
+
+      return helpers.isAsyncUtil(parentIdentifier, [
+        'waitFor',
+        'waitForElementToBeRemoved',
+      ]);
+    }
+
     function reportIfEmpty(
       node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression
     ) {
+      if (!isValidWaitFor(node)) {
+        return;
+      }
+
       if (
         isBlockStatement(node.body) &&
         node.body.body.length === 0 &&
@@ -56,17 +66,27 @@ export default ESLintUtils.RuleCreator(getDocsUrl)<Options, MessageIds>({
     }
 
     function reportNoop(node: TSESTree.Identifier) {
+      if (!isValidWaitFor(node)) {
+        return;
+      }
+
       context.report({
         node,
         loc: node.loc.start,
         messageId: 'noWaitForEmptyCallback',
+        data: {
+          methodName:
+            isCallExpression(node.parent) &&
+            ASTUtils.isIdentifier(node.parent.callee) &&
+            node.parent.callee.name,
+        },
       });
     }
 
     return {
-      [`${WAIT_EXPRESSION_QUERY} > ArrowFunctionExpression`]: reportIfEmpty,
-      [`${WAIT_EXPRESSION_QUERY} > FunctionExpression`]: reportIfEmpty,
-      [`${WAIT_EXPRESSION_QUERY} > Identifier[name="noop"]`]: reportNoop,
+      'CallExpression > ArrowFunctionExpression': reportIfEmpty,
+      'CallExpression > FunctionExpression': reportIfEmpty,
+      'CallExpression > Identifier[name="noop"]': reportNoop,
     };
   },
 });

lib/utils.ts

@@ -114,6 +114,13 @@ const ALL_RETURNING_NODES = [
 const PRESENCE_MATCHERS = ['toBeInTheDocument', 'toBeTruthy', 'toBeDefined'];
 const ABSENCE_MATCHERS = ['toBeNull', 'toBeFalsy'];
 
+export type VALID_ASYNC_UTILS =
+  | 'waitFor'
+  | 'waitForElementToBeRemoved'
+  | 'wait'
+  | 'waitForElement'
+  | 'waitForDomChange';
+
 export {
   combineQueries,
   getDocsUrl,