tewip-ai 0.17.1 → 0.17.3

package/dist/engine/autofix/locate.js

@@ -82,4 +82,4 @@ export function hasAssertionAfter(source, line) {
  * fixed-wait removals were refused as "nothing is asserted after the wait" when the very next line
  * was an assertion, which is how this was found. Python's bare `assert` counts for the same reason.
  */
-const ASSERTION = /\bexpect\s*\(|\.should\s*\(|\bassert\s+|\bassertThat\s*\(/;
+const ASSERTION = /\bexpect\s*\(|\.should\s*\(|\bassert\s*[.(]|\bassert\s+|\bassertThat\s*\(/;

package/dist/engine/autofix/wait-candidates.js

@@ -19,6 +19,10 @@
 // else Tewip must name something to wait for, or refuse.
 /** A step that waits by itself, so a fixed wait in front of it only adds time. */
 export function nextStepRetries(line, framework) {
+    // A step that is itself a wait needs no framework behind it: `await waitFor(() => ready)` blocks
+    // until the condition holds, so a fixed sleep in front of it is pure delay whatever the stack.
+    if (SELF_WAITING.test(line))
+        return true;
     if (framework === 'cypress') {
         // Every cy.* query retries until it resolves, except cy.wait itself.
         return /\bcy\.(?!wait\b)\w+\s*\(/.test(line);
@@ -38,7 +42,7 @@ export function nextStepRetries(line, framework) {
     // An action on a locator waits for that element to be actionable first.
     return ACTION_ON_LOCATOR.test(line);
 }
-const SELF_WAITING = /\.\s*waitFor(?:Selector|URL|LoadState|Function|Event|Response|Request|Navigation)?\s*\(|\.\s*goto\s*\(/;
+const SELF_WAITING = /\.\s*waitFor(?:Selector|URL|LoadState|Function|Event|Response|Request|Navigation)?\s*\(|\.\s*goto\s*\(|\b(?:waitFor|waitUntil|wait_for|waitForCondition|until)\w*\s*\(/;
 const LOCATOR_EXPRESSION = /(?:page|frame|component|[\w$]+)\s*\.\s*(?:getBy\w+|locator|frameLocator)\s*\(|^\s*[\w$]+\s*$/;
 const ACTION_ON_LOCATOR = /(?:getBy\w+\([^;]*?\)|locator\([^;]*?\))(?:\s*\.\s*\w+\([^;]*?\))*?\s*\.\s*(?:click|fill|press|check|uncheck|selectOption|hover|type|tap|dragTo|setInputFiles|focus)\s*\(/;
 /**

package/dist/engine/import/junit.js

@@ -47,7 +47,37 @@ function relativeFile(file, workspace) {
         return f.slice(ws.length);
     return f;
 }
+/**
+ * Does this report come from a run that re-ran tests? Either the runner said so with a rerun
+ * element, or some test in it is written twice with a failure recorded - both of which pytest's
+ * rerun plugin does and an ordinary passing run never does.
+ */
+function looksLikeReruns(root) {
+    let rerunElements = false;
+    let failureSeen = false;
+    const names = new Set();
+    let duplicateWithFailure = false;
+    const walk = (node) => {
+        for (const child of node.children) {
+            if (child.name === 'testcase') {
+                const key = `${child.attrs.classname ?? ''}::${child.attrs.name ?? ''}`;
+                const failed = child.children.some((c) => FAILURE.has(c.name));
+                if (child.children.some((c) => RETRY_FAILURE.has(c.name)))
+                    rerunElements = true;
+                if (failed)
+                    failureSeen = true;
+                if (names.has(key) && failureSeen)
+                    duplicateWithFailure = true;
+                names.add(key);
+            }
+            walk(child);
+        }
+    };
+    walk(root);
+    return rerunElements || duplicateWithFailure;
+}
 function junitCases(root, workspace) {
+    const rerunning = looksLikeReruns(root);
     const out = [];
     const walk = (e, suite) => {
         for (const c of e.children) {
@@ -70,10 +100,16 @@ function junitCases(root, workspace) {
         const previous = out.at(-1);
         if (previous?.testId === testId) {
             // Rerun plugins (pytest-rerunfailures and others) write every attempt as its own entry and
-            // only re-run after a failure, so an earlier entry of the same test is a failed attempt even
-            // when the plugin left its error out. Only adjacent entries are merged.
+            // only re-run after a failure, so an earlier entry of the same test can be a failed attempt
+            // whose error the plugin left out. Only adjacent entries are merged.
+            //
+            // The inference is only safe where the report shows this runner re-runs tests at all. Without
+            // that condition two adjacent entries of the same name were enough to invent a failure, and
+            // real suites produce those innocently: node:test repeats a name for a subtest and its
+            // parent, so piscina's own 152 passing tests came back as two failing ones, diagnosed as
+            // flaky. A test that passed must never be reported as having failed.
             const earlier = previous.attempts.at(-1);
-            if (!earlier.failed)
+            if (!earlier.failed && rerunning)
                 previous.attempts[previous.attempts.length - 1] = { failed: true, message: '', stack: '' };
             previous.attempts.push(...attempts);
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "description": "Tewip finds why each failing test failed - real bug, flaky test, environment, test data or changed selector - for any stack, from the command line, CI, or your editor.",
   "keywords": [
     "test-failures",