magus-cli 7.10.1 → 7.10.3

package/src/__tests__/blind/c18-probe-adopts-homebrew-keg.test.ts

@@ -0,0 +1,345 @@
+/**
+ * Blind tests, contract C18: Homebrew owns an installed tool whose file lies
+ * in `<brew prefix>/Cellar/<short name>/<version>/...`, whatever installer the
+ * spec declares. A pinned spec is not adopted (brew takes no version).
+ *
+ * Written from the spec only, through a scripted fake `ToolProbeIO`.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+	type ExecResult,
+	type FetchJsonResult,
+	type ToolProbeIO,
+	classifyTool,
+	probeTool,
+} from "../../services/tool-probe.js";
+import type { BinRequirement } from "../../types/index.js";
+
+interface FakeSetup {
+	exec?: Record<string, Partial<ExecResult>>;
+	fetch?: Record<string, FetchJsonResult>;
+	files?: Record<string, string>;
+	real?: Record<string, string>;
+	onPath?: Record<string, string>;
+	env?: Record<string, string>;
+}
+
+function fakeIO(setup: FakeSetup): ToolProbeIO & { calls: string[] } {
+	const calls: string[] = [];
+	return {
+		calls,
+		exec: async (command) => {
+			const key = [command.cmd, ...command.args].join(" ");
+			calls.push(key);
+			const h = setup.exec?.[key];
+			if (h === undefined) {
+				return {
+					code: null,
+					stdout: "",
+					stderr: "",
+					timedOut: false,
+					missing: true,
+				};
+			}
+			return {
+				code: 0,
+				stdout: "",
+				stderr: "",
+				timedOut: false,
+				missing: false,
+				...h,
+			};
+		},
+		fetchJson: async (url) => {
+			const r = setup.fetch?.[url];
+			return r ?? { ok: false, reason: "returned 404" };
+		},
+		readJson: async (file) => {
+			const t = setup.files?.[file];
+			if (t === undefined) return null;
+			try {
+				return JSON.parse(t);
+			} catch {
+				return null;
+			}
+		},
+		readText: async (file) => setup.files?.[file] ?? null,
+		readlink: async () => null,
+		realpath: async (file) => setup.real?.[file] ?? null,
+		resolveExecutable: async (name) => setup.onPath?.[name] ?? null,
+		env: setup.env ?? {},
+		homedir: "/Users/j",
+	};
+}
+
+const PREFIX = "/opt/homebrew";
+const CELLAR = { "/opt/homebrew/Cellar": "/opt/homebrew/Cellar" };
+const BREW_PREFIX_OK: Record<string, Partial<ExecResult>> = {
+	"brew --prefix": { stdout: `${PREFIX}\n` },
+};
+
+const OUTDATED_NONE = JSON.stringify({ formulae: [], casks: [] });
+const outdatedBehind = (name: string, installed: string, current: string) =>
+	JSON.stringify({
+		formulae: [
+			{
+				name,
+				installed_versions: [installed],
+				current_version: current,
+				pinned: false,
+			},
+		],
+		casks: [],
+	});
+
+/** A tool whose PATH entry resolves into a Homebrew keg. */
+function kegWorld(
+	bin: string,
+	short: string,
+	version: string,
+	outdatedKey: string,
+	outdatedStdout: string,
+	extraExec: Record<string, Partial<ExecResult>> = BREW_PREFIX_OK,
+): FakeSetup {
+	const file = `${PREFIX}/Cellar/${short}/${version}/bin/${bin}`;
+	const onPath = `${PREFIX}/bin/${bin}`;
+	return {
+		onPath: { [bin]: onPath },
+		real: { [onPath]: file, [file]: file, ...CELLAR },
+		exec: {
+			...extraExec,
+			[`brew outdated --json=v2 ${outdatedKey}`]: { stdout: outdatedStdout },
+		},
+	};
+}
+
+const MNEMEX: BinRequirement = {
+	name: "mnemex",
+	via: "brew",
+	formula: "madappgang/tap/mnemex",
+};
+
+describe("C18 case 1: tap formula, brew spec, current", () => {
+	test("managed, version from the keg, state current", async () => {
+		const f = await probeTool(
+			MNEMEX,
+			fakeIO(
+				kegWorld(
+					"mnemex",
+					"mnemex",
+					"0.36.2",
+					"madappgang/tap/mnemex",
+					OUTDATED_NONE,
+				),
+			),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.installed).toBe("0.36.2");
+		expect(classifyTool(MNEMEX, f).state).toBe("current");
+	});
+});
+
+describe("C18 case 2: tap formula behind", () => {
+	test("state upgrade, latest from brew", async () => {
+		const f = await probeTool(
+			MNEMEX,
+			fakeIO(
+				kegWorld(
+					"mnemex",
+					"mnemex",
+					"0.36.2",
+					"madappgang/tap/mnemex",
+					outdatedBehind("madappgang/tap/mnemex", "0.36.2", "0.37.0"),
+				),
+			),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.latest).toBe("0.37.0");
+		expect(classifyTool(MNEMEX, f).state).toBe("upgrade");
+	});
+});
+
+describe("C18 case 3: bun spec, file in a Homebrew keg", () => {
+	const spec: BinRequirement = {
+		name: "claudish",
+		via: "bun",
+		package: "claudish",
+	};
+	test("adopted by brew: brew upgrade command, never bun", async () => {
+		const f = await probeTool(
+			spec,
+			fakeIO(
+				kegWorld(
+					"claudish",
+					"claudish",
+					"10.5.0",
+					"claudish",
+					outdatedBehind("claudish", "10.5.0", "10.6.0"),
+				),
+			),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.installed).toBe("10.5.0");
+		expect(f.latest).toBe("10.6.0");
+		expect(f.upgradeCommand).toEqual({
+			cmd: "brew",
+			args: ["upgrade", "claudish"],
+		});
+		expect(f.upgradeCommand?.cmd).not.toBe("bun");
+		expect(classifyTool(spec, f).state).toBe("upgrade");
+	});
+});
+
+describe("C18 case 4: npm spec, file in a Homebrew keg", () => {
+	const spec: BinRequirement = {
+		name: "claudish",
+		via: "npm",
+		package: "claudish",
+	};
+	test("current, upgrade command is brew", async () => {
+		const f = await probeTool(
+			spec,
+			fakeIO(
+				kegWorld("claudish", "claudish", "10.5.0", "claudish", OUTDATED_NONE),
+			),
+		);
+		expect(f.upgradeCommand?.cmd).toBe("brew");
+		expect(classifyTool(spec, f).state).toBe("current");
+	});
+});
+
+describe("C18 case 5: a pinned spec is not adopted by Homebrew", () => {
+	const spec: BinRequirement = {
+		name: "claudish",
+		via: "bun",
+		package: "claudish",
+		version: "10.4.0",
+	};
+	test("unknown, no brew command, note mentions the pin", async () => {
+		const f = await probeTool(
+			spec,
+			fakeIO(
+				kegWorld(
+					"claudish",
+					"claudish",
+					"10.5.0",
+					"claudish",
+					outdatedBehind("claudish", "10.5.0", "10.6.0"),
+				),
+			),
+		);
+		expect(f.upgradeCommand?.cmd).not.toBe("brew");
+		const s = classifyTool(spec, f);
+		expect(s.state).toBe("unknown");
+		expect(s.note ?? "").toContain("10.4.0");
+	});
+});
+
+describe("C18 case 6: a directory merely named Cellar is not Homebrew's", () => {
+	const spec: BinRequirement = {
+		name: "claudish",
+		via: "bun",
+		package: "claudish",
+	};
+	test("not adopted: external, no upgrade command", async () => {
+		const file = "/Users/u/projects/Cellar/claudish/1.0.0/bin/claudish";
+		const f = await probeTool(
+			spec,
+			fakeIO({
+				onPath: { claudish: file },
+				real: { [file]: file, ...CELLAR },
+				exec: BREW_PREFIX_OK,
+			}),
+		);
+		expect(f.managed).not.toBe(true);
+		expect(f.upgradeCommand).toBeUndefined();
+		expect(classifyTool(spec, f).state).toBe("external");
+	});
+});
+
+describe("C18 case 7: Homebrew unavailable", () => {
+	const spec: BinRequirement = {
+		name: "claudish",
+		via: "bun",
+		package: "claudish",
+	};
+	const world = (exec: Record<string, Partial<ExecResult>>): FakeSetup =>
+		kegWorld(
+			"claudish",
+			"claudish",
+			"10.5.0",
+			"claudish",
+			outdatedBehind("claudish", "10.5.0", "10.6.0"),
+			exec,
+		);
+	test("brew --prefix missing: not adopted", async () => {
+		const f = await probeTool(spec, fakeIO(world({})));
+		expect(f.upgradeCommand?.cmd).not.toBe("brew");
+		expect(classifyTool(spec, f).state).not.toBe("upgrade");
+	});
+	test("brew --prefix exits non-zero: not adopted", async () => {
+		const f = await probeTool(
+			spec,
+			fakeIO(world({ "brew --prefix": { code: 1, stderr: "boom" } })),
+		);
+		expect(f.upgradeCommand?.cmd).not.toBe("brew");
+		expect(classifyTool(spec, f).state).not.toBe("upgrade");
+	});
+});
+
+describe("C18 case 8: a non-tap brew spec still works", () => {
+	test("tmux current, installed 3.8", async () => {
+		const spec: BinRequirement = {
+			name: "tmux",
+			via: "brew",
+			formula: "tmux",
+			check: "tmux -V",
+		};
+		const f = await probeTool(
+			spec,
+			fakeIO(kegWorld("tmux", "tmux", "3.8", "tmux", OUTDATED_NONE)),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.installed).toBe("3.8");
+		expect(classifyTool(spec, f).state).toBe("current");
+	});
+});
+
+describe("C18 case 9: bun ownership still wins over a brew spec", () => {
+	test("file in bun's global tree: bun command, current", async () => {
+		const root = "/Users/j/.bun/install/global/node_modules";
+		const pkgDir = `${root}/mnemex`;
+		const file = `${pkgDir}/dist/index.js`;
+		const onPath = "/Users/j/.bun/bin/mnemex";
+		const f = await probeTool(
+			MNEMEX,
+			fakeIO({
+				env: { HOMEBREW_PREFIX: PREFIX },
+				onPath: { mnemex: onPath },
+				real: {
+					[onPath]: file,
+					[file]: file,
+					[pkgDir]: pkgDir,
+					[root]: root,
+					...CELLAR,
+				},
+				files: {
+					[`${pkgDir}/package.json`]: JSON.stringify({
+						name: "mnemex",
+						version: "0.36.2",
+					}),
+				},
+				exec: BREW_PREFIX_OK,
+				fetch: {
+					"https://registry.npmjs.org/-/package/mnemex/dist-tags": {
+						ok: true,
+						body: { latest: "0.36.2" },
+					},
+				},
+			}),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.upgradeCommand?.cmd).toBe("bun");
+		expect(classifyTool(MNEMEX, f).state).toBe("current");
+	});
+});