From ade554087b0cebacf7b5485f6360e6b904ddf061 Mon Sep 17 00:00:00 2001 From: garrytan Date: Fri, 16 Oct 2026 23:33:03 +0000 Subject: [PATCH] test(ship-queue): stamp journal and resume, verify from a separate clone, gate-ahead attempts, ready Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --- bin/gstack-ship-queue | 1 + lib/ship-queue.ts | 13 +- test/gstack-ship-queue.test.ts | 282 +++++++++++++++++++++++++++++ test/helpers/ship-queue-fixture.ts | 25 +++ 4 files changed, 318 insertions(+), 3 deletions(-) create mode 100644 test/gstack-ship-queue.test.ts diff --git a/bin/gstack-ship-queue b/bin/gstack-ship-queue index 97658b38c..bff0a9165 100755 --- a/bin/gstack-ship-queue +++ b/bin/gstack-ship-queue @@ -140,6 +140,7 @@ function main(argv: string[]): number { return finish('stamp', stamp(ctx, { pr, version, expectGated, expectBase, expectOrder: flag(args, '--expect-order')?.split(',').map(s => s.trim()).filter(Boolean), allowRepoCommands: args.includes('--allow-repo-commands'), gateExit: gateExit === undefined ? undefined : Number(gateExit), gateLog: flag(args, '--gate-log'), + failAfter: process.env.GSTACK_SHIP_QUEUE_FAIL_AFTER, })); } if (cmd === 'verify') { diff --git a/lib/ship-queue.ts b/lib/ship-queue.ts index bcb961747..f5d0afc15 100644 --- a/lib/ship-queue.ts +++ b/lib/ship-queue.ts @@ -131,7 +131,7 @@ export function ready(ctx: QueueContext, o: { pr: string; pregate?: string }): S export interface StampOptions { pr: string; version: string; expectGated: string; expectBase: string; expectOrder?: string[]; allowRepoCommands: boolean; - gateExit?: number; gateLog?: string; + gateExit?: number; gateLog?: string; failAfter?: string; } interface StageRow { name: 'preflight' | 'restamp' | 'commit' | 'receipt'; status: 'done' | 'failed'; detail: string } interface StampJournal { @@ -217,11 +217,12 @@ export function stamp(ctx: QueueContext, o: StampOptions): StepOutput { const save = () => writeJsonAtomic(file, journal); const done = (name: StageRow['name']) => journal.stages.some(s => s.name === name && s.status === 'done'); const mark = (name: StageRow['name'], status: StageRow['status'], detail: string) => { journal.stages = journal.stages.filter(s => s.name !== name); journal.stages.push({ name, status, detail }); save(); }; - const refusal = (stage: StageRow['name'], failure: QueueFailure): StepOutput => { - mark(stage, 'failed', failure.message); + const stopped = (stage: StageRow['name'], failure: QueueFailure): StepOutput => { const now = git(ctx.repoRoot, ['rev-parse', 'HEAD']).out; return fail(failure, [`QUEUE_STAMP_REFUSED: ${o.pr} head=${now} committed=${now !== journal.start_head ? `yes ${now}` : 'no'} stage=${stage}`, ...journal.stages.map(s => `stage ${s.name}: ${s.status} (${s.detail})`)], run); }; + const refusal = (stage: StageRow['name'], failure: QueueFailure): StepOutput => { mark(stage, 'failed', failure.message); return stopped(stage, failure); }; + const injected = (stage: StageRow['name']) => (o.failAfter === stage ? stopped(stage, { code: 'QUEUE_PROOF_MISSING', message: `injected failure after ${stage}; rerun the identical command to resume` }) : null); const policy = loadBasePolicy(ctx); if ('message' in policy) return refusal('preflight', policy); const gated = git(ctx.repoRoot, ['rev-parse', '--verify', '--quiet', `${o.expectGated}^{commit}`]).out; @@ -231,17 +232,23 @@ export function stamp(ctx: QueueContext, o: StampOptions): StepOutput { if ('message' in pre) return refusal('preflight', pre); journal.gate = pre.gate; mark('preflight', 'done', pre.detail); + const stop = injected('preflight'); + if (stop) return stop; } if (!done('restamp')) { const r = restamp({ repoRoot: ctx.repoRoot, base: ctx.base, version: o.version, pr: o.pr, expectBase: o.expectBase, expectOrder: o.expectOrder, policyFrom: 'base', allowRepoCommands: o.allowRepoCommands, dryRun: false }); if (r.status === 'refused' || r.status === 'failed') return refusal('restamp', { code: r.code ?? 'RESTAMP_CONFLICT', message: r.message ?? r.status, fix: r.recompute ?? r.fix }); journal.files = r.files ?? []; mark('restamp', 'done', `${r.status}: ${r.oldVersion} -> ${r.newVersion}, ${journal.files.length} file(s)`); + const stop = injected('restamp'); + if (stop) return stop; } if (!done('commit')) { const c = journal.files.length ? stampCommit(ctx, o, journal) : 'nothing to commit (restamp was a noop)'; if (typeof c !== 'string') return refusal('commit', c); mark('commit', 'done', c); + const stop = injected('commit'); + if (stop) return stop; } const head = git(ctx.repoRoot, ['rev-parse', 'HEAD']).out; const rcpt = treeReceipt(ctx, policy, gated, head); diff --git a/test/gstack-ship-queue.test.ts b/test/gstack-ship-queue.test.ts new file mode 100644 index 000000000..96b302788 --- /dev/null +++ b/test/gstack-ship-queue.test.ts @@ -0,0 +1,282 @@ +/** + * Field list 2, W1: gstack-ship-queue over real fixture repos (bare origin, + * lane clone, a separate coordinator clone), every git and gstack call a real + * subprocess with a timeout. Covers stamp (journal, injected stops and + * resume, identical retry, refusals that say what was committed), verify from + * a separate clone (plain and gate-ahead: the merge recomputed with git + * merge-tree, the gated tree rebuilt from the recorded stamp patch, tamper + * and predecessor-movement controls), gate-ahead attempts (concurrent + * preparations, out-of-order completion, a moved worktree refused) and ready + * (pushed-head, CI-at-head and pregate refusals) with an offline gh. + */ +import { afterEach, describe, expect, test } from 'bun:test'; +import { spawn } from 'node:child_process'; +import * as fs from 'node:fs'; +import * as path from 'node:path'; +import { EXIT } from '../lib/headless-artifacts'; +import { SHIP_QUEUE_KEYS_VERSION } from '../lib/ship-policy'; +import { applyStampPatch } from '../lib/ship-queue-gate'; +import { BASE_POLICY, BIN, cleanup, makeFixtureRepo, makePr, mergeMain, mergeToMain, restamp, runBin, type FixtureRepo } from './helpers/restamp-fixture'; +import { coordinatorClone, ghQueueShim } from './helpers/ship-queue-fixture'; + +const repos: FixtureRepo[] = []; +const fixture = (policy?: Record) => { const r = makeFixtureRepo(policy ? { policy } : {}); repos.push(r); return r; }; +afterEach(() => { while (repos.length) cleanup(repos.pop()!); }); + +const queue = (repo: FixtureRepo, args: string[], extraEnv: Record = {}, cwd = repo.work) => runBin(repo, 'gstack-ship-queue', [...args, '--base', 'main'], extraEnv, cwd); +const line = (out: string, prefix: string) => out.split('\n').find(l => l.startsWith(prefix)) ?? ''; +const field = (text: string, key: string) => new RegExp(`${key}=(\\S+)`).exec(text)?.[1] ?? ''; +const publish = (repo: FixtureRepo, pr: string, ref = 'HEAD') => repo.git('push', '-q', '-f', 'origin', `${ref}:refs/pull/${pr}/head`); + +describe('stamp, then verify from a separate clone (plain flow)', () => { + test('QUEUE_STAMP binds head, gated and receipt; the identical retry returns it; nothing is pushed; verify agrees from the coordinator clone', () => { + const repo = fixture(); + const gated = makePr(repo, 'pr-a', { expects: '1.2.4.0' }); + const base = repo.git('rev-parse', 'origin/main'); + const r = queue(repo, ['stamp', '--pr', '1', '--version', '1.2.4.0', '--expect-gated', gated, '--expect-base', base, '--allow-repo-commands']); + expect(r.status).toBe(EXIT.ok); + const stampLine = line(r.out, 'QUEUE_STAMP:'); + const head = repo.git('rev-parse', 'HEAD'); + expect(stampLine).toMatch(new RegExp(`^QUEUE_STAMP: 1 1\\.2\\.4\\.0 head=${head} gated=${gated} tree=same-modulo-stamps receipt=[0-9a-f]{64}$`)); + expect(repo.git('rev-parse', 'HEAD^')).toBe(gated); + expect(repo.git('log', '-1', '--format=%s')).toBe('v1.2.4.0 chore(release): queue stamp onto main (#1)'); + expect(repo.git('status', '--porcelain', '--untracked-files=no')).toBe(''); + expect(r.out).toMatch(/^stage preflight: done/m); + expect(r.out).toMatch(/^GSTACK_RESULT: skill=ship-queue status=complete run=\.gstack\/tmp\/ship-queue\/stamp-1\.json$/m); + expect(repo.git('ls-remote', 'origin')).not.toContain('pr-a'); + const again = queue(repo, ['stamp', '--pr', '1', '--version', '1.2.4.0', '--expect-gated', gated, '--expect-base', base, '--allow-repo-commands']); + expect(again.status).toBe(EXIT.ok); + expect(line(again.out, 'QUEUE_STAMP:')).toBe(stampLine); + expect(again.out).toContain('note: identical retry'); + expect(repo.git('rev-parse', 'HEAD')).toBe(head); + + publish(repo, '1'); + const coord = coordinatorClone(repo); + const receipt = field(stampLine, 'receipt'); + const v = queue(repo, ['verify', '--pr', '1', '--gated', gated, '--receipt', receipt, '--expect-head', head], {}, coord); + expect(v.status).toBe(EXIT.ok); + expect(line(v.out, 'VERIFY:')).toBe(`VERIFY: 1 1.2.4.0 head=${head} gated=${gated} tree=same-modulo-stamps receipt=${receipt}`); + expect(v.out).toContain(`MERGE_CONDITION: sha=${head}`); + const wrong = queue(repo, ['verify', '--pr', '1', '--gated', gated, '--receipt', '0'.repeat(64)], {}, coord); + expect(wrong.status).toBe(EXIT.fail); + expect(wrong.err).toContain('(QUEUE_VERIFY_MISMATCH)'); + }, 180_000); + + test('a later real edit pushed after the stamp fails verify with the residual path', () => { + const repo = fixture(); + const gated = makePr(repo, 'pr-a'); + expect(queue(repo, ['stamp', '--pr', '1', '--version', '1.2.4.0', '--expect-gated', gated, '--expect-base', repo.git('rev-parse', 'origin/main'), '--allow-repo-commands']).status).toBe(EXIT.ok); + fs.appendFileSync(path.join(repo.work, 'pr-a.txt'), 'late\n'); + repo.git('commit', '-qam', 'late edit'); + publish(repo, '1'); + const v = queue(repo, ['verify', '--pr', '1', '--gated', gated], {}, coordinatorClone(repo)); + expect(v.status).toBe(EXIT.fail); + expect(v.err).toMatch(/differs from the gated tree beyond stamps: pr-a\.txt.*\(QUEUE_VERIFY_MISMATCH\)/); + }, 180_000); +}); + +describe('stamp journal, resume and refusals', () => { + for (const stage of ['restamp', 'commit'] as const) { + test(`a stop after ${stage} reports what was committed; the identical command resumes at the next stage`, () => { + const repo = fixture(); + const gated = makePr(repo, 'pr-a'); + const args = ['stamp', '--pr', '1', '--version', '1.2.4.0', '--expect-gated', gated, '--expect-base', repo.git('rev-parse', 'origin/main'), '--allow-repo-commands']; + const stopped = queue(repo, args, { GSTACK_SHIP_QUEUE_FAIL_AFTER: stage }); + expect(stopped.status).toBe(EXIT.refused); + const committed = repo.git('rev-parse', 'HEAD') !== gated; + expect(committed).toBe(stage === 'commit'); + expect(line(stopped.out, 'QUEUE_STAMP_REFUSED:')).toBe(`QUEUE_STAMP_REFUSED: 1 head=${repo.git('rev-parse', 'HEAD')} committed=${committed ? `yes ${repo.git('rev-parse', 'HEAD')}` : 'no'} stage=${stage}`); + expect(stopped.err).toContain(`injected failure after ${stage}`); + if (stage === 'restamp') expect(repo.git('status', '--porcelain', '--untracked-files=no')).toContain('VERSION'); + const resumed = queue(repo, args); + expect(resumed.status).toBe(EXIT.ok); + expect(line(resumed.out, 'QUEUE_STAMP:')).toContain(`gated=${gated} tree=same-modulo-stamps`); + expect(repo.git('rev-list', '--count', `${gated}..HEAD`)).toBe('1'); + const journal = JSON.parse(fs.readFileSync(path.join(repo.work, '.gstack/tmp/ship-queue/stamp-1.json'), 'utf8')); + expect(journal.stages.map((s: any) => `${s.name}:${s.status}`)).toEqual(['preflight:done', 'restamp:done', 'commit:done', 'receipt:done']); + }, 180_000); + } + + test('a moved base, a tree beyond the gated one and a missing full_e2e gate refuse with nothing written', () => { + const repo = fixture({ ...BASE_POLICY, full_e2e: true, min_gstack_version: SHIP_QUEUE_KEYS_VERSION }); + const gated = makePr(repo, 'pr-a'); + const base = repo.git('rev-parse', 'origin/main'); + const stale = queue(repo, ['stamp', '--pr', '1', '--version', '1.2.4.0', '--expect-gated', gated, '--expect-base', 'deadbeef', '--allow-repo-commands']); + expect(stale.status).toBe(EXIT.refused); + expect(stale.err).toContain('(QUEUE_STALE)'); + expect(line(stale.out, 'QUEUE_STAMP_REFUSED:')).toBe(`QUEUE_STAMP_REFUSED: 1 head=${gated} committed=no stage=preflight`); + const gateless = queue(repo, ['stamp', '--pr', '1', '--version', '1.2.4.0', '--expect-gated', gated, '--expect-base', base, '--allow-repo-commands']); + expect(gateless.err).toMatch(/no gate result bound to .*\(QUEUE_GATE_MISSING\)/); + const log = path.join(repo.root, 'gate.log'); + fs.writeFileSync(log, 'FAIL 1\n'); + expect(queue(repo, ['stamp', '--pr', '1', '--version', '1.2.4.0', '--expect-gated', gated, '--expect-base', base, '--allow-repo-commands', '--gate-exit', '1', '--gate-log', log]).err).toContain('exited 1'); + fs.appendFileSync(path.join(repo.work, 'pr-a.txt'), 'after the gate\n'); + repo.git('commit', '-qam', 'after the gate'); + const beyond = queue(repo, ['stamp', '--pr', '1', '--version', '1.2.4.0', '--expect-gated', gated, '--expect-base', base, '--allow-repo-commands', '--gate-exit', '0', '--gate-log', log]); + expect(beyond.err).toMatch(/beyond stamps \(pr-a\.txt\).*\(QUEUE_PROOF_MISSING\)/); + expect(repo.git('status', '--porcelain', '--untracked-files=no')).toBe(''); + expect(repo.git('log', '-1', '--format=%s')).toBe('after the gate'); + }, 180_000); +}); + +/** #1 stamped and published; #2 branched with its own [Unreleased] entry. */ +function twoLanes(policy?: Record) { + const repo = fixture(policy); + makePr(repo, 'pr-a', { expects: '1.2.4.0' }); + expect(restamp(repo, ['--next', '--pr', '1']).status).toBe(EXIT.ok); + repo.git('commit', '-qam', 'stamp a'); + publish(repo, '1'); + const bHead = makePr(repo, 'pr-b', { expects: '1.2.4.0' }); + return { repo, bHead }; +} + +function prepare(repo: FixtureRepo): { out: string; attempt: string; record: string; worktree: string; gated: string; status: number | null; err: string } { + const r = queue(repo, ['gate-ahead', '--after', '1', '--pr', '2', '--predecessor-ref', 'pr-a', '--allow-repo-commands']); + return { ...r, out: r.out, attempt: field(line(r.out, 'GATE_AHEAD:'), 'attempt'), gated: field(line(r.out, 'GATE_AHEAD:'), 'gated'), record: line(r.out, 'record: ').slice(8), worktree: line(r.out, 'worktree: ').slice(10) }; +} + +describe('gate-ahead, then stamp and verify from a separate clone', () => { + test('the record reproduces from the PR alone: merge-tree, stamp patch, receipt digest; tamper and predecessor movement fail', () => { + const { repo, bHead } = twoLanes({ ...BASE_POLICY, gate_command: 'node -e "process.exit(0)"', min_gstack_version: SHIP_QUEUE_KEYS_VERSION }); + const p = prepare(repo); + expect(p.status).toBe(EXIT.ok); + expect(line(p.out, 'GATE_COMMAND:')).toBe('GATE_COMMAND: node -e "process.exit(0)"'); + expect(repo.git('rev-parse', 'HEAD')).toBe(bHead); + const log = path.join(repo.root, 'gate.log'); + fs.writeFileSync(log, 'all passed\n'); + const rec = queue(repo, ['gate-ahead', '--record', '--pr', '2', '--attempt', p.attempt, '--exit', '0', '--log', log]); + expect(rec.status).toBe(EXIT.ok); + expect(line(rec.out, 'GATE_RECORD:')).toMatch(new RegExp(`^GATE_RECORD: pr=2 attempt=${p.attempt} exit=0 gated_tree=[0-9a-f]{40} log_sha256=[0-9a-f]{64} current=yes$`)); + expect(fs.existsSync(p.worktree)).toBe(false); + expect(fs.existsSync(path.join(path.dirname(p.record), `${p.attempt}.log`))).toBe(true); + + mergeToMain(repo, 'pr-a'); + repo.git('checkout', '-q', 'pr-b'); + mergeMain(repo); + const base = repo.git('rev-parse', 'origin/main'); + const s = queue(repo, ['stamp', '--pr', '2', '--version', '1.2.5.0', '--expect-gated', p.gated, '--expect-base', base, '--allow-repo-commands']); + expect(s.status).toBe(EXIT.ok); + expect(s.out).toMatch(/^stage preflight: done \(.*gate exit 0 \(gate-ahead attempt /m); + const receipt = field(line(s.out, 'QUEUE_STAMP:'), 'receipt'); + publish(repo, '2'); + const coord = coordinatorClone(repo); + const v = queue(repo, ['verify', '--pr', '2', '--record', p.record, '--receipt', receipt], {}, coord); + expect(v.status).toBe(EXIT.ok); + expect(line(v.out, 'VERIFY:')).toMatch(new RegExp(`^VERIFY: 2 1\\.2\\.5\\.0 head=${repo.git('rev-parse', 'HEAD')} gated=${p.gated} tree=same-modulo-stamps receipt=${receipt}$`)); + expect(v.out).toMatch(/^merge_tree: [0-9a-f]{40} reproduced by git merge-tree --write-tree /m); + expect(v.out).toMatch(/^gated_tree: [0-9a-f]{40} reproduced from the recorded stamp patch \(stamps only/m); + expect(v.out).toMatch(/^gate: exit 0 log_sha256=/m); + + const record = JSON.parse(fs.readFileSync(p.record, 'utf8')); + const tamper = (mutate: (r: any) => void) => { const r = JSON.parse(JSON.stringify(record)); mutate(r); const f = path.join(repo.root, 'tampered.json'); fs.writeFileSync(f, JSON.stringify(r)); return queue(repo, ['verify', '--pr', '2', '--record', f], {}, coord); }; + const forgedPatch = record.stamp_patch + 'diff --git a/pr-b.txt b/pr-b.txt\n--- a/pr-b.txt\n+++ b/pr-b.txt\n@@ -1 +1 @@\n-pr-b\n+pr-b sneaky\n'; + const forgedTree = applyStampPatch(coord, record.merge_tree, forgedPatch); + expect('tree' in forgedTree).toBe(true); + const sneaky = tamper(r => { r.stamp_patch = forgedPatch; r.gated_tree = (forgedTree as { tree: string }).tree; }); + expect(sneaky.status).toBe(EXIT.fail); + expect(sneaky.err).toMatch(/the recorded stamp patch changes more than stamps: pr-b\.txt.*\(QUEUE_VERIFY_MISMATCH\)/); + expect(tamper(r => { r.gated_tree = '0'.repeat(40); }).err).toMatch(/not the recorded gated tree 000000000000/); + expect(tamper(r => { r.merge_tree = '0'.repeat(40); }).err).toMatch(/git merge-tree gives .*the record says 000000000000/); + expect(tamper(r => { r.result.exit = 2; }).err).toContain('(QUEUE_GATE_MISSING)'); + + repo.git('checkout', '-q', 'pr-a'); + fs.appendFileSync(path.join(repo.work, 'pr-a.txt'), 'late\n'); + repo.git('commit', '-qam', 'late predecessor fix'); + publish(repo, '1'); + const moved = queue(repo, ['verify', '--pr', '2', '--record', p.record], {}, coord); + expect(moved.status).toBe(EXIT.fail); + expect(moved.err).toMatch(/PREDECESSOR MOVED: #1 is at .*\(QUEUE_VERIFY_MISMATCH\)/); + }, 240_000); +}); + +function runAsync(repo: FixtureRepo, args: string[]): Promise<{ status: number | null; out: string }> { + return new Promise(resolve => { + const child = spawn(BIN('gstack-ship-queue'), [...args, '--base', 'main'], { cwd: repo.work, env: { ...process.env, ...repo.env }, timeout: 120_000 }); + let out = ''; + child.stdout.on('data', d => { out += d; }); + child.on('close', status => resolve({ status, out })); + }); +} + +describe('gate-ahead attempts', () => { + test('concurrent preparations get their own worktrees; completing out of order never replaces the newest attempt', async () => { + const { repo } = twoLanes(); + const args = ['gate-ahead', '--after', '1', '--pr', '2', '--predecessor-ref', 'pr-a', '--allow-repo-commands']; + const [a, b] = await Promise.all([runAsync(repo, args), runAsync(repo, args)]); + expect([a.status, b.status]).toEqual([EXIT.ok, EXIT.ok]); + const ids = [a, b].map(r => field(line(r.out, 'GATE_AHEAD:'), 'attempt')); + expect(new Set(ids).size).toBe(2); + const trees = [a, b].map(r => line(r.out, 'worktree: ').slice(10)); + for (const t of trees) expect(fs.existsSync(t)).toBe(true); + const list = queue(repo, ['gate-ahead', '--list', '--pr', '2']).out.split('\n').filter(l => l.startsWith('ATTEMPT:')); + expect(list).toHaveLength(2); + const [older, newer] = list.map(l => l.split(' ')[1]!); + expect(list[1]).toContain(' current'); + const log = path.join(repo.root, 'gate.log'); + fs.writeFileSync(log, 'ok\n'); + const first = queue(repo, ['gate-ahead', '--record', '--pr', '2', '--attempt', newer!, '--exit', '0', '--log', log]); + expect(line(first.out, 'GATE_RECORD:')).toContain('current=yes'); + expect(fs.existsSync(trees[ids.indexOf(older!)]!)).toBe(true); + const late = queue(repo, ['gate-ahead', '--record', '--pr', '2', '--attempt', older!, '--exit', '0', '--log', log]); + expect(late.status).toBe(EXIT.ok); + expect(line(late.out, 'GATE_RECORD:')).toContain(`current=no (superseded by ${newer})`); + expect(queue(repo, ['gate-ahead', '--list', '--pr', '2']).out).toMatch(new RegExp(`^ATTEMPT: ${newer} state=recorded .* exit=0 current$`, 'm')); + const repeat = queue(repo, ['gate-ahead', '--record', '--pr', '2', '--attempt', older!, '--exit', '0', '--log', log]); + expect(repeat.out).toContain('note: identical retry'); + const changed = queue(repo, ['gate-ahead', '--record', '--pr', '2', '--attempt', older!, '--exit', '1', '--log', log]); + expect(changed.status).toBe(EXIT.refused); + expect(changed.err).toContain('(GATE_AHEAD_ATTEMPT_INVALID)'); + }, 240_000); + + test('a worktree that no longer holds the gated commit cannot bind a result', () => { + const { repo } = twoLanes(); + const p = prepare(repo); + fs.appendFileSync(path.join(p.worktree, 'pr-b.txt'), 'edited by the gate\n'); + const log = path.join(repo.root, 'gate.log'); + fs.writeFileSync(log, 'ok\n'); + const r = queue(repo, ['gate-ahead', '--record', '--pr', '2', '--attempt', p.attempt, '--exit', '0', '--log', log]); + expect(r.status).toBe(EXIT.refused); + expect(r.err).toMatch(/no longer holds the gated commit .*tracked edits.*\(GATE_AHEAD_ATTEMPT_INVALID\)/); + expect(fs.existsSync(p.worktree)).toBe(true); + expect(queue(repo, ['gate-ahead', '--record', '--pr', '2', '--attempt', 'nope', '--exit', '0', '--log', log]).err).toContain('no gate-ahead attempt nope for #2'); + }, 180_000); +}); + +describe('ready', () => { + function pregateFor(repo: FixtureRepo, head: string): string { + const tree = runBin(repo, 'gstack-wtree', []).out.trim(); + const file = path.join(repo.root, 'pregate.json'); + fs.writeFileSync(file, JSON.stringify({ schema_version: 1, tree, head, verdict: 'pass', checks: [{ id: 'unit', status: 'pass' }] })); + return file; + } + const green = { check_runs: [{ status: 'completed', conclusion: 'success' }, { status: 'completed', conclusion: 'skipped' }] }; + + test('one READY block about the exact pushed head; refusals for an unpushed head, red CI and a stale pregate', () => { + const repo = fixture(); + const head = makePr(repo, 'pr-a'); + const pregate = pregateFor(repo, head); + const shim = (prHead: string, checks: unknown) => ghQueueShim(repo, { prs: { '1': { headRefOid: prHead, url: 'https://github.com/o/r/pull/1', body: 'no receipt' } }, checks: { [head]: checks } }); + const ok = queue(repo, ['ready', '--pr', '1', '--pregate', pregate], shim(head, green)); + expect(ok.status).toBe(EXIT.ok); + const lines = ok.out.split('\n'); + expect(lines[0]).toBe(`READY #1 ${head} STAMP_VERSION=unstamped`); + expect(lines.slice(1, 9)).toEqual([ + 'pr: https://github.com/o/r/pull/1', `head: ${head}`, 'version: unstamped', `base: origin/main@${repo.git('rev-parse', 'origin/main')}`, + `ci: green at ${head.slice(0, 12)} (passed=1 failed=0 pending=0 skipped=1)`, expect.stringMatching(/^PREGATE: pass tree=[0-9a-f]{12} head=[0-9a-f]{12} checks=1$/), + 'gate: command=none full_e2e=no gate-ahead=none', 'SHIP_RECEIPT: none in the PR body', + ]); + const unpushed = queue(repo, ['ready', '--pr', '1', '--pregate', pregate], shim('f'.repeat(40), green)); + expect(unpushed.status).toBe(EXIT.refused); + expect(unpushed.err).toMatch(/is not PR #1's pushed head ffffffffffff.*\(QUEUE_NOT_READY\)/); + const red = queue(repo, ['ready', '--pr', '1', '--pregate', pregate], shim(head, { check_runs: [{ status: 'completed', conclusion: 'failure' }, { status: 'in_progress', conclusion: null }] })); + expect(red.err).toMatch(/CI is not green at .*pending at [0-9a-f]{12} \(passed=0 failed=1 pending=1 skipped=0\).*\(QUEUE_NOT_READY\)/); + fs.appendFileSync(path.join(repo.work, 'pr-a.txt'), 'more\n'); + repo.git('commit', '-qam', 'more'); + const moved = repo.git('rev-parse', 'HEAD'); + const stale = queue(repo, ['ready', '--pr', '1', '--pregate', pregate], ghQueueShim(repo, { prs: { '1': { headRefOid: moved, body: '' } }, checks: { [moved]: green } })); + expect(stale.status).toBe(EXIT.refused); + expect(stale.out).toMatch(/^PREGATE: pass .* \(PREGATE_STALE\)$/m); + fs.appendFileSync(path.join(repo.work, 'pr-a.txt'), 'dirty\n'); + expect(queue(repo, ['ready', '--pr', '1'], shim(moved, green)).err).toMatch(/uncommitted tracked changes: pr-a\.txt.*\(QUEUE_NOT_READY\)/); + }, 180_000); +}); diff --git a/test/helpers/ship-queue-fixture.ts b/test/helpers/ship-queue-fixture.ts index e43fab794..a1d9f55dd 100644 --- a/test/helpers/ship-queue-fixture.ts +++ b/test/helpers/ship-queue-fixture.ts @@ -74,3 +74,28 @@ export function gbrainPairRepo(): { repo: FixtureRepo; pair: GbrainPair; gated: }; return { repo, pair, gated, stamp }; } + +/** A `gh` on PATH answering `gh pr view --json …` and `gh api …/commits//check-runs…` from fixed data, so ready runs offline. */ +export function ghQueueShim(repo: FixtureRepo, data: { prs: Record; checks: Record }): { PATH: string } { + const dir = path.join(repo.root, 'gh-queue-shim'); + fs.mkdirSync(dir, { recursive: true }); + fs.writeFileSync(path.join(dir, 'data.json'), JSON.stringify(data)); + const js = [ + "const d = require(process.argv[2]); const a = process.argv.slice(3);", + "if (a[0] === 'pr' && a[1] === 'view') { const p = d.prs[a[2]]; if (!p) { console.error('no pull request found'); process.exit(1); } console.log(JSON.stringify(p)); process.exit(0); }", + "if (a[0] === 'api') { const m = /commits\\/([0-9a-f]+)\\/check-runs/.exec(a[1] || ''); const c = m && d.checks[m[1]]; if (!c) { console.error('HTTP 404'); process.exit(1); } console.log(JSON.stringify(c)); process.exit(0); }", + "console.error('gh shim: unsupported ' + a.join(' ')); process.exit(1);", + ].join('\n'); + fs.writeFileSync(path.join(dir, 'shim.js'), js); + fs.writeFileSync(path.join(dir, 'gh'), `#!/bin/sh\nexec node "${path.join(dir, 'shim.js')}" "${path.join(dir, 'data.json')}" "$@"\n`, { mode: 0o755 }); + return { PATH: `${dir}:${process.env.PATH ?? ''}` }; +} + +/** A coordinator's separate clone of the fixture origin. */ +export function coordinatorClone(repo: FixtureRepo): string { + const dir = path.join(repo.root, 'coordinator'); + const r = spawnSync('git', ['clone', '-q', repo.origin, dir], { timeout: 60_000, env: { ...process.env, ...repo.env } }); + if (r.status !== 0) throw new Error(`clone failed: ${r.stderr?.toString()}`); + return dir; +} +