repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
scripts/release/prepare.test.ts
Rawimport { 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);
});
});