magus-cli 7.7.0 → 7.9.0

package/src/__tests__/failure-popup.test.tsx

@@ -0,0 +1,419 @@
+/**
+ * The failure popup — ONE shape for every plugin apply path on the Plugins
+ * screen (`a`, a single update, a scope key, a removal, a repair).
+ *
+ * The words are built by a pure function from what the apply engine reported,
+ * and each reason is the engine's own string — the one `magus update` prints on
+ * that item's `✗` line — so the two front ends name a failure the same way.
+ * Successes are never listed: the screen reloads and shows them.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import type React from "react";
+import { act } from "react";
+import { stripAnsi } from "../cli/ansi.js";
+import { applyRow } from "../cli/update-view.js";
+import type { StaleLoadRepairResult } from "../services/claude-settings.js";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	applyPlugins,
+} from "../services/update-engine.js";
+import type { PluginUpdateItem } from "../services/update-plan.js";
+import {
+	failureReasons,
+	pluginFailureReport,
+	reasonWithoutVersions,
+} from "../ui/adapters/pluginsAdapter.js";
+import {
+	FailureListModal,
+	failureListWidth,
+	reasonBelow,
+} from "../ui/components/modals/FailureListModal.js";
+import { theme } from "../ui/theme.js";
+
+const PROJECT = "/tmp/magus-failure-popup";
+
+function updateItem(pluginId: string): PluginUpdateItem {
+	return {
+		pluginId,
+		pinned: "latest",
+		installed: "2.0.3",
+		loaded: "2.0.3",
+		available: "2.0.6",
+		target: "2.0.6",
+		action: "update",
+		reason: "behind",
+		scopes: ["project"],
+		beforeVersions: { project: "2.0.3" },
+	};
+}
+
+/**
+ * Each plugin lands its update, and Claude Code keeps loading `loads[id]` —
+ * the failure `magus update` reports as "installed vX, but Claude Code still
+ * loads vY in this folder". A plugin in `throws` fails with that error instead.
+ */
+function deps(
+	loads: Record<string, string>,
+	throws: Record<string, string> = {},
+): PluginApplyDeps {
+	return {
+		install: async () => {},
+		update: async (id) => {
+			if (throws[id]) throw new Error(throws[id]);
+		},
+		repair: async () => {},
+		readInstalled: async () => "2.0.6",
+		saveInstalled: async () => {},
+		loadedVersion: async (id) => loads[id] ?? null,
+		repairStaleLoad: async (id, target): Promise<StaleLoadRepairResult> => ({
+			pluginId: id,
+			target,
+			rewritten: 0,
+			backup: null,
+			loaded: loads[id] ?? null,
+			ok: false,
+			error: `Claude Code still loads v${loads[id]} in this folder`,
+		}),
+	};
+}
+
+/** What the CLI prints for each finished item: its `✗` row, colour stripped. */
+function cliRows(): { reporter: ApplyReporter; rows: Map<string, string> } {
+	const rows = new Map<string, string>();
+	return {
+		rows,
+		reporter: {
+			begin: () => {},
+			finish: (ok, name, detail, ms) =>
+				rows.set(name, stripAnsi(applyRow(ok, name, 20, detail, ms))),
+			detach: (work) => work(),
+		},
+	};
+}
+
+/** Both reporters at once — one apply, the CLI's and the popup's view of it. */
+function both(a: ApplyReporter, b: ApplyReporter): ApplyReporter {
+	return {
+		begin: (n) => {
+			a.begin(n);
+			b.begin(n);
+		},
+		finish: (...args) => {
+			a.finish(...args);
+			b.finish(...args);
+		},
+		detach: (work) => work(),
+	};
+}
+
+describe("the popup's words", () => {
+	test("one failure: the headline names it, the row carries the CLI's exact reason", async () => {
+		const popup = failureReasons();
+		const cli = cliRows();
+		const result = await applyPlugins(
+			[updateItem("claudish@magus"), updateItem("mnemex@magus")],
+			PROJECT,
+			deps({ "claudish@magus": "2.0.3", "mnemex@magus": "2.0.6" }),
+			both(popup.reporter, cli.reporter),
+		);
+
+		// mnemex loads its new version: a success, so it is not listed.
+		expect(result.failed).toEqual(["claudish@magus"]);
+		const report = popup.report(result.failed);
+		expect(report).toEqual({
+			headline: "claudish was not updated",
+			rows: [
+				{
+					subject: "claudish",
+					reason:
+						"installed v2.0.6, but Claude Code still loads v2.0.3 in this folder",
+				},
+			],
+			fix: null,
+		});
+		// The same text the CLI prints on that item's ✗ line.
+		const line = cli.rows.get("claudish@magus") ?? "";
+		expect(line.trimStart().startsWith("✗")).toBe(true);
+		expect(line).toContain(report?.rows[0]?.reason ?? "<none>");
+	});
+
+	test("several: the headline counts them, and one reason at different versions is ONE row", async () => {
+		const popup = failureReasons();
+		const result = await applyPlugins(
+			["claudish", "mnemex", "setup"].map((n) => updateItem(`${n}@magus`)),
+			PROJECT,
+			deps({
+				"claudish@magus": "2.0.3",
+				"mnemex@magus": "1.0.3",
+				"setup@magus": "0.9.0",
+			}),
+			popup.reporter,
+		);
+		expect(popup.report(result.failed)).toEqual({
+			headline: "3 plugins were not updated",
+			rows: [
+				{
+					subject: "claudish, mnemex, setup",
+					// M6: the versions differ, so each becomes a noun that keeps the
+					// sentence true — never "still loads in this folder".
+					reason:
+						"installed the new version, but Claude Code still loads an older version in this folder",
+				},
+			],
+			fix: null,
+		});
+	});
+
+	test("different reasons: one row each; an exception keeps its first line only", async () => {
+		const popup = failureReasons();
+		const result = await applyPlugins(
+			[updateItem("claudish@magus"), updateItem("omega@magus")],
+			PROJECT,
+			deps(
+				{ "claudish@magus": "2.0.3" },
+				{
+					"omega@magus":
+						"network unreachable (ECONNRESET)\n    at fetch (node:internal)\n    at run",
+				},
+			),
+			popup.reporter,
+		);
+		const report = popup.report(result.failed);
+		expect(report?.headline).toBe("2 plugins were not updated");
+		expect(report?.rows).toEqual([
+			{
+				subject: "claudish",
+				reason:
+					"installed v2.0.6, but Claude Code still loads v2.0.3 in this folder",
+			},
+			// M10: a network failure is one magus recognises, so it carries a fix.
+			{
+				subject: "omega",
+				reason: "network unreachable (ECONNRESET)",
+				fix: "Check your network connection and try again",
+			},
+		]);
+	});
+
+	test("a removal says 'removed'; a mix says both", () => {
+		expect(
+			pluginFailureReport([
+				{
+					pluginId: "code-analysis@magus",
+					verb: "removed",
+					detail: "still installed at USER scope",
+				},
+			])?.headline,
+		).toBe("code-analysis was not removed");
+		expect(
+			pluginFailureReport([
+				{ pluginId: "a@magus", verb: "updated", detail: "x" },
+				{ pluginId: "b@magus", verb: "removed", detail: "y" },
+			])?.headline,
+		).toBe("2 plugins were not updated or removed");
+	});
+
+	test("every row sharing one fix: said once, under the rows, and taken off each", () => {
+		const report = pluginFailureReport([
+			{
+				pluginId: "dev@magus",
+				verb: "updated",
+				detail: "v8.1.3 is not downloaded — run magus install",
+			},
+			{
+				pluginId: "go@magus",
+				verb: "updated",
+				detail: "v1.2.0 is not downloaded — run magus install",
+			},
+		]);
+		expect(report).toEqual({
+			headline: "2 plugins were not updated",
+			rows: [{ subject: "dev, go", reason: "that version is not downloaded" }],
+			fix: "Run magus install",
+		});
+	});
+
+	test("NEGATIVE CONTROL: different fixes are not merged into one", () => {
+		const report = pluginFailureReport([
+			{
+				pluginId: "dev@magus",
+				verb: "updated",
+				detail: "v8.1.3 is not downloaded — run magus install",
+			},
+			{
+				pluginId: "go@magus",
+				verb: "updated",
+				detail:
+					"Claude Code loads the USER install of it here — update it at USER scope",
+			},
+		]);
+		expect(report?.fix).toBeNull();
+		// Each row keeps its OWN fix, drawn under its reason; the reason no
+		// longer repeats it.
+		expect(report?.rows).toEqual([
+			{
+				subject: "dev",
+				reason: "v8.1.3 is not downloaded",
+				fix: "Run magus install",
+			},
+			{
+				subject: "go",
+				reason: "Claude Code loads the USER install of it here",
+				fix: "Update it at USER scope",
+			},
+		]);
+	});
+
+	test("NEGATIVE CONTROL: nothing failed, no popup", () => {
+		expect(pluginFailureReport([])).toBeNull();
+		expect(failureReasons().report([])).toBeNull();
+	});
+
+	test("the grouping key replaces versions with nouns and changes nothing else", () => {
+		expect(
+			reasonWithoutVersions(
+				"installed v2.0.6, but Claude Code still loads v2.0.3 in this folder",
+			),
+		).toBe(
+			"installed the new version, but Claude Code still loads an older version in this folder",
+		);
+		expect(reasonWithoutVersions("still installed at USER scope")).toBe(
+			"still installed at USER scope",
+		);
+	});
+});
+
+// ── the rendering ────────────────────────────────────────────────────────────
+
+interface Node {
+	type: unknown;
+	props: Record<string, unknown> & { children?: unknown };
+}
+
+/** Every text-bearing element in the tree, with the fg it is drawn in. */
+function spans(
+	el: unknown,
+	inherited?: unknown,
+): Array<{ text: string; fg: unknown }> {
+	if (el === null || el === undefined || el === false) return [];
+	if (typeof el === "string" || typeof el === "number") {
+		return [{ text: String(el), fg: inherited }];
+	}
+	if (Array.isArray(el)) return el.flatMap((c) => spans(c, inherited));
+	const node = el as Node;
+	const fg = node.props?.fg ?? inherited;
+	return spans(node.props?.children, fg);
+}
+
+describe("the popup's drawing", () => {
+	const report = {
+		headline: "2 plugins were not updated",
+		rows: [
+			{
+				subject: "claudish",
+				reason: "Claude Code still loads v2.0.3 in this folder",
+			},
+			{ subject: "omega", reason: "network unreachable" },
+		],
+		fix: null,
+	};
+
+	test("✗ in danger, the subject in text, the reason muted — theme tokens only", () => {
+		const drawn = spans(
+			FailureListModal({ report, terminalWidth: 120 }) as React.ReactElement,
+		);
+		const text = drawn.map((s) => s.text).join("");
+		expect(text).toContain("2 plugins were not updated");
+		for (const s of drawn.filter((d) => d.text === "✗ ")) {
+			expect(s.fg).toBe(theme.colors.danger);
+		}
+		// Headline plus one mark per row.
+		expect(drawn.filter((d) => d.text === "✗ ")).toHaveLength(3);
+		expect(drawn.find((d) => d.text.startsWith("claudish"))?.fg).toBe(
+			theme.colors.text,
+		);
+		expect(
+			drawn.find(
+				(d) => d.text === "Claude Code still loads v2.0.3 in this folder",
+			)?.fg,
+		).toBe(theme.colors.muted);
+		// No fix shared, so no fix line.
+		expect(text).not.toContain("Run ");
+	});
+
+	test("rows kept apart with group:false get distinct React keys even when subject and reason repeat", () => {
+		const row = { subject: "designer", reason: "network unreachable" };
+		const keys: string[] = [];
+		const walk = (node: unknown): void => {
+			if (Array.isArray(node)) {
+				for (const child of node) walk(child);
+				return;
+			}
+			if (!node || typeof node !== "object" || !("props" in node)) return;
+			const el = node as React.ReactElement<{ children?: unknown }>;
+			if (el.key !== null && el.key !== undefined) keys.push(String(el.key));
+			walk(el.props.children);
+		};
+		walk(
+			FailureListModal({
+				report: {
+					headline: "2 plugins were not updated",
+					rows: [row, row],
+					fix: null,
+				},
+				terminalWidth: 120,
+			}),
+		);
+		// One keyed box per row, and no two alike — a repeat makes React drop one.
+		expect(keys).toHaveLength(2);
+		expect(new Set(keys).size).toBe(2);
+	});
+
+	test("fits the terminal, and a long subject puts its reason underneath", () => {
+		expect(failureListWidth(200)).toBe(88);
+		expect(failureListWidth(60)).toBe(56);
+		expect(failureListWidth(20)).toBe(40);
+		expect(reasonBelow("claudish", 80)).toBe(false);
+		expect(reasonBelow("claudish, mnemex, setup, designer, terminal", 80)).toBe(
+			true,
+		);
+	});
+
+	test("drawn on a narrow terminal: the reason wraps, the name stays whole", async () => {
+		const { captureCharFrame, renderOnce, renderer } = await testRender(
+			<FailureListModal
+				report={{
+					headline: "claudish was not updated",
+					rows: [
+						{
+							subject: "claudish",
+							reason:
+								"installed v2.0.6, but Claude Code still loads v2.0.3 in this folder",
+						},
+					],
+					fix: "Run magus update to try again",
+				}}
+				terminalWidth={50}
+			/>,
+			{ width: 50, height: 16 },
+		);
+		await act(async () => {
+			await renderOnce();
+			await renderOnce();
+		});
+		const frame = captureCharFrame();
+		await act(async () => renderer.destroy());
+
+		expect(frame).toContain("✗ claudish was not updated");
+		expect(frame).toContain("✗ claudish  installed v2.0.6, but");
+		// Wrapped onto the next line, not cut off.
+		expect(frame.replace(/[│\s]+/g, " ")).toContain(
+			"Claude Code still loads v2.0.3 in this folder",
+		);
+		expect(frame).toContain("Run magus update to try again");
+		expect(frame).toContain("Press any key to continue");
+	});
+});