@bongos/core 1.19.1038 → 1.19.1040

package/tests/ship_land_ci_not_started.mjs

@@ -0,0 +1,168 @@
+// tests/ship_land_ci_not_started.mjs — a land wait that says "CI never ran" when it did
+// not, instead of "fix your code" (task 1004289).
+//
+// WHY. During the 2026-09-25 GitHub Actions budget outage (blocker 1000173) every job on
+// every PR "failed" in about two seconds without running: conclusion FAILURE, no steps, no
+// runner, and one annotation — "The job was not started because an Actions budget is
+// preventing further use." Task 1003764's red-check reader saw an ordinary red `unit`
+// check and told the builder on PR 1211 to fix it, commit and re-run, plus the "CI tests
+// your branch MERGED with main" trap. None of that can help: nothing was tested, and the
+// fix is the owner's, on the GitHub account. These drive the laptop poll with a fake gh
+// carrying the REAL payloads from PR 1211 (run 36210373664, attempt 1).
+//
+// Run:  node tests/ship_land_ci_not_started.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import {
+  jobNeverStarted, landPendingLines, localMergeDriver, notStartedLines, pollCiDeploy, redBlocksMerge, redPrLine, redPrLines,
+} from '../scripts/gds/ship-land.js';
+
+const require = createRequire(import.meta.url);
+const { CARDS, cardFor } = require('../scripts/gds/plain-cards.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
+}
+async function capture(fn) {
+  const lines = [];
+  const orig = console.log;
+  console.log = (...a) => { lines.push(a.join(' ')); };
+  try { return { result: await fn(), out: lines.join('\n') }; }
+  finally { console.log = orig; }
+}
+
+const SHA = 'b9b03b03687ce823c016a29b0141736a3595c547';
+const RUN = '36210373664';
+const JOB_UNIT = '108315429264';
+const JOB_REPORT = '108315436139';
+const jobUrl = (job) => `https://github.com/example-org/example-repo/actions/runs/${RUN}/job/${job}`;
+const checkRun = (name, job, conclusion = 'FAILURE') => ({
+  __typename: 'CheckRun', name, conclusion, status: 'COMPLETED', workflowName: 'unit', detailsUrl: jobUrl(job),
+  startedAt: '2026-09-26T02:01:46Z', completedAt: '2026-09-26T02:01:48Z',
+});
+const ctx = (context, state) => ({ __typename: 'StatusContext', context, state, targetUrl: '' });
+const openPr = (rollup) => ({ state: 'OPEN', mergeCommit: null, mergeStateStatus: 'BLOCKED', headRefOid: SHA, statusCheckRollup: rollup });
+// PR 1211's rollup during the outage: both unit-workflow jobs "failed", the trust status green.
+const OUTAGE_ROLLUP = [checkRun('unit', JOB_UNIT), checkRun('report', JOB_REPORT), ctx('gate-author-trust', 'SUCCESS')];
+
+// The two annotations GitHub returned for job 108315429264, verbatim (paths trimmed).
+const BUDGET_NOTES = [
+  { path: '.github', annotation_level: 'failure', title: '', message: 'The job was not started because an Actions budget is preventing further use.' },
+  { path: '.github', annotation_level: 'notice', title: '', message: '"The ubuntu-latest label will migrate to Ubuntu 26 beginning October 19, 2026."' },
+];
+const NOTICE_ONLY = [BUDGET_NOTES[1]];
+const annotationsPath = (job) => `repos/{owner}/{repo}/check-runs/${job}/annotations`;
+
+// ---- the detector ----
+
+await test('jobNeverStarted: the budget annotation on the job reads as never started', async () => {
+  const asked = [];
+  const gh = (args) => { asked.push(args); return BUDGET_NOTES; };
+  assert.equal(jobNeverStarted(checkRun('unit', JOB_UNIT), gh), true);
+  assert.deepEqual(asked, [['api', annotationsPath(JOB_UNIT)]], 'reads the check run named by the job id in its detailsUrl');
+});
+
+await test('jobNeverStarted: the payment-failed wording is the same shape and is caught too', async () => {
+  const gh = () => [{ annotation_level: 'failure', message: 'The job was not started because recent account payments have failed or your spending limit needs to be increased.' }];
+  assert.equal(jobNeverStarted(checkRun('unit', JOB_UNIT), gh), true);
+});
+
+await test('jobNeverStarted is FAIL-OPEN: a real failure, an unreadable read, or no job id is "no"', async () => {
+  assert.equal(jobNeverStarted(checkRun('unit', JOB_UNIT), () => NOTICE_ONLY), false, 'a job that ran and failed');
+  assert.equal(jobNeverStarted(checkRun('unit', JOB_UNIT), () => null), false, 'gh could not read the annotations');
+  assert.equal(jobNeverStarted(checkRun('unit', JOB_UNIT), () => ({ message: 'Not Found' })), false, 'an error object, not a list');
+  let calls = 0;
+  const gh = () => { calls++; return BUDGET_NOTES; };
+  assert.equal(jobNeverStarted({ __typename: 'CheckRun', name: 'x', detailsUrl: 'https://example.com/checks' }, gh), false);
+  assert.equal(jobNeverStarted(ctx('unit-report', 'FAILURE'), gh), false, 'a commit status is not a job');
+  assert.equal(calls, 0, 'nothing to look up, so nothing is asked');
+});
+
+// ---- the merge-driver answer and the lines it prints ----
+
+await test('localMergeDriver: every red check never started → ci_not_started, not a failing check', async () => {
+  const md = localMergeDriver(openPr(OUTAGE_ROLLUP), () => 'must not be asked', () => true);
+  assert.deepEqual(md, { reason: 'ci_not_started:unit', not_started: true, failing_tests: null, run_id: RUN });
+});
+
+await test('localMergeDriver: one real failure beside a never-started job is still a failing check', async () => {
+  const rollup = [checkRun('unit', JOB_UNIT), checkRun('lint', '999', 'FAILURE')];
+  const md = localMergeDriver(openPr(rollup), () => null, (c) => c.name === 'unit');
+  assert.equal(md.reason, 'failing_check:unit');
+  assert.equal(md.not_started, undefined);
+});
+
+await test('localMergeDriver: without a never-started answer (the default) nothing changes', async () => {
+  assert.deepEqual(localMergeDriver(openPr(OUTAGE_ROLLUP), () => null), { reason: 'failing_check:unit', failing_tests: null });
+});
+
+await test('the red line says CI never ran and the work needs nothing; no fix-your-code, no merge trap', async () => {
+  const md = { reason: 'ci_not_started:unit', not_started: true, failing_tests: null, run_id: RUN };
+  const out = redPrLines(md, { taskId: 42, via: 'local' }).join('\n');
+  assert.match(redPrLine(md), /CI NEVER RAN/);
+  assert.match(out, /the `unit` job/);
+  assert.match(out, /nothing in it to fix/);
+  assert.match(out, /repo OWNER's to fix/);
+  assert.match(out, new RegExp(`gh run rerun ${RUN} --failed`), 'names the re-run for the exact run');
+  assert.match(out, /do not re-push or edit the work/);
+  assert.doesNotMatch(out, /fix it, commit/, 'the advice that cannot help is gone');
+  assert.doesNotMatch(out, /MERGED with the current main/, 'and so is the merge trap');
+  assert.ok(out.includes(CARDS.ci_not_started.happened), 'the plain card rides along');
+  assert.ok(!out.includes(CARDS.failing_check.happened), 'not the "a test failed" card');
+  assert.equal(cardFor('ci_not_started:unit'), CARDS.ci_not_started, 'the named reason resolves to its card');
+  assert.equal(redBlocksMerge(md), false, 'it is not the failing-check kind of red');
+});
+
+await test('notStartedLines without a run id points at the PR button instead of inventing a command', async () => {
+  const out = notStartedLines({ reason: 'ci_not_started:unit', not_started: true, run_id: null }).join('\n');
+  assert.match(out, /"Re-run failed jobs" on the PR/);
+  assert.doesNotMatch(out, /gh run rerun/);
+});
+
+await test('the closing banner for a never-started CI is neither "NOT a failure" nor "fix the check"', async () => {
+  const out = landPendingLines(42, { notStarted: true }).join('\n');
+  assert.match(out, /CI never started/);
+  assert.match(out, /Nothing in the work needs to change/);
+  assert.match(out, /node scripts\/gds\/ship\.js 42/);
+  assert.doesNotMatch(out, /NOT a failure/);
+  assert.doesNotMatch(out, /Do what the lines above say/);
+});
+
+// ---- the laptop poll, end to end ----
+
+await test('pollCiDeploy (laptop): an Actions-budget outage is named as CI never running, once, with no code advice', async () => {
+  const seen = { prView: 0, annotations: 0, status: 0 };
+  const gh = (args) => {
+    if (args[0] === 'pr' && args[1] === 'view') { seen.prView++; return openPr(OUTAGE_ROLLUP); }
+    if (args[0] === 'api' && /check-runs\/\d+\/annotations$/.test(args[1])) { seen.annotations++; return BUDGET_NOTES; }
+    if (args[0] === 'api') { seen.status++; return { statuses: [] }; }
+    throw new Error(`unexpected gh call: ${args.join(' ')}`);
+  };
+  const { result, out } = await capture(() => pollCiDeploy(42, 'task-42', SHA, { ghJson: gh, pause: () => {} }));
+  assert.equal(result.pending, true, 'the land is still pending — the checks can yet run');
+  assert.equal(seen.prView, 30, 'polled the whole window');
+  assert.equal(seen.annotations, 2, 'each job\'s annotations are read once, not once per poll');
+  assert.equal(out.split('CI NEVER RAN on this PR').length - 1, 1, 'named once');
+  assert.match(out, /CI never started on the PR/, 'the closing banner says the same');
+  assert.doesNotMatch(out, /fix it, commit/);
+  assert.doesNotMatch(out, /MERGED with the current main/);
+  assert.doesNotMatch(out, /This is NOT a failure/);
+  assert.ok(!out.includes(CARDS.land_pending.happened), 'nor the "nothing to do" card');
+});
+
+await test('pollCiDeploy: when the annotations cannot be read, it falls back to the ordinary red wording', async () => {
+  const gh = (args) => {
+    if (args[0] === 'pr' && args[1] === 'view') return openPr(OUTAGE_ROLLUP);
+    return null; // no Checks read on this gh, or the API is down
+  };
+  const { out } = await capture(() => pollCiDeploy(42, 'task-42', SHA, { ghJson: gh, pause: () => {} }));
+  assert.match(out, /the PR is RED — the `unit` check failed/);
+  assert.doesNotMatch(out, /CI NEVER RAN/);
+});
+
+console.log(`\nship-land CI never started (task 1004289) tests: ${passed} passed, ${failed} failed`);
+process.exitCode = failed > 0 ? 1 : 0;