claudeup 4.42.0 → 5.0.0

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

@@ -0,0 +1,223 @@
+/**
+ * Regression tests for the `claudeup update` APPLY path.
+ *
+ * Every defect a multi-model review found in this feature lived here, in the
+ * half that had no coverage, while the pure planner beside it had forty tests.
+ * These lock the apply path's contract so that gap cannot silently reopen.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { type PluginApplyDeps, applyPlugins } from "../cli/update.js";
+import type { PluginScope } from "../services/claude-cli.js";
+import type { PluginUpdateItem } from "../services/update-plan.js";
+
+const PROJECT = "/tmp/project";
+
+/** Records every call, and lets a test dictate what the registry reads back. */
+function stubDeps(
+	installedAfter: string | null | ((scope: PluginScope) => string | null),
+) {
+	const saved: Array<{ id: string; version: string; scope: PluginScope }> = [];
+	const updated: Array<{ id: string; scope: PluginScope }> = [];
+	const repaired: Array<{ id: string; scope: PluginScope }> = [];
+
+	const deps: PluginApplyDeps = {
+		update: mock(async (id: string, scope: PluginScope) => {
+			updated.push({ id, scope });
+		}),
+		repair: mock(async (id: string, scope: PluginScope) => {
+			repaired.push({ id, scope });
+		}),
+		readInstalled: mock(async (_id: string, scope: PluginScope) =>
+			typeof installedAfter === "function"
+				? installedAfter(scope)
+				: installedAfter,
+		),
+		saveInstalled: mock(
+			async (id: string, version: string, scope: PluginScope) => {
+				saved.push({ id, version, scope });
+			},
+		),
+	};
+	return { deps, saved, updated, repaired };
+}
+
+function item(over: Partial<PluginUpdateItem>): PluginUpdateItem {
+	return {
+		pluginId: "dev@magus",
+		pinned: "latest",
+		installed: "1.0.0",
+		available: "2.0.0",
+		target: "2.0.0",
+		action: "update",
+		scopes: ["project"],
+		...over,
+	};
+}
+
+let logs: string[];
+beforeEach(() => {
+	logs = [];
+	// biome-ignore lint/suspicious/noExplicitAny: test double
+	console.log = ((...a: unknown[]) => logs.push(a.join(" "))) as any;
+	// biome-ignore lint/suspicious/noExplicitAny: test double
+	console.warn = ((...a: unknown[]) => logs.push(a.join(" "))) as any;
+});
+
+describe("what gets RECORDED is what got installed", () => {
+	test("records the version read back, not the version we asked for", async () => {
+		// `claude plugin install` accepts no version — it installs the newest.
+		// Recording `target` instead of the read-back made the registry claim a
+		// version that was never on disk.
+		const { deps, saved } = stubDeps("9.9.9");
+		await applyPlugins([item({ target: "2.0.0" })], PROJECT, deps);
+		expect(saved).toEqual([
+			{ id: "dev@magus", version: "9.9.9", scope: "project" },
+		]);
+	});
+
+	test("an exact pin the installer could not honour is reported, not hidden", async () => {
+		const { deps, saved } = stubDeps("9.9.9");
+		const result = await applyPlugins(
+			[item({ pinned: "4.6.1", target: "4.6.1" })],
+			PROJECT,
+			deps,
+		);
+		// The pin is NOT written as if satisfied...
+		expect(saved).toEqual([
+			{ id: "dev@magus", version: "9.9.9", scope: "project" },
+		]);
+		// ...and the shortfall is surfaced to the caller.
+		expect(result.mismatches).toEqual([
+			{
+				pluginId: "dev@magus",
+				pinned: "4.6.1",
+				actual: "9.9.9",
+				scope: "project",
+			},
+		]);
+	});
+
+	test("a satisfied exact pin produces no mismatch", async () => {
+		const { deps } = stubDeps("4.6.1");
+		const result = await applyPlugins(
+			[item({ pinned: "4.6.1", target: "4.6.1" })],
+			PROJECT,
+			deps,
+		);
+		expect(result.mismatches).toEqual([]);
+	});
+
+	test("a 'latest' pin never counts as a mismatch", async () => {
+		const { deps } = stubDeps("9.9.9");
+		const result = await applyPlugins(
+			[item({ pinned: "latest", target: "2.0.0" })],
+			PROJECT,
+			deps,
+		);
+		expect(result.mismatches).toEqual([]);
+	});
+
+	test("nothing is recorded when the registry has no version to read back", async () => {
+		// Writing a guess here would be the same fabrication in another costume.
+		const { deps, saved } = stubDeps(null);
+		await applyPlugins([item({})], PROJECT, deps);
+		expect(saved).toEqual([]);
+	});
+});
+
+describe("scope handling", () => {
+	test("a fresh install goes to project scope only", async () => {
+		const { deps, updated } = stubDeps("2.0.0");
+		await applyPlugins(
+			[item({ action: "install", installed: null, scopes: [] })],
+			PROJECT,
+			deps,
+		);
+		expect(updated).toEqual([{ id: "dev@magus", scope: "project" }]);
+	});
+
+	test("every outdated scope is updated AND recorded separately", async () => {
+		const { deps, updated, saved } = stubDeps((scope) =>
+			scope === "user" ? "2.0.0" : "1.5.0",
+		);
+		await applyPlugins([item({ scopes: ["user", "project"] })], PROJECT, deps);
+		expect(updated).toEqual([
+			{ id: "dev@magus", scope: "user" },
+			{ id: "dev@magus", scope: "project" },
+		]);
+		// Each scope records ITS OWN read-back, never one shared value.
+		expect(saved).toEqual([
+			{ id: "dev@magus", version: "2.0.0", scope: "user" },
+			{ id: "dev@magus", version: "1.5.0", scope: "project" },
+		]);
+	});
+
+	test("a repair uses repairPlugin, not a plain install", async () => {
+		// A content-stale plugin has no version bump, so `install` is a no-op that
+		// reports success — only uninstall+install refreshes the files.
+		const { deps, repaired, updated } = stubDeps("1.0.0");
+		await applyPlugins([item({ action: "repair" })], PROJECT, deps);
+		expect(repaired).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(updated).toEqual([]);
+	});
+});
+
+describe("what is skipped", () => {
+	test("'current' and 'unknown' items are never touched", async () => {
+		const { deps, updated, saved } = stubDeps("1.0.0");
+		await applyPlugins(
+			[
+				item({ action: "current", scopes: [] }),
+				item({ pluginId: "b@magus", action: "unknown", scopes: [] }),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(updated).toEqual([]);
+		expect(saved).toEqual([]);
+	});
+
+	test("an 'unknown' plugin is not installed on a guess", async () => {
+		// It is unknown because the catalog could not be reached. Acting on that
+		// would be picking a version at random.
+		const { deps, updated } = stubDeps("1.0.0");
+		await applyPlugins(
+			[item({ action: "unknown", target: null, scopes: ["project"] })],
+			PROJECT,
+			deps,
+		);
+		expect(updated).toEqual([]);
+	});
+});
+
+describe("failure handling", () => {
+	test("a failing plugin is reported, and the rest still run", async () => {
+		const { deps, updated } = stubDeps("2.0.0");
+		deps.update = mock(async (id: string, scope: PluginScope) => {
+			if (id === "bad@magus") throw new Error("network down");
+			updated.push({ id, scope });
+		});
+
+		const result = await applyPlugins(
+			[item({ pluginId: "bad@magus" }), item({ pluginId: "good@magus" })],
+			PROJECT,
+			deps,
+		);
+
+		expect(result.failed).toEqual(["bad@magus"]);
+		expect(result.ok).toBe(1);
+		expect(updated).toEqual([{ id: "good@magus", scope: "project" }]);
+	});
+
+	test("a scope that threw records nothing for that plugin", async () => {
+		// Half-applied state must not be recorded as if it succeeded.
+		const { deps, saved } = stubDeps("2.0.0");
+		deps.update = mock(async () => {
+			throw new Error("boom");
+		});
+		const result = await applyPlugins([item({})], PROJECT, deps);
+		expect(saved).toEqual([]);
+		expect(result.ok).toBe(0);
+	});
+});