claudeup 6.5.1 → 6.6.0

package/src/__tests__/update-apply.test.ts

@@ -8,13 +8,23 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 import type { PluginScope } from "../services/claude-cli.js";
+import type { ToolFacts } from "../services/tool-probe.js";
 import {
+	type ApplyReporter,
 	type PluginApplyDeps,
+	applyBins,
+	applyPlan,
 	applyPlugins,
 	installPluginInScope,
 	updatePluginInScope,
 } from "../services/update-engine.js";
-import type { PluginUpdateItem } from "../services/update-plan.js";
+import type {
+	BinUpdateItem,
+	PluginUpdateItem,
+	UpdatePlan,
+} from "../services/update-plan.js";
+import type { ResolvedBin } from "../types/index.js";
+import { noMoveReasons } from "../ui/adapters/pluginsAdapter.js";
 
 const PROJECT = "/tmp/project";
 
@@ -59,7 +69,9 @@ function item(over: Partial<PluginUpdateItem>): PluginUpdateItem {
 		available: "2.0.0",
 		target: "2.0.0",
 		action: "update",
+		reason: "behind",
 		scopes: ["project"],
+		beforeVersions: { project: "1.0.0" },
 		...over,
 	};
 }
@@ -353,3 +365,273 @@ describe("installPluginInScope — a fresh install records what landed", () => {
 		expect(updatePluginInScope.length).toBe(3);
 	});
 });
