@intentius/chant 0.124.31 → 0.124.33

package/src/workspace/ci-serve.test.ts

@@ -15,7 +15,7 @@ import { join } from "node:path";
 import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { cleanScratch, declaration, git, repoFixture, scratchDir, writeFiles } from "./__fixtures__/contract-repo";
 import { ciServeInterval, ciServeKey, ciServePass, formatCiServeEvent, readCiServeState, type CiServeEvent, type CiServeForge, type CiServeOptions } from "./ci-serve";
-import { ciRun } from "./ci-run";
+import { ciRun, type CiRunResult } from "./ci-run";
 import { acquireLease, releaseLease } from "../lifecycle/lease";
 import { prApplyGroup, prApplyRecordKey } from "../components/pr-pipeline";
 import { parseArgs } from "../cli/parse-args";
@@ -23,9 +23,9 @@ import { forgejoForge, githubForge, type ForgeFetch, type OpenPullRequest } from
 
 afterAll(cleanScratch);
 
-function commit(root: string, file: string): string {
+function commit(root: string, file: string, message = file): string {
   writeFiles(root, { [file]: `${file} ${Math.random()}\n` });
-  for (const args of [["add", "-A"], ["commit", "-q", "-m", file]]) {
+  for (const args of [["add", "-A"], ["commit", "-q", "-m", message]]) {
     execFileSync("git", ["-c", "user.name=t", "-c", "user.email=t@example.com", "-c", "commit.gpgsign=false", ...args], { cwd: root, stdio: "ignore" });
   }
   return git(root, "rev-parse", "HEAD");
@@ -53,11 +53,12 @@ const workspaceTemplate = repoFixture(() => {
 }, "chant-ci-serve-");
 
 /** A copy of the template, its origin pointed at the copy of the bare one. */
-function workspace(): { root: string; app: string; main: string } {
+function workspace(): { root: string; app: string; main: string; origin: string } {
   const top = workspaceTemplate();
   const root = join(top, "root");
-  git(root, "remote", "set-url", "origin", join(top, "origin"));
-  return { root, app: join(root, "app"), main: git(root, "rev-parse", "HEAD") };
+  const origin = join(top, "origin");
+  git(root, "remote", "set-url", "origin", origin);
+  return { root, app: join(root, "app"), main: git(root, "rev-parse", "HEAD"), origin };
 }
 
 /** A pull request's head commit, on a branch off main, pushed to the forge's refs/pull/<n>/head. */
@@ -142,6 +143,8 @@ function serve(app: string, client: CiServeForge, extra: Partial<CiServeOptions>
       client,
       stateDir: state,
       holder: "serve-test",
+      // Most tests here cover the apply on merge, which #4168 made opt-in; the record tests pass false.
+      applyOnMerge: true,
       // A job image of its own, so no setup line downloads OpenTofu.
       job: { image: "chant-ci-serve-test:local", chant: fakeChant(), hostEnv: env, passEnv: Object.keys(hostEnv ?? {}) },
       log: (e) => events.push(e),
@@ -150,9 +153,89 @@ function serve(app: string, client: CiServeForge, extra: Partial<CiServeOptions>
   };
 }
 
+const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+
+/** A commit on no branch, with `parent` when given, as a ledger commit stands in. */
+const ledgerCommit = (root: string, message: string, parent?: string): string => git(root, "commit-tree", EMPTY_TREE, ...(parent ? ["-p", parent] : []), "-m", message);
+
+/** Seed `chant/lifecycle` in the clone and on the forge, as an earlier apply left it. */
+function seedLedger(root: string): string {
+  const seed = ledgerCommit(root, "seed");
+  git(root, "update-ref", "refs/heads/chant/lifecycle", seed);
+  git(root, "push", "-q", "origin", "chant/lifecycle");
+  expect(git(root, "rev-parse", "refs/remotes/origin/chant/lifecycle")).toBe(seed);
+  return seed;
+}
+
+const isAncestor = (cwd: string, a: string, b: string): boolean => {
+  try {
+    git(cwd, "merge-base", "--is-ancestor", a, b);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
 const argsOf = (report: string, stage: string): string[] => readFileSync(join(report, `${stage}.args`), "utf-8").trimEnd().split("\n");
 const ofType = <T extends CiServeEvent["type"]>(events: CiServeEvent[], type: T) => events.filter((e): e is Extract<CiServeEvent, { type: T }> => e.type === type);
 
+describe("ci serve records each merge unless apply on merge is opted in (#4168)", () => {
+  test("a merge to the target branch gets the record job, measured from the head before it, and no resume record", async () => {
+    const { root, app, main } = workspace();
+    const forge = fakeForge(main);
+    const { opts, events, state } = serve(app, forge, { applyOnMerge: false });
+    await ciServePass(opts);
+    const merged = commit(root, "app/merged.txt");
+    git(root, "push", "-q", "origin", "main");
+    forge.head = merged;
+    forge.merges.set(merged, 21);
+
+    const pass = await ciServePass(opts);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "record", commit: merged, base: main, pr: 21, status: "ok" })]);
+    const argv = argsOf(pass.jobs[0]!.report!, "pr-record");
+    expect(argv.slice(0, 4)).toEqual(["components", "pr-record", "--base", main]);
+    expect(argv).not.toContain("--resume");
+    expect(ofType(events, "started")[0]).not.toHaveProperty("resume");
+    expect(existsSync(join(state, "resume"))).toBe(false);
+    const saved = readCiServeState(join(state, `${prApplyGroup("prod", "app")}.json`), { forge: "forgejo", repo: "demo/estate", env: "prod", branch: "main" });
+    expect(saved.target).toBe(merged);
+    expect(saved.jobs[ciServeKey({ job: "record", commit: merged })]).toMatchObject({ status: "ok" });
+    expect((await ciServePass(opts)).jobs).toEqual([]);
+  });
+
+  test("each settled job runs the tick, and a tick that fails is an error event, never a failed job", async () => {
+    const { root, app, main } = workspace();
+    const forge = fakeForge(main);
+    const ticks: string[] = [];
+    let fail = false;
+    const { opts, events } = serve(app, forge, {
+      applyOnMerge: false,
+      tick: async () => {
+        ticks.push("tick");
+        if (fail) throw new Error("forge said no");
+        return ["ci/green/abc"];
+      },
+    });
+    await ciServePass(opts);
+    expect(ticks).toEqual([]);
+    const merged = commit(root, "app/merged.txt");
+    git(root, "push", "-q", "origin", "main");
+    forge.head = merged;
+    await ciServePass(opts);
+    expect(ticks).toEqual(["tick"]);
+    expect(ofType(events, "tick")).toEqual([{ type: "tick", made: ["ci/green/abc"] }]);
+    expect(formatCiServeEvent({ type: "tick", made: ["ci/green/abc"] })).toBe("ci tick made ci/green/abc");
+
+    fail = true;
+    const next = commit(root, "app/next.txt");
+    git(root, "push", "-q", "origin", "main");
+    forge.head = next;
+    const pass = await ciServePass(opts);
+    expect(pass.jobs[0]).toMatchObject({ job: "record", status: "ok" });
+    expect(ofType(events, "error").map((e) => e.message)).toContain("ci tick after a job settled: forge said no");
+  });
+});
+
 describe("chant ci serve (#4095)", () => {
   test("one poll plans a new pull request head once, and skips forks and authors not given", async () => {
     const { root, app, main } = workspace();
@@ -365,3 +448,123 @@ describe("chant ci serve (#4095)", () => {
     expect(() => ciServeInterval("0")).toThrow(/a second or more/);
   });
 });
+
+describe("ci serve follows the forge's chant/lifecycle (#4121)", () => {
+  /** A serve past its baseline pass, with one merge waiting to apply, and each run's result in `results`. */
+  async function mergeWaiting() {
+    const w = workspace();
+    const seed = seedLedger(w.root);
+    const forge = fakeForge(w.main);
+    const results: CiRunResult[] = [];
+    const { opts, events } = serve(w.app, forge, { run: async (req) => { const r = await ciRun(req); results.push(r); return r; } });
+    await ciServePass(opts);
+    const merged = commit(w.root, "app/merged.txt");
+    git(w.root, "push", "-q", "origin", "main");
+    forge.head = merged;
+    return { ...w, seed, opts, events, results };
+  }
+
+  test("a ledger the forge deleted is deleted here, and the next apply runs clean", async () => {
+    const { root, origin, seed, opts, events, results } = await mergeWaiting();
+    git(origin, "update-ref", "-d", "refs/heads/chant/lifecycle");
+
+    const pass = await ciServePass(opts);
+    expect(ofType(events, "ledger")).toEqual([{ type: "ledger", action: "deleted", local: seed }]);
+    expect(formatCiServeEvent(ofType(events, "ledger")[0]!)).toContain("was deleted");
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", status: "ok" })]);
+    expect(results[0]).toMatchObject({ pushed: true });
+    const tip = git(origin, "rev-parse", "refs/heads/chant/lifecycle");
+    expect(git(root, "rev-parse", "chant/lifecycle")).toBe(tip);
+    expect(isAncestor(origin, seed, tip)).toBe(false);
+  });
+
+  test("a ledger the forge rewrote is reset to the forge's and not pushed back", async () => {
+    const { root, origin, seed, opts, events, results } = await mergeWaiting();
+    const rewritten = ledgerCommit(root, "rewritten");
+    git(root, "push", "-q", "origin", `${rewritten}:refs/scratch/rewritten`);
+    git(origin, "update-ref", "refs/heads/chant/lifecycle", rewritten);
+
+    const pass = await ciServePass(opts);
+    expect(ofType(events, "ledger")).toEqual([{ type: "ledger", action: "reset", local: seed, forge: rewritten }]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", status: "ok" })]);
+    expect(results[0]).toMatchObject({ pushed: true });
+    const tip = git(origin, "rev-parse", "refs/heads/chant/lifecycle");
+    expect(isAncestor(origin, rewritten, tip)).toBe(true);
+    expect(isAncestor(root, seed, tip)).toBe(false);
+  });
+
+  test("a ledger ahead of the forge's keeps its facts, and the apply pushes them", async () => {
+    const { root, origin, seed, opts, events, results } = await mergeWaiting();
+    const ahead = ledgerCommit(root, "unpushed fact", seed);
+    git(root, "update-ref", "refs/heads/chant/lifecycle", ahead);
+
+    const pass = await ciServePass(opts);
+    expect(ofType(events, "ledger")).toEqual([]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", status: "ok" })]);
+    expect(results[0]).toMatchObject({ pushed: true });
+    expect(isAncestor(origin, ahead, git(origin, "rev-parse", "refs/heads/chant/lifecycle"))).toBe(true);
+  });
+});
+
+describe("ci serve applies fast-forwards only, and honours [skip ci] (#4122)", () => {
+  test("a force push back to an older commit is recorded as seen and not applied, and the next fast-forward applies", async () => {
+    const { root, app, main } = workspace();
+    const later = commit(root, "app/later.txt");
+    git(root, "push", "-q", "origin", "main");
+    const forge = fakeForge(later);
+    const { opts, events, state } = serve(app, forge);
+    await ciServePass(opts);
+    expect(ofType(events, "baseline")).toEqual([{ type: "baseline", commit: later }]);
+
+    git(root, "reset", "-q", "--hard", main);
+    git(root, "push", "-q", "-f", "origin", "main");
+    forge.head = main;
+    const back = await ciServePass(opts);
+    expect(back.jobs).toEqual([]);
+    expect(ofType(events, "not-run")).toEqual([{ type: "not-run", job: "apply", commit: main, reason: "not-fast-forward", branch: "main", from: later }]);
+    expect(formatCiServeEvent(ofType(events, "not-run")[0]!)).toContain("not a fast-forward");
+    const file = join(state, `${prApplyGroup("prod", "app")}.json`);
+    expect(readCiServeState(file, { forge: "forgejo", repo: "demo/estate", env: "prod", branch: "main" }).target).toBe(main);
+
+    const next = commit(root, "app/next.txt");
+    git(root, "push", "-q", "origin", "main");
+    forge.head = next;
+    const pass = await ciServePass(opts);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", commit: next, base: main, status: "ok" })]);
+  });
+
+  test("a target head whose message says [skip ci] is recorded as seen and not applied", async () => {
+    const { root, app, main } = workspace();
+    const forge = fakeForge(main);
+    const { opts, events, state } = serve(app, forge);
+    await ciServePass(opts);
+    const skip = commit(root, "app/tidy.txt", "tidy the app [skip ci]");
+    git(root, "push", "-q", "origin", "main");
+    forge.head = skip;
+
+    expect((await ciServePass(opts)).jobs).toEqual([]);
+    expect(ofType(events, "not-run")).toEqual([{ type: "not-run", job: "apply", commit: skip, reason: "skip-ci" }]);
+    expect(formatCiServeEvent(ofType(events, "not-run")[0]!)).toContain("says [skip ci]");
+    const file = join(state, `${prApplyGroup("prod", "app")}.json`);
+    expect(readCiServeState(file, { forge: "forgejo", repo: "demo/estate", env: "prod", branch: "main" }).target).toBe(skip);
+  });
+
+  test("a pull request head whose message says [ci skip] is not planned", async () => {
+    const { root, app, main } = workspace();
+    git(root, "checkout", "-q", "-b", "pr-4");
+    const head = commit(root, "app/pr-4.txt", "draft [ci skip]");
+    git(root, "push", "-q", "origin", `${head}:refs/pull/4/head`);
+    git(root, "checkout", "-q", "main");
+    const forge = fakeForge(main);
+    forge.prs = [pr(4, head, main)];
+    const { opts, events, state } = serve(app, forge);
+
+    expect((await ciServePass(opts)).jobs).toEqual([]);
+    expect(ofType(events, "not-run")).toEqual([{ type: "not-run", job: "plan", commit: head, pr: 4, reason: "skip-ci" }]);
+    const file = join(state, `${prApplyGroup("prod", "app")}.json`);
+    expect(readCiServeState(file, { forge: "forgejo", repo: "demo/estate", env: "prod", branch: "main" }).skipped).toEqual({ [ciServeKey({ job: "plan", pr: 4, commit: head })]: "skip-ci" });
+    // Seen once: the next poll says nothing of it.
+    expect((await ciServePass(opts)).jobs).toEqual([]);
+    expect(ofType(events, "not-run")).toHaveLength(1);
+  });
+});