Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

scripts/release/prepare.test.ts

Raw
import { spawnSync } from "node:child_process";
import {
	mkdirSync,
	mkdtempSync,
	readFileSync,
	rmSync,
	writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, describe, expect, it } from "vitest";
import { treeDigest } from "../build/release.ts";
import { setRootVersion } from "../extensions.ts";
import { parseRequest, prepareRelease } from "./prepare.ts";

const roots: string[] = [];

function git(root: string, ...args: string[]): string {
	const result = spawnSync("git", args, { cwd: root, encoding: "utf8" });
	if (result.status !== 0) throw new Error(result.stderr);
	return result.stdout.trim();
}

function fixture() {
	const root = mkdtempSync(join(tmpdir(), "pi-ext-release-prepare-"));
	const remote = join(root, "remote.git");
	const work = join(root, "work");
	roots.push(root);
	git(root, "init", "--bare", remote);
	git(root, "init", "-q", work);
	git(work, "config", "user.name", "test");
	git(work, "config", "user.email", "test@invalid");
	mkdirSync(join(work, ".ci"), { recursive: true });
	writeFileSync(
		join(work, "package.json"),
		'{"name":"pi-ext","version":"2.0.0","pi-ext":{"minimumPi":"1.4.0"}}\n',
	);
	writeFileSync(
		join(work, "package-lock.json"),
		'{"name":"pi-ext","version":"2.0.0","packages":{"":{"name":"pi-ext","version":"2.0.0"}}}\n',
	);
	writeFileSync(join(work, ".gitignore"), "/dist/\n/release-manifest.json\n");
	writeFileSync(
		join(work, "mise.toml"),
		'monorepo_root = true\n\n[tasks.release-version]\nrun = "node task.mjs version"\n\n[tasks.release-all]\nrun = "node task.mjs build"\n\n[tasks.verify-packages]\nrun = "node task.mjs verify"\n',
	);
	writeFileSync(
		join(work, "task.mjs"),
		`import { createHash } from "node:crypto";
import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
import { join } from "node:path";
if (process.argv[2] === "build") {
  const dir = join(process.cwd(), "dist", "demo");
  mkdirSync(dir, { recursive: true });
  writeFileSync(join(dir, "package.json"), "{\\"version\\":\\"2.0.0\\"}\\n");
  writeFileSync(join(dir, ".pi-ext-build.json"), "{\\"files\\":[\\"package.json\\"]}\\n");
  const hash = createHash("sha256");
  for (const file of [".pi-ext-build.json", "package.json"]) hash.update(file + "\\0file:" + createHash("sha256").update(readFileSync(join(dir, file))).digest("hex") + "\\n");
  writeFileSync("release-manifest.json", JSON.stringify({ extensions: [{ extension: "demo", digest: hash.digest("hex") }] }) + "\\n");
}
`,
	);
	git(work, "add", ".");
	git(work, "commit", "-qm", "source");
	const source = git(work, "rev-parse", "HEAD");
	writeFileSync(
		join(work, ".ci", "release-request.json"),
		`${JSON.stringify({ sourceCommit: source, targetBranch: "release/v2.0.0", version: "2.0.0" }, null, "\t")}\n`,
	);
	git(work, "add", ".ci/release-request.json");
	git(work, "commit", "-qm", "request");
	const request = git(work, "rev-parse", "HEAD");
	git(work, "remote", "add", "origin", remote);
	git(work, "push", "-q", "origin", "HEAD:trunk");
	const runTask = (task: string, args: string[], cwd: string) => {
		if (task === "//:release-version")
			return setRootVersion(args[0] ?? "", cwd);
		if (task === "//:release-all") {
			const dir = join(cwd, "dist", "demo");
			mkdirSync(dir, { recursive: true });
			writeFileSync(join(dir, "package.json"), '{"version":"2.0.0"}\n');
			writeFileSync(
				join(dir, ".pi-ext-build.json"),
				'{"files":["package.json"]}\n',
			);
			writeFileSync(
				join(cwd, "release-manifest.json"),
				`${JSON.stringify({ extensions: [{ extension: "demo", digest: treeDigest(dir) }] })}\n`,
			);
			return;
		}
		if (task === "//:verify-packages") return;
		throw new Error(`unexpected task ${task}`);
	};
	return { root: work, remote, request, runTask, source };
}

afterEach(() =>
	roots
		.splice(0)
		.forEach((root) => rmSync(root, { recursive: true, force: true })),
);

