magus-cli 0.0.0-placeholder → 7.1.0

package/src/__tests__/cli-update-view.test.ts

@@ -0,0 +1,524 @@
+/**
+ * Tests for the `magus update` report.
+ *
+ * These assert the things a screenshot cannot: that every row lines up at every
+ * data shape, that turning colour off leaves a report someone can still read,
+ * and that no bar lies about what it measures.
+ *
+ * The alignment tests exist because the old report built each row with string
+ * concatenation and `String.padEnd`, which counts escape bytes as columns. Add
+ * one colour to one cell and every column below it shifts — invisible to a
+ * character-level assertion, obvious and ugly on screen.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { setColorEnabled, stripAnsi, width } from "../cli/ansi.js";
+import {
+	type ApplyState,
+	type Step,
+	applyFrame,
+	applyRow,
+	header,
+	nothingToApplyNotice,
+	planReport,
+	stepFrame,
+	stepRecord,
+	summaryLine,
+	uncheckedGateNotice,
+	unknownToolsNotice,
+} from "../cli/update-view.js";
+import type { UpdatePlan } from "../services/update-plan.js";
+
+afterEach(() => setColorEnabled(null));
+
+// -- fixtures -----------------------------------------------------------------
+
+function plan(over: Partial<UpdatePlan> = {}): UpdatePlan {
+	return {
+		profileId: "default",
+		plugins: [
+			{
+				pluginId: "agentdev@magus",
+				pinned: "latest",
+				installed: "1.7.0",
+				available: "1.7.0",
+				target: null,
+				action: "current",
+				scopes: ["project"],
+			},
+			{
+				pluginId: "dev@magus",
+				pinned: "latest",
+				installed: "4.6.1",
+				available: "5.0.0",
+				target: "5.0.0",
+				action: "update",
+				scopes: ["project"],
+			},
+			{
+				pluginId: "feature-dev@claude-plugins-official",
+				pinned: "latest",
+				installed: null,
+				available: null,
+				target: null,
+				action: "install",
+				scopes: [],
+			},
+			{
+				pluginId: "designer@magus",
+				pinned: "latest",
+				installed: "1.8.0",
+				available: null,
+				target: null,
+				action: "unknown",
+				scopes: ["project"],
+				note: "catalog unreachable",
+			},
+		],
+		bins: [
+			{
+				name: "tmux-mcp",
+				action: "current",
+				reason: "at-pin",
+				version: "v1.7.1",
+				installed: "v1.7.1",
+				latest: null,
+				target: null,
+				sources: [],
+			},
+			{
+				name: "tmux",
+				action: "upgrade",
+				reason: "behind",
+				installed: "3.7b",
+				latest: "3.7c",
+				target: "3.7c",
+				note: "3.7c is available",
+				sources: [],
+			},
+		],
+		skills: [
+			{
+				name: "release",
+				action: "install",
+				ref: { name: "release", repo: "MadAppGang/magus", path: "s/SKILL.md" },
+			},
+		],
+		binSpecs: new Map([
+			["tmux-mcp", { name: "tmux-mcp", via: "bun", sources: [] }],
+			["tmux", { name: "tmux", via: "brew", formula: "tmux", sources: [] }],
+		]),
+		...over,
+	} as UpdatePlan;
+}
+
+function steps(): Step[] {
+	return [
+		{
+			label: "profile",
+			state: "done",
+			detail: "4 plugins",
+			startedAt: 0,
+			endedAt: 100,
+		},
+		{
+			label: "marketplaces",
+			state: "running",
+			detail: "pulling magus",
+			startedAt: 100,
+			progress: { done: 1, total: 4 },
+		},
+		{ label: "catalog", state: "pending", detail: "" },
+	];
+}
+
+// -- alignment ----------------------------------------------------------------
+
+describe("alignment", () => {
+	test("every plugin row shares one column layout, colour or not", () => {
+		setColorEnabled(true);
+		const rows = planReport(plan())
+			.filter((l) => /@/.test(stripAnsi(l)))
+			.map((l) => stripAnsi(l));
+		// Every row's version column starts at the same visible offset, whatever
+		// mix of badges, dim text and notes the rows carry.
+		const offsets = rows.map((r) => r.indexOf("1.") + r.indexOf("latest"));
+		expect(offsets.length).toBeGreaterThan(0);
+		const versionCol = rows.map((r) =>
+			r.search(/(1\.7\.0|4\.6\.1|latest|1\.8\.0)/),
+		);
+		expect(new Set(versionCol).size).toBe(1);
+	});
+
+	test("the same row is the same visible width with colour on and off", () => {
+		setColorEnabled(false);
+		const plain = planReport(plan()).map((l) => width(l));
+		setColorEnabled(true);
+		const painted = planReport(plan()).map((l) => width(l));
+		expect(painted).toEqual(plain);
+	});
+
+	test("a very long plugin id widens the column for every row", () => {
+		setColorEnabled(false);
+		const long = "a-very-long-plugin-name-indeed@some-marketplace";
+		const p = plan();
+		p.plugins[0]!.pluginId = long;
+		const rows = planReport(p).filter((l) => l.includes("@"));
+		const cols = rows.map((r) => r.search(/(1\.7\.0|4\.6\.1|latest|1\.8\.0)/));
+		expect(new Set(cols).size).toBe(1);
+		// Not `rows[0]`: grouping means row order follows state, not plan order,
+		// and this fixture's long id is `current` — the LAST group. The claim is
+		// that the id is printed in full somewhere, not where it lands.
+		expect(rows.some((r) => r.includes(long))).toBe(true);
+	});
+});
+
+// -- readability without colour ----------------------------------------------
+
+describe("NO_COLOR", () => {
+	test("the report emits no escape sequence at all", () => {
+		setColorEnabled(false);
+		const out = [
+			...header("default"),
+			...stepFrame(steps(), 3, 500),
+			...stepRecord(steps(), 500),
+			...planReport(plan()),
+			...applyFrame(
+				{ done: 1, total: 4, current: "dev@magus", startedAt: 0 },
+				2,
+				900,
+			),
+			applyRow(true, "dev@magus", 20, "project", 400),
+			...summaryLine(2, 5, 1, 0, 9000),
+		].join("\n");
+		expect(out).not.toContain("\x1b");
+	});
+
+	test("every action stays distinguishable without colour", () => {
+		setColorEnabled(false);
+		const out = planReport(plan()).join("\n");
+		// Colour never carries meaning alone: the report has to survive a pipe
+		// and colour blindness. Plugins say their state as a GROUP HEADING and a
+		// glyph; the tool and skill sections still badge each row with its own
+		// action word.
+		for (const heading of ["Update", "Fix required", "Current"])
+			expect(out).toContain(heading);
+		for (const label of ["CURRENT", "UPGRADE", "INSTALL"])
+			expect(out).toContain(label);
+		for (const glyph of ["=", "↑", "+", "?"]) expect(out).toContain(glyph);
+	});
+
+	// Two states that an apply treats very differently, and which a reader must
+	// never have to tell apart by hue. `unknown` is grouped under Current and
+	// wears `?`; an update wears `↑` under its own heading.
+	test("an unverified row is not confusable with an up-to-date one", () => {
+		setColorEnabled(false);
+		const rows = planReport(plan());
+		const unknown = rows.find((l) => l.includes("designer@magus"))!;
+		const current = rows.find((l) => l.includes("agentdev@magus"))!;
+		expect(unknown).toContain("?");
+		expect(current).toContain("=");
+		expect(unknown).toContain("catalog unreachable");
+	});
+
+	test("a note rides along on the row it explains", () => {
+		setColorEnabled(false);
+		const row = planReport(plan()).find((l) => l.includes("designer@magus"))!;
+		expect(row).toContain("catalog unreachable");
+	});
+});
+
+// -- the bars tell the truth --------------------------------------------------
+
+describe("bars", () => {
+	test("a running step with a denominator gets a determinate meter", () => {
+		setColorEnabled(false);
+		const frame = stepFrame(steps(), 0, 500);
+		// 1 of 4 → a quarter of the 18-cell bar filled.
+		const bar = frame[1]!.match(/[█░]+/)?.[0] ?? "";
+		expect(bar).toHaveLength(18);
+		expect(bar.split("█").length - 1).toBe(5);
+	});
+
+	test("a running step with no denominator gets a sweep, not a fake meter", () => {
+		setColorEnabled(false);
+		const s = steps();
+		s[1]!.progress = undefined;
+		const bar = stepFrame(s, 3, 500)[1]!.match(/[█░]+/)?.[0] ?? "";
+		expect(bar).toHaveLength(18);
+		// A sweep is partly filled at every tick; a "0%" meter would be all track.
+		expect(bar).toContain("█");
+		expect(bar).toContain("░");
+	});
+
+	test("only the running row carries a bar in the live frame", () => {
+		setColorEnabled(false);
+		const frame = stepFrame(steps(), 0, 500);
+		expect(frame[0]).not.toMatch(/[█░]/);
+		expect(frame[1]).toMatch(/[█░]/);
+		expect(frame[2]).not.toMatch(/[█░]/);
+	});
+
+	// The record carries NO bar: a share-of-the-slowest meter restated the
+	// millisecond column next to it. The durations themselves still have to be
+	// right, and still have to rank the steps.
+	test("the record reports each step's duration and draws no bar", () => {
+		setColorEnabled(false);
+		const record = stepRecord(
+			[
+				{
+					label: "fast",
+					state: "done",
+					detail: "",
+					startedAt: 0,
+					endedAt: 100,
+				},
+				{
+					label: "slow",
+					state: "done",
+					detail: "",
+					startedAt: 0,
+					endedAt: 1000,
+				},
+			],
+			1000,
+		);
+		for (const row of record) expect(row).not.toMatch(/[█░]/);
+		expect(record[0]).toContain("100ms");
+		expect(record[1]).toContain("1.0s");
+	});
+
+	test("a step that never ran reports no elapsed time, and does not throw", () => {
+		setColorEnabled(false);
+		const record = stepRecord(
+			[{ label: "x", state: "pending", detail: "" }],
+			0,
+		);
+		expect(record[0]).toContain("x");
+		expect(record[0]).not.toMatch(/[█░]/);
+	});
+
+	test("the apply meter is full exactly when the work is done", () => {
+		setColorEnabled(false);
+		const state: ApplyState = { done: 4, total: 4, current: "", startedAt: 0 };
+		const bar = applyFrame(state, 0, 100)[1]!.match(/[█░]+/)![0];
+		expect(bar).toBe("█".repeat(36));
+	});
+
+	test("an empty apply reads as complete rather than as stuck at zero", () => {
+		setColorEnabled(false);
+		const state: ApplyState = { done: 0, total: 0, current: "", startedAt: 0 };
+		expect(applyFrame(state, 0, 100)[1]).toContain("█".repeat(36));
+	});
+
+	test("the summary bar survives an all-zero run", () => {
+		setColorEnabled(false);
+		const line = summaryLine(0, 0, 0, 0, 100)[1]!;
+		expect(line.match(/[█░]+/)![0]).toHaveLength(36);
+	});
+
+	test("unchanged is its own count, never folded into changed", () => {
+		setColorEnabled(false);
+		const line = summaryLine(1, 4, 0, 0, 100, 2)[1]!;
+		expect(line).toContain("1 changed");
+		expect(line).toContain("2 unchanged");
+		// Omitted when zero, and the parameter defaults to zero.
+		expect(summaryLine(1, 4, 0, 0, 100)[1]).not.toContain("unchanged");
+	});
+});
+
+// -- misc ---------------------------------------------------------------------
+
+describe("sections", () => {
+	test("an empty section is omitted entirely, not printed as a heading", () => {
+		setColorEnabled(false);
+		const out = planReport(plan({ bins: [], skills: [] }) as UpdatePlan).join(
+			"\n",
+		);
+		expect(out).toContain("Plugins");
+		expect(out).not.toContain("CLI");
+		expect(out).not.toContain("Skills");
+	});
+
+	// The Plugins section is grouped by state, so its counts live on the group
+	// headings, not on one legend line. The invariant that matters is the one
+	// that broke once already: the counts printed must add up to the rows
+	// printed. A fixed heading order used to render an unnamed group as nothing
+	// while the total above still counted it — "Plugins 4" over three rows.
+	test("every plugin row sits under a heading, and the headings add up", () => {
+		setColorEnabled(false);
+		const out = planReport(plan());
+		const total = out.find((l) => /^\s+Plugins\s+\d+$/.test(l))!;
+		expect(total).toContain("4");
+
+		// Matches ANY "<words>  <count>" heading, not a fixed alternation of the
+		// group names. A named list silently stops counting a group that is added
+		// later, which is the same blind spot as the fixed order above — the sum
+		// then holds against a subset and the test passes while rows go unheaded.
+		const headings = out.flatMap((l) => {
+			const m = l.match(/^\s+([A-Z][A-Za-z ]+?)\s\s+(\d+)$/);
+			return m && m[1] !== "Plugins"
+				? [{ group: m[1], count: Number(m[2]) }]
+				: [];
+		});
+		// This fixture has one of each except Deprecated, whose row would need a
+		// `not-offered` reason. `designer@magus` is unknown with a note, so it is
+		// Unverified — NOT Current, which would claim a failed check succeeded.
+		expect(headings.map((h) => h.group)).toEqual([
+			"Update",
+			"Fix required",
+			"Unverified",
+			"Current",
+		]);
+		// Every counted row is a row on screen: 1 + 1 + 1 + 1 === the 4 above.
+		const rows = out.filter((l) => l.includes("@"));
+		expect(headings.reduce((n, h) => n + h.count, 0)).toBe(rows.length);
+		expect(rows.length).toBe(4);
+	});
+
+	// The regression the reviewer caught before release: a pin naming a plugin no
+	// marketplace offers, with nothing installed, was filtered out of the table
+	// on the grounds that a notice printed it instead. That notice never existed.
+	// The row appeared nowhere while the closing lines still counted it.
+	test("a pin nothing offers still gets a row", () => {
+		setColorEnabled(false);
+		const p = plan();
+		p.plugins = [
+			{
+				pluginId: "agentdev@magus",
+				pinned: "latest",
+				installed: null,
+				available: null,
+				target: null,
+				action: "unknown",
+				reason: "not-offered",
+				scopes: [],
+			},
+			...p.plugins,
+		] as UpdatePlan["plugins"];
+
+		const out = planReport(p);
+		expect(out.join("\n")).toContain("agentdev@magus");
+		// And it is counted where it is shown, not somewhere else.
+		const total = out.find((l) => /^\s+Plugins\s+\d+$/.test(l))!;
+		expect(total).toContain("5");
+		expect(out.filter((l) => l.includes("@")).length).toBe(5);
+	});
+
+	test("a CLI upgrade shows the command that will run", () => {
+		setColorEnabled(false);
+		const row = planReport(plan()).find(
+			(l) => l.includes("tmux ") && l.includes("UPGRADE"),
+		)!;
+		expect(row).toContain("brew upgrade tmux");
+		expect(row).toContain("3.7b → 3.7c");
+	});
+
+	test("an unpinned CURRENT tool shows its version, not 'pinned —' (F8)", () => {
+		setColorEnabled(false);
+		const p = plan();
+		p.bins = [
+			{
+				name: "tmux",
+				action: "current",
+				reason: "up-to-date",
+				installed: "3.7c",
+				latest: null,
+				target: null,
+				sources: [],
+			},
+		];
+		const row = planReport(p).find(
+			(l) => l.includes("tmux ") && l.includes("CURRENT"),
+		)!;
+		expect(row).toContain("3.7c");
+		expect(row).not.toContain("pinned");
+	});
+
+	test("a pinned current tool still names its pin", () => {
+		setColorEnabled(false);
+		const row = planReport(plan()).find((l) => l.includes("tmux-mcp"))!;
+		expect(row).toContain("pinned v1.7.1");
+	});
+
+	test("an UNKNOWN tool shows its reason and no command", () => {
+		setColorEnabled(false);
+		const p = plan();
+		p.bins = [
+			{
+				name: "crush",
+				action: "unknown",
+				reason: "not-managed",
+				note: "on PATH at /n/crush.js, which npm (root /l) does not own",
+				installed: "0.7.1",
+				latest: null,
+				target: null,
+				sources: [],
+			},
+		];
+		p.binSpecs = new Map([
+			[
+				"crush",
+				{ name: "crush", via: "npm", package: "@charmland/crush", sources: [] },
+			],
+		]);
+		const row = planReport(p).find((l) => l.includes("crush"))!;
+		expect(row).toContain("0.7.1");
+		expect(row).toContain("which npm (root /l) does not own");
+		expect(row).not.toContain("npm install");
+	});
+});
+
+// -- unverified notices -------------------------------------------------------
+
+describe("unverified notices", () => {
+	// A plugin is `unknown` for several reasons, each printed on its own row. The
+	// closing notices must hold for every one of them. They used to say "re-run
+	// once the catalog is reachable", which is false advice for a plugin whose
+	// marketplace publishes no version — the case a real dry run showed five of.
+	const notices = () => [
+		nothingToApplyNotice(5),
+		unknownToolsNotice(1, ["crush"]),
+		uncheckedGateNotice(6),
+	];
+
+	test("never advise a re-run, never blame the catalog", () => {
+		setColorEnabled(false);
+		for (const line of notices()) {
+			expect(line).not.toMatch(/re-run/i);
+			expect(line).not.toContain("catalog is reachable");
+			expect(line).toContain("Reasons are shown above.");
+		}
+	});
+
+	// There is no per-plugin notice under the plan any more: every unverified
+	// plugin is a row in the table, under a heading naming its state, so the
+	// line restated the table and miscounted it. `nothingToApplyNotice` is a
+	// different case — it fires when there IS no table worth reading.
+	test("an unverified plugin is never reported as up to date", () => {
+		setColorEnabled(false);
+		const nothing = nothingToApplyNotice(5);
+		expect(nothing.trimStart()).toStartWith("⚠  Nothing to apply.");
+		expect(nothing).toContain("5 plugin(s) could not be checked");
+		expect(nothing).toContain("They are NOT reported as up to date.");
+	});
+
+	test("the tool notice names the tools it could not check", () => {
+		setColorEnabled(false);
+		expect(unknownToolsNotice(2, ["crush", "tmux"])).toContain(
+			"2 tool(s) could not be checked: crush, tmux — not applied.",
+		);
+	});
+
+	test("the gate notice says the unknowns passed without being verified", () => {
+		// `--check` exits 0 with unknowns present, so this line carries the whole
+		// difference between "nothing is known to be behind" and "all verified".
+		setColorEnabled(false);
+		const line = uncheckedGateNotice(6);
+		expect(line).toContain("6 item(s) could not be checked");
+		expect(line).toContain("they do not fail this gate");
+		expect(line).toContain("They are NOT reported as up to date.");
+		// A warning, not a failure: the gate is about to pass.
+		expect(line.trimStart()).toStartWith("⚠");
+	});
+});