@e2e-dev/github 0.3.2 → 0.3.3

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.3.2"}
+{"version":"0.3.3"}

package/dist/merge.d.ts

@@ -11,13 +11,19 @@ import type { Report } from 'e2e';
 /**
  * The rerun folded into the run it selected from. A result the rerun has
  * under the same id is folded with it; a test the rerun left out keeps what
- * the run before said. Results the rerun has no id for at all, the further
+ * the run before said, or what the rerun carries for it when an earlier run
+ * left it owed (`run.carried`), and so do the serial groups those results'
+ * attempts live on. Results the rerun has no id for at all, the further
  * repeats of a `--repeat-each` first pass a plain rerun ran once, fold into
  * the rerun's first result of that test, or stay as carried rows when the
  * rerun left the test out. A run before of another project leaves the rerun
  * as it is. The outcome is the rerun's unless a carried result failed, as a
- * test another filter kept out of the rerun can have: then the page is red,
- * since it lists a failure. The start is the run before's, so the footer's
- * duration spans both.
+ * test another filter kept out of the rerun can have, or the rerun carries
+ * a test it owed and never ran, a failure limit's skip among them, or a
+ * suite hook failure whose scope it did not run again (`run.carried`). Then
+ * the page is red, since the suite is not known to pass. A carried test the
+ * first pass interrupted reached no verdict: it leaves the outcome alone and
+ * the page reads interrupted, not green. The start is the run before's, so
+ * the footer's duration spans both.
  */
 export declare function foldLastRun(current: Report, lastRun: Report): Report;

package/dist/merge.js

@@ -7,8 +7,8 @@
  * passed reads as flaky with both runs' attempts. Rendering only: nothing
  * here is written back to a report file.
  */
