claudeup 6.5.1 → 6.6.0

package/src/__tests__/dual-write-prevention.test.ts

@@ -1,380 +0,0 @@
-/**
- * Version tracking tests
- *
- * The Claude CLI's `plugin install` command does NOT update `installedPluginVersions`
- * in settings.json — it only manages `enabledPlugins`. Claudeup must save the version
- * itself after a successful CLI install/update.
- *
- * PluginsScreen: no saveVersionAfterInstall helper (removed in v4.5.0), but each
- *   action handler calls saveVersionForScope after CLI success.
- * Prerunner: calls saveGlobalInstalledPluginVersion after successful updatePlugin,
- *   but NOT when CLI is unavailable or update fails (no phantom state).
- */
-
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as url from "node:url";
-import * as actualClaudeCli from "../services/claude-cli.js";
-// Real modules captured before the mock.module() overrides below, so the mocks
-// can spread the full export surface instead of stripping it.
-import * as actualClaudeSettings from "../services/claude-settings.js";
-import * as actualPluginManager from "../services/plugin-manager.js";
-
-// ---------------------------------------------------------------------------
-// PART 1: PluginsScreen source-level policy tests
-//
-// The dual-write calls in PluginsScreen are inside React event handlers.
-// Rendering the full TUI component in a unit test would require the opentui
-// terminal runtime. Instead we assert the source does NOT contain the
-// forbidden call pattern — this is a code-policy test that:
-//   - FAILS before the fix  (6 saveVersionAfterInstall calls follow CLI calls)
-//   - PASSES after the fix  (those calls are removed)
-// ---------------------------------------------------------------------------
-
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const PLUGINS_SCREEN_PATH = path.resolve(
-	__dirname,
-	"../ui/screens/PluginsScreen.tsx",
-);
-
-describe("PluginsScreen — no dual-write after CLI operations", () => {
-	let source: string;
-
-	beforeEach(() => {
-		source = fs.readFileSync(PLUGINS_SCREEN_PATH, "utf8");
-	});
-
-	it("does not call saveVersionAfterInstall immediately after cliUpdatePlugin", () => {
-		// Find every occurrence of cliUpdatePlugin in the source. Each one should
-		// NOT be immediately followed (within 3 lines) by saveVersionAfterInstall.
-		const lines = source.split("\n");
-		const violations: number[] = [];
-
-		for (let i = 0; i < lines.length; i++) {
-			if (lines[i].includes("cliUpdatePlugin(")) {
-				// Check the next 3 lines for a dual-write call
-				for (let j = i + 1; j <= Math.min(i + 3, lines.length - 1); j++) {
-					if (lines[j].includes("saveVersionAfterInstall(")) {
-						violations.push(i + 1); // 1-indexed line number
-						break;
-					}
-				}
-			}
-		}
-
-		expect(violations).toEqual([]);
-	});
-
-	it("does not call saveVersionAfterInstall immediately after cliInstallPlugin", () => {
-		const lines = source.split("\n");
-		const violations: number[] = [];
-
-		for (let i = 0; i < lines.length; i++) {
-			if (lines[i].includes("cliInstallPlugin(")) {
-				for (let j = i + 1; j <= Math.min(i + 3, lines.length - 1); j++) {
-					if (lines[j].includes("saveVersionAfterInstall(")) {
-						violations.push(i + 1);
-						break;
-					}
-				}
-			}
-		}
-
-		expect(violations).toEqual([]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// PART 2: Prerunner — saveGlobalInstalledPluginVersion guarded by CLI success
-//
-// We mock the prerunner's module dependencies so we can call prerunClaude()
-// directly and inspect call counts.
-// ---------------------------------------------------------------------------
-
-// Mutable state shared between mock factories and test assertions.
-let mockSaveGlobal: ReturnType<typeof mock>;
-let mockSaveProject: ReturnType<typeof mock>;
-let mockSaveLocal: ReturnType<typeof mock>;
-let mockUpdatePlugin: ReturnType<typeof mock>;
-let mockRepairPlugin: ReturnType<typeof mock>;
-let mockIsClaudeAvailable: ReturnType<typeof mock>;
-let mockGetAvailablePlugins: ReturnType<typeof mock>;
-
-// Spread the REAL modules and override only the functions under test, so this
-// file's mock.module doesn't strip other exports the module graph needs (which
-// breaks both this file in isolation and — because bun's mock.module is global
-// and not restored across files — every later test file). The `import * as`
-// bindings are evaluated before these mock.module() calls run, so they capture
-// the real modules.
-mock.module("../services/claude-settings.js", () => ({
-	...actualClaudeSettings,
-	recoverMarketplaceSettings: mock(() =>
-		Promise.resolve({ enabledAutoUpdate: [], removed: [], reregistered: [] }),
-	),
-	migrateMarketplaceRename: mock(() =>
-		Promise.resolve({
-			projectMigrated: 0,
-			globalMigrated: 0,
-			localMigrated: 0,
-			registryMigrated: 0,
-			knownMarketplacesMigrated: false,
-		}),
-	),
-	getGlobalEnabledPlugins: mock(() => Promise.resolve({})),
-	getEnabledPlugins: mock(() => Promise.resolve({})),
-	getLocalEnabledPlugins: mock(() => Promise.resolve({})),
-	saveGlobalInstalledPluginVersion: (...args: unknown[]) =>
-		mockSaveGlobal(...args),
-	saveLocalInstalledPluginVersion: (...args: unknown[]) =>
-		mockSaveLocal(...args),
-	readGlobalSettings: mock(() => Promise.resolve({ hooks: {} })),
-	writeGlobalSettings: mock(() => Promise.resolve()),
-}));
-
-mock.module("../services/claude-cli.js", () => ({
-	...actualClaudeCli,
-	updatePlugin: (...args: unknown[]) => mockUpdatePlugin(...args),
-	repairPlugin: (...args: unknown[]) => mockRepairPlugin(...args),
-	isClaudeAvailable: (...args: unknown[]) => mockIsClaudeAvailable(...args),
-	addMarketplace: mock(() => Promise.resolve()),
-	updateMarketplace: mock(() => Promise.resolve()),
-}));
-
-mock.module("../services/plugin-manager.js", () => ({
-	...actualPluginManager,
-	getAvailablePlugins: (...args: unknown[]) => mockGetAvailablePlugins(...args),
-	saveInstalledPluginVersion: (...args: unknown[]) => mockSaveProject(...args),
-	clearMarketplaceCache: mock(() => undefined),
-}));
-
-mock.module("../services/update-cache.js", () => ({
-	UpdateCache: class {
-		shouldCheckForUpdates = mock(() => Promise.resolve(true));
-		saveCheck = mock(() => Promise.resolve());
-	},
-}));
-
-mock.module("../services/claude-runner.js", () => ({
-	runClaude: mock(() => Promise.resolve(0)),
-}));
-
-mock.module("../data/marketplaces.js", () => ({
-	defaultMarketplaces: [],
-}));
-
-mock.module("../utils/string-utils.js", () => ({
-	parsePluginId: mock((_id: string) => null),
-}));
-
-mock.module("fs-extra", () => ({
-	default: {
-		pathExists: mock(() => Promise.resolve(false)),
-		readJson: mock(() => Promise.resolve({})),
-		writeJson: mock(() => Promise.resolve()),
-		ensureDir: mock(() => Promise.resolve()),
-	},
-}));
-
-// Now import the module under test (after mock.module registrations).
-const { prerunClaude } = await import("../prerunner/index.js");
-
-interface ScopeStatusLike {
-	enabled: boolean;
-	version?: string;
-}
-interface PluginLike {
-	id: string;
-	enabled: boolean;
-	hasUpdate: boolean;
-	contentStale?: boolean;
-	installedVersion: string;
-	version: string;
-	userScope?: ScopeStatusLike;
-	projectScope?: ScopeStatusLike;
-	localScope?: ScopeStatusLike;
-}
-
-/**
- * Minimal PluginInfo-like object. The per-scope status matters: the prerunner
- * updates the scopes that actually hold an outdated install, so a fixture with
- * no scope status describes a plugin installed nowhere and is correctly skipped.
- */
-function makePlugin(overrides: Partial<PluginLike> = {}): PluginLike {
-	return {
-		id: "test-plugin@magus",
-		enabled: true,
-		hasUpdate: true,
-		installedVersion: "1.0.0",
-		version: "1.1.0",
-		userScope: { enabled: true, version: "1.0.0" },
-		...overrides,
-	};
-}
-
-describe("prerunner — saveGlobalInstalledPluginVersion call count", () => {
-	beforeEach(() => {
-		mockSaveGlobal = mock(() => Promise.resolve());
-		mockSaveProject = mock(() => Promise.resolve());
-		mockSaveLocal = mock(() => Promise.resolve());
-		mockUpdatePlugin = mock(() => Promise.resolve());
-		mockRepairPlugin = mock(() => Promise.resolve());
-		mockIsClaudeAvailable = mock(() => Promise.resolve(true));
-		mockGetAvailablePlugins = mock(() => Promise.resolve([makePlugin()]));
-	});
-
-	it("calls saveGlobalInstalledPluginVersion once after successful CLI update", async () => {
-		// CLI is available, updatePlugin succeeds.
-		// The CLI does NOT update installedPluginVersions, so claudeup must save
-		// the version after a successful update.
-		mockIsClaudeAvailable = mock(() => Promise.resolve(true));
-		mockUpdatePlugin = mock(() => Promise.resolve());
-
-		await prerunClaude(["--help"], { force: true });
-
-		expect(mockSaveGlobal).toHaveBeenCalledTimes(1);
-	});
-
-	/**
-	 * The prerunner used to call `updatePlugin(id, "user")` unconditionally.
-	 * `hasUpdate` is computed from the CURRENT PROJECT's resolved version, but
-	 * installs live per project in installed_plugins.json — 495 of 496 magus
-	 * installs on the reporter's machine are project-scoped. So it detected
-	 * project drift, updated user scope, reported success, and left the project
-	 * untouched, re-detecting the identical drift on every subsequent run.
-	 */
-	it("updates the PROJECT scope when that is where the outdated install is", async () => {
-		mockGetAvailablePlugins = mock(() =>
-			Promise.resolve([
-				makePlugin({
-					userScope: undefined,
-					projectScope: { enabled: true, version: "1.0.0" },
-				}),
-			]),
-		);
-
-		await prerunClaude(["--help"], { force: true });
-
-		expect(mockUpdatePlugin).toHaveBeenCalledTimes(1);
-		expect(mockUpdatePlugin.mock.calls[0]?.[1]).toBe("project");
-		expect(mockSaveProject).toHaveBeenCalledTimes(1);
-		expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
-	});
-
-	it("updates every scope that is outdated, not just the first", async () => {
-		mockGetAvailablePlugins = mock(() =>
-			Promise.resolve([
-				makePlugin({
-					userScope: { enabled: true, version: "1.0.0" },
-					projectScope: { enabled: true, version: "1.0.0" },
-					localScope: { enabled: true, version: "1.1.0" }, // already current
-				}),
-			]),
-		);
-
-		await prerunClaude(["--help"], { force: true });
-
-		const scopes = mockUpdatePlugin.mock.calls
-			.map((c: unknown[]) => c[1])
-			.sort();
-		expect(scopes).toEqual(["project", "user"]);
-		expect(mockSaveLocal).toHaveBeenCalledTimes(0);
-	});
-
-	/**
-	 * A content-stale plugin has no version bump to install over, and
-	 * `claude plugin install` no-ops on "already installed" (verified against the
-	 * real marketplace in autotest/plugin-system/probe-05). The prerunner must
-	 * therefore repair — uninstall+install — not update.
-	 */
-	it("repairs a content-stale plugin instead of updating it", async () => {
-		mockGetAvailablePlugins = mock(() =>
-			Promise.resolve([
-				makePlugin({
-					hasUpdate: false,
-					contentStale: true,
-					installedVersion: "1.0.0",
-					version: "1.0.0",
-					userScope: undefined,
-					projectScope: { enabled: true, version: "1.0.0" },
-				}),
-			]),
-		);
-
-		await prerunClaude(["--help"], { force: true });
-
-		expect(mockRepairPlugin).toHaveBeenCalledTimes(1);
-		expect(mockRepairPlugin.mock.calls[0]?.[1]).toBe("project");
-		expect(mockUpdatePlugin).toHaveBeenCalledTimes(0);
-	});
-
-	it("prefers a real version update over a repair when both apply", async () => {
-		// A pending version bump reinstalls the files anyway, so repairing as well
-		// would double the work and the uninstall window.
-		mockGetAvailablePlugins = mock(() =>
-			Promise.resolve([makePlugin({ hasUpdate: true, contentStale: true })]),
-		);
-
-		await prerunClaude(["--help"], { force: true });
-
-		expect(mockUpdatePlugin).toHaveBeenCalledTimes(1);
-		expect(mockRepairPlugin).toHaveBeenCalledTimes(0);
-	});
-
-	it("does not repair when the CLI is unavailable", async () => {
-		mockIsClaudeAvailable = mock(() => Promise.resolve(false));
-		mockGetAvailablePlugins = mock(() =>
-			Promise.resolve([
-				makePlugin({
-					hasUpdate: false,
-					contentStale: true,
-					version: "1.0.0",
-					projectScope: { enabled: true, version: "1.0.0" },
-				}),
-			]),
-		);
-
-		await prerunClaude(["--help"], { force: true });
-
-		expect(mockRepairPlugin).toHaveBeenCalledTimes(0);
-	});
-
-	it("does nothing when no scope holds an outdated install", async () => {
-		// hasUpdate can be true from a stale settings base while every real
-		// install is already current. Updating "somewhere" would be a guess.
-		mockGetAvailablePlugins = mock(() =>
-			Promise.resolve([
-				makePlugin({
-					userScope: { enabled: true, version: "1.1.0" },
-					projectScope: undefined,
-				}),
-			]),
-		);
-
-		await prerunClaude(["--help"], { force: true });
-
-		expect(mockUpdatePlugin).toHaveBeenCalledTimes(0);
-		expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
-	});
-
-	it("does NOT call saveGlobalInstalledPluginVersion when CLI is unavailable", async () => {
-		// CLI unavailable — we must NOT write phantom state.
-		mockIsClaudeAvailable = mock(() => Promise.resolve(false));
-
-		await prerunClaude(["--help"], { force: true });
-
-		expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
-	});
-
-	it("does NOT call saveGlobalInstalledPluginVersion when CLI updatePlugin throws", async () => {
-		// CLI available but updatePlugin fails — must NOT write phantom state.
-		mockIsClaudeAvailable = mock(() => Promise.resolve(true));
-		mockUpdatePlugin = mock(() =>
-			Promise.reject(new Error("CLI update failed")),
-		);
-
-		await prerunClaude(["--help"], { force: true });
-
-		expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
-	});
-});