eslint-plugin-test-flakiness 1.2.0 → 1.3.0

package/lib/rules/no-element-removal-check.js

@@ -4,7 +4,7 @@
  */
 'use strict';
 
-const { isTestFile, getFilename } = require('../utils/helpers');
+const { isTestFile, getFilename, findEnclosingFunction, ensureAsyncFunction, addWaitForImport } = require('../utils/helpers');
 
 module.exports = {
   meta: {
@@ -15,11 +15,13 @@ module.exports = {
       recommended: true,
       url: 'https://github.com/tigredonorte/eslint-plugin-test-flakiness/blob/main/docs/rules/no-element-removal-check.md'
     },
+    fixable: 'code',
     schema: [],
     messages: {
       avoidRemovalCheck: 'Checking for element removal can be flaky. Use waitForElementToBeRemoved or wait for a positive condition instead.',
-      useWaitForRemoval: 'Use waitForElementToBeRemoved() instead of checking for null/undefined.',
-      avoidNotInDocument: 'Avoid .not.toBeInTheDocument() without proper waiting.'
+      useWaitForRemoval: 'Avoid checking for null/undefined without proper waiting. Wrap in waitFor() to handle timing.',
+      avoidNotInDocument: 'Avoid .not.toBeInTheDocument() without proper waiting.',
+      avoidNotVisibleWithoutWaitFor: 'Avoid .not.toBeVisible() without proper waiting. Wrap in waitFor() to handle timing.'
     }
   },
 
@@ -28,33 +30,65 @@ module.exports = {
       return {};
     }
 
+    function isInsideWaitFor(node) {
+      let parent = node.parent;
+      while (parent && parent.type !== 'Program') {
+        if (parent.type === 'CallExpression') {
+          const calleeName = parent.callee.name ||
+            (parent.callee.property && parent.callee.property.name);
+          if (calleeName === 'waitFor' || calleeName === 'waitForElementToBeRemoved') {
+            return true;
+          }
+        }
+        parent = parent.parent;
+      }
+      return false;
+    }
+
+    function createWaitForFix(node) {
+      return function(fixer) {
+        const sourceCode = context.getSourceCode();
+        // Find the containing expression statement
+        let statement = node.parent;
+        while (statement && statement.type !== 'ExpressionStatement') {
+          statement = statement.parent;
+        }
+        if (!statement || !statement.expression) return null;
+
+        const importFixes = addWaitForImport(fixer, context);
+        if (importFixes === null) return null; // Skip fix for incompatible frameworks
+
+        const funcNode = findEnclosingFunction(node);
+        const asyncFixes = ensureAsyncFunction(fixer, funcNode);
+        if (asyncFixes === null) return null; // Skip fix for getters/setters/constructors
+
+        const statementText = sourceCode.getText(statement.expression);
+
+        return [
+          fixer.replaceText(
+            statement,
+            `await waitFor(() => { ${statementText}; });`
+          ),
+          ...asyncFixes,
+          ...importFixes
+        ];
+      };
+    }
+
     function checkNotToBeInTheDocument(node) {
       // Check for expect().not.toBeInTheDocument() patterns
       if (node.callee.type === 'MemberExpression' &&
           node.callee.property.name === 'toBeInTheDocument') {
-        
+
         const expectCall = node.callee.object;
         if (expectCall.type === 'MemberExpression' &&
             expectCall.property.name === 'not') {
-          
-          // Check if it's wrapped in waitFor
-          let parent = node.parent;
-          let insideWaitFor = false;
-          
-          while (parent && parent.type !== 'Program') {
-            if (parent.type === 'CallExpression' &&
-                (parent.callee.name === 'waitFor' ||
-                 parent.callee.name === 'waitForElementToBeRemoved')) {
-              insideWaitFor = true;
-              break;
-            }
-            parent = parent.parent;
-          }
-          
-          if (!insideWaitFor) {
+
+          if (!isInsideWaitFor(node)) {
             context.report({
               node,
-              messageId: 'avoidNotInDocument'
+              messageId: 'avoidNotInDocument',
+              fix: createWaitForFix(node)
             });
           }
         }
@@ -88,10 +122,11 @@ module.exports = {
                                    arg.callee.property &&
                                    (/^query/.test(arg.callee.property.name) || arg.callee.property.name === 'querySelector');
 
-            if (isQueryMethod || isScreenQuery || isContainerQuery) {
+            if ((isQueryMethod || isScreenQuery || isContainerQuery) && !isInsideWaitFor(node)) {
               context.report({
                 node,
-                messageId: 'useWaitForRemoval'
+                messageId: 'useWaitForRemoval',
+                fix: createWaitForFix(node)
               });
             }
           }
@@ -125,10 +160,11 @@ module.exports = {
                                   arg.callee.property &&
                                   /^query/.test(arg.callee.property.name);
 
-              if (isQueryMethod || isScreenQuery) {
+              if ((isQueryMethod || isScreenQuery) && !isInsideWaitFor(node)) {
                 context.report({
                   node,
-                  messageId: 'useWaitForRemoval'
+                  messageId: 'useWaitForRemoval',
+                  fix: createWaitForFix(node)
                 });
               }
             }
@@ -169,24 +205,11 @@ module.exports = {
         if (expectCall.type === 'MemberExpression' &&
             expectCall.property.name === 'not') {
 
-          // Check if it's wrapped in waitFor
-          let parent = node.parent;
-          let insideWaitFor = false;
-
-          while (parent && parent.type !== 'Program') {
-            if (parent.type === 'CallExpression' &&
-                (parent.callee.name === 'waitFor' ||
-                 parent.callee.name === 'waitForElementToBeRemoved')) {
-              insideWaitFor = true;
-              break;
-            }
-            parent = parent.parent;
-          }
-
-          if (!insideWaitFor) {
+          if (!isInsideWaitFor(node)) {
             context.report({
               node,
-              messageId: 'avoidNotInDocument'
+              messageId: 'avoidNotVisibleWithoutWaitFor',
+              fix: createWaitForFix(node)
             });
           }
         }

package/lib/rules/no-long-text-match.js

@@ -16,6 +16,7 @@ module.exports = {
       url: 'https://github.com/tigredonorte/eslint-plugin-test-flakiness/blob/main/docs/rules/no-long-text-match.md'
     },
     fixable: null,
+    hasSuggestions: true,
     schema: [
       {
         type: 'object',
@@ -44,7 +45,9 @@ module.exports = {
       textTooLong: 'Text match of {{length}} characters is too long and brittle. Use partial matches or data-testid.',
       usePartialMatch: 'Use partial text matching or regex for long content.',
       useTestId: 'Consider using data-testid for element selection instead of text content.',
-      avoidExactMatch: 'Exact matching of long dynamic content is fragile.'
+      avoidExactMatch: 'Exact matching of long dynamic content is fragile.',
+      suggestExactFalse: 'Add { exact: false } option for partial matching.',
+      suggestUseRegex: 'Convert to regex pattern for partial matching.'
     }
   },
 
@@ -72,7 +75,43 @@ module.exports = {
       DECIMAL_NUMBERS: /\d+[.,]\d+[.,]\d+/ // Multiple decimal/comma separated numbers
     };
 
-    function checkTextContent(node, text) {
+    function createTextSuggestions(callNode, textNode, text) {
+      const suggestions = [];
+
+      // Suggestion 1: Add { exact: false }
+      if (callNode && callNode.arguments) {
+        const hasSecondArg = callNode.arguments.length > 1;
+        if (!hasSecondArg) {
+          suggestions.push({
+            messageId: 'suggestExactFalse',
+            fix(fixer) {
+              return fixer.insertTextAfter(textNode, ', { exact: false }');
+            }
+          });
+        }
+      }
+
+      // Suggestion 2: Convert to regex (use up to 3 significant words for a more targeted pattern)
+      if (textNode && textNode.type === 'Literal' && typeof textNode.value === 'string') {
+        const words = text.split(/\s+/).filter(w => w.length > 3);
+        if (words.length > 0) {
+          const keywordWords = words.slice(0, 3).map(w =>
+            w.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\//g, '\\/')
+          );
+          const keyword = keywordWords.join('\\s+');
+          suggestions.push({
+            messageId: 'suggestUseRegex',
+            fix(fixer) {
+              return fixer.replaceText(textNode, `/${keyword}/`);
+            }
+          });
+        }
+      }
+
+      return suggestions.length > 0 ? suggestions : undefined;
+    }
+
+    function checkTextContent(node, text, suggestions) {
       if (typeof text !== 'string') return;
 
       // Ignore if it's in a comment
@@ -94,14 +133,20 @@ module.exports = {
                          DYNAMIC_PATTERNS.TEMPLATE_VAR.test(text) ||
                          DYNAMIC_PATTERNS.DECIMAL_NUMBERS.test(text);
 
-        context.report({
+        const report = {
           node,
           messageId: isDynamic ? 'avoidExactMatch' : 'textTooLong',
           data: {
             length: text.length,
             maxLength: maxLength
           }
-        });
+        };
+
+        if (suggestions) {
+          report.suggest = suggestions;
+        }
+
+        context.report(report);
       }
     }
 
@@ -143,7 +188,7 @@ module.exports = {
 
           if (arg && arg.type === 'Literal') {
             if (typeof arg.value === 'string') {
-              checkTextContent(arg, arg.value);
+              checkTextContent(arg, arg.value, createTextSuggestions(node, arg, arg.value));
             } else if (arg.regex) {
               // For regex literals, check the pattern length
               const patternLength = arg.regex.pattern.length;
@@ -202,7 +247,7 @@ module.exports = {
 
           if (arg && arg.type === 'Literal') {
             if (typeof arg.value === 'string') {
-              checkTextContent(arg, arg.value);
+              checkTextContent(arg, arg.value, createTextSuggestions(node, arg, arg.value));
             } else if (arg.regex) {
               // For regex literals, check the pattern length
               const patternLength = arg.regex.pattern.length;
@@ -258,7 +303,7 @@ module.exports = {
 
           if (arg && arg.type === 'Literal') {
             if (typeof arg.value === 'string') {
-              checkTextContent(arg, arg.value);
+              checkTextContent(arg, arg.value, createTextSuggestions(node, arg, arg.value));
             } else if (arg.regex) {
               // For regex literals, check the pattern length
               const patternLength = arg.regex.pattern.length;

package/lib/utils/helpers.js

@@ -540,9 +540,39 @@ function addWaitForImport(fixer, context) {
     }
   }
 
-  // No suitable import found — add a new one at the top of the file
+  // Try to augment an existing @testing-library require that actually exports waitFor
+  if (ast && ast.body) {
+    for (const node of ast.body) {
+      if (node.type === 'VariableDeclaration') {
+        for (const decl of node.declarations) {
+          if (!decl.init) continue;
+          const init = decl.init;
+          const isRequire = init.type === 'CallExpression' && init.callee && init.callee.name === 'require';
+          if (!isRequire) continue;
+          const requireArg = init.arguments && init.arguments[0];
+          if (!requireArg || !WAITFOR_MODULES.has(requireArg.value)) continue;
+          if (decl.id.type === 'ObjectPattern' && decl.id.properties.length > 0) {
+            const lastProp = decl.id.properties[decl.id.properties.length - 1];
+            return [fixer.insertTextAfter(lastProp, ', waitFor')];
+          }
+        }
+      }
+    }
+  }
+
+  // No suitable import/require found — add a new one at the top of the file.
+  // Default to @testing-library/react since it's the most common testing-library package.
+  // Detect CJS by looking for top-level require() calls; default to ESM otherwise.
   const firstNode = ast && ast.body && ast.body[0];
   if (firstNode) {
+    const isCJS = ast.body.some(n =>
+      n.type === 'VariableDeclaration' && n.declarations.some(d =>
+        d.init && d.init.type === 'CallExpression' && d.init.callee && d.init.callee.name === 'require'
+      )
+    );
+    if (isCJS) {
+      return [fixer.insertTextBefore(firstNode, 'const { waitFor } = require(\'@testing-library/react\');\n')];
+    }
     return [fixer.insertTextBefore(firstNode, 'import { waitFor } from \'@testing-library/react\';\n')];
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-test-flakiness",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "ESLint plugin to detect flaky test patterns and suggest fixes",
   "keywords": [
     "eslint",
@@ -27,6 +27,9 @@
     "test:coverage": "jest --coverage",
     "test:ci": "jest --ci --coverage --maxWorkers=2",
     "lint": "eslint .",
+    "dev:check": "bash scripts/dev-lint.sh --main && bash scripts/dev-test.sh --main",
+    "dev:lint": "bash scripts/dev-lint.sh",
+    "dev:test": "bash scripts/dev-test.sh",
     "lint:fix": "eslint . --fix",
     "lint:markdown": "npx markdownlint-cli '**/*.md' '.github/**/*.md' --ignore node_modules --config .markdownlintrc.json",
     "lint:markdown:fix": "npx markdownlint-cli '**/*.md' '.github/**/*.md' --ignore node_modules --config .markdownlintrc.json --fix",