Files
pipelines/web/test/changes.test.mjs
T
alan 9d1745da1d web: run Summary Changes section with rendered/raw diff viewer (R4)
Add a collapsed-by-default Changes section to the run Summary tab and a
full-screen diff viewer, ported from the Android RunChanges/ChangeDiffViewer
wording. Pure aggregation and unified-patch parsing live in src/changes.js;
app.js wires the section/viewer and sets every server string with textContent.
Unit tests cover the header variants, kind merge, stat sums and hunk parsing;
ui-smoke captures the collapsed/expanded section, rendered and raw viewer,
paging, Escape/backdrop close, binary, truncated and a running run's header.
2026-10-19 04:06:44 +01:00

563 lines
21 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
// aggregation (kind merge, stat sums, binary/truncated OR, mode first/last),
// 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,
} 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("the later step wins the kind, but `other` never downgrades it", () => {
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 downgrade = 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" })] } }),
]);
assert.equal(downgrade.files[0].kind, ChangeKind.Added);
});
test("stat sums, binary/truncated OR and mode first/last-seen across steps", () => {
const changes = runChanges([
step({
stage: "a",
file_changes: {
status: "complete",
files: [
file({
path: "x",
kind: "modified",
patch: "@@ -1 +1 @@\n-old\n+new",
before_mode: "0644",
after_mode: "0644",
}),
],
},
}),
step({
stage: "b",
file_changes: {
status: "complete",
files: [
file({
path: "x",
kind: "modified",
patch: "@@ -1 +1 @@\n-gone\n+kept",
binary: true,
truncated: true,
before_mode: "0755",
after_mode: "0755",
}),
],
},
}),
]);
const entry = changes.files[0];
assert.equal(entry.added, 2);
assert.equal(entry.removed, 2);
assert.equal(entry.binary, true);
assert.equal(entry.truncated, true);
assert.equal(entry.beforeMode, "0644"); // first-seen
assert.equal(entry.afterMode, "0755"); // last-seen
assert.equal(entryModeChanged(entry), true);
assert.equal(entryHasPatch(entry), false); // binary hides the patch
assert.equal(changes.added, 2);
assert.equal(changes.removed, 2);
});
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");
});
// ---------------------------------------------------------------------------
// 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);
assert.equal(changes.files.find((f) => f.path === "internal/server/retry_test.go").added, 2);
assert.equal(
runChangesHeader(changes),
`22 files changed · +23 -23 · 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."));
});