jochen
cc1305a354
mesh/merge-gate pass: the merge check passed
mesh/delivery superseded: a newer head of the same pull request
The gate's status says what the change does and how it was judged; a change that builds something gets its plan as a comment — the tiers, what each machine receives, and what is not an ordinary send.
104 lines
6.6 KiB
TypeScript
104 lines
6.6 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { test } from "node:test";
|
|
import { createServer } from "node:http";
|
|
|
|
// A pull request's merge check (novox/hq to-be 45 §9): each new head announced once, and the verdict set
|
|
// where the pull request shows it — an error never as a success.
|
|
|
|
test("each open pull request's new head is announced once, and nothing closed or merged", async () => {
|
|
const { headsToAnnounce } = await import("../pulls.ts");
|
|
const pulls = [
|
|
{ number: 1, title: "a", state: "open", merged: false, head_sha: "aaa", html_url: "" },
|
|
{ number: 2, title: "b", state: "open", merged: false, head_sha: "bbb", html_url: "" },
|
|
{ number: 3, title: "c", state: "closed", merged: true, head_sha: "ccc", html_url: "" },
|
|
{ number: 4, title: "d", state: "open", merged: false, html_url: "" },
|
|
];
|
|
const announced = { "novox/mesh-catalog#1": "aaa", "novox/mesh-catalog#2": "old" };
|
|
assert.deepEqual(headsToAnnounce("novox/mesh-catalog", pulls, announced).map((p) => p.number), [2],
|
|
"only a head not announced, of a pull request that is open");
|
|
});
|
|
|
|
test("a verdict is the head commit's status; an error is the forge's error, never a success", async () => {
|
|
const { statusFor, commentFor, CHECK_CONTEXT } = await import("../pulls.ts");
|
|
const base = { owner: "novox", repo: "mesh-catalog", number: 7, commit: "0123456789abcdef", id: "build-1", on: "laptop" };
|
|
assert.equal(statusFor({ ...base, verdict: "pass", summary: "every machine composes" }).state, "success");
|
|
assert.equal(statusFor({ ...base, verdict: "warning", summary: "a merge rebuilds 14 module(s)" }).state, "warning");
|
|
assert.equal(statusFor({ ...base, verdict: "fail", summary: "x" }).state, "failure");
|
|
assert.equal(statusFor({ ...base, verdict: "error", summary: "the check could not run" }).state, "error");
|
|
assert.equal(statusFor({ ...base, verdict: "", summary: "" }).state, "error", "no verdict is no pass");
|
|
const long = statusFor({ ...base, verdict: "fail", summary: "y".repeat(500) });
|
|
assert.ok(long.description.length <= 140 && long.context === CHECK_CONTEXT);
|
|
assert.equal(commentFor({ ...base, verdict: "pass", summary: "fine" }), null, "a pass leaves no comment");
|
|
const said = commentFor({ ...base, verdict: "fail", summary: "lemurs refused", report: "fails:\n - ```x```" }) ?? "";
|
|
assert.match(said, /mesh\/merge-gate`: \*\*FAIL\*\*/);
|
|
assert.match(said, /01234567/);
|
|
assert.match(said, /builds --log build-1/);
|
|
assert.ok(!said.slice(said.indexOf("```") + 3, said.lastIndexOf("```")).includes("```"), "the report cannot close its own block");
|
|
});
|
|
|
|
test("each layer is its own status: the gate with the modules it judged, the repository's own check beside it", async () => {
|
|
const { statusesFor, commentFor, CHECK_CONTEXT, REPO_CHECK_CONTEXT } = await import("../pulls.ts");
|
|
const base = { owner: "novox", repo: "mesh-catalog", number: 7, commit: "0123456789abcdef", id: "build-1" };
|
|
const both = statusesFor({ ...base, verdict: "pass", summary: "every machine composes",
|
|
gate: { verdict: "pass", summary: "every machine composes", modules: ["gitea", "keycloak"], dependents: ["node-tools"] },
|
|
"repo-check": { verdict: "fail", summary: "its merge-check.sh failed: FAIL x" } });
|
|
assert.deepEqual(both.map((s) => [s.context, s.state]), [[CHECK_CONTEXT, "success"], [REPO_CHECK_CONTEXT, "failure"]]);
|
|
assert.match(both[0].description, /gitea, keycloak \+1 dependent/);
|
|
assert.match(commentFor({ ...base, verdict: "pass", summary: "", gate: { verdict: "pass", summary: "" },
|
|
"repo-check": { verdict: "fail", summary: "its merge-check.sh failed" } }) ?? "", /mesh\/repo-check`: \*\*FAIL/);
|
|
|
|
// Nothing of the graph touched, no script: a pass and a warning, and no comment on every push.
|
|
const quiet = { ...base, verdict: "pass", summary: "the change touches no module of the mesh's graph",
|
|
gate: { verdict: "pass", summary: "the change touches no module of the mesh's graph" },
|
|
"repo-check": { verdict: "warning", summary: "the repository declares no merge-check.sh" } };
|
|
assert.deepEqual(statusesFor(quiet).map((s) => s.state), ["success", "warning"]);
|
|
assert.equal(commentFor(quiet), null);
|
|
|
|
// A repository outside the mesh, touching nothing: the gate alone, a pass.
|
|
assert.equal(statusesFor({ ...base, verdict: "pass", summary: "x", gate: { verdict: "pass", summary: "x" } }).length, 1);
|
|
|
|
// A controller from before the layers: its verdict is the gate's.
|
|
assert.deepEqual(statusesFor({ ...base, verdict: "warning", summary: "wide" }).map((s) => [s.context, s.state]),
|
|
[[CHECK_CONTEXT, "warning"]]);
|
|
});
|
|
|
|
test("a commit status is set on the commit, under the merge check's context", async () => {
|
|
const { GiteaClient } = await import("../client.ts");
|
|
let seen: { path: string; body: any } | null = null;
|
|
const server = createServer((req, res) => {
|
|
let raw = "";
|
|
req.on("data", (c) => (raw += c));
|
|
req.on("end", () => {
|
|
seen = { path: `${req.method} ${req.url}`, body: JSON.parse(raw) };
|
|
res.statusCode = 201;
|
|
res.end("{}");
|
|
});
|
|
});
|
|
await new Promise<void>((r) => server.listen(0, r));
|
|
const port = (server.address() as any).port;
|
|
const client = new GiteaClient(`http://127.0.0.1:${port}`, "t");
|
|
await client.setCommitStatus("novox", "mesh-catalog", "abc123", { state: "failure", context: "mesh/merge-gate", description: "x" });
|
|
server.close();
|
|
assert.equal(seen!.path, "POST /api/v1/repos/novox/mesh-catalog/statuses/abc123");
|
|
assert.equal(seen!.body.state, "failure");
|
|
assert.equal(seen!.body.context, "mesh/merge-gate");
|
|
});
|
|
|
|
test("a change plan is the gate's result: said on the status and, when it builds something, as a comment", async () => {
|
|
const { statusFor, commentFor } = await import("../pulls.ts");
|
|
const plan = {
|
|
repository: "novox/mesh-catalog", base: "main", head: "0123456789abcdef", moved: ["gitea"],
|
|
tiers: [["gitea"]], machines: [{ machine: "anchor", receives: ["gitea"] }], steps: [],
|
|
summary: "builds gitea → anchor; no bus step",
|
|
};
|
|
const c = { owner: "novox", repo: "mesh-catalog", number: 7, commit: "0123456789abcdef", id: "b", verdict: "pass",
|
|
summary: "every machine composes", gate: { verdict: "pass", summary: "every machine composes", modules: ["gitea"] }, plan };
|
|
assert.equal(statusFor(c).description, "pass: builds gitea → anchor; no bus step; every machine composes");
|
|
const said = commentFor(c) ?? "";
|
|
assert.match(said, /Change plan\*\* — builds gitea → anchor/);
|
|
assert.match(said, /- anchor: receives gitea/);
|
|
// A plan that builds nothing, passing: the statuses say it, no comment.
|
|
const nothing = { ...c, plan: { ...plan, moved: [], tiers: [], machines: [], summary: "builds nothing" } };
|
|
assert.equal(commentFor(nothing), null);
|
|
});
|