magus-cli 0.0.0-placeholder → 7.0.0

package/src/__tests__/blackbox-convergence.test.ts

@@ -0,0 +1,334 @@
+/**
+ * BLACK-BOX: R6 — convergence. A no-op installer run (brew "already installed",
+ * uv reinstalling the same version) is never counted as changed, unknown tools
+ * are never applied, and a second plan after a successful apply has no work
+ * for what the first run changed. Written from requirements.md and §8.2/§8.5/§8.8.
+ *
+ * IO is injected through the contracts' seams: applyBins(run, probe),
+ * applyPlugins(deps), applyPlan({ run, probe, deps }). No mock.module.
+ */
+import { describe, expect, test } from "bun:test";
+import { summaryLine } from "../cli/update-view.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import type { ToolFacts } from "../services/tool-probe.js";
+import {
+	type PluginApplyDeps,
+	SILENT_REPORTER,
+	applyBins,
+	applyPlan,
+	applyPlugins,
+	planWorkItems,
+} from "../services/update-engine.js";
+import {
+	type UpdatePlan,
+	classifyPlugin,
+	indexCatalog,
+	planBinUpdates,
+	planHasWork,
+} from "../services/update-plan.js";
+import type { ResolvedBin } from "../types/index.js";
+import type { Command } from "../utils/command-utils.js";
+
+function facts(name: string, over: Partial<ToolFacts> = {}): ToolFacts {
+	return {
+		name,
+		present: true,
+		resolvedPath: `/usr/local/bin/${name}`,
+		installed: "1.0.0",
+		latest: null,
+		behind: null,
+		managed: true,
+		sources: ["path"],
+		...over,
+	};
+}
+
+const SPECS: Record<string, ResolvedBin> = {
+	codex: {
+		name: "codex",
+		via: "npm",
+		package: "@openai/codex",
+		sources: ["profile"],
+	},
+	mnemex: {
+		name: "mnemex",
+		via: "bun",
+		version: "1.0.0",
+		sources: ["profile"],
+	},
+	tmux: {
+		name: "tmux",
+		via: "brew",
+		check: "tmux -V",
+		sources: ["terminal@magus"],
+	},
+	gemini: {
+		name: "gemini",
+		via: "npm",
+		package: "@google/gemini-cli",
+		sources: ["profile"],
+	},
+};
+
+function toolPlan(names: string[], before: ToolFacts[]): UpdatePlan {
+	const bins = names.map((n) => SPECS[n] as ResolvedBin);
+	return {
+		profileId: "default",
+		plugins: [],
+		bins: planBinUpdates(bins, before),
+		skills: [],
+		binSpecs: new Map(bins.map((b) => [b.name, b])),
+	};
+}
+
+function recorder(ok = true) {
+	const ran: Command[] = [];
+	return {
+		ran,
+		run: async (c: Command) => {
+			ran.push(c);
+			return ok;
+		},
+	};
+}
+
+function probeFrom(after: Record<string, ToolFacts>) {
+	return async (spec: ResolvedBin) =>
+		after[spec.name] ?? facts(spec.name, { installed: null });
+}
+
+const CODEX_BEHIND = facts("codex", { installed: "0.40.0", latest: "0.41.0" });
+
+describe("applyBins read-back (R6)", () => {
+	test("installer exits 0 but nothing moved (brew 'already installed'): unchanged, not changed", async () => {
+		const plan = toolPlan(["codex"], [CODEX_BEHIND]);
+		const r = recorder();
+
+		const res = await applyBins(
+			plan,
+			SILENT_REPORTER,
+			r.run,
+			probeFrom({ codex: CODEX_BEHIND }),
+		);
+
+		expect(plan.bins[0]?.action).toBe("upgrade");
+		expect(r.ran.length).toBe(1);
+		expect({
+			ok: res.ok,
+			unchanged: res.unchanged,
+			failed: res.failed,
+		}).toEqual({
+			ok: 0,
+			unchanged: ["codex"],
+			failed: [],
+		});
+	});
+
+	test("installer exits 0 and read-back shows the new version: changed", async () => {
+		const plan = toolPlan(["codex"], [CODEX_BEHIND]);
+		const r = recorder();
+		const after = facts("codex", { installed: "0.41.0", latest: "0.41.0" });
+
+		const res = await applyBins(
+			plan,
+			SILENT_REPORTER,
+			r.run,
+			probeFrom({ codex: after }),
+		);
+
+		expect({
+			ok: res.ok,
+			unchanged: res.unchanged,
+			failed: res.failed,
+		}).toEqual({
+			ok: 1,
+			unchanged: [],
+			failed: [],
+		});
+	});
+
+	test("current and unknown tools are never run and never counted", async () => {
+		const plan = toolPlan(
+			["tmux", "gemini"],
+			[
+				facts("tmux", { installed: "3.7c", behind: false }),
+				facts("gemini", { installed: "0.5.0", failure: "timed out after 8s" }),
+			],
+		);
+		const r = recorder();
+
+		const res = await applyBins(plan, SILENT_REPORTER, r.run, probeFrom({}));
+
+		expect(plan.bins.map((b) => b.action)).toEqual(["current", "unknown"]);
+		expect(planWorkItems(plan)).toEqual([]);
+		expect(r.ran).toEqual([]);
+		expect({
+			ok: res.ok,
+			unchanged: res.unchanged,
+			failed: res.failed,
+		}).toEqual({
+			ok: 0,
+			unchanged: [],
+			failed: [],
+		});
+	});
+
+	test("installer exits non-zero: failed, not changed", async () => {
+		const plan = toolPlan(["codex"], [CODEX_BEHIND]);
+		const r = recorder(false);
+
+		const res = await applyBins(
+			plan,
+			SILENT_REPORTER,
+			r.run,
+			probeFrom({ codex: CODEX_BEHIND }),
+		);
+
+		expect(res.ok).toBe(0);
+		expect(res.failed).toContain("codex");
+	});
+
+	test("after an upgrade to the pin, the next plan has no tool work", async () => {
+		const before = facts("mnemex", { installed: "0.9.0", latest: "1.2.0" });
+		const after = facts("mnemex", { installed: "1.0.0", latest: "1.2.0" });
+		const plan1 = toolPlan(["mnemex"], [before]);
+		const r = recorder();
+
+		const res = await applyBins(
+			plan1,
+			SILENT_REPORTER,
+			r.run,
+			probeFrom({ mnemex: after }),
+		);
+		const plan2 = toolPlan(["mnemex"], [after]);
+
+		expect(plan1.bins[0]?.action).toBe("upgrade");
+		expect(res.ok).toBe(1);
+		expect(plan2.bins[0]?.action).toBe("current");
+		expect(planWorkItems(plan2)).toEqual([]);
+		expect(planHasWork(plan2)).toBe(false);
+	});
+});
+
+// ── plugins ────────────────────────────────────────────────────────────────
+
+function designer(installed: string): PluginInfo {
+	return {
+		id: "designer@magus",
+		name: "designer",
+		version: "2.0.0",
+		description: "",
+		marketplace: "magus",
+		marketplaceDisplay: "magus",
+		enabled: true,
+		installedVersion: installed,
+		projectScope: { enabled: true, version: installed },
+	};
+}
+
+function pluginDeps(readBack: string | null) {
+	const calls: string[] = [];
+	const deps: PluginApplyDeps = {
+		install: async (id, scope) => {
+			calls.push(`install ${id} ${scope}`);
+		},
+		update: async (id, scope) => {
+			calls.push(`update ${id} ${scope}`);
+		},
+		repair: async (id, scope) => {
+			calls.push(`repair ${id} ${scope}`);
+		},
+		readInstalled: async () => readBack,
+		saveInstalled: async () => {},
+	};
+	return { calls, deps };
+}
+
+describe("applyPlugins read-back (R6)", () => {
+	test("update exits 0 but the registry still shows the before-version: unchanged, not changed", async () => {
+		const item = classifyPlugin(
+			"designer@magus",
+			"latest",
+			indexCatalog([designer("1.5.0")]),
+		);
+		const { calls, deps } = pluginDeps("1.5.0");
+
+		const res = await applyPlugins([item], "/proj", deps, SILENT_REPORTER);
+
+		expect(item.action).toBe("update");
+		expect(calls.length).toBeGreaterThan(0);
+		expect({ ok: res.ok, unchanged: res.unchanged }).toEqual({
+			ok: 0,
+			unchanged: ["designer@magus"],
+		});
+		expect(res.failed).toEqual([]);
+	});
+
+	test("update moves the registry to the target: changed, and the next classification is current", async () => {
+		const item = classifyPlugin(
+			"designer@magus",
+			"latest",
+			indexCatalog([designer("1.5.0")]),
+		);
+		const { deps } = pluginDeps("2.0.0");
+
+		const res = await applyPlugins([item], "/proj", deps, SILENT_REPORTER);
+		const next = classifyPlugin(
+			"designer@magus",
+			"latest",
+			indexCatalog([designer("2.0.0")]),
+		);
+
+		expect({ ok: res.ok, unchanged: res.unchanged }).toEqual({
+			ok: 1,
+			unchanged: [],
+		});
+		expect(next.action).toBe("current");
+	});
+});
+
+describe("applyPlan totals (R6)", () => {
+	test("changed counts only real movement; the no-op is listed as unchanged", async () => {
+		const plan = toolPlan(
+			["codex", "mnemex", "tmux"],
+			[
+				CODEX_BEHIND,
+				facts("mnemex", { installed: "0.9.0", latest: "1.2.0" }),
+				facts("tmux", { installed: "3.7c", behind: false }),
+			],
+		);
+		const r = recorder();
+		const { deps } = pluginDeps(null);
+
+		const out = await applyPlan(plan, "/proj", {
+			deps,
+			report: SILENT_REPORTER,
+			run: r.run,
+			probe: probeFrom({
+				codex: CODEX_BEHIND,
+				mnemex: facts("mnemex", { installed: "1.0.0", latest: "1.2.0" }),
+			}),
+		});
+
+		expect(r.ran.length).toBe(2); // tmux is current: never run
+		expect({
+			changed: out.changed,
+			unchanged: out.unchanged,
+			failed: out.failed,
+		}).toEqual({
+			changed: 1,
+			unchanged: ["codex"],
+			failed: [],
+		});
+	});
+});
+
+describe("summaryLine never reports a no-op as changed", () => {
+	test("three no-op runs do not read as '3 changed', and the unchanged count is visible", () => {
+		const withUnchanged = summaryLine(0, 5, 1, 0, 1200, 3).join("\n");
+		const without = summaryLine(0, 5, 1, 0, 1200, 0).join("\n");
+
+		expect(withUnchanged).not.toMatch(/\b3 changed\b/);
+		expect(withUnchanged).not.toBe(without);
+	});
+});