-/** Statuses that count as a failure of the run, the ones `--last-failed` runs again. */
-const FAILED_STATUSES = new Set(['failed', 'timed-out', 'interrupted']);
+/** Statuses that count as a failure of the run. `--last-failed` also runs an interrupted test again, but that one reached no verdict. */
+const FAILED_STATUSES = new Set(['failed', 'timed-out']);
 /**
  * A test per target and agent, whatever its `--repeat-each` run: the identity
  * `--last-failed` selects by, so a rerun without the flag runs once a test any
@@ -20,14 +20,16 @@ function testKey(result) {
 /**
  * The rerun's result with the run before's attempts in front of its own:
  * the same test's result there, and the further repeats the rerun has no
- * result of its own for. A pass after a failure there is flaky.
+ * result of its own for. A pass after a failure there is flaky; an
+ * interrupted rerun of a test that failed there keeps that failure.
  */
 function foldRerun(current, history) {
     if (history.length === 0)
         return current;
     const before = history.toSorted((a, b) => a.repeat - b.repeat);
     const attempts = [...before.flatMap((result) => result.attempts), ...current.attempts];
-    const status = current.status === 'passed' && before.some((result) => FAILED_STATUSES.has(result.status)) ? 'flaky' : current.status;
+    const failure = before.findLast((result) => FAILED_STATUSES.has(result.status));
+    const status = failure === undefined ? current.status : current.status === 'passed' ? 'flaky' : current.status === 'interrupted' ? failure.status : current.status;
     return { ...current, status, attempts };
 }
 /**
@@ -41,18 +43,21 @@ function foldGroup(current, before) {
     const attempts = [...before.attempts, ...current.attempts].map((attempt, index) => ({ ...attempt, index }));
     return { ...current, attempts };
 }
-/** The counts the way the runner tallies them, over the folded results. */
+/** The counts the way the runner tallies them, over the folded results: the status counts are over the selected ones. */
 function summarize(results, base) {
-    const summary = { ...base, discovered: results.length, selected: 0, executed: 0, passed: 0, failed: 0, flaky: 0, skipped: 0 };
+    const summary = { ...base, discovered: results.length, selected: 0, executed: 0, passed: 0, failed: 0, interrupted: 0, flaky: 0, skipped: 0 };
     for (const result of results) {
-        if (result.selected)
-            summary.selected += 1;
         if (result.attempts.length > 0 || (result.serialGroupId !== undefined && result.status !== 'skipped'))
             summary.executed += 1;
+        if (!result.selected)
+            continue;
+        summary.selected += 1;
         if (result.status === 'passed')
             summary.passed += 1;
         else if (result.status === 'flaky')
             summary.flaky += 1;
+        else if (result.status === 'interrupted')
+            summary.interrupted += 1;
         else if (FAILED_STATUSES.has(result.status))
             summary.failed += 1;
         else
@@ -63,22 +68,32 @@ function summarize(results, base) {
 /**
  * The rerun folded into the run it selected from. A result the rerun has
  * under the same id is folded with it; a test the rerun left out keeps what
- * the run before said. Results the rerun has no id for at all, the further
+ * the run before said, or what the rerun carries for it when an earlier run
+ * left it owed (`run.carried`), and so do the serial groups those results'
+ * attempts live on. Results the rerun has no id for at all, the further
  * repeats of a `--repeat-each` first pass a plain rerun ran once, fold into
  * the rerun's first result of that test, or stay as carried rows when the
  * rerun left the test out. A run before of another project leaves the rerun
  * as it is. The outcome is the rerun's unless a carried result failed, as a
- * test another filter kept out of the rerun can have: then the page is red,
- * since it lists a failure. The start is the run before's, so the footer's
- * duration spans both.
+ * test another filter kept out of the rerun can have, or the rerun carries
+ * a test it owed and never ran, a failure limit's skip among them, or a
+ * suite hook failure whose scope it did not run again (`run.carried`). Then
+ * the page is red, since the suite is not known to pass. A carried test the
+ * first pass interrupted reached no verdict: it leaves the outcome alone and
+ * the page reads interrupted, not green. The start is the run before's, so
+ * the footer's duration spans both.
  */
 export function foldLastRun(current, lastRun) {
     if (lastRun.run.project.id !== current.run.project.id)
         return current;
+    const carried = current.run.carried;
+    const carriedById = new Map((carried?.results ?? []).map((result) => [result.id, result]));
     const currentIds = new Set(current.run.results.map((result) => result.id));
-    const beforeById = new Map(lastRun.run.results.map((result) => [result.id, result]));
+    // The run before's own carried rows stand for the tests it left out, over their filtered rows.
+    const before = [...lastRun.run.results, ...(lastRun.run.carried?.results ?? [])];
+    const beforeById = new Map(before.map((result) => [result.id, result]));
     const leftovers = new Map();
-    for (const result of lastRun.run.results) {
+    for (const result of beforeById.values()) {
         if (currentIds.has(result.id))
             continue;
         const key = testKey(result);
@@ -91,26 +106,31 @@ export function foldLastRun(current, lastRun) {
     }
     const results = [];
     for (const result of current.run.results) {
-        const before = beforeById.get(result.id);
+        const previous = beforeById.get(result.id);
         if (!result.selected) {
-            results.push(before ?? result);
+            results.push(carriedById.get(result.id) ?? previous ?? result);
             continue;
         }
         const key = testKey(result);
         const extra = firstOfKey.get(key) === result.id ? (leftovers.get(key) ?? []) : [];
         if (extra.length > 0)
             leftovers.delete(key);
-        results.push(foldRerun(result, before === undefined ? extra : [before, ...extra]));
+        results.push(foldRerun(result, previous === undefined ? extra : [previous, ...extra]));
     }
     for (const extra of leftovers.values())
         results.push(...extra);
-    const beforeGroups = new Map(lastRun.run.serialGroups.map((group) => [group.id, group]));
+    const beforeGroups = new Map([...lastRun.run.serialGroups, ...(lastRun.run.carried?.serialGroups ?? [])].map((group) => [group.id, group]));
     const currentGroupIds = new Set(current.run.serialGroups.map((group) => group.id));
+    const carriedGroups = (carried?.serialGroups ?? []).filter((group) => !currentGroupIds.has(group.id) && !beforeGroups.has(group.id));
     const serialGroups = [
-        ...lastRun.run.serialGroups.filter((group) => !currentGroupIds.has(group.id)),
+        ...[...beforeGroups.values()].filter((group) => !currentGroupIds.has(group.id)),
+        ...carriedGroups,
         ...current.run.serialGroups.map((group) => foldGroup(group, beforeGroups.get(group.id))),
     ];
-    const carriedFailure = results.some((result) => result.selected && FAILED_STATUSES.has(result.status));
+    const carriedErrors = carried?.errors ?? [];
+    const carriedFailure = carriedErrors.length > 0 ||
+        [...carriedById.values()].some((result) => result.status !== 'interrupted') ||
+        results.some((result) => result.selected && FAILED_STATUSES.has(result.status));
     return {
         ...current,
         run: {
@@ -120,6 +140,7 @@ export function foldLastRun(current, lastRun) {
             startedAt: lastRun.run.startedAt,
             serialGroups,
             results,
+            errors: [...current.run.errors, ...carriedErrors],
             summary: summarize(results, current.run.summary),
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e2e-dev/github",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "GitHub reporter for e2e: one pull request comment per run, from GitHub Actions",
   "keywords": [
     "e2e",
@@ -46,7 +46,7 @@
     "e2e": ">=0.15.0 <1"
   },
   "devDependencies": {
-    "e2e": "0.16.0",
+    "e2e": "0.17.0",
     "@types/node": "26.6.2",
     "typescript": "7.0.2",
     "vitest": "5.0.1"