tewip-ai 0.17.2 → 0.17.3

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.2",
+  "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",