feat(no-debug): support utilNames option

Author: G-Rath

docs/rules/no-debug.md

@@ -28,6 +28,12 @@ const { screen } = require('@testing-library/react');
 screen.debug();
 ```
 
+If you want to disallow the use of other debugging functions, you can configure what names this rule checks for with the `utilNames` option:
+
+```
+   "testing-library/no-debug": ["error", {"utilNames": ["debug", "logTestingPlaygroundURL"]}],
+```
+
 ## Further Reading
 
 - [debug API in React Testing Library](https://testing-library.com/docs/react-testing-library/api#debug)

lib/create-testing-library-rule/detect-testing-library-utils.ts

@@ -80,6 +80,10 @@ type IsRenderVariableDeclaratorFn = (
   node: TSESTree.VariableDeclarator
 ) => boolean;
 type IsDebugUtilFn = (identifierNode: TSESTree.Identifier) => boolean;
+type IsOneOfDebugUtils = (
+  identifierNode: TSESTree.Identifier,
+  names: string[]
+) => boolean;
 type IsPresenceAssertFn = (node: TSESTree.MemberExpression) => boolean;
 type IsAbsenceAssertFn = (node: TSESTree.MemberExpression) => boolean;
 type CanReportErrorsFn = () => boolean;
@@ -112,6 +116,7 @@ export interface DetectionHelpers {
   isRenderUtil: IsRenderUtilFn;
   isRenderVariableDeclarator: IsRenderVariableDeclaratorFn;
   isDebugUtil: IsDebugUtilFn;
+  isOneOfDebugUtils: IsOneOfDebugUtils;
   isPresenceAssert: IsPresenceAssertFn;
   isAbsenceAssert: IsAbsenceAssertFn;
   canReportErrors: CanReportErrorsFn;
@@ -595,6 +600,26 @@ export function detectTestingLibraryUtils<
       return isRenderUtil(initIdentifierNode);
     };
 
+    const isOneOfDebugUtils: IsOneOfDebugUtils = (
+      identifierNode,
+      names: string[]
+    ) => {
+      const isBuiltInConsole =
+        isMemberExpression(identifierNode.parent) &&
+        ASTUtils.isIdentifier(identifierNode.parent.object) &&
+        identifierNode.parent.object.name === 'console';
+
+      return (
+        !isBuiltInConsole &&
+        isTestingLibraryUtil(
+          identifierNode,
+          (identifierNodeName, originalNodeName) => {
+            return names.includes(originalNodeName || identifierNodeName);
+          }
+        )
+      );
+    };
+
     const isDebugUtil: IsDebugUtilFn = (identifierNode) => {
       const isBuiltInConsole =
         isMemberExpression(identifierNode.parent) &&
@@ -807,6 +832,7 @@ export function detectTestingLibraryUtils<
       isRenderUtil,
       isRenderVariableDeclarator,
       isDebugUtil,
+      isOneOfDebugUtils,
       isPresenceAssert,
       isAbsenceAssert,
       canReportErrors,

lib/rules/no-debug.ts

@@ -13,7 +13,7 @@ import { ASTUtils, TSESTree } from '@typescript-eslint/experimental-utils';
 
 export const RULE_NAME = 'no-debug';
 export type MessageIds = 'noDebug';
-type Options = [];
+type Options = [{ utilNames: string[] }];
 
 export default createTestingLibraryRule<Options, MessageIds>({
   name: RULE_NAME,
@@ -32,11 +32,22 @@ export default createTestingLibraryRule<Options, MessageIds>({
     messages: {
       noDebug: 'Unexpected debug statement',
     },
-    schema: [],
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          utilNames: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
   },
-  defaultOptions: [],
+  defaultOptions: [{ utilNames: ['debug'] }],
 
-  create(context, [], helpers) {
+  create(context, [{ utilNames }], helpers) {
     const suspiciousDebugVariableNames: string[] = [];
     const suspiciousReferenceNodes: TSESTree.Identifier[] = [];
     const renderWrapperNames: string[] = [];
@@ -84,7 +95,7 @@ export default createTestingLibraryRule<Options, MessageIds>({
             if (
               isProperty(property) &&
               ASTUtils.isIdentifier(property.key) &&
-              property.key.name === 'debug'
+              utilNames.includes(property.key.name)
             ) {
               const identifierNode = getDeepestIdentifierNode(property.value);
 
@@ -119,14 +130,17 @@ export default createTestingLibraryRule<Options, MessageIds>({
           return;
         }
 
-        const isDebugUtil = helpers.isDebugUtil(callExpressionIdentifier);
+        const isDebugUtil = helpers.isOneOfDebugUtils(
+          callExpressionIdentifier,
+          utilNames
+        );
         const isDeclaredDebugVariable = suspiciousDebugVariableNames.includes(
           callExpressionIdentifier.name
         );
         const isChainedReferenceDebug = suspiciousReferenceNodes.some(
           (suspiciousReferenceIdentifier) => {
             return (
-              callExpressionIdentifier.name === 'debug' &&
+              utilNames.includes(callExpressionIdentifier.name) &&
               suspiciousReferenceIdentifier.name === referenceIdentifier.name
             );
           }

tests/lib/rules/no-debug.test.ts

@@ -87,6 +87,19 @@ ruleTester.run(RULE_NAME, rule, {
         screen.debug
       `,
     },
+    {
+      code: `
+        import { screen } from '@testing-library/dom'
+        screen.logTestingPlaygroundURL()
+      `,
+    },
+    {
+      code: `
+        import { screen } from '@testing-library/dom'
+        screen.debug()
+      `,
+      options: [{ utilNames: ['anotherUtil'] }],
+    },
     {
       code: `const { queries } = require('@testing-library/dom')`,
     },
@@ -419,6 +432,20 @@ ruleTester.run(RULE_NAME, rule, {
         },
       ],
     },
+    {
+      code: `
+        import { screen } from '@testing-library/dom'
+        screen.logTestingPlaygroundURL()
+      `,
+      options: [{ utilNames: ['logTestingPlaygroundURL'] }],
+      errors: [
+        {
+          line: 3,
+          column: 16,
+          messageId: 'noDebug',
+        },
+      ],
+    },
     {
       settings: { 'testing-library/utils-module': 'test-utils' },
       code: `// aggressive reporting disabled