magus-cli 0.0.0-placeholder → 7.0.0

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

@@ -0,0 +1,445 @@
+/**
+ * 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,
+	unknownPluginsNotice,
+	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);
+		expect(rows[0]).toContain(long);
+	});
+});
+
+// -- 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: each action has its own word AND
+		// its own glyph, so the report survives a pipe and colour blindness.
+		for (const label of ["CURRENT", "UPDATE", "INSTALL", "UNKNOWN", "UPGRADE"])
+			expect(out).toContain(label);
+		for (const glyph of ["=", "↑", "+", "?"]) expect(out).toContain(glyph);
+	});
+
+	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(/[█░]/);
+	});
+
+	test("the record scales each step against the slowest, not the total", () => {
+		setColorEnabled(false);
+		const record = stepRecord(
+			[
+				{
+					label: "fast",
+					state: "done",
+					detail: "",
+					startedAt: 0,
+					endedAt: 100,
+				},
+				{
+					label: "slow",
+					state: "done",
+					detail: "",
+					startedAt: 0,
+					endedAt: 1000,
+				},
+			],
+			1000,
+		);
+		const bars = record.map((r) => r.match(/[█░]+/)![0]);
+		expect(bars[1]!.split("█").length - 1).toBe(18);
+		expect(bars[0]!.split("█").length - 1).toBe(2);
+	});
+
+	test("a step that never ran does not divide by zero", () => {
+		setColorEnabled(false);
+		const record = stepRecord(
+			[{ label: "x", state: "pending", detail: "" }],
+			0,
+		);
+		expect(record[0]).toContain("░");
+	});
+
+	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");
+	});
+
+	test("a section legend counts every action it contains", () => {
+		setColorEnabled(false);
+		const line = planReport(plan()).find((l) => l.includes("Plugins"))!;
+		expect(line).toContain("1 current");
+		expect(line).toContain("1 update");
+		expect(line).toContain("1 install");
+		expect(line).toContain("1 unknown");
+	});
+
+	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 = () => [
+		unknownPluginsNotice(5),
+		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.");
+		}
+	});
+
+	test("an unverified plugin is never reported as up to date", () => {
+		setColorEnabled(false);
+		const under = unknownPluginsNotice(5);
+		expect(under).toContain("5 plugin(s) could not be checked");
+		expect(under).toContain("They are NOT reported as up to date.");
+		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("⚠");
+	});
+});