+
+// ── R6: an installer that exits 0 and changes nothing is never "changed" ────
+//
+// Planning (R4) refuses the upgrades it cannot justify, but it cannot see the
+// no-ops that only appear after an installer runs: a stale brew tap, a PATH
+// that still resolves an older copy, `~/.bun/bin` missing from PATH, a
+// marketplace clone lagging its catalog. Each exits 0 and is replanned
+// identically next run. Read-back — re-probing the one tool, or re-reading the
+// registry row — is what tells them apart. No installer output is parsed.
+
+const bin = (over: Partial<BinUpdateItem> = {}): BinUpdateItem => ({
+	name: "tmux",
+	action: "upgrade",
+	reason: "behind",
+	installed: "1.2.2",
+	latest: "1.2.3",
+	target: "1.2.3",
+	sources: [],
+	...over,
+});
+
+const readBack = (over: Partial<ToolFacts> = {}): ToolFacts => ({
+	name: "tmux",
+	present: true,
+	resolvedPath: "/opt/homebrew/Cellar/tmux/1.2.3/bin/tmux",
+	installed: "1.2.3",
+	latest: null,
+	behind: false,
+	managed: true,
+	sources: [],
+	...over,
+});
+
+function binPlan(item: BinUpdateItem): UpdatePlan {
+	const spec: ResolvedBin = { name: item.name, via: "brew", sources: [] };
+	return {
+		profileId: "test",
+		plugins: [],
+		bins: [item],
+		skills: [],
+		binSpecs: new Map([[item.name, spec]]),
+	};
+}
+
+function recordingReporter() {
+	const rows: Array<{ ok: boolean; name: string; detail: string }> = [];
+	const reporter: ApplyReporter = {
+		begin: () => {},
+		finish: (ok, name, detail) => rows.push({ ok, name, detail }),
+		detach: (work) => work(),
+	};
+	return { reporter, rows };
+}
+
+const RUN_OK = async () => true;
+
+describe("applyBins — read-back", () => {
+	test("an upgrade that reads back the same version is UNCHANGED (v-prefix tolerant)", async () => {
+		const { reporter, rows } = recordingReporter();
+		const result = await applyBins(
+			binPlan(bin({ installed: "v1.2.3", target: "1.2.4" })),
+			reporter,
+			RUN_OK,
+			async () => readBack({ installed: "1.2.3" }),
+		);
+		expect(result).toEqual({ ok: 0, failed: [], unchanged: ["tmux"] });
+		// A finished row, not a failure, carrying the reason.
+		expect(rows).toEqual([
+			{
+				ok: true,
+				name: "tmux",
+				detail: "no change — the installer exited 0 but tmux is still 1.2.3",
+			},
+		]);
+	});
+
+	test("a read-back where PATH still runs another copy is UNCHANGED", async () => {
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			RUN_OK,
+			async () =>
+				readBack({
+					installed: "1.2.3",
+					managed: false,
+					resolvedPath: "/usr/local/bin/tmux",
+				}),
+		);
+		expect(result.unchanged).toEqual(["tmux"]);
+		expect(result.ok).toBe(0);
+	});
+
+	test("an install that is still not on PATH is UNCHANGED", async () => {
+		const { reporter, rows } = recordingReporter();
+		const result = await applyBins(
+			binPlan(bin({ action: "install", installed: null, reason: "absent" })),
+			reporter,
+			RUN_OK,
+			async () => readBack({ present: false, installed: null, managed: null }),
+		);
+		expect(result.unchanged).toEqual(["tmux"]);
+		expect(rows[0]!.detail).toContain("still not on PATH");
+	});
+
+	test("a read-back that cannot read a version counts as CHANGED", async () => {
+		// Failing to read is not evidence nothing moved — otherwise every
+		// go-less machine's upgrade would turn into a warning.
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			RUN_OK,
+			async () => readBack({ installed: null }),
+		);
+		expect(result).toEqual({ ok: 1, failed: [], unchanged: [] });
+	});
+
+	test("a read-back that throws counts as CHANGED, never as a failure", async () => {
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			RUN_OK,
+			async () => {
+				throw new Error("probe blew up");
+			},
+		);
+		expect(result).toEqual({ ok: 1, failed: [], unchanged: [] });
+	});
+
+	test("a real move is CHANGED", async () => {
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			RUN_OK,
+			async () => readBack({ installed: "1.2.3" }),
+		);
+		expect(result).toEqual({ ok: 1, failed: [], unchanged: [] });
+	});
+
+	test("an installer that fails is FAILED and is not read back", async () => {
+		const probe = mock(async () => readBack());
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			async () => false,
+			probe,
+		);
+		expect(result).toEqual({ ok: 0, failed: ["tmux"], unchanged: [] });
+		expect(probe).not.toHaveBeenCalled();
+	});
+
+	test("applyPlan: changed excludes the unchanged, which it lists", async () => {
+		const outcome = await applyPlan(
+			binPlan(bin({ installed: "1.2.2" })),
+			PROJECT,
+			{ run: RUN_OK, probe: async () => readBack({ installed: "1.2.2" }) },
+		);
+		expect(outcome.changed).toBe(0);
+		expect(outcome.unchanged).toEqual(["tmux"]);
+		expect(outcome.failed).toEqual([]);
+	});
+});
+
+describe("applyPlugins — read-back against beforeVersions", () => {
+	test("an update whose every scope reads back its before-version is UNCHANGED", async () => {
+		// `claude plugin update` answering "already at the latest version" while
+		// the marketplace clone lags the catalog: exit 0, nothing moved.
+		const { deps } = stubDeps("1.0.0");
+		const { reporter, rows } = recordingReporter();
+		const result = await applyPlugins(
+			[item({ beforeVersions: { project: "1.0.0" } })],
+			PROJECT,
+			deps,
+			reporter,
+		);
+		expect(result.ok).toBe(0);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(result.failed).toEqual([]);
+		expect(rows[0]).toMatchObject({ ok: true });
+		expect(rows[0]!.detail).toContain("still 1.0.0");
+	});
+
+	test("an update where ONE scope moved is CHANGED", async () => {
+		const { deps } = stubDeps((scope) =>
+			scope === "user" ? "2.0.0" : "1.0.0",
+		);
+		const result = await applyPlugins(
+			[
+				item({
+					scopes: ["user", "project"],
+					beforeVersions: { user: "1.0.0", project: "1.0.0" },
+				}),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+	});
+
+	test("an install that reads back nothing in any scope is UNCHANGED", async () => {
+		const { deps } = stubDeps(null);
+		const result = await applyPlugins(
+			[
+				item({
+					action: "install",
+					installed: null,
+					scopes: [],
+					beforeVersions: {},
+				}),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(result.ok).toBe(0);
+	});
+
+	test("an install that lands a version is CHANGED", async () => {
+		const { deps } = stubDeps("2.0.0");
+		const result = await applyPlugins(
+			[
+				item({
+					action: "install",
+					installed: null,
+					scopes: [],
+					beforeVersions: {},
+				}),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(result.ok).toBe(1);
+	});
+
+	test("a repair is always CHANGED — same version is its definition", async () => {
+		const { deps } = stubDeps("1.0.0");
+		const result = await applyPlugins(
+			[
+				item({
+					action: "repair",
+					target: "1.0.0",
+					beforeVersions: { project: "1.0.0" },
+				}),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+	});
+
+	test("the TUI's collector names the same cause the CLI prints", async () => {
+		// The screen used to branch on `failed.length` alone: a no-op update
+		// closed with a success and a row that had not moved.
+		const { deps } = stubDeps("1.0.0");
+		const reasons = noMoveReasons();
+		const result = await applyPlugins(
+			[item({ beforeVersions: { project: "1.0.0" } })],
+			PROJECT,
+			deps,
+			reasons.reporter,
+		);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(reasons.lines(result.unchanged)).toBe(
+			"dev@magus: the installer exited 0 but dev@magus is still 1.0.0",
+		);
+		// An item with no recorded cause still gets a line.
+		expect(reasons.lines(["other@magus"])).toBe("other@magus");
+	});
+});