Files
pipelines/web/test/changes.test.mjs
T
alan b011f4ada4 web: show per-visit changes and last-visit summary
Each visit's This run pane reports its own recorded capture: the File
changes status line (with skipped/omitted counts and diagnostic) and its
Changed files list with parseable stats. The Summary aggregate now keeps
each path's last recorded step rather than summing visits, and is only
rendered for a succeeded run; a failed run keeps its evidence in the
visit panes. This is a deliberate divergence from Android, noted in R4.
2026-10-19 18:27:39 +01:00

691 lines
26 KiB
JavaScript

// Pure unit tests for the run summary's Changes section and its diff viewer:
// the kind mapping and labels, the unified-patch parser (hunks, line numbers,
// stat counts, the `\ No newline` marker and header closing), the cross-step
// final-state aggregation (last sequence wins every per-file fact, every
// touching stage retained), every header/note/detail wording variant and the
// row/viewer helpers.
// No server, no DOM.
import { test } from "node:test";
import assert from "node:assert/strict";
import {
ChangeKind,
ChangeLineKind,
BINARY_DIFF_MESSAGE,
NO_LINE_CHANGES_MESSAGE,
TRUNCATED_PATCH_NOTE,
changeEntryTags,
changeKind,
changeKindLabel,
changeKindTitle,
changePositionLabel,
changeRowMeta,
changeStat,
changesListSummary,
diffLineClass,
diffLineSymbol,
entryHasPatch,
entryModeChanged,
gutterText,
gutterWidth,
noChangeDetail,
parseUnifiedPatch,
patchUnavailableReason,
runChanges,
runChangesHeader,
runChangesNote,
showRunChangesSummary,
} from "../src/changes.js";
// A step file-change with sane defaults, overridable per test.
function file(overrides = {}) {
return { path: "a.txt", kind: "modified", patch: "", ...overrides };
}
// A run step with a file_changes capture, overridable per test.
function step(overrides = {}) {
return { stage: "s", status: "completed", sequence: 1, file_changes: null, ...overrides };
}
// ---------------------------------------------------------------------------
// Kind mapping
// ---------------------------------------------------------------------------
test("changeKind trims and lowercases, never inventing a kind", () => {
assert.equal(changeKind("added"), ChangeKind.Added);
assert.equal(changeKind(" Deleted "), ChangeKind.Deleted);
assert.equal(changeKind("MODIFIED"), ChangeKind.Modified);
assert.equal(changeKind("copied"), ChangeKind.Other);
assert.equal(changeKind(""), ChangeKind.Other);
assert.equal(changeKind(null), ChangeKind.Other);
});
test("changeKindLabel and changeKindTitle spell the app's words", () => {
assert.equal(changeKindLabel(ChangeKind.Added), "added");
assert.equal(changeKindLabel(ChangeKind.Modified), "modified");
assert.equal(changeKindLabel(ChangeKind.Deleted), "deleted");
assert.equal(changeKindLabel(ChangeKind.Other), "changed");
assert.equal(changeKindTitle(ChangeKind.Added), "Added");
assert.equal(changeKindTitle(ChangeKind.Other), "Changed");
});
// ---------------------------------------------------------------------------
// changeStat and changesListSummary
// ---------------------------------------------------------------------------
test("changeStat omits a zero side and is blank when both are zero", () => {
assert.equal(changeStat(3, 2), "+3 -2");
assert.equal(changeStat(3, 0), "+3");
assert.equal(changeStat(0, 2), "-2");
assert.equal(changeStat(0, 0), "");
});
test("changesListSummary keeps the file(s) wording and appends the stat", () => {
const one = { files: [{}], added: 2, removed: 0 };
assert.equal(changesListSummary(one), "1 file changed · +2");
assert.equal(changesListSummary({ files: [{}, {}], added: 0, removed: 0 }), "2 files changed");
});
// ---------------------------------------------------------------------------
// parseUnifiedPatch
// ---------------------------------------------------------------------------
test("parseUnifiedPatch treats a blank patch as an empty diff", () => {
for (const blank of ["", " ", "\n", null, undefined]) {
assert.deepEqual(parseUnifiedPatch(blank), {
raw: "",
headerLines: [],
hunks: [],
added: 0,
removed: 0,
});
}
});
test("parseUnifiedPatch numbers a single hunk and counts the body", () => {
const patch = [
"--- a/x.txt",
"+++ b/x.txt",
"@@ -1,3 +1,3 @@",
" ctx",
"-old",
"+new",
" tail",
].join("\n");
const parsed = parseUnifiedPatch(patch);
assert.equal(parsed.raw, patch);
assert.deepEqual(parsed.headerLines, ["--- a/x.txt", "+++ b/x.txt"]);
assert.equal(parsed.hunks.length, 1);
const hunk = parsed.hunks[0];
assert.equal(hunk.header, "@@ -1,3 +1,3 @@");
assert.deepEqual([hunk.oldStart, hunk.oldCount, hunk.newStart, hunk.newCount], [1, 3, 1, 3]);
assert.deepEqual(
hunk.lines.map((line) => [line.kind, line.text, line.oldLine, line.newLine]),
[
[ChangeLineKind.Context, "ctx", 1, 1],
[ChangeLineKind.Remove, "old", 2, 0],
[ChangeLineKind.Add, "new", 0, 2],
[ChangeLineKind.Context, "tail", 3, 3],
],
);
assert.equal(parsed.added, 1);
assert.equal(parsed.removed, 1);
});
test("parseUnifiedPatch defaults a missing count to 1", () => {
const parsed = parseUnifiedPatch("@@ -5 +7 @@\n-old\n+new");
const hunk = parsed.hunks[0];
assert.deepEqual([hunk.oldStart, hunk.oldCount, hunk.newStart, hunk.newCount], [5, 1, 7, 1]);
assert.equal(parsed.added, 1);
assert.equal(parsed.removed, 1);
});
test("parseUnifiedPatch flags a `\\ No newline` marker without numbering it", () => {
const parsed = parseUnifiedPatch(
["@@ -1 +1 @@", "-one", "\\ No newline at end of file", "+two"].join("\n"),
);
const lines = parsed.hunks[0].lines;
assert.equal(lines[1].noNewlineMarker, true);
assert.equal(lines[1].text, "\\ No newline at end of file");
assert.equal(lines[1].oldLine, 0);
assert.equal(lines[1].newLine, 0);
assert.equal(lines[1].kind, ChangeLineKind.Context);
});
test("a `---`/`+++` header closes the current hunk instead of numbering into it", () => {
const parsed = parseUnifiedPatch(
[
"--- a/x",
"+++ b/x",
"@@ -1 +1 @@",
"-old",
"+new",
"--- a/y",
"+++ b/y",
"@@ -1 +1 @@",
"-alt",
"+neu",
].join("\n"),
);
assert.equal(parsed.hunks.length, 2);
assert.deepEqual(
parsed.hunks[0].lines.map((line) => line.text),
["old", "new"],
);
assert.deepEqual(
parsed.hunks[1].lines.map((line) => line.text),
["alt", "neu"],
);
assert.equal(parsed.headerLines.filter((line) => line.startsWith("--- ")).length, 2);
assert.equal(parsed.added, 2);
assert.equal(parsed.removed, 2);
});
test("an unrecognised tail is kept as unnumbered context and header lines before a hunk are kept", () => {
const parsed = parseUnifiedPatch(
["index abc..def 100644", "--- a/x", "+++ b/x", "@@ -1 +1 @@", "-old", "+new", "trailing junk"].join("\n"),
);
assert.equal(parsed.headerLines[0], "index abc..def 100644");
const tail = parsed.hunks[0].lines.at(-1);
assert.equal(tail.kind, ChangeLineKind.Context);
assert.equal(tail.text, "trailing junk");
assert.equal(tail.oldLine, 0);
assert.equal(tail.newLine, 0);
});
test("a trailing newline becomes a numbered empty context line", () => {
const parsed = parseUnifiedPatch("@@ -1 +1 @@\n ctx\n");
const lines = parsed.hunks[0].lines;
assert.equal(lines.length, 2);
assert.deepEqual([lines[1].text, lines[1].oldLine, lines[1].newLine], ["", 2, 2]);
});
// ---------------------------------------------------------------------------
// Aggregation
// ---------------------------------------------------------------------------
test("a null capture that is running/waiting is pending, otherwise a missing capture", () => {
const running = runChanges([step({ status: "running" }), step({ status: "waiting" })]);
assert.equal(running.pending, true);
assert.equal(running.missingCaptures, 0);
assert.equal(running.stepsWithChanges, 0);
const missing = runChanges([step({ status: "completed" }), step({ status: "failed" })]);
assert.equal(missing.pending, false);
assert.equal(missing.missingCaptures, 2);
});
test("a present capture with no files is a captured no-change", () => {
const changes = runChanges([
step({ stage: "a", file_changes: { status: "complete", files: [] } }),
]);
assert.equal(changes.stepsWithChanges, 1);
assert.deepEqual(changes.files, []);
assert.equal(changes.partial, false);
assert.equal(runChangesHeader(changes), "Changes · no changes observed");
assert.equal(noChangeDetail(changes), "The captured snapshots were identical: the workspace was unchanged.");
});
test("a later step's kind wins, including an unrecognised later kind", () => {
const changes = runChanges([
step({ stage: "a", file_changes: { status: "complete", files: [file({ path: "x", kind: "modified" })] } }),
step({ stage: "b", file_changes: { status: "complete", files: [file({ path: "x", kind: "added" })] } }),
]);
assert.equal(changes.files.length, 1);
assert.equal(changes.files[0].kind, ChangeKind.Added);
assert.deepEqual(changes.files[0].steps, ["a", "b"]);
const unknown = runChanges([
step({ stage: "a", file_changes: { status: "complete", files: [file({ path: "x", kind: "added" })] } }),
step({ stage: "b", file_changes: { status: "complete", files: [file({ path: "x", kind: "copied" })] } }),
]);
// No downgrade heuristic: the final visit recorded an unrecognised kind, so
// the row says `changed` rather than guessing from the earlier visit.
assert.equal(unknown.files[0].kind, ChangeKind.Other);
});
test("a path changed in three visits reports only the last visit's facts", () => {
const changes = runChanges([
step({
stage: "a",
sequence: 1,
file_changes: {
status: "complete",
files: [
file({
path: "x",
kind: "modified",
patch: "@@ -1 +1 @@\n-old\n+one",
before_mode: "0644",
after_mode: "0644",
}),
],
},
}),
step({
stage: "b",
sequence: 2,
file_changes: {
status: "complete",
files: [
file({
path: "x",
kind: "modified",
patch: "@@ -1 +1 @@\n-one\n+two",
before_mode: "0644",
after_mode: "0644",
}),
],
},
}),
step({
stage: "c",
sequence: 3,
file_changes: {
status: "complete",
files: [
file({
path: "x",
kind: "added",
patch: "@@ -1 +2 @@\n-two\n+three\n+four",
before_mode: "0755",
after_mode: "0600",
}),
],
},
}),
]);
const entry = changes.files[0];
assert.equal(entry.kind, ChangeKind.Added);
assert.equal(entry.added, 2);
assert.equal(entry.removed, 1);
assert.equal(entry.patch, "@@ -1 +2 @@\n-two\n+three\n+four");
assert.equal(entry.binary, false);
assert.equal(entry.truncated, false);
assert.equal(entry.beforeMode, "0755");
assert.equal(entry.afterMode, "0600");
assert.equal(entryModeChanged(entry), true);
assert.deepEqual(entry.steps, ["a", "b", "c"]);
assert.equal(changeRowMeta(entry), "changed by a → b → c · mode 0755→0600");
// The run total is the final state's stat, not the three visits summed.
assert.equal(changes.added, 2);
assert.equal(changes.removed, 1);
});
test("later binary/truncated flags and modes replace the earlier rows", () => {
const changes = runChanges([
step({
stage: "a",
file_changes: {
status: "complete",
files: [
file({
path: "x",
kind: "modified",
patch: "@@ -1 +1 @@\n-old\n+new",
binary: true,
truncated: true,
before_mode: "0644",
after_mode: "0755",
}),
],
},
}),
step({
stage: "b",
file_changes: {
status: "complete",
files: [
file({
path: "x",
kind: "modified",
patch: "",
binary: false,
truncated: false,
before_mode: "0755",
after_mode: "0755",
}),
],
},
}),
]);
const entry = changes.files[0];
assert.equal(entry.binary, false);
assert.equal(entry.truncated, false);
assert.equal(entry.patch, null);
assert.equal(entry.beforeMode, "0755");
assert.equal(entry.afterMode, "0755");
assert.equal(entryModeChanged(entry), false);
assert.equal(entry.added, 0);
assert.equal(entry.removed, 0);
// A truncated row anywhere in the run still makes the capture partial.
assert.equal(changes.partial, true);
});
test("an earlier-only path keeps its own values", () => {
const changes = runChanges([
step({
stage: "a",
file_changes: {
status: "complete",
files: [file({ path: "x", kind: "added", patch: "@@ -0,0 +1 @@\n+x" })],
},
}),
step({
stage: "b",
file_changes: {
status: "complete",
files: [file({ path: "y", kind: "deleted", patch: "@@ -1 +0,0 @@\n-y" })],
},
}),
]);
assert.deepEqual(changes.files.map((entry) => entry.path), ["x", "y"]);
assert.equal(changes.files[0].kind, ChangeKind.Added);
assert.equal(changes.files[0].added, 1);
assert.equal(changes.files[0].removed, 0);
assert.equal(changes.files[1].kind, ChangeKind.Deleted);
assert.equal(changes.files[1].added, 0);
assert.equal(changes.files[1].removed, 1);
});
test("ordering follows numeric sequence, not input order", () => {
const outOfOrder = runChanges([
step({ stage: "c", sequence: 3, file_changes: { status: "complete", files: [file({ path: "y", kind: "added" })] } }),
step({ stage: "a", sequence: 1, file_changes: { status: "complete", files: [file({ path: "y", kind: "modified" })] } }),
step({ stage: "b", sequence: 2, file_changes: { status: "complete", files: [file({ path: "x", kind: "added" })] } }),
]);
assert.deepEqual(outOfOrder.files.map((entry) => entry.path), ["y", "x"]);
const y = outOfOrder.files.find((entry) => entry.path === "y");
assert.equal(y.kind, ChangeKind.Added);
assert.deepEqual(y.steps, ["a", "c"]);
assert.equal(changeRowMeta(y), "changed by a → c");
});
test("changed-by lists the stage names in run order, deduped", () => {
const changes = runChanges([
step({ stage: "implementer", file_changes: { status: "complete", files: [file({ path: "x" })] } }),
step({ stage: "reviewer", file_changes: { status: "complete", files: [file({ path: "x" })] } }),
step({ stage: "implementer", file_changes: { status: "complete", files: [file({ path: "x" })] } }),
]);
assert.deepEqual(changes.files[0].steps, ["implementer", "reviewer"]);
assert.equal(changeRowMeta(changes.files[0]), "changed by implementer → reviewer");
});
test("a blank stage name falls back to `stage` and blank paths are skipped", () => {
const changes = runChanges([
step({ stage: " ", file_changes: { status: "complete", files: [file({ path: "x" }), file({ path: " " })] } }),
]);
assert.equal(changes.files.length, 1);
assert.deepEqual(changes.files[0].steps, ["stage"]);
});
test("partial is OR'd from the capture status, a truncated file or any omitted count", () => {
assert.equal(
runChanges([step({ file_changes: { status: "partial", files: [] } })]).partial,
true,
);
assert.equal(
runChanges([step({ file_changes: { status: "complete", files: [file({ truncated: true })] } })]).partial,
true,
);
assert.equal(
runChanges([step({ file_changes: { status: "complete", files: [], omitted: 2 } })]).partial,
true,
);
});
test("diagnostics from several captures are joined with a space, deduped", () => {
const changes = runChanges([
step({ file_changes: { status: "partial", files: [], diagnostic: "why one" } }),
step({ file_changes: { status: "partial", files: [], diagnostic: "why one" } }),
step({ file_changes: { status: "partial", files: [], diagnostic: "why two" } }),
]);
assert.equal(changes.diagnostic, "why one why two");
});
test("showRunChangesSummary is true only for a settled succeeded run", () => {
assert.equal(showRunChangesSummary("succeeded"), true);
assert.equal(showRunChangesSummary(" Succeeded "), true);
for (const status of ["failed", "running", "waiting", "canceled", "interrupted", "blocked", ""]) {
assert.equal(showRunChangesSummary(status), false, `${status} must not show an aggregate`);
}
assert.equal(showRunChangesSummary(null), false);
assert.equal(showRunChangesSummary(undefined), false);
});
// ---------------------------------------------------------------------------
// Header, note and detail wording
// ---------------------------------------------------------------------------
test("runChangesHeader covers every empty-capture variant", () => {
assert.equal(
runChangesHeader({ unavailable: true, files: [], partial: false, pending: false, stepsWithChanges: 0, missingCaptures: 0 }),
"Changes · capture unavailable",
);
assert.equal(
runChangesHeader({ unavailable: false, files: [], partial: false, pending: true, stepsWithChanges: 0, missingCaptures: 0 }),
"Changes · capture pending",
);
assert.equal(
runChangesHeader({ unavailable: false, files: [], partial: true, pending: false, stepsWithChanges: 1, missingCaptures: 0 }),
"Changes · partial capture",
);
assert.equal(
runChangesHeader({ unavailable: false, files: [], partial: false, pending: false, stepsWithChanges: 0, missingCaptures: 0 }),
"Changes · not recorded for this run",
);
assert.equal(
runChangesHeader({ unavailable: false, files: [], partial: false, pending: false, stepsWithChanges: 1, missingCaptures: 1 }),
"Changes · capture incomplete",
);
assert.equal(
runChangesHeader({ unavailable: false, files: [], partial: false, pending: false, stepsWithChanges: 2, missingCaptures: 0 }),
"Changes · no changes observed",
);
});
test("runChangesHeader counts files, omits a zero stat side and appends the caveats", () => {
const one = { unavailable: false, partial: false, pending: false, stepsWithChanges: 1, missingCaptures: 0, added: 4, removed: 0, files: [{}] };
assert.equal(runChangesHeader(one), "1 file changed · +4");
const many = { ...one, added: 0, removed: 0, files: [{}, {}] };
assert.equal(runChangesHeader(many), "2 files changed");
const partial = { ...one, partial: true, added: 4, removed: 2, files: [{}, {}] };
assert.equal(runChangesHeader(partial), "2 files changed · +4 -2 · partial capture");
const incomplete = { ...one, added: 4, removed: 2, files: [{}, {}], missingCaptures: 1 };
assert.equal(runChangesHeader(incomplete), "2 files changed · +4 -2 · capture incomplete");
});
test("runChangesNote spells the partial, missing and unavailable notes", () => {
assert.equal(
runChangesNote({ unavailable: true, diagnostic: "" }),
"The workspace snapshot could not be compared; the changes below may be incomplete.",
);
assert.equal(
runChangesNote({ unavailable: true, diagnostic: "server says so" }),
"server says so",
);
assert.equal(
runChangesNote({
unavailable: false,
partial: true,
skipped: 8,
omitted: 0,
diagnostic: "Excluded protected files.",
files: [],
missingCaptures: 1,
}),
"Partial capture: some changes may be missing. (8 files skipped) Excluded protected files. " +
"Missing capture: 1 stage did not record changes.",
);
assert.equal(
runChangesNote({
unavailable: false,
partial: true,
skipped: 0,
omitted: 3,
diagnostic: "",
files: [{ truncated: true }, { truncated: true }],
missingCaptures: 2,
}),
"Partial capture: some changes may be missing. (3 omitted, 2 truncated) " +
"Missing capture: 2 stages did not record changes.",
);
assert.equal(runChangesNote({ unavailable: false, partial: false, missingCaptures: 0 }), "");
assert.equal(
runChangesNote({ unavailable: false, partial: false, missingCaptures: 1 }),
"Missing capture: 1 stage did not record changes.",
);
});
test("noChangeDetail distinguishes pending, unavailable, not-recorded and unchanged", () => {
assert.equal(
noChangeDetail({ pending: true }),
"The capture runs after the stage finishes; nothing is recorded yet.",
);
assert.equal(
noChangeDetail({ pending: false, unavailable: true }),
"The workspace snapshot could not be compared, so no changes can be shown.",
);
assert.equal(
noChangeDetail({ pending: false, unavailable: false, stepsWithChanges: 0 }),
"This run recorded no change capture (a historical step, or a stage that does not capture).",
);
assert.equal(
noChangeDetail({ pending: false, unavailable: false, stepsWithChanges: 2 }),
"The captured snapshots were identical: the workspace was unchanged.",
);
});
test("changeEntryTags and changeRowMeta spell the tags and mode exactly", () => {
const binary = { binary: true, truncated: false, otherModeChange: true, beforeMode: "0644", afterMode: "0755", steps: ["a"] };
assert.deepEqual(changeEntryTags(binary), ["binary"]);
assert.equal(changeRowMeta(binary), "changed by a · binary");
const truncated = { binary: false, truncated: true, otherModeChange: false, steps: ["a", "b"] };
assert.deepEqual(changeEntryTags(truncated), ["truncated"]);
assert.equal(changeRowMeta(truncated), "changed by a → b · truncated");
const modeOnly = { binary: false, truncated: false, otherModeChange: true, beforeMode: "0644", afterMode: "0755", steps: ["a"] };
assert.deepEqual(changeEntryTags(modeOnly), ["mode change"]);
assert.equal(changeRowMeta(modeOnly), "changed by a · mode change · mode 0644→0755");
});
test("patchUnavailableReason names the truncation, the mode-only change, else the bare record", () => {
assert.equal(
patchUnavailableReason({ truncated: true }),
"The server truncated this file's patch at its capture limit; no diff text was recorded.",
);
assert.equal(
patchUnavailableReason({ truncated: false, otherModeChange: true, beforeMode: "0644", afterMode: "0755" }),
"Only the file's mode changed (0644→0755); the server recorded no text diff.",
);
assert.equal(
patchUnavailableReason({ truncated: false, otherModeChange: false }),
"The server recorded this change without a patch.",
);
});
test("the viewer's honest messages are the app's exact wording", () => {
assert.equal(
BINARY_DIFF_MESSAGE,
"This is a binary file: the server recorded the change but has no textual diff to show.",
);
assert.equal(
TRUNCATED_PATCH_NOTE,
"The server truncated this patch at its capture limit; the raw text is the whole record.",
);
assert.equal(NO_LINE_CHANGES_MESSAGE, "no line changes recorded");
});
// ---------------------------------------------------------------------------
// Viewer helpers
// ---------------------------------------------------------------------------
test("changePositionLabel and gutterWidth line up", () => {
assert.equal(changePositionLabel(0, 3), "1 of 3");
assert.equal(changePositionLabel(2, 3), "3 of 3");
assert.equal(gutterWidth({ lines: [] }), 1);
assert.equal(gutterWidth({ lines: [{ oldLine: 9, newLine: 0 }, { oldLine: 0, newLine: 12 }] }), 2);
assert.equal(gutterText(0, 2), " ");
assert.equal(gutterText(7, 2), " 7");
});
test("diffLineSymbol and diffLineClass are the app's one diff language", () => {
assert.equal(diffLineSymbol(ChangeLineKind.Add), "+");
assert.equal(diffLineSymbol(ChangeLineKind.Remove), "-");
assert.equal(diffLineSymbol(ChangeLineKind.Context), " ");
assert.equal(diffLineClass(ChangeLineKind.Add), "diff-add");
assert.equal(diffLineClass(ChangeLineKind.Remove), "diff-remove");
assert.equal(diffLineClass(ChangeLineKind.Context), "diff-context");
});
// ---------------------------------------------------------------------------
// A full aggregate matches the section it renders
// ---------------------------------------------------------------------------
test("runChanges derives run 438's shape: 22 files, partial, one missing capture", () => {
// Six steps, 23 recorded file rows for 22 unique paths, one step without a
// capture, every capture partial with a diagnostic.
const diag = "Excluded protected, symlinked, oversized or unreadable files; this is not a complete workspace diff.";
const patch = "@@ -1 +1 @@\n-old\n+new";
const steps = [
step({
stage: "implementer",
file_changes: {
status: "partial",
skipped: 2,
diagnostic: diag,
files: [
file({ path: "docs/notes.md", kind: "added", patch }),
file({ path: "internal/server/retry_test.go", kind: "modified", patch }),
file({ path: "internal/server/runner.go", kind: "modified", patch }),
],
},
}),
step({ stage: "reviewer", file_changes: { status: "partial", skipped: 2, diagnostic: diag, files: [] } }),
step({
stage: "implementer",
file_changes: {
status: "partial",
skipped: 2,
diagnostic: diag,
files: [file({ path: "internal/server/retry_test.go", kind: "modified", patch })],
},
}),
step({ stage: "reviewer", file_changes: { status: "partial", skipped: 2, diagnostic: diag, files: [] } }),
step({ stage: "ui_reviewer" }),
step({
stage: "committer",
file_changes: {
status: "partial",
skipped: 2,
diagnostic: diag,
files: Array.from({ length: 19 }, (_, i) => file({ path: `android/file${i}.kt`, kind: "modified", patch })),
},
}),
];
const changes = runChanges(steps);
assert.equal(changes.files.length, 22);
assert.equal(changes.stepsWithChanges, 5);
assert.equal(changes.missingCaptures, 1);
assert.equal(changes.partial, true);
assert.equal(changes.unavailable, false);
assert.equal(changes.pending, false);
assert.equal(changes.skipped, 10);
// The retry test was modified by two implementer visits; only the last one's
// stat counts (the earlier patch must not be added to it).
assert.equal(changes.files.find((f) => f.path === "internal/server/retry_test.go").added, 1);
assert.equal(changes.files.find((f) => f.path === "internal/server/retry_test.go").removed, 1);
assert.equal(changes.added, 22);
assert.equal(changes.removed, 22);
assert.equal(
runChangesHeader(changes),
`22 files changed · +22 -22 · partial capture`,
);
assert.ok(runChangesNote(changes).startsWith("Partial capture: some changes may be missing. (10 files skipped)"));
assert.ok(runChangesNote(changes).endsWith("Missing capture: 1 stage did not record changes."));
});