Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

scripts/release/cli.test.ts

Raw
import { spawnSync } from "node:child_process";
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { pathToFileURL } from "node:url";
import { describe, expect, it } from "vitest";
import { ROOT } from "../build/build.ts";
import { digestTree } from "./index.ts";

function release(...args: string[]) {
	return spawnSync(
		process.execPath,
		["--no-warnings", join(ROOT, "scripts/release/cli.ts"), ...args],
		{
			cwd: ROOT,
			encoding: "utf8",
		},
	);
}

function plannedReleaseFixture() {
	const root = mkdtempSync(join(tmpdir(), "pi-ext-release-cli-"));
	writeFileSync(join(root, "package.json"), '{"version":"1.2.3"}\n');
	for (const name of ["eligible", "private"]) {
		const dir = join(root, "extensions", name);
		mkdirSync(dir, { recursive: true });
		writeFileSync(join(dir, "scenario.mjs"), "export function verify() {}\n");
		writeFileSync(
			join(dir, "package.json"),
			JSON.stringify({
				"pi-ext":
					name === "eligible"
						? {
								publish: true,
								publicName: "@owned/eligible",
								git: "file:///never-push",
								releaseScenario: "scenario.mjs",
							}
						: {},
			}),
		);
	}
	// Keep the real CLI and release logic; replace only the repository root and
	// build boundary so an accidental build leaves an observable fixture change.
	const buildUrl = pathToFileURL(join(ROOT, "scripts/build/build.ts")).href;
	const source = `
		export * from ${JSON.stringify(`${buildUrl}?original`)};
		import { writeFileSync } from "node:fs";
		export const ROOT = ${JSON.stringify(root)};
		export const DIST_ROOT = ${JSON.stringify(join(root, "dist"))};
		export async function buildExtension() {
			writeFileSync(${JSON.stringify(join(root, "unexpected-build"))}, "called");
			throw new Error("unexpected build");
		}
	`;
	const bootstrap = `
		import { registerHooks } from "node:module";
		registerHooks({ load(url, context, nextLoad) {
			return url === ${JSON.stringify(buildUrl)}
				? { format: "module", source: ${JSON.stringify(source)}, shortCircuit: true }
				: nextLoad(url, context);
		} });
	`;
	return {
		root,
		run: (...args: string[]) =>
			spawnSync(
				process.execPath,
				[
					"--no-warnings",
					"--import",
					`data:text/javascript,${encodeURIComponent(bootstrap)}`,
					join(ROOT, "scripts/release/cli.ts"),
					...args,
				],
				{ cwd: root, encoding: "utf8" },
			),
	};
}

describe("release CLI gates", () => {
	it("successfully plans eligible packages through the CLI without builds or writes", () => {
		const fixture = plannedReleaseFixture();
		try {
			const before = digestTree(fixture.root);
			const result = fixture.run("plan", "eligible");
			expect(result.status, result.stderr).toBe(0);
			expect(JSON.parse(result.stdout)).toEqual([
				{
					extension: "eligible",
					package: "@owned/eligible",
					version: "1.2.3",
					git: "file:///never-push",
				},
			]);
			expect(digestTree(fixture.root)).toBe(before);
		} finally {
			rmSync(fixture.root, { recursive: true, force: true });
		}
	});

	it("validates a later ineligible selection before building an earlier eligible package", () => {
		const fixture = plannedReleaseFixture();
		try {
			const before = digestTree(fixture.root);
			const result = fixture.run("snapshot", "eligible", "private");
			expect(result.status).not.toBe(0);
			expect(result.stderr).toContain("private is not eligible");
			expect(digestTree(fixture.root)).toBe(before);
		} finally {
			rmSync(fixture.root, { recursive: true, force: true });
		}
	});
	it("rejects invalid commands before attempting a build", () => {
		const result = release("invalid", "__missing_release_cli_fixture__");
		expect(result.status).toBe(2);
		expect(result.stderr).toContain("usage: release");
	});

	it("rejects pushing snapshots before attempting a build", () => {
		const result = release(
			"snapshot",
			"__missing_release_cli_fixture__",
			"--push",
		);
		expect(result.status).toBe(2);
		expect(result.stderr).toContain("usage: release");
	});

	it.each(["plan", "snapshot"])(
		"%s rejects ineligible extensions before attempting a build",
		(command) => {
			const result = release(command, "afk");
			expect(result.status).not.toBe(0);
			expect(result.stderr).toContain("afk is not eligible");
			expect(result.stdout).not.toContain("OK snapshot");
		},
	);

	it("requires an existing receipt instead of rebuilding during publication", () => {
		const result = release("publish", "__missing_release_cli_fixture__");
		expect(result.status).not.toBe(0);
		expect(result.stderr).toContain("has no verified snapshot receipt");
		expect(result.stdout).not.toContain("OK snapshot");
	});
});