@intentius/chant 0.124.37 → 0.124.39

package/src/workspace/ci-green-builds.test.ts

@@ -158,6 +158,32 @@ describe("the tick for a newest phase (#4169)", () => {
   });
 });
 
+describe("the tick for a missing every phase (#4216)", () => {
+  const CHECK_WORKFLOW = "name: ci\non:\n  push:\n    branches: [main]\n  workflow_dispatch: {}\njobs:\n  check:\n    runs-on: ubuntu-latest\n    steps:\n      - run: true\n";
+
+  test("a commit the forge never ran check on gets one request, started at its ci/build tag, and the record keeps it", async () => {
+    const { root, origin } = workspace();
+    writeFiles(root, { ".github/workflows/ci.yml": CHECK_WORKFLOW });
+    const a = commitAt(root, 2, "app/a.txt");
+    git(root, "push", "-q", "origin", "main");
+    // GitHub skipped a's push run of ci.yml; release-suites ran.
+    const runs = new Map([[a, [run("suites", "success")]]]);
+    const forge = fakeForge(runs);
+    const tick = await ciTick({ cwd: root, forge, now: NOW });
+    expect(tick.requested.map((r) => [r.commit, r.phases, r.reason])).toEqual([[a, ["check"], "missing"]]);
+    expect(forge.dispatched).toEqual([`ci.yml@ci/build/${a}`]);
+    expect(remoteTags(origin)).toEqual([`ci/build/${a}`]);
+    expect(remoteRecord(origin, a)).toMatchObject({ state: "pending", missing: { phases: ["check"] }, request: { reason: "missing", dispatched: true }, phases: { check: { reason: "requested" } } });
+
+    // The started run passes: the commit goes green and the request is done.
+    runs.set(a, [run("suites", "success"), run("check", "success")]);
+    const second = await ciTick({ cwd: root, forge, now: NOW });
+    expect(second.made).toEqual([`ci/green/${a}`]);
+    expect(second.requested).toEqual([]);
+    expect(forge.dispatched).toHaveLength(1);
+  });
+});
+
 describe("chant ci run --at (#4169)", () => {
   test("pushes a request for every required phase and starts the workflows holding them", async () => {
     const { root, origin } = workspace();

package/src/workspace/ci-green-cli.ts

@@ -192,7 +192,7 @@ export async function runCiWorkflow(ctx: CommandContext): Promise<number> {
       console.log(
         e.build === "newest"
           ? `Wrote ${path}'s triggers and concurrency: ${e.phases.join(", ")} build${e.phases.length === 1 ? "s" : ""} the newest commit on ${green.branch} when a run ends, and a ci/build/<sha> tag by hand.`
-          : `Wrote ${path}'s concurrency: ${e.phases.join(", ")} build${e.phases.length === 1 ? "s" : ""} every commit on ${green.branch}, none cancelled.`,
+          : `Wrote ${path}'s triggers and concurrency: ${e.phases.join(", ")} build${e.phases.length === 1 ? "s" : ""} every commit on ${green.branch}, none cancelled, and a ci/build/<sha> tag by hand when the forge ran nothing.`,
       );
     }
     return 0;

package/src/workspace/ci-green-forge.test.ts

@@ -64,3 +64,34 @@ describe("the GitHub check-run client (#3573)", () => {
     expect(() => ciForgeFromEnv("forgejo", {})).toThrow(/GitHub only/);
   });
 });
+
+describe("re-running a failed check run (#4219)", () => {
+  const run = (id: number) => ({ id, name: "suites", status: "completed", conclusion: "failure", completedAt: null, url: null });
+  const forgeWith = (jobs: Record<number, unknown>) => {
+    const calls: string[] = [];
+    const fetch: ForgeFetch = async (url, init) => {
+      calls.push(`${init.method} ${new URL(url).pathname}`);
+      const m = /\/actions\/jobs\/(\d+)$/.exec(new URL(url).pathname);
+      if (init.method === "GET" && m) return { ok: true, status: 200, text: async () => JSON.stringify(jobs[Number(m[1])] ?? {}) };
+      return { ok: true, status: 201, text: async () => "" };
+    };
+    return { forge: githubCiForge({ apiBase: "https://api.github.com", repo: "acme/app", token: "t", fetch }), calls };
+  };
+
+  test("re-runs the failed jobs of the job's workflow run, so an aggregate's shards go again with it, once per run", async () => {
+    const { forge, calls } = forgeWith({ 7: { id: 7, run_id: 500 }, 8: { id: 8, run_id: 500 } });
+    await forge.rerun!(run(7));
+    await forge.rerun!(run(8));
+    expect(calls).toEqual([
+      "GET /repos/acme/app/actions/jobs/7",
+      "POST /repos/acme/app/actions/runs/500/rerun-failed-jobs",
+      "GET /repos/acme/app/actions/jobs/8",
+    ]);
+  });
+
+  test("falls back to the job's own re-run when the job names no workflow run", async () => {
+    const { forge, calls } = forgeWith({ 9: { id: 9 } });
+    await forge.rerun!(run(9));
+    expect(calls).toEqual(["GET /repos/acme/app/actions/jobs/9", "POST /repos/acme/app/actions/jobs/9/rerun"]);
+  });
+});

package/src/workspace/ci-green-forge.ts

@@ -57,7 +57,9 @@ export interface CiForge {
   checkRuns(sha: string): Promise<CheckRun[]>;
   /**
    * Run a failed check run's job again (#4169), so a flake costs one more
-   * run before the commit counts red. Absent on a forge chant can't ask.
+   * run before the commit counts red: on GitHub, every failed job of its
+   * workflow run, so the jobs an aggregate needs go again with it (#4219).
+   * Absent on a forge chant can't ask.
    */
   rerun?(run: CheckRun): Promise<void>;
   /**
@@ -86,6 +88,7 @@ export function githubCiForge(opts: GithubCiForgeOptions): CiForge {
   const root = opts.apiBase.replace(/\/+$/, "");
   const fetchImpl = opts.fetch ?? (globalThis.fetch as unknown as ForgeFetch);
   const headers = { Authorization: `Bearer ${opts.token}`, Accept: "application/vnd.github+json" };
+  const rerunRuns = new Set<number>();
   return {
     kind: "github",
     async checkRuns(sha) {
@@ -115,9 +118,24 @@ export function githubCiForge(opts: GithubCiForgeOptions): CiForge {
       }
       return out;
     },
-    // An Actions job's check run has the job's id, so the job is re-run by it. Both need `actions: write`.
+    // An Actions job's check run has the job's id. Re-running only that job
+    // would re-run an aggregate such as `suites` against the shards' old
+    // results, so the failed jobs of its workflow run go again together,
+    // each run once per tick (#4219). Both calls need `actions: write`.
     async rerun(run) {
-      await post(`${root}/repos/${opts.repo}/actions/jobs/${run.id}/rerun`, {});
+      const jobUrl = `${root}/repos/${opts.repo}/actions/jobs/${run.id}`;
+      const res = await fetchImpl(jobUrl, { method: "GET", headers });
+      const text = await res.text();
+      if (!res.ok) throw new ForgeApiError("GET", jobUrl, res.status, text);
+      const job: unknown = text ? JSON.parse(text) : null;
+      const runId = isObject(job) && typeof job.run_id === "number" ? job.run_id : null;
+      if (runId === null) {
+        await post(`${jobUrl}/rerun`, {});
+        return;
+      }
+      if (rerunRuns.has(runId)) return;
+      rerunRuns.add(runId);
+      await post(`${root}/repos/${opts.repo}/actions/runs/${runId}/rerun-failed-jobs`, {});
     },
     async dispatch(workflow, ref) {
       await post(`${root}/repos/${opts.repo}/actions/workflows/${encodeURIComponent(workflow)}/dispatches`, { ref });

package/src/workspace/ci-green-workflow.test.ts

@@ -346,8 +346,8 @@ describe("the triggers of a phase that sets build (#4169)", () => {
       [".github/workflows/suites.yml", "newest", ["suites"], true],
     ]);
     const ci = parseYAMLDocument(edits[0].text) as Yaml;
-    // The triggers of an every phase stay, pull requests included.
-    expect(ci.on).toEqual({ push: { branches: ["main"] }, pull_request: null });
+    // The triggers of an every phase stay, pull requests included, and it can be started by hand (#4216).
+    expect(ci.on).toEqual({ push: { branches: ["main"] }, pull_request: null, workflow_dispatch: {} });
     expect(ci.concurrency).toEqual({ group: "chant-build-lint-${{ github.ref == 'refs/heads/main' && github.sha || github.ref }}", "cancel-in-progress": "${{ github.ref != 'refs/heads/main' }}" });
     expect(edits[0].text).toContain(`# Comments above a block stay.\n${BUILD_BLOCK_MARKER}\nconcurrency:`);
     const suites = parseYAMLDocument(edits[1].text) as Yaml;
@@ -388,7 +388,7 @@ describe("the triggers of a phase that sets build (#4169)", () => {
     ];
     const edits = buildTriggerEdits(green(), sources, { compose: true });
     const ci = parseYAMLDocument(edits[0].text) as Yaml;
-    expect(ci.on).toEqual({ push: { branches: ["main", "chant/compose/**"] }, pull_request: null });
+    expect(ci.on).toEqual({ push: { branches: ["main", "chant/compose/**"] }, pull_request: null, workflow_dispatch: {} });
     expect(ci.concurrency).toEqual({
       group: "chant-build-lint-${{ (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/chant/compose/')) && github.sha || github.ref }}",
       "cancel-in-progress": "${{ !(github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/chant/compose/')) }}",
@@ -399,7 +399,7 @@ describe("the triggers of a phase that sets build (#4169)", () => {
     expect(buildTriggerEdits(green(), edits.map((e) => ({ path: e.path, text: e.text })), { compose: true }).map((e) => e.changed)).toEqual([false, false]);
     // A push with no branch list already runs on every branch, so its triggers stay.
     const anyBranch = LINT_WF.replace("  push:\n    branches: [main]\n", "  push:\n");
-    expect((parseYAMLDocument(buildTriggerEdits(green(), [{ path: ".github/workflows/ci.yml", text: anyBranch }], { compose: true })[0].text) as Yaml).on).toEqual({ push: null, pull_request: null });
+    expect((parseYAMLDocument(buildTriggerEdits(green(), [{ path: ".github/workflows/ci.yml", text: anyBranch }], { compose: true })[0].text) as Yaml).on).toEqual({ push: null, pull_request: null, workflow_dispatch: {} });
     // Without compose the bytes are what #4169 wrote.
     expect(buildTriggerEdits(green(), sources).map((e) => e.text)).toEqual(buildTriggerEdits(green(), sources, { compose: false }).map((e) => e.text));
     const tick = parseYAMLDocument(renderCiGreenWorkflow({ green: green(), workflows: ["ci"], chantVersion: "0.124.33", workspaceRoot: ".", compose: true })) as Yaml;

package/src/workspace/ci-green-workflow.ts

@@ -327,9 +327,11 @@ export interface BuildTriggerEdit {
  *   ref that never cancels a run in progress, so GitHub keeps the newest
  *   push waiting and drops the ones between, and each tag's build runs in a
  *   group of its own.
- * - `every`: the triggers stay, and the group is the commit itself on the
- *   branch, so no push cancels or replaces another's run; elsewhere, such as
- *   a pull request, a new push cancels the run it supersedes.
+ * - `every`: the triggers stay, with `workflow_dispatch` added so the tick
+ *   can start a run the forge never started on a commit (#4216), and the
+ *   group is the commit itself on the branch, so no push cancels or replaces
+ *   another's run; elsewhere, such as a pull request or a `ci/build/<sha>`
+ *   tag, a new push cancels the run it supersedes.
  *
  * With `compose` (#4220, a workspace declaring `ci.workflow`), both builds
  * also run on pushes to `chant/compose/**`: `newest` adds the filter to the
@@ -337,7 +339,7 @@ export interface BuildTriggerEdit {
  * and `every`'s group keys a compose branch's runs by commit, as the trunk
  * branch's.
  *
- * Only the top-level `on:` (for `newest`, or `every` with `compose`) and `concurrency:` blocks change,
+ * Only the top-level `on:` and `concurrency:` blocks change,
  * each under {@link BUILD_BLOCK_MARKER}; the rest of the file is kept as it
  * is. Throws when one workflow holds a phase of each build, which no one
  * concurrency group can serve.
@@ -375,12 +377,16 @@ export function buildTriggerEdits(green: CiGreen, sources: readonly WorkflowSour
       text = writeTopLevel(text, "concurrency", { group: `chant-build-${tag}-\${{ github.ref }}`, "cancel-in-progress": false });
     } else {
       const main = `refs/heads/${green.branch}`;
+      const on = triggersOf(isObject(doc) ? doc.on : undefined);
+      let next = on;
       // A push filter that lists branches gains the compose branches; one with no list already runs on every branch.
-      const on = isObject(doc) && isObject(doc.on) ? doc.on : undefined;
-      const pushOn = on && isObject(on.push) ? on.push : undefined;
-      if (compose && on && pushOn && Array.isArray(pushOn.branches) && !pushOn.branches.includes(COMPOSE_BRANCHES)) {
-        text = writeTopLevel(text, "on", { ...on, push: { ...pushOn, branches: [...pushOn.branches, COMPOSE_BRANCHES] } });
+      const pushOn = isObject(on.push) ? on.push : undefined;
+      if (compose && pushOn && Array.isArray(pushOn.branches) && !pushOn.branches.includes(COMPOSE_BRANCHES)) {
+        next = { ...next, push: { ...pushOn, branches: [...pushOn.branches, COMPOSE_BRANCHES] } };
       }
+      // #4216: the tick starts the workflow by hand at a ci/build/<sha> tag when the forge ran nothing on a commit.
+      if (!("workflow_dispatch" in next)) next = { ...next, workflow_dispatch: {} };
+      if (next !== on) text = writeTopLevel(text, "on", next);
       // #4220: a compose branch's commits each get a verdict, so its runs are keyed by commit, as the trunk branch's are.
       const keyed = compose ? `(github.ref == '${main}' || startsWith(github.ref, 'refs/heads/${COMPOSE_BRANCH_PREFIX}'))` : `github.ref == '${main}'`;
       const unkeyed = compose ? `!${keyed}` : `github.ref != '${main}'`;
@@ -396,6 +402,14 @@ export function buildTriggerEdits(green: CiGreen, sources: readonly WorkflowSour
   return out;
 }
 
+/** A workflow's `on:` as a map: `on: push` and `on: [push, pull_request]` name triggers with no settings. */
+function triggersOf(on: unknown): Record<string, unknown> {
+  if (isObject(on)) return on;
+  if (typeof on === "string") return { [on]: null };
+  if (Array.isArray(on)) return Object.fromEntries(on.filter((t): t is string => typeof t === "string").map((t) => [t, null]));
+  return {};
+}
+
 /**
  * Replace the top-level `key:` block of a YAML file with `value` (or with
  * `value`'s lines, the key's own line first), under