describe("release preparation request", () => {
	const sourceCommit = "a".repeat(40);

	it("accepts one explicit semantic version request", () => {
		expect(
			parseRequest(
				JSON.stringify({
					sourceCommit,
					targetBranch: "release/v1.2.3-rc.1",
					version: "1.2.3-rc.1",
				}),
			),
		).toEqual({
			sourceCommit,
			targetBranch: "release/v1.2.3-rc.1",
			version: "1.2.3-rc.1",
		});
	});

	it.each([
		"not json",
		JSON.stringify({ sourceCommit, targetBranch: "trunk", version: "1.2.3" }),
		JSON.stringify({
			sourceCommit: "a".repeat(39),
			targetBranch: "release/v1.2.3",
			version: "1.2.3",
		}),
		JSON.stringify({
			sourceCommit,
			targetBranch: "release/v1.2.3-01",
			version: "1.2.3-01",
		}),
		JSON.stringify({
			sourceCommit,
			targetBranch: "release/v1.2.3",
			version: "1.2.3",
			extra: true,
		}),
	])("rejects invalid input before release work: %s", (input) => {
		expect(() => parseRequest(input)).toThrow(/release preparation/u);
	});
});

describe("release preparation coordinator", () => {
	it("prepares once, retains evidence, and retries without another commit", () => {
		const input = fixture();
		prepareRelease({
			root: input.root,
			remote: input.remote,
			runTask: input.runTask,
		});
		const branch = "refs/heads/release/v2.0.0";
		const prepared = git(
			input.root,
			"--git-dir",
			input.remote,
			"rev-parse",
			branch,
		);
		expect(
			git(
				input.root,
				"--git-dir",
				input.remote,
				"show",
				`${prepared}:package.json`,
			),
		).toBe(git(input.root, "show", `${input.source}:package.json`));
		expect(
			git(
				input.root,
				"--git-dir",
				input.remote,
				"show",
				`${prepared}:package-lock.json`,
			),
		).toBe(git(input.root, "show", `${input.source}:package-lock.json`));
		git(input.root, "checkout", "-q", input.request);
		prepareRelease({
			root: input.root,
			remote: input.remote,
			runTask: input.runTask,
		});
		expect(
			git(input.root, "--git-dir", input.remote, "rev-parse", branch),
		).toBe(prepared);
		expect(
			readFileSync(join(input.root, "release-provenance.json"), "utf8"),
		).toContain(input.source);
	});

	it("executes the checked-out source's Mise task handoff", () => {
		const input = fixture();
		prepareRelease({ root: input.root, remote: input.remote });
		expect(
			git(
				input.root,
				"--git-dir",
				input.remote,
				"rev-parse",
				"refs/heads/release/v2.0.0",
			),
		).toMatch(/^[0-9a-f]{40}$/u);
	});

	it("rejects a candidate with forged non-version metadata", () => {
		const input = fixture();
		prepareRelease({
			root: input.root,
			remote: input.remote,
			runTask: input.runTask,
		});
		const branch = "refs/heads/release/v2.0.0";
		const prepared = git(
			input.root,
			"--git-dir",
			input.remote,
			"rev-parse",
			branch,
		);
		const packagePath = join(input.root, "package.json");
		writeFileSync(
			packagePath,
			readFileSync(packagePath, "utf8").replace("minimumPi", "forgedPi"),
		);
		git(input.root, "add", "package.json");
		git(input.root, "commit", "--amend", "--no-edit");
		git(input.root, "push", "-q", "--force", "origin", `HEAD:${branch}`);
		git(input.root, "checkout", "-q", input.request);
		expect(() =>
			prepareRelease({
				root: input.root,
				remote: input.remote,
				runTask: input.runTask,
			}),
		).toThrow(/non-version metadata/u);
		expect(
			git(input.root, "--git-dir", input.remote, "rev-parse", branch),
		).not.toBe(prepared);
	});

	it("leaves the remote unchanged when verification fails", () => {
		const input = fixture();
		expect(() =>
			prepareRelease({
				root: input.root,
				remote: input.remote,
				runTask: (task, args, cwd) => {
					if (task === "//:release-version")
						return setRootVersion(args[0] ?? "", cwd);
					if (task === "//:release-all") return input.runTask(task, args, cwd);
					throw new Error(`simulated ${task} failure`);
				},
			}),
		).toThrow(/simulated/u);
		expect(
			git(
				input.root,
				"ls-remote",
				"--heads",
				input.remote,
				"refs/heads/release/v2.0.0",
			),
		).toBe("");
	});

	it("rejects a concurrent release-branch creation through its lease", () => {
		const input = fixture();
		expect(() =>
			prepareRelease({
				root: input.root,
				remote: input.remote,
				runTask: input.runTask,
				beforePush: () => {
					git(
						input.root,
						"--git-dir",
						input.remote,
						"update-ref",
						"refs/heads/release/v2.0.0",
						input.source,
					);
				},
			}),
		).toThrow(/Git operation/u);
		expect(
			git(
				input.root,
				"--git-dir",
				input.remote,
				"rev-parse",
				"refs/heads/release/v2.0.0",
			),
		).toBe(input.source);
	});
});