@markjaquith/agency 3.2.13 → 3.2.15

package/src/services/PullRequestService.test.ts

@@ -1,716 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { chmod, mkdir, realpath, rm } from "node:fs/promises"
-import { join } from "node:path"
-import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { PhaseService } from "./PhaseService"
-import { TaskService } from "./TaskService"
-import { PullRequestService } from "./PullRequestService"
-import { WorktreeService } from "./WorktreeService"
-
-interface CommandResult {
-	readonly stdout: string
-	readonly stderr: string
-	readonly exitCode: number
-}
-
-const runCommand = async (
-	args: readonly string[],
-	cwd?: string,
-): Promise<CommandResult> => {
-	const process = Bun.spawn([...args], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	const [stdout, stderr, exitCode] = await Promise.all([
-		new Response(process.stdout).text(),
-		new Response(process.stderr).text(),
-		process.exited,
-	])
-	return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode }
-}
-
-const requireCommand = async (args: readonly string[], cwd?: string) => {
-	const result = await runCommand(args, cwd)
-	if (result.exitCode !== 0) {
-		throw new Error(`${args.join(" ")} failed: ${result.stderr}`)
-	}
-	return result
-}
-
-describe("PullRequestService", () => {
-	let root: string
-	let remotePath: string
-	let ghCallPath: string
-	let originalPath: string | undefined
-
-	const createTask = (id = "example", branch = `task/${id}`) =>
-		runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id,
-							ticketUrl: "https://example.com/task",
-							repo: "agency",
-							branch,
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-
-	const createPullRequest = (
-		taskId = "example",
-		phaseId?: string,
-		draft = false,
-		force = false,
-		options: Record<string, unknown> = {},
-	) =>
-		runTestEffect(
-			PullRequestService.pipe(
-				Effect.flatMap((service) =>
-					service.create(taskId, phaseId, draft, root, { force, ...options }),
-				),
-			),
-		)
-
-	const materialize = (taskId = "example", phaseId?: string) =>
-		runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) => service.materialize(taskId, phaseId, root)),
-			),
-		)
-
-	const writeFakeGh = async ({
-		stdout = "",
-		stderr = "",
-		exitCode = 0,
-		listStdouts = ["[]"],
-	}: {
-		stdout?: string
-		stderr?: string
-		exitCode?: number
-		listStdouts?: readonly string[]
-	}) => {
-		const path = join(root, "bin", "gh")
-		await Bun.write(
-			path,
-			`#!/usr/bin/env bun
-const args = Bun.argv.slice(2)
-const callFile = Bun.file(${JSON.stringify(ghCallPath)})
-const calls = await callFile.exists() ? await callFile.json() : []
-const listIndex = calls.filter((call) => call.args[1] === "list").length
-calls.push({ args, cwd: process.cwd() })
-await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify(calls))
-if (args[1] === "list") {
-  const responses = ${JSON.stringify(listStdouts)}
-  process.stdout.write(responses[Math.min(listIndex, responses.length - 1)] ?? "[]")
-  process.exit(0)
-}
-process.stdout.write(${JSON.stringify(stdout)})
-process.stderr.write(${JSON.stringify(stderr)})
-process.exit(${exitCode})
-`,
-		)
-		await chmod(path, 0o755)
-	}
-
-	const readGhCall = async () =>
-		(
-			(await Bun.file(ghCallPath).json()) as {
-				args: string[]
-				cwd: string
-			}[]
-		).at(-1)!
-
-	const readGhCalls = async () =>
-		(await Bun.file(ghCallPath).json()) as {
-			args: string[]
-			cwd: string
-		}[]
-
-	const githubRecord = (
-		number: number,
-		branch = "task/example",
-		base = "main",
-	) => ({
-		number,
-		url: `https://github.com/example/agency/pull/${number}`,
-		state: "OPEN",
-		isDraft: false,
-		headRefName: branch,
-		baseRefName: base,
-		headRepository: { nameWithOwner: "example/agency" },
-		mergeable: "UNKNOWN",
-	})
-
-	const expectRemoteBranch = async (branch: string, exists = true) => {
-		const result = await runCommand([
-			"git",
-			"--git-dir",
-			remotePath,
-			"show-ref",
-			"--verify",
-			`refs/heads/${branch}`,
-		])
-		expect(result.exitCode === 0).toBe(exists)
-	}
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		remotePath = join(root, "remote.git")
-		ghCallPath = join(root, "gh-call.json")
-		originalPath = process.env.PATH
-		await mkdir(join(root, "bin"), { recursive: true })
-		process.env.PATH = `${join(root, "bin")}:${originalPath ?? ""}`
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await mkdir(join(root, "repos"), { recursive: true })
-		await requireCommand([
-			"git",
-			"init",
-			"--bare",
-			"--initial-branch=main",
-			remotePath,
-		])
-		const seedPath = join(root, "seed")
-		await requireCommand(["git", "init", "--initial-branch=main", seedPath])
-		await requireCommand(
-			["git", "config", "user.name", "Agency Test"],
-			seedPath,
-		)
-		await requireCommand(
-			["git", "config", "user.email", "agency@example.com"],
-			seedPath,
-		)
-		await Bun.write(join(seedPath, "README.md"), "# Test repository\n")
-		await requireCommand(["git", "add", "README.md"], seedPath)
-		await requireCommand(["git", "commit", "-m", "Initial commit"], seedPath)
-		await requireCommand(
-			["git", "remote", "add", "origin", remotePath],
-			seedPath,
-		)
-		await requireCommand(["git", "push", "-u", "origin", "main"], seedPath)
-		await requireCommand([
-			"git",
-			"clone",
-			"--bare",
-			remotePath,
-			join(root, "repos", "agency"),
-		])
-	})
-
-	afterEach(async () => {
-		process.env.PATH = originalPath
-		await cleanupTempDir(root)
-	})
-
-	test("updates the execution document with a PR URL", async () => {
-		await createTask()
-		const url = "https://github.com/markjaquith/agency/pull/123"
-		await runTestEffect(
-			PullRequestService.pipe(
-				Effect.flatMap((service) =>
-					service.setUrl("example", undefined, url, root),
-				),
-			),
-		)
-		const task = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("example", root)),
-			),
-		)
-		expect("pr" in task.data && task.data.pr).toMatchObject({
-			provider: "github",
-			repository: "markjaquith/agency",
-			identifier: "123",
-			url,
-		})
-	})
-
-	test("rejects non-GitHub PR URLs", async () => {
-		await createTask()
-		await expect(
-			runTestEffect(
-				PullRequestService.pipe(
-					Effect.flatMap((service) =>
-						service.setUrl(
-							"example",
-							undefined,
-							"https://example.com/pr/1",
-							root,
-						),
-					),
-				),
-			),
-		).rejects.toThrow("Invalid GitHub pull request URL")
-	})
-
-	test("creates a clean single-phase PR and preserves the task body", async () => {
-		await createTask()
-		const taskPath = join(root, "tasks", "example", "TASK.md")
-		const body = "# Example\n\nKeep this exact body after creating the PR."
-		const original = await Bun.file(taskPath).text()
-		await Bun.write(
-			taskPath,
-			original.replace(
-				"# Example\n\n## Outcome\n\nDescribe the task outcome.\n\n## Plan\n\nDescribe the current approach.\n\n## Important Decisions\n\nRecord consequential decisions and their rationale.",
-				body,
-			),
-		)
-		const url = "https://github.com/example/agency/pull/42"
-		await writeFakeGh({ stdout: `${url}\n` })
-
-		expect(await createPullRequest()).toBe(url)
-		await expectRemoteBranch("task/example")
-		const ghCall = await readGhCall()
-		expect(ghCall).toEqual({
-			args: [
-				"pr",
-				"create",
-				"--fill",
-				"--repo",
-				remotePath.replace(/\.git$/, ""),
-				"--base",
-				"main",
-				"--head",
-				"task/example",
-			],
-			cwd: await realpath(join(root, "tasks", "example", "code", "agency")),
-		})
-		const updated = await Bun.file(taskPath).text()
-		expect(updated).toContain("pr:\n  provider: github")
-		expect(updated).toContain("url: https://github.com/example/agency/pull/42")
-		expect(updated.endsWith(`${body}\n`)).toBe(true)
-	})
-
-	test("passes --draft to gh", async () => {
-		await createTask()
-		await writeFakeGh({
-			stdout: "https://github.com/example/agency/pull/43\n",
-		})
-
-		await createPullRequest("example", undefined, true)
-
-		expect((await readGhCall()).args).toEqual([
-			"pr",
-			"create",
-			"--fill",
-			"--repo",
-			remotePath.replace(/\.git$/, ""),
-			"--base",
-			"main",
-			"--head",
-			"task/example",
-			"--draft",
-		])
-	})
-
-	test("passes task-aware GitHub title and labels with declared refs", async () => {
-		await createTask()
-		await writeFakeGh({
-			stdout: "https://github.com/example/agency/pull/45\n",
-		})
-
-		await createPullRequest("example", undefined, true, false, {
-			title: "Ship the workflow",
-			head: "task/example",
-			base: "main",
-			labels: ["ai-assisted", "platform"],
-		})
-
-		expect((await readGhCall()).args).toEqual([
-			"pr",
-			"create",
-			"--fill",
-			"--title",
-			"Ship the workflow",
-			"--repo",
-			remotePath.replace(/\.git$/, ""),
-			"--base",
-			"main",
-			"--head",
-			"task/example",
-			"--draft",
-			"--label",
-			"ai-assisted",
-			"--label",
-			"platform",
-		])
-	})
-
-	test("records an existing matching GitHub PR without creating another", async () => {
-		await createTask()
-		const existing = githubRecord(46)
-		await writeFakeGh({ listStdouts: [JSON.stringify([existing])] })
-
-		expect(await createPullRequest()).toBe(existing.url)
-		const calls = await readGhCalls()
-		expect(calls).toHaveLength(1)
-		expect(calls[0]!.args).toEqual([
-			"pr",
-			"list",
-			"--repo",
-			remotePath.replace(/\.git$/, ""),
-			"--head",
-			"task/example",
-			"--base",
-			"main",
-			"--state",
-			"all",
-			"--json",
-			"number,state,isDraft,headRefName,baseRefName,headRepository,url,mergedAt,mergeable",
-		])
-	})
-
-	test("recovers a matching GitHub PR after an ambiguous create failure", async () => {
-		await createTask()
-		const recovered = githubRecord(47)
-		await writeFakeGh({
-			stderr: "a pull request already exists",
-			exitCode: 1,
-			listStdouts: ["[]", JSON.stringify([recovered])],
-		})
-
-		expect(await createPullRequest()).toBe(recovered.url)
-		expect((await readGhCalls()).map((call) => call.args[1])).toEqual([
-			"list",
-			"create",
-			"list",
-		])
-		const task = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("example", root)),
-			),
-		)
-		expect("pr" in task.data && task.data.pr).toMatchObject({
-			url: recovered.url,
-			headBranch: "task/example",
-			baseBranch: "main",
-		})
-	})
-
-	test("recovers a matching GitHub PR after create output is lost", async () => {
-		await createTask()
-		const recovered = githubRecord(48)
-		await writeFakeGh({
-			stdout: "Pull request created successfully",
-			listStdouts: ["[]", JSON.stringify([recovered])],
-		})
-
-		expect(await createPullRequest()).toBe(recovered.url)
-		expect((await readGhCalls()).map((call) => call.args[1])).toEqual([
-			"list",
-			"create",
-			"list",
-		])
-	})
-
-	test("does not adopt a GitHub PR with mismatched refs", async () => {
-		await createTask()
-		await writeFakeGh({
-			stdout: "Pull request created successfully",
-			listStdouts: [
-				JSON.stringify([githubRecord(49, "task/other")]),
-				JSON.stringify([githubRecord(49, "task/other")]),
-			],
-		})
-
-		await expect(createPullRequest()).rejects.toThrow(
-			"GitHub CLI did not return a pull request URL",
-		)
-		const task = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("example", root)),
-			),
-		)
-		expect("pr" in task.data && task.data.pr).toBeNull()
-	})
-
-	test("rejects task-aware head and base values that contradict declarations", async () => {
-		await createTask()
-		await expect(
-			createPullRequest("example", undefined, false, false, {
-				head: "other",
-			}),
-		).rejects.toThrow("does not match declared branch")
-		await expect(
-			createPullRequest("example", undefined, false, false, {
-				base: "release",
-			}),
-		).rejects.toThrow("does not match declared base")
-	})
-
-	test("guards terminal targets before materializing unless forced", async () => {
-		await createTask()
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.setStatus("example", "dropped", root),
-				),
-			),
-		)
-
-		await expect(createPullRequest()).rejects.toThrow("Task status is dropped")
-		expect(
-			await Bun.file(join(root, "tasks/example/code/agency")).exists(),
-		).toBe(false)
-
-		const url = "https://github.com/example/agency/pull/49"
-		await writeFakeGh({ stdout: url })
-		expect(await createPullRequest("example", undefined, false, true)).toBe(url)
-	})
-
-	test("requires reopening non-PR completed work even when forced", async () => {
-		await createTask()
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.setStatus("example", "done", root, {
-						summary: "Investigation completed without changes.",
-					}),
-				),
-			),
-		)
-
-		await expect(
-			createPullRequest("example", undefined, false, true),
-		).rejects.toThrow("Reopen non-PR completed work")
-		expect(
-			await Bun.file(join(root, "tasks/example/code/agency")).exists(),
-		).toBe(false)
-	})
-
-	test("updates only PHASE.md for a phase PR", async () => {
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "multi",
-							ticketUrl: "https://example.com/task",
-							multiPhase: true,
-						},
-						root,
-					),
-				),
-			),
-		)
-		await runTestEffect(
-			PhaseService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							taskId: "multi",
-							id: "implementation",
-							repo: "agency",
-							branch: "task/multi-implementation",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const taskPath = join(root, "tasks", "multi", "TASK.md")
-		const phasePath = join(
-			root,
-			"tasks",
-			"multi",
-			"phases",
-			"implementation",
-			"PHASE.md",
-		)
-		const originalTask = await Bun.file(taskPath).text()
-		const url = "https://github.com/example/agency/pull/44"
-		await writeFakeGh({ stdout: url })
-
-		await createPullRequest("multi", "implementation")
-
-		expect(await Bun.file(taskPath).text()).toBe(originalTask)
-		expect(await Bun.file(phasePath).text()).toContain(`url: ${url}`)
-		await expectRemoteBranch("task/multi-implementation")
-	})
-
-	test("blocks a dirty checkout before push or gh", async () => {
-		await createTask()
-		const workspace = await materialize()
-		await Bun.write(join(workspace.writablePath!, "dirty.txt"), "dirty\n")
-		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/45" })
-
-		await expect(createPullRequest()).rejects.toThrow(
-			"Cannot create a PR with a dirty worktree",
-		)
-
-		await expectRemoteBranch("task/example", false)
-		expect(await Bun.file(ghCallPath).exists()).toBe(false)
-	})
-
-	test("blocks PR creation when workbase validation fails", async () => {
-		await createTask()
-		await materialize()
-		await mkdir(join(root, "tasks", "missing-document"), { recursive: true })
-		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/45" })
-
-		await expect(createPullRequest()).rejects.toThrow(
-			"Required document is missing",
-		)
-
-		await expectRemoteBranch("task/example", false)
-		expect(await Bun.file(ghCallPath).exists()).toBe(false)
-	})
-
-	test("reports push failure and does not invoke gh", async () => {
-		await createTask()
-		await materialize()
-		const hookPath = join(remotePath, "hooks", "pre-receive")
-		await Bun.write(hookPath, "#!/bin/sh\necho push rejected >&2\nexit 1\n")
-		await chmod(hookPath, 0o755)
-		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/46" })
-
-		await expect(createPullRequest()).rejects.toThrow("Failed to push branch")
-
-		await expectRemoteBranch("task/example", false)
-		expect(await Bun.file(ghCallPath).exists()).toBe(false)
-	})
-
-	test("reports gh failure without persisting a URL", async () => {
-		await createTask()
-		await writeFakeGh({ stderr: "authentication failed\n", exitCode: 1 })
-
-		await expect(createPullRequest()).rejects.toThrow(
-			"Failed to create pull request: authentication failed",
-		)
-
-		const task = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("example", root)),
-			),
-		)
-		expect("pr" in task.data && task.data.pr).toBeNull()
-	})
-
-	test("rejects successful gh output without a PR URL", async () => {
-		await createTask()
-		await writeFakeGh({ stdout: "Pull request created successfully\n" })
-
-		await expect(createPullRequest()).rejects.toThrow(
-			"GitHub CLI did not return a pull request URL",
-		)
-	})
-
-	test("extracts a PR URL from noisy gh output", async () => {
-		await createTask()
-		const url = "https://github.com/example/agency/pull/47"
-		await writeFakeGh({
-			stdout: `Creating pull request...\n${url}\nView it in your browser.\n`,
-		})
-
-		expect(await createPullRequest()).toBe(url)
-
-		const task = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("example", root)),
-			),
-		)
-		expect("pr" in task.data && task.data.pr).toMatchObject({ url })
-	})
-
-	test("uses a configured remote and argv provider", async () => {
-		await createTask()
-		await requireCommand(
-			["git", "remote", "rename", "origin", "upstream"],
-			join(root, "repos", "agency"),
-		)
-		const callPath = join(root, "delivery-call.json")
-		const providerRecord = {
-			provider: "forge",
-			repository: remotePath.replace(/\.git$/, ""),
-			identifier: "17",
-			url: "https://forge.example/example/agency/pulls/17",
-			state: "open",
-			draft: false,
-			merged: false,
-		} as const
-		await Bun.write(
-			join(root, "bin", "deliver"),
-			`#!/usr/bin/env bun
-await Bun.write(${JSON.stringify(callPath)}, JSON.stringify({ args: Bun.argv.slice(2), base: process.env.DELIVERY_BASE }))
-process.stdout.write(${JSON.stringify(JSON.stringify(providerRecord))})
-`,
-		)
-		await chmod(join(root, "bin", "deliver"), 0o755)
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({
-				version: 2,
-				delivery: {
-					provider: "forge",
-					remote: "upstream",
-					createCommand: ["deliver", "create", "{repository}", "{branch}"],
-					queryCommand: ["deliver", "query", "{identifier}"],
-					environment: { DELIVERY_BASE: "{base}" },
-				},
-			}),
-		)
-
-		expect(await createPullRequest()).toBe(providerRecord.url)
-		expect(await Bun.file(callPath).json()).toEqual({
-			args: ["create", remotePath.replace(/\.git$/, ""), "task/example"],
-			base: "main",
-		})
-		const task = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("example", root)),
-			),
-		)
-		expect("pr" in task.data && task.data.pr).toEqual(providerRecord)
-	})
-
-	test("does not persist malformed provider output", async () => {
-		await createTask()
-		await Bun.write(
-			join(root, "bin", "deliver"),
-			"#!/usr/bin/env bun\nprocess.stdout.write('{}')\n",
-		)
-		await chmod(join(root, "bin", "deliver"), 0o755)
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({
-				version: 2,
-				delivery: {
-					provider: "forge",
-					createCommand: ["deliver", "create"],
-					queryCommand: ["deliver", "query"],
-				},
-			}),
-		)
-
-		await expect(createPullRequest()).rejects.toThrow(
-			"Delivery provider did not return a valid pull request record",
-		)
-		const task = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("example", root)),
-			),
-		)
-		expect("pr" in task.data && task.data.pr).toBeNull()
-	})
-
-	test("reports invalid reused Git checkout before push or gh", async () => {
-		await createTask()
-		const workspace = await materialize()
-		await rm(join(workspace.writablePath!, ".git"))
-		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/48" })
-
-		await expect(createPullRequest()).rejects.toThrow(
-			"Failed to locate local excludes",
-		)
-
-		await expectRemoteBranch("task/example", false)
-		expect(await Bun.file(ghCallPath).exists()).toBe(false)
-	})
-})