// 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.")); });