diff --git a/README.md b/README.md index c6d3f856..4c6a40af 100644 --- a/README.md +++ b/README.md @@ -265,8 +265,8 @@ git fetch origin main quest check --base origin/main --branch quest/m0/export ``` -Fetch the base first, since a stale one can predate the quest. The -`quest-merge` skill runs this before landing a PR. A repository with +Fetch the base first, since a stale one can predate the quest. `quest merge` +runs this on the head it lands. A repository with `quest` installed in CI can also run it on pull requests, where the checkout is detached, so pass the head branch: @@ -284,8 +284,8 @@ still judge whether a rewrite matches what remains. binary carries, and reports a missing, outdated, or retired one. A job that checks a PR with a binary built from the base passes `--no-stubs`, since that binary's skills would reject a PR that changes a stub; the PR's own binary -checks them in its own `quest check`. This repository's merge queue and the -`quest-merge` skill's preflight do so. +checks them in its own `quest check`. This repository's merge queue and +`quest merge` do so. A link into a submodule that is not checked out, as in a fresh worktree or `actions/checkout` by default, resolves at the commit its gitlink pins when a @@ -563,7 +563,11 @@ it creates is the queue signal, so a queued PR shows no hold. It refuses while any session holds the PR, so release your own hold first. `--land` needs the full 40-character head SHA and refuses once the head moves, or while the latest run of any check on it failed, required or not, naming each; pending checks do not block. -It enables auto-merge bound to that SHA, or merges at once when nothing is +It also refuses a head that fails `quest check --no-stubs --base --branch +`, which it runs on git objects it fetches, so nothing from the +head runs, and ignores findings the base already has; run a `quest` the PR +cannot modify, since the head's own build could skip the check. A base without +quests skips it. It enables auto-merge bound to that SHA, or merges at once when nothing is left to wait for. `--squash` or `--rebase` picks the method, and it refuses one the repository disallows; otherwise it uses the only method the repository allows, or else a merge commit, and refuses when merge commits are off and more diff --git a/assets/skills/merge.md b/assets/skills/merge.md index 0ae0f840..f17896e7 100644 --- a/assets/skills/merge.md +++ b/assets/skills/merge.md @@ -31,11 +31,8 @@ Otherwise, the changes since the reviewed head need no new review only when they The repository's review policy decides whose record counts and may require more, such as a maintainer's review. Where it says nothing, only a record on a PR whose author has write access counts: anyone else writes their own PR body, so their head needs a local review that rewrites the record. -Before queueing, check the head with a `quest` the PR cannot modify: fetch the PR's base branch and its exact head, check the head out apart from your own checkout, such as in a detached worktree under `.tmp/`, and from a directory outside it run `quest --root check --no-stubs --base / --branch `. -The head's files are untrusted, and a stale local base can skip the check; `--no-stubs` is there because the PR's own checks verify its stubs. -A finding means the PR leaves its quest inaccurate: it needs `/quest-iterate`. - Queue the head with `quest merge --land `, adding `--squash` or `--rebase` when the repository's root instructions name that method for the PR's base. +Run a `quest` the PR cannot modify, such as an installed release rather than a build from the head's checkout: it refuses a head that leaves its quest inaccurate, a check the head's own code could skip. A refusal says what the head or the repository needs: follow it, sending a head that needs a fix or its base merged to `/quest-iterate`. Ask instead when it refuses a head `/quest-iterate` left unchanged, and never pass `--direct` unless the user explicitly asks. diff --git a/quest/m0/token-waste/merge-check.md b/quest/m0/token-waste/merge-check.md deleted file mode 100644 index cde74749..00000000 --- a/quest/m0/token-waste/merge-check.md +++ /dev/null @@ -1,45 +0,0 @@ -# [M] quest merge runs the landing check itself - -## Goal - -`quest merge --land` refuses a head whose diff leaves its quest -inaccurate, by running what `quest check --base --branch ` -checks against the exact head it is about to queue, so `/quest-merge` no -longer tells the agent to fetch the head, check it out apart, and run the -check by hand. Of the paragraph that describes those steps, -`assets/skills/merge.md` keeps only what a program cannot enforce on -itself: run `quest merge` with a `quest` the PR cannot modify. - -Non-goal: the other landable conditions `/quest-merge` judges, such as -whose review counts. - -## Plan - -Found 2026-11-12 while trimming the skills against five days of session -transcripts: 81 sessions ran the hand check 235 times, 219 passed, about 5 -found something, and 3 failed because the scratch checkout was missing. -The steps are also the kind of rule prose holds badly: the head's files are -untrusted, so the agent must use a `quest` the PR cannot modify, from a -directory outside the head's checkout, against a freshly fetched base. In -this repository `bun run quest` inside a head checkout would run the -head's own code. - -Agent's choices, for the implementer to revisit: - -- `quest merge` already reads the head and base from GitHub, so it - fetches both and checks the head's tree itself, without running anything - from it. Reading the tree from Git objects avoids a checkout; a - temporary detached worktree that it removes is the fallback if - `quest check` needs files on disk. -- The check is only as trusted as the `quest` that runs it. A session that - reviewed a PR sits in its head's checkout, where a PR that edits the CLI - or the repository's pin of it could skip the check, so the skill still - says to run `quest merge` with a `quest` the PR cannot modify, such as - an installed release from outside the head's checkout. Weigh having - `quest merge` refuse to run from a checkout of the head it lands. -- A finding is a refusal that names it and says the PR needs - `/quest-iterate`, like the refusal of a failed check - ([moq-dev/quest#601](https://github.com/moq-dev/quest/pull/601)). -- A base whose gate already runs the check, as this repository's - `queue-build.yml` does, still gets it: the refusal arrives before a queue - build is spent. diff --git a/src/cli/hold.ts b/src/cli/hold.ts index 8961bd6b..2e9e39e0 100644 --- a/src/cli/hold.ts +++ b/src/cli/hold.ts @@ -2,7 +2,7 @@ // a time. It holds the `quest:active` label, and the ID of the timeline event // that added the label is its hold token, since sessions often share an account. // `quest merge` takes no label: the pinned auto-merge or merge-queue entry it creates is the queue signal. -import { ACTIVE_LABEL, handedBack, isHoldLabel, latestHold, heldToken, withoutHandBack } from "../core"; +import { ACTIVE_LABEL, formatFinding, handedBack, isHoldLabel, latestHold, heldToken, withoutHandBack } from "../core"; import { cleanAutoMergeRefusal, immediateMerge, queueHead } from "../github/merge"; import { repositoryPath } from "./claims"; import { @@ -19,6 +19,7 @@ import { import { latestContexts } from "../github/checks"; import { ALLOWS, LAND_CHECK, METHOD_NAMES, contexts, enqueue } from "./land"; import { QUEUE_CHECK } from "./land-queue"; +import type { LandingCheck } from "./landed"; import { classifyCheck } from "./status"; import { Refusal, ago } from "./start"; @@ -28,7 +29,7 @@ export type Method = "merge" | "squash" | "rebase"; const READ = `query HoldOwnership($owner: String!, $repo: String!, $number: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $number) { - id url state isDraft body updatedAt baseRefName headRefOid mergeStateStatus isMergeQueueEnabled isInMergeQueue + id url state isDraft body updatedAt baseRefName baseRefOid headRefName headRefOid mergeStateStatus isMergeQueueEnabled isInMergeQueue labels(first: 100) { nodes { name } } timelineItems(last: 100, itemTypes: [LABELED_EVENT]) { nodes { __typename ... on LabeledEvent { id createdAt label { name } } } @@ -52,6 +53,10 @@ interface Snapshot { body: string; updatedAt: string; base: string; + /** The commit the base branch points at. */ + baseSha: string; + /** The head branch's name. */ + branch: string; head: string; mergeState: string; queue: boolean; @@ -208,6 +213,17 @@ function signalMethod( return method; } +/** What `quest merge` lands, and how. */ +export interface LandRequest { + /** The full head SHA to land, which must still be the PR's head. */ + sha: string; + /** The method the caller asked for; otherwise {@link mergeMethod} picks one on an ungated base. */ + method?: Method; + /** Merge at once on an ungated base with auto-merge disabled. */ + direct?: boolean; + check: LandingCheck; +} + /** * Land `sha`, which must still be the head of `pr`, while no session holds it: * enable auto-merge bound to it, or merge at once when GitHub would refuse auto-merge because @@ -215,15 +231,11 @@ function signalMethod( * A base that requires the `quest land` check queues it for `quest land` instead: * auto-merge whose commit body pins `sha`, with a method {@link signalMethod} picks. * That request only signals the queue: `quest land` lands with its own method. It takes no label. - * `named` is the method the caller asked for; otherwise {@link mergeMethod} picks one on an ungated base. + * It first refuses a head whose quest check finds anything, so the refusal comes before a queue + * build is spent, even on a base whose gate checks it again. */ -export async function land( - pr: PullRequest, - sha: string, - named: Method | undefined, - deps: GitHubDependencies, - direct = false, -): Promise { +export async function land(pr: PullRequest, request: LandRequest, deps: GitHubDependencies): Promise { + const { sha, method: named, direct = false } = request; const labels = new Labels(pr, deps); const current = (snapshot: Snapshot) => headAt(snapshot, sha); const snapshot = await labels.read(); @@ -241,6 +253,18 @@ export async function land( } }; await passing(labels.github, pr, snapshot.url, sha); + const findings = await request.check({ + remote: `https://github.com/${pr.owner}/${pr.repo}.git`, + base: snapshot.base, + baseSha: snapshot.baseSha, + branch: snapshot.branch, + sha, + token: deps.token, + }); + if (findings.length > 0) + throw new Refusal( + `${snapshot.url} head ${sha} fails quest check against ${snapshot.base}:\n${findings.map(formatFinding).join("\n")}\nfix the PR, then land it again`, + ); const needs = await requirements(labels.github, pr, snapshot.base); if (needs.checks.some((check) => check.name === LAND_CHECK)) { if (named !== undefined) @@ -518,6 +542,8 @@ class Labels { body: typeof row.body === "string" ? row.body : "", updatedAt: string(row.updatedAt), base: string(row.baseRefName), + baseSha: string(row.baseRefOid), + branch: string(row.headRefName), head: string(row.headRefOid), mergeState: string(row.mergeStateStatus), queue: row.isMergeQueueEnabled === true, diff --git a/src/cli/land-bump.ts b/src/cli/land-bump.ts index 9bcce2c9..7c3969f5 100644 --- a/src/cli/land-bump.ts +++ b/src/cli/land-bump.ts @@ -453,7 +453,8 @@ async function settle(target: Repository, record: Bump, connection: BumpConnecti direct = object(await (await github.request(path)).json()).allow_auto_merge !== true; } try { - await land({ ...target, number: pr }, head, undefined, connection.deps, direct); + // The bump PR is this process's own commit of version files, so it has no quest to check. + await land({ ...target, number: pr }, { sha: head, direct, check: async () => [] }, connection.deps); } catch (error) { if (!(error instanceof Refusal)) throw error; return fail(`landing it was refused: ${error.message}`); diff --git a/src/cli/landed.ts b/src/cli/landed.ts index d2035456..200f3a88 100644 --- a/src/cli/landed.ts +++ b/src/cli/landed.ts @@ -4,28 +4,39 @@ // lives here rather than in the core. import { spawnSync } from "node:child_process"; +import { accessSync, constants, mkdtempSync, rmSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; -import { type Finding, branchQuest } from "../core"; +import { type Finding, branchQuest, check } from "../core"; import { discoveryEnv } from "./git"; +import { snapshot } from "./tree"; /** * A finding when `branch` (default: the current branch) is a quest's branch - * and the working tree neither deletes nor modifies that quest relative to its - * merge base with `base`. Not a quest branch, or no such quest at the merge - * base, is no finding. + * and `head` (default: the working tree) neither deletes nor modifies that + * quest relative to its merge base with `base`. Not a quest branch, or no such + * quest at the merge base, is no finding. With `head`, `root` is the + * repository's top level, as in a bare repository. */ -export function landed(root: string, base: string, branch?: string): Finding[] { - const name = branch ?? currentBranch(root); - const mergeBase = git(root, ["merge-base", base, "HEAD"]); +export function landed(root: string, base: string, options: { branch?: string; head?: string } = {}): Finding[] { + const name = options.branch ?? currentBranch(root); + const head = options.head ?? "HEAD"; + const mergeBase = git(root, ["merge-base", base, head]); if (mergeBase.status !== 0) { - throw new Error(`no merge base between ${base} and HEAD: ${mergeBase.stderr.trim() || "unrelated histories"}`); + throw new Error( + `no merge base between ${base} and ${head}: ${mergeBase.stderr.trim() || "unrelated histories"}`, + ); } const commit = mergeBase.stdout.trim(); - const path = questAt(root, commit, name); + // Without a head, the pathspec and `:./path` are relative to the root, + // which may sit below the repository's top level; a bare repository has no + // work tree to be relative to. + const relative = options.head === undefined ? "./" : ""; + const path = questAt(root, commit, name, relative); if (path === null) return []; - // The pathspec and `:./path` are relative to the root, which may sit - // below the repository's top level. - const diff = git(root, ["diff", "--quiet", "--no-ext-diff", commit, "--", `./${path}`]); + const heads = options.head === undefined ? [] : [options.head]; + const diff = git(root, ["diff", "--quiet", "--no-ext-diff", commit, ...heads, "--", `${relative}${path}`]); if (diff.status === 1) return []; if (diff.status !== 0) throw new Error(`git diff ${commit} -- ${path}: ${diff.stderr.trim()}`); return [ @@ -39,11 +50,119 @@ export function landed(root: string, base: string, branch?: string): Finding[] { ]; } +/** The PR head `quest merge` is about to land, and where to fetch it and its base. */ +export interface LandingHead { + /** The base repository's Git URL, which serves the head's commits even from a fork. */ + remote: string; + /** The base branch's name, and the commit it points at. */ + base: string; + baseSha: string; + branch: string; + sha: string; + token: string; +} + +/** Checks a head before `quest merge` queues it; resolves to its findings, empty when it may land. */ +export type LandingCheck = (head: LandingHead) => Promise; + +/** + * What `quest check --no-stubs --base --branch ` reports on `head.sha`, against a + * freshly fetched base. The head is untrusted, so nothing from it runs or is checked out: the + * check reads git objects. It fetches both commits by SHA into the repository of the checkout at + * `root`, writing no ref, so Git sends only what that repository lacks and an interrupted run leaves + * nothing behind. A checkout it cannot write, or a shallow one whose history could hide the merge + * base, gives way to a temporary bare repository, as does no checkout. + * A finding the base already has is not the head's, as the land daemon screens a head, and a + * repository with no quests on either side does not use them. + */ +export function landingCheck(root: string): LandingCheck { + return async (head) => { + const local = git(root, ["rev-parse", "--path-format=absolute", "--git-common-dir", "--is-shallow-repository"]); + const [common, shallow] = local.stdout.trim().split("\n"); + const borrowed = local.status === 0 && shallow === "false" && writable(common); + const dir = borrowed ? common : mkdtempSync(join(tmpdir(), "quest-merge-")); + const { baseSha: base, sha: tip } = head; + const run = (args: string[], env: Record = {}) => { + const result = spawnSync("git", ["-c", "core.hooksPath=/dev/null", "-C", dir, ...args], { + encoding: "utf8", + env: { ...discoveryEnv(), GIT_TERMINAL_PROMPT: "0", ...env }, + maxBuffer: 1 << 30, + }); + if (result.error) throw result.error; + if (result.status !== 0) throw new Error(`git ${args[0]} failed: ${result.stderr.trim()}`); + return result.stdout.trim(); + }; + // Findings and errors name the scratch directory and the base's SHA, which the refusal need not show. + const tidy = (finding: Finding): Finding => ({ + ...finding, + message: finding.message.replaceAll(`${dir}/`, "").replaceAll(base, `origin/${head.base}`), + }); + try { + if (!borrowed) run(["init", "--quiet", "--bare"]); + // The token rides in the environment, after any configuration the user's environment already passes. + const count = Number(process.env.GIT_CONFIG_COUNT ?? 0) || 0; + const basic = Buffer.from(`x-access-token:${head.token}`).toString("base64"); + run(["fetch", "--quiet", "--no-tags", "--no-write-fetch-head", head.remote, base, tip], { + GIT_CONFIG_COUNT: String(count + 2), + // An empty value drops any header the checkout already sends, such as actions/checkout's, which GitHub would reject as a duplicate. + [`GIT_CONFIG_KEY_${count}`]: "http.https://github.com/.extraheader", + [`GIT_CONFIG_VALUE_${count}`]: "", + [`GIT_CONFIG_KEY_${count + 1}`]: "http.https://github.com/.extraheader", + [`GIT_CONFIG_VALUE_${count + 1}`]: `Authorization: basic ${basic}`, + }); + const quests = (ref: string) => run(["ls-tree", "--name-only", ref, "quest"]) !== ""; + const based = quests(base); + if (!based && !quests(tip)) return []; + // A finding the base already has is not this PR's, such as one a `quest` older than the tree's + // format reports; one more of the same in the head is. + const known = based ? treeCheck(dir, base) : []; + const findings = treeCheck(dir, tip).filter((finding) => { + const index = known.findIndex((old) => old.path === finding.path && old.message === finding.message); + if (index === -1) return true; + known.splice(index, 1); + return false; + }); + let accurate: Finding[]; + try { + accurate = landed(dir, base, { branch: head.branch, head: tip }); + } catch (error) { + throw new Error( + tidy({ path: "", line: null, message: String(error instanceof Error ? error.message : error) }) + .message, + ); + } + return [...findings, ...accurate].map(tidy); + } finally { + if (!borrowed) rmSync(dir, { recursive: true, force: true }); + } + }; +} + +/** Whether this process may write the objects of the Git directory `dir`. */ +function writable(dir: string): boolean { + try { + accessSync(join(dir, "objects"), constants.W_OK); + return true; + } catch { + return false; + } +} + +/** `quest check`'s findings on `commit`; a tree it cannot read, such as one with no quests left, is one. */ +function treeCheck(dir: string, commit: string): Finding[] { + try { + const tree = snapshot(dir, commit, null); + return check(tree.docs, tree.exists); + } catch (error) { + return [{ path: "quest", line: null, message: error instanceof Error ? error.message : String(error) }]; + } +} + /** The quest file `branch` names, if it existed at `commit`. */ -function questAt(root: string, commit: string, branch: string): string | null { +function questAt(root: string, commit: string, branch: string, relative: string): string | null { if (!branch.startsWith("quest/") || branch.endsWith("/")) return null; const path = branchQuest(branch); - return git(root, ["cat-file", "-e", `${commit}:./${path}`]).status === 0 ? path : null; + return git(root, ["cat-file", "-e", `${commit}:${relative}${path}`]).status === 0 ? path : null; } function currentBranch(root: string): string { diff --git a/src/cli/main.ts b/src/cli/main.ts index 0c5a9c2b..24113a60 100644 --- a/src/cli/main.ts +++ b/src/cli/main.ts @@ -41,7 +41,7 @@ import { apply, pushCommand } from "./land-apply"; import { EFFORT_VARIABLE, EFFORTS, fix, FixerAgentError } from "./land-fix"; import { serve, type ServeOptions } from "./land-serve"; import { watch, type WatchOptions } from "./land-watch"; -import { landed } from "./landed"; +import { landed, landingCheck } from "./landed"; import { type Report, fixHeadings, fixLinks, moveQuest, removeQuest } from "./move"; import { type ResolveOptions, resolveFile } from "./resolve"; import { hosts } from "../core/doc"; @@ -203,7 +203,7 @@ export function main(argv: string[], out: Output): number | Promise { } const tree = checkout(root(), warn); const findings = check(tree.docs, tree.exists); - if (options.base !== undefined) findings.push(...landed(root(), options.base, options.branch)); + if (options.base !== undefined) findings.push(...landed(root(), options.base, { branch: options.branch })); // A tree nested in another checkout, such as an example, has no stubs of its own. const stubs = options.stubs && questRoot(resolve(root())) === resolve(root()) ? stubFindings(root()) : []; if (findings.length === 0 && stubs.length === 0) { @@ -623,7 +623,9 @@ export function main(argv: string[], out: Output): number | Promise { "once when nothing is left to wait for. It takes no label: the auto-merge or merge-queue entry it " + "creates is the queue signal. It refuses while a session holds the PR, so release your own hold " + "first, once the head has moved, and while the latest run of any check on the head failed, required " + - "or not, naming each; a pending or absent check does not block. It uses the method --squash or --rebase names, refusing one " + + "or not, naming each; a pending or absent check does not block. It refuses a head on which quest check " + + "--no-stubs --base --branch finds anything, read from git objects fetched from the base repository, " + + "so nothing from the head runs, except findings the base already has; a base without quests skips it. It uses the method --squash or --rebase names, refusing one " + "the repository disallows; otherwise the only method the repository allows, or else a merge commit. " + "On a base with GitHub's merge queue, which applies its own method, it enqueues that head, or arms " + "auto-merge bound to it while required checks may be pending; a head behind the base is enqueued as " + @@ -647,7 +649,14 @@ export function main(argv: string[], out: Output): number | Promise { const pr = pullRequest(value, root()); if (!/^[\da-f]{40}$/i.test(options.land)) throw new UsageError("--land needs a full 40-character SHA"); const method = options.squash ? "squash" : options.rebase ? "rebase" : undefined; - settle(land(pr, options.land, method, gitHubDependencies(warn), options.direct), () => undefined); + settle( + land( + pr, + { sha: options.land, method, direct: options.direct, check: landingCheck(root()) }, + gitHubDependencies(warn), + ), + () => undefined, + ); }); const landCommand = program.command("land").summary("Land queued PRs through a host daemon"); diff --git a/test/hold.test.ts b/test/hold.test.ts index 59454cab..e240cc96 100644 --- a/test/hold.test.ts +++ b/test/hold.test.ts @@ -8,10 +8,18 @@ import { withoutHandBack } from "../src/core"; import { type Output, main } from "../src/cli/main"; import { Refusal } from "../src/cli/start"; +// `quest merge` through main would fetch the PR from GitHub to check it; these PRs exist only in memory. +vi.mock("../src/cli/landed", async (original) => ({ + ...(await original()), + landingCheck: () => async () => [], +})); + const PR = { owner: "example", repo: "project", number: 7 }; const URL_ = "https://github.com/example/project/pull/7"; const HEAD = "a".repeat(40); const BASE = "b".repeat(40); +/** A landing check that finds nothing. */ +const clean = async () => []; interface Event { __typename: "LabeledEvent" | "AutoMergeEnabledEvent" | "AddedToMergeQueueEvent"; @@ -182,6 +190,8 @@ class FakePull { body: this.body, updatedAt: new Date(this.clock).toISOString(), baseRefName: this.baseRef, + baseRefOid: this.base, + headRefName: "quest/m0/example", headRefOid: this.head, mergeStateStatus: this.mergeState, isMergeQueueEnabled: this.queue, @@ -299,7 +309,9 @@ describe("merge --land", () => { const pull = new FakePull(); pull.allowAutoMerge = false; pull.mergeState = state; - expect(await refused(land(PR, HEAD, "squash", pull.deps()))).toContain("CONTRIBUTING.md or AGENTS.md"); + expect(await refused(land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps()))).toContain( + "CONTRIBUTING.md or AGENTS.md", + ); expect(pull.writes).toEqual([]); expect(pull.state).toBe("OPEN"); }); @@ -322,13 +334,13 @@ describe("merge --land", () => { run(2, "Lint", "IN_PROGRESS", null), run(4, "quest queue", "COMPLETED", "FAILURE"), ]; - expect(await refused(land(PR, HEAD, "merge", pull.deps()))).toContain( + expect(await refused(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()))).toContain( `head ${HEAD} failed a check: Check (https://ci.example/1)`, ); expect(pull.writes).toEqual([]); // A rerun that passed supersedes the failure; a pending check does not block. pull.checks.push(run(3, "Check", "COMPLETED", "SUCCESS")); - await land(PR, HEAD, "merge", pull.deps()); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()); expect(pull.writes).not.toEqual([]); }); @@ -336,21 +348,25 @@ describe("merge --land", () => { const pull = new FakePull(); pull.allowAutoMerge = null; pull.mergeState = "CLEAN"; - expect(await refused(land(PR, HEAD, "squash", pull.deps()))).toContain("not visible to this token"); + expect(await refused(land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps()))).toContain( + "not visible to this token", + ); expect(pull.writes).toEqual([]); }); test("takes no label, and refuses while a session holds the PR", async () => { const pull = new FakePull(); const { token } = await take(PR, undefined, pull.deps()); - const message = await refused(land(PR, HEAD, "merge", pull.deps())); + const message = await refused(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps())); expect(message).toContain("held by quest:active, added just now"); expect(message).not.toContain(token); await release(PR, token, pull.deps()); pull.label("quest:active"); - expect(await refused(land(PR, HEAD, "merge", pull.deps()))).toContain("held by quest:active"); + expect(await refused(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()))).toContain( + "held by quest:active", + ); pull.labels = ["quest:merge"]; - await land(PR, HEAD, "merge", pull.deps()); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} MERGE`); expect(pull.labels).toEqual(["quest:merge"]); }); @@ -362,16 +378,22 @@ describe("merge --land", () => { pull.afterRead = undefined; pull.baseRef = "release"; }; - expect(await refused(land(PR, HEAD, "squash", pull.deps()))).toContain("retargeted from main to release"); + expect(await refused(land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps()))).toContain( + "retargeted from main to release", + ); expect(pull.writes).toEqual([]); }); test("refuses a merged PR or a draft its starter still holds", async () => { const pull = new FakePull(); pull.draft = true; - expect(await refused(land(PR, HEAD, "merge", pull.deps()))).toContain("its starter still holds"); + expect(await refused(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()))).toContain( + "its starter still holds", + ); pull.state = "MERGED"; - expect(await refused(land(PR, HEAD, "merge", pull.deps()))).toContain("is merged"); + expect(await refused(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()))).toContain( + "is merged", + ); expect(pull.writes).toEqual([]); }); @@ -379,7 +401,7 @@ describe("merge --land", () => { const pull = new FakePull(); pull.allowAutoMerge = false; pull.queue = true; - await land(PR, HEAD, "merge", pull.deps()); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} MERGE`); }); @@ -391,7 +413,7 @@ describe("merge --land", () => { pull.mergeState = state; pull.comparison = "diverged"; const warnings: string[] = []; - await land(PR, HEAD, "merge", pull.deps(warnings)); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps(warnings)); expect(pull.writes).toEqual([`enqueuePullRequest ${HEAD}`]); expect(pull.queueEntry).not.toBeNull(); expect(pull.comparisons).toEqual([]); @@ -403,7 +425,7 @@ describe("merge --land", () => { const pull = new FakePull(); pull.queue = true; pull.mergeState = "BLOCKED"; - await land(PR, HEAD, "merge", pull.deps()); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()); expect(pull.writes).toEqual([`enablePullRequestAutoMerge ${HEAD} MERGE`]); }); @@ -412,7 +434,7 @@ describe("merge --land", () => { pull.queue = true; pull.mergeState = "UNKNOWN"; pull.beforeAutoMerge = () => "Pull request is in clean status"; - await land(PR, HEAD, "squash", pull.deps()); + await land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps()); expect(pull.writes).toEqual([`enablePullRequestAutoMerge ${HEAD} SQUASH`, `enqueuePullRequest ${HEAD}`]); }); @@ -421,7 +443,7 @@ describe("merge --land", () => { pull.queue = true; pull.mergeState = "DIRTY"; pull.beforeEnqueue = () => ({ message: "Pull request is not mergeable", type: "UNPROCESSABLE" }); - expect(await refused(land(PR, HEAD, "merge", pull.deps()))).toBe( + expect(await refused(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()))).toBe( `${URL_}: GitHub refused to enqueue ${HEAD} (GitHub GraphQL error: Pull request is not mergeable); fix the PR, for example with /quest-iterate, and land it again`, ); expect(pull.queueEntry).toBeNull(); @@ -436,7 +458,7 @@ describe("merge --land", () => { return { message: "Pull request is already queued" }; }; const warnings: string[] = []; - await land(PR, HEAD, "merge", pull.deps(warnings)); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps(warnings)); expect(warnings).toEqual([]); }); @@ -448,7 +470,9 @@ describe("merge --land", () => { pull.head = "c".repeat(40); return { message: "Head ref has moved" }; }; - expect(await refused(land(PR, HEAD, "merge", pull.deps()))).toContain(`head moved to ${"c".repeat(40)}`); + expect(await refused(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()))).toContain( + `head moved to ${"c".repeat(40)}`, + ); }); test("passes on an enqueue error that faults the token rather than the PR", async () => { @@ -456,7 +480,9 @@ describe("merge --land", () => { pull.queue = true; pull.mergeState = "CLEAN"; pull.beforeEnqueue = () => ({ message: "Resource not accessible by integration", type: "FORBIDDEN" }); - const error = await land(PR, HEAD, "merge", pull.deps()).catch((caught: unknown) => caught); + const error = await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()).catch( + (caught: unknown) => caught, + ); expect(error).not.toBeInstanceOf(Refusal); expect(error).toMatchObject({ message: "GitHub GraphQL error: Resource not accessible by integration" }); }); @@ -487,7 +513,7 @@ describe("merge --land", () => { const pull = new FakePull(); pull.allowAutoMerge = false; pull.mergeState = state; - await land(PR, HEAD, "squash", pull.deps(), true); + await land(PR, { sha: HEAD, method: "squash", direct: true, check: clean }, pull.deps()); expect(pull.writes).toEqual([`mergePullRequest ${HEAD} SQUASH`]); }); @@ -496,12 +522,12 @@ describe("merge --land", () => { async (status) => { const pull = new FakePull(); pull.comparison = status; - const refusal = await refused(land(PR, HEAD, "squash", pull.deps())); + const refusal = await refused(land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps())); expect(refusal).toContain(`head ${HEAD} does not contain main at ${BASE}`); expect(pull.writes).toEqual([]); pull.head = "c".repeat(40); pull.comparison = "ahead"; - await land(PR, pull.head, "squash", pull.deps()); + await land(PR, { sha: pull.head, method: "squash", check: clean }, pull.deps()); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${pull.head} SQUASH`); }, ); @@ -510,13 +536,13 @@ describe("merge --land", () => { const pull = new FakePull(); pull.comparison = "identical"; pull.base = HEAD; - await land(PR, HEAD, "merge", pull.deps()); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} MERGE`); }); test("enables auto-merge with a merge commit by default, bound to the head", async () => { const pull = new FakePull(); - await land(PR, HEAD, "merge", pull.deps()); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()); expect(pull.writes).toEqual([`enablePullRequestAutoMerge ${HEAD} MERGE`]); expect(pull.labels).toEqual([]); }); @@ -525,7 +551,7 @@ describe("merge --land", () => { for (const method of ["squash", "rebase"] as const) { const pull = new FakePull(); pull.mergeState = "CLEAN"; - await land(PR, HEAD, method, pull.deps()); + await land(PR, { sha: HEAD, method: method, check: clean }, pull.deps()); expect(pull.writes.at(-1)).toBe(`mergePullRequest ${HEAD} ${method.toUpperCase()}`); } }); @@ -544,14 +570,14 @@ describe("merge --land", () => { test("uses the only method allowed without a flag", async () => { for (const method of ["squash", "rebase"]) { const pull = allowing(method); - await land(PR, HEAD, undefined, pull.deps()); + await land(PR, { sha: HEAD, check: clean }, pull.deps()); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} ${method.toUpperCase()}`); } }); test("keeps a merge commit by default while one is allowed", async () => { const pull = allowing("merge", "squash"); - await land(PR, HEAD, undefined, pull.deps()); + await land(PR, { sha: HEAD, check: clean }, pull.deps()); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} MERGE`); }); @@ -559,7 +585,7 @@ describe("merge --land", () => { const pull = allowing("squash"); pull.allowAutoMerge = false; pull.mergeState = "CLEAN"; - await land(PR, HEAD, undefined, pull.deps(), true); + await land(PR, { sha: HEAD, direct: true, check: clean }, pull.deps()); expect(pull.writes).toEqual([`mergePullRequest ${HEAD} SQUASH`]); }); @@ -572,7 +598,9 @@ describe("merge --land", () => { ]; for (const [methods, named, refusal] of cases) { const pull = allowing(...methods); - expect(await refused(land(PR, HEAD, named, pull.deps()))).toContain(refusal); + expect(await refused(land(PR, { sha: HEAD, method: named, check: clean }, pull.deps()))).toContain( + refusal, + ); expect(pull.writes).toEqual([]); } }); @@ -588,7 +616,7 @@ describe("merge --land", () => { const gated = allowing(...methods); gated.required = ["quest land"]; if (ruled) gated.rules = [{ type: "pull_request", parameters: { allowed_merge_methods: [...ruled] } }]; - await land(PR, HEAD, undefined, gated.deps()); + await land(PR, { sha: HEAD, check: clean }, gated.deps()); expect(gated.writes.at(-1)).toBe( `enablePullRequestAutoMerge ${HEAD} ${signal} Quest-Land-Head: ${HEAD}`, ); @@ -596,11 +624,11 @@ describe("merge --land", () => { const refusing = allowing("merge", "squash"); refusing.required = ["quest land"]; refusing.rules = [{ type: "pull_request", parameters: { allowed_merge_methods: ["merge"] } }]; - expect(await refused(land(PR, HEAD, "squash", refusing.deps()))).toContain( + expect(await refused(land(PR, { sha: HEAD, method: "squash", check: clean }, refusing.deps()))).toContain( "cannot land with squash merges on main, by its repository settings or rulesets", ); refusing.rules.push({ type: "pull_request", parameters: { allowed_merge_methods: ["squash"] } }); - expect(await refused(land(PR, HEAD, undefined, refusing.deps()))).toContain( + expect(await refused(land(PR, { sha: HEAD, check: clean }, refusing.deps()))).toContain( "has no merge method its repository and main's rulesets both allow", ); expect(refusing.writes).toEqual([]); @@ -608,7 +636,7 @@ describe("merge --land", () => { const queued = allowing("squash"); queued.queue = true; const warnings: string[] = []; - await land(PR, HEAD, undefined, queued.deps(warnings)); + await land(PR, { sha: HEAD, check: clean }, queued.deps(warnings)); expect(queued.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} MERGE`); expect(warnings).toEqual([]); }); @@ -619,7 +647,7 @@ describe("merge --land", () => { pull.mergeState = "CLEAN"; pull.queue = true; const warnings: string[] = []; - await land(PR, HEAD, "squash", pull.deps(warnings)); + await land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps(warnings)); expect(pull.writes.at(-1)).toBe(`enqueuePullRequest ${HEAD}`); expect(warnings).toEqual([`${URL_} lands through a merge queue, which applies its own merge method`]); }); @@ -630,7 +658,7 @@ describe("merge --land", () => { pull.allowAutoMerge = false; // The host-gated path does not use the ungated pre-check. pull.comparison = "diverged"; const warnings: string[] = []; - await land(PR, HEAD, "merge", pull.deps(warnings)); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps(warnings)); expect(pull.writes).toEqual([`enablePullRequestAutoMerge ${HEAD} MERGE Quest-Land-Head: ${HEAD}`]); expect(warnings).toEqual([`${URL_} lands through quest land, which applies its own merge method`]); expect(pull.comparisons).toEqual([]); @@ -640,7 +668,7 @@ describe("merge --land", () => { const pull = new FakePull(); pull.required = ["test", "quest land"]; pull.autoMerge = { enabledAt: "2026-10-20T12:00:00Z", commitBody: `Quest-Land-Head: ${"0".repeat(40)}` }; - await land(PR, HEAD, "squash", pull.deps()); + await land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps()); expect(pull.writes.slice(-2)).toEqual([ "disablePullRequestAutoMerge", `enablePullRequestAutoMerge ${HEAD} SQUASH Quest-Land-Head: ${HEAD}`, @@ -652,7 +680,7 @@ describe("merge --land", () => { const pull = new FakePull(); pull.required = ["test", "quest land"]; pull.autoMerge = { enabledAt: "2026-10-20T12:00:00Z", commitBody: "" }; - await land(PR, HEAD, "squash", pull.deps()); + await land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps()); expect(pull.autoMerge?.commitBody).toBe(`Quest-Land-Head: ${HEAD}`); }); @@ -665,7 +693,7 @@ describe("merge --land", () => { pull.mergeState = state; return "Pull request is in clean status"; }; - await land(PR, HEAD, "squash", pull.deps()); + await land(PR, { sha: HEAD, method: "squash", check: clean }, pull.deps()); expect(pull.writes).toEqual([ `enablePullRequestAutoMerge ${HEAD} SQUASH`, `mergePullRequest ${HEAD} SQUASH`, @@ -678,7 +706,7 @@ describe("merge --land", () => { test("keeps UNKNOWN on auto-merge when GitHub accepts it", async () => { const pull = new FakePull(); pull.mergeState = "UNKNOWN"; - await land(PR, HEAD, "merge", pull.deps()); + await land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} MERGE`); expect(pull.reads).toBe(2); expect(pull.state).toBe("OPEN"); @@ -690,7 +718,7 @@ describe("merge --land", () => { const pull = new FakePull(); pull.mergeState = "UNKNOWN"; pull.beforeAutoMerge = () => reason; - await expect(land(PR, HEAD, "merge", pull.deps())).rejects.toThrow(reason); + await expect(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps())).rejects.toThrow(reason); expect(pull.reads).toBe(reason.includes("clean status") ? 3 : 2); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} MERGE`); }, @@ -710,7 +738,7 @@ describe("merge --land", () => { if (change === "queue") pull.queue = true; return "Pull request is in clean status"; }; - await expect(land(PR, HEAD, "merge", pull.deps())).rejects.toThrow(); + await expect(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps())).rejects.toThrow(); expect(pull.state).toBe("OPEN"); expect(pull.writes.at(-1)).toBe(`enablePullRequestAutoMerge ${HEAD} MERGE`); }, @@ -719,7 +747,9 @@ describe("merge --land", () => { test("refuses a head that moved", async () => { const pull = new FakePull(); pull.head = "b".repeat(40); - expect(await refused(land(PR, HEAD, "merge", pull.deps()))).toContain(`head moved to ${"b".repeat(40)}`); + expect(await refused(land(PR, { sha: HEAD, method: "merge", check: clean }, pull.deps()))).toContain( + `head moved to ${"b".repeat(40)}`, + ); expect(pull.writes).toEqual([]); }); }); diff --git a/test/land-bump.test.ts b/test/land-bump.test.ts index 5c46f7e3..22ea34cf 100644 --- a/test/land-bump.test.ts +++ b/test/land-bump.test.ts @@ -317,10 +317,8 @@ describe("bumpPass", () => { expect(target.pulls[0].body).toContain("changed `stub.md`"); expect(landed).toHaveBeenCalledExactlyOnceWith( { ...target.target, number: 7 }, - head, - undefined, + { sha: head, direct: false, check: expect.any(Function) }, expect.anything(), - false, ); // The next pass at the same commit asks GitHub nothing. @@ -393,10 +391,8 @@ describe("bumpPass", () => { expect(await bumpPass(ctx, NEW)).toEqual(["bump landing moq-dev/widget 7"]); expect(landed).toHaveBeenCalledExactlyOnceWith( { ...target.target, number: 7 }, - head, - undefined, + { sha: head, direct: true, check: expect.any(Function) }, expect.anything(), - true, ); }); diff --git a/test/landed.test.ts b/test/landed.test.ts index 96422de8..75feae72 100644 --- a/test/landed.test.ts +++ b/test/landed.test.ts @@ -2,9 +2,14 @@ import { execFileSync } from "node:child_process"; -import { expect, test } from "vitest"; +import { chmodSync, readdirSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; -import { Tree } from "./fixture"; +import { describe, expect, test } from "vitest"; + +import { landingCheck } from "../src/cli/landed"; +import { Tree, initRepository, tempDir } from "./fixture"; const FINDING = "neither deletes nor edits its quest since main"; @@ -120,3 +125,149 @@ test("an unknown base fails", () => { test("--branch without --base is a usage error", () => { expect(Tree.baseline().run("check", "--branch", "quest/m0/epic/one").code).toBe(2); }); + +describe("quest merge's landing check", () => { + /** Check `branch`'s tip in `tree` as `quest merge` would, fetching from `tree` into `root`. */ + function inspect(tree: Tree, branch: string, root = tempDir()) { + const sha = git(tree, "rev-parse", branch).trim(); + const baseSha = git(tree, "rev-parse", "main").trim(); + return landingCheck(root)({ remote: tree.path, base: "main", baseSha, branch, sha, token: "token" }); + } + + test("finds a head that leaves its quest untouched, against the fetched base", async () => { + const tree = repo("quest/m0/epic/one"); + tree.write("src.ts", "work\n"); + commit(tree, "work"); + const findings = await inspect(tree, "quest/m0/epic/one"); + expect(findings.map((finding) => [finding.path, finding.message])).toEqual([ + ["quest/m0/epic/one.md", expect.stringContaining("neither deletes nor edits its quest since origin/main")], + ]); + }); + + test("passes a head that edits its quest, borrowing a checkout's objects", async () => { + const tree = repo("quest/m0/epic/one"); + tree.append("quest/m0/epic/one.md", "\n## Plan\n\nWhat remains.\n"); + commit(tree, "trim one"); + expect(await inspect(tree, "quest/m0/epic/one", tree.path)).toEqual([]); + }); + + test("reads the committed head, not a working tree", async () => { + const tree = repo("quest/m0/epic/one"); + commit(tree, "nothing"); + // An uncommitted edit in the remote's own checkout is not part of the head. + tree.append("quest/m0/epic/one.md", "\nMore.\n"); + expect(await inspect(tree, "quest/m0/epic/one")).toHaveLength(1); + }); + + test("reports a structural finding in the head's tree", async () => { + const tree = repo("fix/link"); + tree.append("quest/m0/epic/one.md", "\n## Related\n\n- [Gone](/quest/m0/gone.md) - missing\n"); + commit(tree, "dangling link"); + const findings = await inspect(tree, "fix/link"); + expect(findings.map((finding) => finding.path)).toEqual(["quest/m0/epic/one.md"]); + }); + + test("skips a finding the base already has", async () => { + const tree = Tree.committed(); + tree.append("quest/m0/epic/one.md", "\n## Related\n\n- [Gone](/quest/m0/gone.md) - missing\n"); + commit(tree, "dangling link on main"); + git(tree, "switch", "--quiet", "-c", "fix/other"); + tree.append("quest/m0/epic/two.md", "\n## Related\n\n- [Lost](/quest/m0/lost.md) - missing\n"); + commit(tree, "another dangling link"); + const findings = await inspect(tree, "fix/other"); + expect(findings.map((finding) => finding.path)).toEqual(["quest/m0/epic/two.md"]); + }); + + test("reports one more of a finding the base already has", async () => { + const tree = Tree.committed(); + tree.append("quest/m0/epic/one.md", "\n## Related\n\n- [Gone](/quest/m0/gone.md) - missing\n"); + commit(tree, "dangling link on main"); + git(tree, "switch", "--quiet", "-c", "fix/again"); + tree.append("quest/m0/epic/one.md", "- [Gone again](/quest/m0/gone.md) - missing\n"); + commit(tree, "the same dangling link"); + expect((await inspect(tree, "fix/again")).map((finding) => finding.path)).toEqual(["quest/m0/epic/one.md"]); + }); + + test("fetches into a checkout's repository, writing none of its refs", async () => { + const tree = repo("quest/m0/epic/one"); + tree.write("src.ts", "work\n"); + commit(tree, "work"); + const local = Tree.committed(); + const refs = git(local, "for-each-ref"); + expect(await inspect(tree, "quest/m0/epic/one", local.path)).toHaveLength(1); + expect(git(local, "for-each-ref")).toBe(refs); + // The head's objects arrived in the checkout's repository. + git(local, "cat-file", "-e", git(tree, "rev-parse", "quest/m0/epic/one").trim()); + }); + + test("does not borrow a shallow checkout's history", async () => { + const tree = repo("quest/m0/epic/one"); + tree.append("quest/m0/epic/one.md", "\nMore.\n"); + commit(tree, "edit"); + const shallow = tempDir(); + execFileSync("git", ["clone", "--quiet", "--depth=1", `file://${tree.path}`, shallow], { stdio: "ignore" }); + expect(await inspect(tree, "quest/m0/epic/one", shallow)).toEqual([]); + // It fetched nothing into the shallow checkout. + expect(() => git(new Tree(shallow), "cat-file", "-e", git(tree, "rev-parse", "main").trim())).toThrow(); + }); + + test("does not write to a checkout it cannot write", async () => { + const tree = repo("quest/m0/epic/one"); + tree.append("quest/m0/epic/one.md", "\nMore.\n"); + commit(tree, "edit"); + const local = Tree.committed(); + chmodSync(join(local.path, ".git/objects"), 0o555); + try { + expect(await inspect(tree, "quest/m0/epic/one", local.path)).toEqual([]); + } finally { + chmodSync(join(local.path, ".git/objects"), 0o755); + } + }); + + test("a head that adopts quests is checked", async () => { + const tree = new Tree(initRepository()); + tree.write("README.md", "hi\n"); + commit(tree, "init"); + git(tree, "switch", "--quiet", "-c", "adopt"); + Tree.baseline().copy(tree.path); + tree.append("quest/m0/epic/one.md", "\n## Related\n\n- [Gone](/quest/m0/gone.md) - missing\n"); + commit(tree, "adopt quests"); + expect((await inspect(tree, "adopt")).map((finding) => finding.path)).toEqual(["quest/m0/epic/one.md"]); + }); + + test("a head that removes every quest is a finding", async () => { + const tree = repo("fix/purge"); + git(tree, "rm", "--quiet", "-r", "quest"); + commit(tree, "purge"); + const findings = await inspect(tree, "fix/purge"); + expect(findings).toEqual([ + { path: "quest", line: null, message: expect.stringContaining("no quest documents") }, + ]); + }); + + test("a base without quests does not use them", async () => { + const path = initRepository(); + const tree = new Tree(path); + tree.write("README.md", "hi\n"); + commit(tree, "init"); + git(tree, "switch", "--quiet", "-c", "quest/m0/anything"); + tree.write("src.ts", "work\n"); + commit(tree, "work"); + expect(await inspect(tree, "quest/m0/anything")).toEqual([]); + }); + + test("fails on a head the remote does not have, and leaves no scratch repository", async () => { + const tree = repo("quest/m0/epic/one"); + const before = readdirSync(tmpdir()).filter((name) => name.startsWith("quest-merge-")).length; + const check = landingCheck(tempDir())({ + remote: tree.path, + base: "main", + baseSha: git(tree, "rev-parse", "main").trim(), + branch: "quest/m0/epic/one", + sha: "c".repeat(40), + token: "token", + }); + await expect(check).rejects.toThrow("git fetch failed"); + expect(readdirSync(tmpdir()).filter((name) => name.startsWith("quest-merge-")).length).toBe(before); + }); +}); diff --git a/test/status.test.ts b/test/status.test.ts index 51da6e17..7cec8117 100644 --- a/test/status.test.ts +++ b/test/status.test.ts @@ -35,6 +35,8 @@ function pull( body: "Summary.", updatedAt: "2026-10-07T12:00:00Z", baseRefName: "main", + baseRefOid: "b".repeat(40), + headRefName: "quest/m0/example", isMergeQueueEnabled: false, labels: { nodes: [] }, state: "OPEN",