eslint-plugin-test-flakiness 1.3.0 → 1.3.1

package/lib/rules/await-async-events.js

@@ -31,7 +31,6 @@ module.exports = {
     ],
     messages: {
       missingAwait: '{{method}} must be awaited to prevent race conditions',
-      missingAwaitFireEvent: 'fireEvent.{{method}} should be awaited',
       missingAwaitUserEvent: 'userEvent.{{method}} must be awaited',
       missingAwaitAct: 'act() with async callback must be awaited',
       missingAwaitPage: 'Playwright page.{{method}} must be awaited',
@@ -58,11 +57,6 @@ module.exports = {
       'hover', 'unhover', 'paste', 'keyboard'
     ];
     
-    const asyncFireEventMethods = [
-      'click', 'change', 'input', 'submit', 'focus', 'blur',
-      'keyDown', 'keyUp', 'keyPress', 'mouseDown', 'mouseUp'
-    ];
-    
     const asyncPageMethods = [
       'click', 'fill', 'type', 'press', 'check', 'uncheck',
       'selectOption', 'setInputFiles', 'focus', 'hover', 'tap',
@@ -144,32 +138,6 @@ module.exports = {
       }
     }
 
-    function checkFireEvent(node) {
-      if (node.callee.type === 'MemberExpression' &&
-          node.callee.object.name === 'fireEvent') {
-        
-        const methodName = node.callee.property.name;
-        if (asyncFireEventMethods.includes(methodName) && 
-            !isPromiseHandled(node)) {
-          
-          context.report({
-            node,
-            messageId: 'missingAwaitFireEvent',
-            data: { method: methodName },
-            fix(fixer) {
-              const funcNode = findEnclosingFunction(node);
-              const asyncFixes = ensureAsyncFunction(fixer, funcNode);
-              if (asyncFixes === null) return null;
-              return [
-                fixer.insertTextBefore(node, 'await '),
-                ...asyncFixes
-              ];
-            }
-          });
-        }
-      }
-    }
-
     function checkAct(node) {
       if (node.callee.name === 'act' && node.arguments[0]) {
         const callback = node.arguments[0];
@@ -309,7 +277,6 @@ module.exports = {
       },
       CallExpression(node) {
         checkUserEvent(node);
-        checkFireEvent(node);
         checkAct(node);
         checkPlaywright(node);
         checkElementMethods(node);

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

@@ -21,7 +21,10 @@ module.exports = {
       avoidRemovalCheck: 'Checking for element removal can be flaky. Use waitForElementToBeRemoved or wait for a positive condition instead.',
       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.'
+      avoidNotVisibleWithoutWaitFor: 'Avoid .not.toBeVisible() without proper waiting. Wrap in waitFor() to handle timing.',
+      avoidNotInDocumentNoEvidence: 'Element absence check without prior presence evidence. If the element was removed by an action, wrap in waitFor().',
+      useWaitForRemovalNoEvidence: 'Element null/undefined check without prior presence evidence. If the element was removed by an action, wrap in waitFor().',
+      avoidNotVisibleNoEvidence: 'Element not-visible check without prior presence evidence. If the element was hidden by an action, wrap in waitFor().'
     }
   },
 
@@ -45,6 +48,129 @@ module.exports = {
       return false;
     }
 
+    /**
+     * Find the enclosing it()/test() block body as an array of statements.
+     */
+    function findTestBody(node) {
+      let current = node.parent;
+      while (current) {
+        if (current.type === 'CallExpression' &&
+            current.callee && current.callee.type === 'Identifier' &&
+            (current.callee.name === 'it' || current.callee.name === 'test' || current.callee.name === 'specify')) {
+          // The callback is the second argument (or first if no description)
+          const callback = current.arguments[1] || current.arguments[0];
+          if (callback && callback.body && callback.body.type === 'BlockStatement') {
+            return callback.body.body;
+          }
+        }
+        current = current.parent;
+      }
+      return null;
+    }
+
+    /**
+     * Extract the query target text from an assertion node for matching.
+     * Returns the literal string/regex argument of the query call, or null if unmatchable.
+     */
+    function extractQueryTarget(node) {
+      // Walk up to find the expect() call
+      let expectCall = null;
+      let current = node;
+      while (current) {
+        if (current.type === 'CallExpression' && current.callee && current.callee.name === 'expect') {
+          expectCall = current;
+          break;
+        }
+        if (current.type === 'MemberExpression') {
+          current = current.object;
+          continue;
+        }
+        if (current.type === 'CallExpression' && current.callee) {
+          current = current.callee;
+          continue;
+        }
+        break;
+      }
+
+      if (!expectCall || !expectCall.arguments[0]) return null;
+      const arg = expectCall.arguments[0];
+
+      // arg should be a query call: queryByText('X'), screen.queryByRole('X')
+      let queryCall = arg;
+      if (queryCall.type !== 'CallExpression') return null;
+      if (!queryCall.arguments[0]) return null;
+
+      const firstArg = queryCall.arguments[0];
+      if (firstArg.type === 'Literal' && typeof firstArg.value === 'string') {
+        return { type: 'string', value: firstArg.value };
+      }
+      if (firstArg.regex) {
+        return { type: 'regex', pattern: firstArg.regex.pattern, flags: firstArg.regex.flags };
+      }
+      return null; // unmatchable (variable, template, function call)
+    }
+
+    /**
+     * Check if a statement node contains a positive assertion or usage matching the given target.
+     */
+    function statementMatchesTarget(stmt, target) {
+      const sourceCode = context.getSourceCode();
+      const stmtText = sourceCode.getText(stmt);
+
+      // Check for positive assertions: getByText('X'), getByRole('X'), etc.
+      // or expect(getByText('X')).toBeInTheDocument()
+      if (target.type === 'string') {
+        // Look for getBy/findBy calls with the same string argument
+        const escapedValue = target.value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const pattern = new RegExp(`(?:getBy|findBy)\\w+\\s*\\(\\s*['"]${escapedValue}['"]`);
+        return pattern.test(stmtText);
+      }
+      if (target.type === 'regex') {
+        const pattern = new RegExp(`(?:getBy|findBy)\\w+\\s*\\(\\s*/${target.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/${target.flags}`);
+        return pattern.test(stmtText);
+      }
+      return false;
+    }
+
+    /**
+     * Check if there is evidence that an element was present and then removed.
+     * Evidence = prior userEvent interaction + (optional) prior positive assertion on the same target.
+     * fireEvent is sync so it's NOT evidence (element removed synchronously).
+     */
+    function hasRemovalEvidence(node) {
+      const testBody = findTestBody(node);
+      if (!testBody) return false;
+
+      const target = extractQueryTarget(node);
+
+      // Find the index of the current statement in the test body
+      let currentStmt = node;
+      while (currentStmt && currentStmt.parent && currentStmt.parent.type !== 'BlockStatement') {
+        currentStmt = currentStmt.parent;
+      }
+      const currentIndex = testBody.indexOf(currentStmt);
+      if (currentIndex === -1) return false; // Node not found in this block
+      if (currentIndex === 0) return false;  // First statement — no prior evidence possible
+
+      const sourceCode = context.getSourceCode();
+      let hasUserEvent = false;
+      let hasPositiveAssertion = false;
+
+      for (let i = 0; i < currentIndex; i++) {
+        const stmtText = sourceCode.getText(testBody[i]);
+        if (/userEvent\.\w+\s*\(/.test(stmtText)) {
+          hasUserEvent = true;
+        }
+        if (target && statementMatchesTarget(testBody[i], target)) {
+          hasPositiveAssertion = true;
+        }
+      }
+
+      // Evidence: userEvent interaction + either matchable target with positive assertion, or unmatchable target
+      if (hasUserEvent && (!target || hasPositiveAssertion)) return true;
+      return false;
+    }
+
     function createWaitForFix(node) {
       return function(fixer) {
         const sourceCode = context.getSourceCode();
@@ -85,11 +211,18 @@ module.exports = {
             expectCall.property.name === 'not') {
 
           if (!isInsideWaitFor(node)) {
-            context.report({
-              node,
-              messageId: 'avoidNotInDocument',
-              fix: createWaitForFix(node)
-            });
+            if (hasRemovalEvidence(node)) {
+              context.report({
+                node,
+                messageId: 'avoidNotInDocument',
+                fix: createWaitForFix(node)
+              });
+            } else {
+              context.report({
+                node,
+                messageId: 'avoidNotInDocumentNoEvidence'
+              });
+            }
           }
         }
       }
@@ -123,11 +256,18 @@ module.exports = {
                                    (/^query/.test(arg.callee.property.name) || arg.callee.property.name === 'querySelector');
 
             if ((isQueryMethod || isScreenQuery || isContainerQuery) && !isInsideWaitFor(node)) {
-              context.report({
-                node,
-                messageId: 'useWaitForRemoval',
-                fix: createWaitForFix(node)
-              });
+              if (hasRemovalEvidence(node)) {
+                context.report({
+                  node,
+                  messageId: 'useWaitForRemoval',
+                  fix: createWaitForFix(node)
+                });
+              } else {
+                context.report({
+                  node,
+                  messageId: 'useWaitForRemovalNoEvidence'
+                });
+              }
             }
           }
         }
@@ -161,11 +301,18 @@ module.exports = {
                                   /^query/.test(arg.callee.property.name);
 
               if ((isQueryMethod || isScreenQuery) && !isInsideWaitFor(node)) {
-                context.report({
-                  node,
-                  messageId: 'useWaitForRemoval',
-                  fix: createWaitForFix(node)
-                });
+                if (hasRemovalEvidence(node)) {
+                  context.report({
+                    node,
+                    messageId: 'useWaitForRemoval',
+                    fix: createWaitForFix(node)
+                  });
+                } else {
+                  context.report({
+                    node,
+                    messageId: 'useWaitForRemovalNoEvidence'
+                  });
+                }
               }
             }
           }
@@ -187,10 +334,17 @@ module.exports = {
                           (nonNullSide.callee.property && nonNullSide.callee.property.name);
 
           if (queryName && /^query/.test(queryName)) {
-            context.report({
-              node,
-              messageId: 'useWaitForRemoval'
-            });
+            if (hasRemovalEvidence(node)) {
+              context.report({
+                node,
+                messageId: 'useWaitForRemoval'
+              });
+            } else {
+              context.report({
+                node,
+                messageId: 'useWaitForRemovalNoEvidence'
+              });
+            }
           }
         }
       }
@@ -206,11 +360,18 @@ module.exports = {
             expectCall.property.name === 'not') {
 
           if (!isInsideWaitFor(node)) {
-            context.report({
-              node,
-              messageId: 'avoidNotVisibleWithoutWaitFor',
-              fix: createWaitForFix(node)
-            });
+            if (hasRemovalEvidence(node)) {
+              context.report({
+                node,
+                messageId: 'avoidNotVisibleWithoutWaitFor',
+                fix: createWaitForFix(node)
+              });
+            } else {
+              context.report({
+                node,
+                messageId: 'avoidNotVisibleNoEvidence'
+              });
+            }
           }
         }
       }

package/lib/rules/no-immediate-assertions.js

@@ -4,7 +4,7 @@
  */
 'use strict';
 
-const { isTestFile, findEnclosingFunction, ensureAsyncFunction, addWaitForImport, getTestFramework } = require('../utils/helpers');
+const { isTestFile, getFilename, findEnclosingFunction, ensureAsyncFunction, addWaitForImport, getTestFramework } = require('../utils/helpers');
 
 module.exports = {
   meta: {
@@ -49,7 +49,7 @@ module.exports = {
   },
 
   create(context) {
-    if (!isTestFile(context.getFilename())) {
+    if (!isTestFile(getFilename(context))) {
       return {};
     }
 
@@ -61,10 +61,31 @@ module.exports = {
 
     const stateChangingPatterns = [
       'setState', 'setProps', 'dispatch', 'commit',
-      'click', 'type', 'change', 'submit', 'fireEvent',
+      'click', 'type', 'change', 'submit',
       'userEvent', 'simulate', 'trigger'
     ];
 
+    /**
+     * Returns true when the node is a fireEvent.* call (synchronous action).
+     * fireEvent is sync — React Testing Library flushes synchronously within act(),
+     * so assertions immediately after fireEvent are correct as-is.
+     */
+    function isSyncFireEvent(node) {
+      // Unwrap `await fireEvent.click()` — still a sync fireEvent even if mistakenly awaited
+      const target = node.type === 'AwaitExpression' ? node.argument : node;
+      if (!target || target.type !== 'CallExpression') return false;
+      const callee = target.callee;
+      // fireEvent.click(...), fireEvent.change(...), etc.
+      if (callee.type === 'MemberExpression' && callee.object && callee.object.name === 'fireEvent') {
+        return true;
+      }
+      // Direct fireEvent(...) call
+      if (callee.type === 'Identifier' && callee.name === 'fireEvent') {
+        return true;
+      }
+      return false;
+    }
+
     function isStateChangingAction(node) {
       if (node.type !== 'CallExpression') return false;
 
@@ -174,6 +195,11 @@ module.exports = {
       if (node.type === 'ExpressionStatement' &&
           isStateChangingAction(node.expression)) {
 
+        // Skip fireEvent — it's synchronous, assertions after it are fine
+        if (isSyncFireEvent(node.expression)) {
+          return;
+        }
+
         // Check the next statement
         const nextStatement = statements[currentIndex + 1];
         if (nextStatement &&
@@ -283,6 +309,11 @@ module.exports = {
           if (isStateChangingAction(expressions[i]) &&
               isExpectCall(expressions[i + 1])) {
 
+            // Skip fireEvent — synchronous action
+            if (isSyncFireEvent(expressions[i])) {
+              continue;
+            }
+
             // Skip if requireWaitFor is false
             if (!requireWaitFor) {
               continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-test-flakiness",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "ESLint plugin to detect flaky test patterns and suggest fixes",
   "keywords": [
     "eslint",