magus-cli 7.5.2 → 7.5.4

package/src/__tests__/update-plan-parity.test.ts

@@ -0,0 +1,249 @@
+/**
+ * Spec 7.5.4 v3 — REQ-7: the CLI and the Plugins screen plan updates with ONE list.
+ * REQ-10: a plugin whose files are missing is repaired in the scope where they are
+ * missing, never at project scope.
+ *
+ * Written blind: from the spec and the exported signatures and interfaces only.
+ * `planPluginUpdates` is what the CLI plans with and `classifyPluginRows` is what the
+ * Plugins screen classifies its rows with; for the same pins and catalog they must say
+ * the same thing about every plugin.
+ *
+ * Both are pure, so everything here runs in-process on hand-built `PluginInfo`s.
+ */
+import { describe, expect, test } from "bun:test";
+import type { PluginInfo, ScopeStatus } from "../services/plugin-manager.js";
+import {
+	type PluginUpdateItem,
+	classifyPluginRows,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+
+interface Spec {
+	name: string;
+	/** What the marketplace offers. */
+	offered: string;
+	installedVersion?: string;
+	userScope?: ScopeStatus;
+	projectScope?: ScopeStatus;
+	localScope?: ScopeStatus;
+}
+
+function pluginInfo(spec: Spec): PluginInfo {
+	return {
+		id: `${spec.name}@magus`,
+		name: spec.name,
+		version: spec.offered,
+		description: "",
+		marketplace: "magus",
+		marketplaceDisplay: "magus",
+		installedVersion: spec.installedVersion,
+		userScope: spec.userScope,
+		projectScope: spec.projectScope,
+		localScope: spec.localScope,
+	};
+}
+
+const PINNED_INSTALLED = "alpha@magus";
+const PINNED_NOWHERE = "bravo@magus";
+const UNPINNED_USER_BEHIND = "charlie@magus";
+const UNPINNED_NOWHERE = "delta@magus";
+
+/**
+ * The REQ-7a mix, built fresh for every test so no call can see another's objects.
+ * Deliberately NOT in id order: the spec compares the plan against the classified rows
+ * sorted by `pluginId`, so an id-ordered catalog would hide the plan's own ordering.
+ */
+function mixedCatalog(): PluginInfo[] {
+	return [
+		// An UNPINNED plugin installed nowhere.
+		pluginInfo({
+			name: "delta",
+			offered: "4.0.0",
+			userScope: { installed: false },
+			projectScope: { installed: false },
+			localScope: { installed: false },
+		}),
+		// An UNPINNED plugin installed at USER scope only, behind the offered version.
+		pluginInfo({
+			name: "charlie",
+			offered: "3.1.0",
+			installedVersion: "3.0.0",
+			userScope: { installed: true, version: "3.0.0" },
+			projectScope: { installed: false },
+			localScope: { installed: false },
+		}),
+		// A pinned plugin installed at project scope.
+		pluginInfo({
+			name: "alpha",
+			offered: "2.0.0",
+			installedVersion: "2.0.0",
+			projectScope: { installed: true, version: "2.0.0" },
+		}),
+		// A pinned plugin installed nowhere.
+		pluginInfo({ name: "bravo", offered: "1.5.0" }),
+	];
+}
+
+function pins(): Record<string, string> {
+	return { [PINNED_INSTALLED]: "2.0.0", [PINNED_NOWHERE]: "latest" };
+}
+
+function byPluginId(a: PluginUpdateItem, b: PluginUpdateItem): number {
+	return a.pluginId < b.pluginId ? -1 : a.pluginId > b.pluginId ? 1 : 0;
+}
+
+function planItem(
+	plan: PluginUpdateItem[],
+	pluginId: string,
+): PluginUpdateItem | undefined {
+	return plan.find((item) => item.pluginId === pluginId);
+}
+
+describe("REQ-7 one update list for the CLI and the Plugins screen", () => {
+	test("REQ-7a the Plugins screen's classified rows, sorted by pluginId, deep-equal the CLI's plan", () => {
+		const plugins = mixedCatalog();
+
+		const plan = planPluginUpdates(pins(), plugins);
+		const rows = [...classifyPluginRows(mixedCatalog(), pins()).values()].sort(
+			byPluginId,
+		);
+
+		// Not vacuous: two of the four plugins are required in the plan (REQ-7b, REQ-7d).
+		expect(plan.length).toBeGreaterThanOrEqual(2);
+		expect(rows).toEqual(plan);
+	});
+
+	test("REQ-7b the unpinned USER-scope plugin that is behind appears, with action update", () => {
+		const plan = planPluginUpdates(pins(), mixedCatalog());
+
+		const item = planItem(plan, UNPINNED_USER_BEHIND);
+
+		expect(item).toBeDefined();
+		expect(item?.action).toBe("update");
+	});
+
+	test("REQ-7c the unpinned plugin installed nowhere does not appear in the plan", () => {
+		const plan = planPluginUpdates(pins(), mixedCatalog());
+
+		expect(plan.map((item) => item.pluginId)).not.toContain(UNPINNED_NOWHERE);
+	});
+
+	test("REQ-7d the pinned plugin installed nowhere appears with action install", () => {
+		const plan = planPluginUpdates(pins(), mixedCatalog());
+
+		const item = planItem(plan, PINNED_NOWHERE);
+
+		expect(item).toBeDefined();
+		expect(item?.action).toBe("install");
+	});
+
+	test("REQ-7e the catalog as a Map keyed by id gives the same plan as the array", () => {
+		const asArray = planPluginUpdates(pins(), mixedCatalog());
+		const asMap = planPluginUpdates(
+			pins(),
+			new Map(mixedCatalog().map((plugin) => [plugin.id, plugin])),
+		);
+
+		expect(asArray.length).toBeGreaterThanOrEqual(2);
+		expect(asMap).toEqual(asArray);
+	});
+});
+
+describe("REQ-10 missing files are repaired where they are missing, never at project scope", () => {
+	test("REQ-10a an unpinned plugin installed at USER scope with no version is reinstalled at user: install / files-missing / [user]", () => {
+		const catalog = [
+			pluginInfo({
+				name: "echo",
+				offered: "1.2.0",
+				userScope: { installed: true },
+				projectScope: { installed: false },
+				localScope: { installed: false },
+			}),
+		];
+
+		const item = planItem(planPluginUpdates({}, catalog), "echo@magus");
+
+		expect(item).toBeDefined();
+		expect({
+			action: item?.action,
+			reason: item?.reason,
+			scopes: item?.scopes,
+		}).toEqual({
+			action: "install",
+			reason: "files-missing",
+			scopes: ["user"],
+		});
+	});
+
+	test("REQ-10b an unpinned plugin installed at LOCAL scope with no version is reinstalled at local: install / files-missing / [local]", () => {
+		const catalog = [
+			pluginInfo({
+				name: "foxtrot",
+				offered: "1.2.0",
+				userScope: { installed: false },
+				projectScope: { installed: false },
+				localScope: { installed: true },
+			}),
+		];
+
+		const item = planItem(planPluginUpdates({}, catalog), "foxtrot@magus");
+
+		expect(item).toBeDefined();
+		expect({
+			action: item?.action,
+			reason: item?.reason,
+			scopes: item?.scopes,
+		}).toEqual({
+			action: "install",
+			reason: "files-missing",
+			scopes: ["local"],
+		});
+	});
+
+	test("REQ-10c a pinned plugin installed nowhere is installed: install / absent", () => {
+		const catalog = [pluginInfo({ name: "golf", offered: "2.0.0" })];
+
+		const item = planItem(
+			planPluginUpdates({ "golf@magus": "latest" }, catalog),
+			"golf@magus",
+		);
+
+		expect(item).toBeDefined();
+		expect({ action: item?.action, reason: item?.reason }).toEqual({
+			action: "install",
+			reason: "absent",
+		});
+	});
+
+	/** Installed at USER 0.9.0, catalog 0.9.0, plus an inherited PROJECT row that is not turned on. */
+	function currentWithInheritedRow(): PluginInfo[] {
+		return [
+			pluginInfo({
+				name: "hotel",
+				offered: "0.9.0",
+				installedVersion: "0.9.0",
+				userScope: { installed: true, version: "0.9.0" },
+				projectScope: { installed: false, version: "0.8.1" },
+			}),
+		];
+	}
+
+	// The spec does not say whether this plugin is pinned, so both are checked: the
+	// not-installed scope's version must not change the answer either way.
+	const PIN_CASES: Array<[label: string, pins: Record<string, string>]> = [
+		["unpinned", {}],
+		["pinned to latest", { "hotel@magus": "latest" }],
+	];
+
+	for (const [label, pinSet] of PIN_CASES) {
+		test(`REQ-10d (${label}) a not-installed PROJECT row at 0.8.1 does not make a current USER install look behind: current`, () => {
+			const item = planItem(
+				planPluginUpdates(pinSet, currentWithInheritedRow()),
+				"hotel@magus",
+			);
+
+			expect(item).toBeDefined();
+			expect(item?.action).toBe("current");
+		});
+	}
+});