From 965ece306f0593d6aa637f30497a1d353f5ca22d Mon Sep 17 00:00:00 2001 From: alexion Date: Mon, 13 Jul 2026 19:55:00 -0400 Subject: [PATCH] feat: add pr edit, close, and reopen (task 0011) Add the PR-side state mutations mirroring the issue-side slice: - `pr edit` applies title/body/base/milestone and the recomputed assignee list in one PATCH, with additive label endpoints and (per the ADR 0007 amendment) the dedicated requested-reviewers POST/DELETE endpoints for `--add-reviewer`/`--remove-reviewer`. - `pr close --comment` posts the comment after the PATCH and surfaces a comment-post failure; an already-closed or merged PR is an `already: true` no-op reporting the actual state. - `pr reopen` is an `already: true` no-op when already open. Extract the fetch-then-patch assignee merge into a shared `src/assignees.ts` (`mergeAssignees` + `assigneeLogins`), now used by both `issue edit` and `pr edit`. --- .claude/tasks/0011-pr-edit-close-reopen.md | 57 +++- src/assignees.ts | 44 +++ src/commands/issue.ts | 28 +- src/commands/pr.ts | 317 +++++++++++++++++++++ test/pr-close.test.ts | 107 +++++++ test/pr-edit.test.ts | 227 +++++++++++++++ test/pr-reopen.test.ts | 57 ++++ 7 files changed, 808 insertions(+), 29 deletions(-) create mode 100644 src/assignees.ts create mode 100644 test/pr-close.test.ts create mode 100644 test/pr-edit.test.ts create mode 100644 test/pr-reopen.test.ts diff --git a/.claude/tasks/0011-pr-edit-close-reopen.md b/.claude/tasks/0011-pr-edit-close-reopen.md index f34eec1..ce51434 100644 --- a/.claude/tasks/0011-pr-edit-close-reopen.md +++ b/.claude/tasks/0011-pr-edit-close-reopen.md @@ -14,9 +14,54 @@ Success outputs follow the action-block pattern: `edited:`/`closed:`/`reopened:` ## Acceptance criteria -- [ ] `pr edit` applies title, body, milestone, and base changes and outputs `edited: { number, status: "ok" }` -- [ ] Label and assignee mutations follow the same rules as `issue edit` (additive endpoints, fetch-then-patch, unapplied-label silent success) -- [ ] `--add-reviewer`/`--remove-reviewer` call the requested-reviewers endpoints with `{ reviewers: [login] }` -- [ ] `pr close --comment` posts the comment after the PATCH and surfaces a comment failure; closing an already-closed-or-merged PR returns the entity block with `already: true` -- [ ] `pr reopen` on an open PR returns the entity block with `already: true`; otherwise outputs `reopened: { number, status: "ok" }` -- [ ] Fixture-server tests cover reviewer add/remove, the merged-PR close no-op, and the reopen paths +- [x] `pr edit` applies title, body, milestone, and base changes and outputs `edited: { number, status: "ok" }` +- [x] Label and assignee mutations follow the same rules as `issue edit` (additive endpoints, fetch-then-patch, unapplied-label silent success) +- [x] `--add-reviewer`/`--remove-reviewer` call the requested-reviewers endpoints with `{ reviewers: [login] }` +- [x] `pr close --comment` posts the comment after the PATCH and surfaces a comment failure; closing an already-closed-or-merged PR returns the entity block with `already: true` +- [x] `pr reopen` on an open PR returns the entity block with `already: true`; otherwise outputs `reopened: { number, status: "ok" }` +- [x] Fixture-server tests cover reviewer add/remove, the merged-PR close no-op, and the reopen paths + +## Implementation Notes + +No criteria were dropped or altered; all six are satisfied. + +Decisions made mid-implementation: + +- The close no-op reports the actual state: `merged` for a merged PR (whose raw + `state` Gitea reports as `closed`), otherwise the raw state — computed by a + small `pullState` helper. `pull.state === "closed"` catches both the closed and + merged cases for the short-circuit, matching the spec's "already closed or + merged". +- `pr reopen` short-circuits only on `state === "open"`, per the spec. A merged + PR (state `closed`) therefore falls through to the PATCH and Gitea rejects it as + a `VALIDATION_ERROR` — the spec asks for no merged-guard on reopen, mirroring the + issue side. +- Reviewer mutations are one POST for all `--add-reviewer` and one DELETE for all + `--remove-reviewer`, each carrying the whole list — the requested-reviewers + endpoints take arrays (ADR 0007 amendment). They are not fetch-then-patch and + are not idempotency-checked; a redundant add/remove surfaces whatever Gitea + answers. +- `--add-label`/`--remove-label`/`--add-assignee`/`--remove-assignee`/`--add-reviewer`/`--remove-reviewer` + are repeatable, matching `issue edit`. +- Name resolution (milestone, remove-label ids) runs before any mutation so a typo + is reported before a change lands. Title/body/base/milestone and the recomputed + assignee list travel in a single PATCH; labels and reviewers use their dedicated + endpoints afterward. +- Added a `VALIDATION_ERROR` when `pr edit` is invoked with no changes, matching + `issue edit`. +- Review finding (Duplicated Code): extracted the fetch-then-patch merge into a + shared `src/assignees.ts` — a pure `mergeAssignees` plus an `assigneeLogins` + reader — now used by both `issue edit` and `pr edit`, replacing the inline copy + that previously lived in `issue.ts`. + +Follow-ups worth flagging (unaddressed review findings, both judgement calls): + +- The close/reopen state-machine (read state → no-op short-circuit → PATCH `{state}` + → render) is still duplicated between `issue.ts` and `pr.ts`. A shared helper was + left unextracted because the two sides diverge in their no-op shape, help + suggestions, and the PR-only merged handling, which would make the abstraction + leaky. +- The no-op output shape differs between the issue side (`message: "Already + closed"`) and the PR side (`already: true` + `state`). This is spec-driven — the + spec fixes `already: true` for PRs — but the CLI's no-op output is not uniform + across the two entities. diff --git a/src/assignees.ts b/src/assignees.ts new file mode 100644 index 0000000..6b3d858 --- /dev/null +++ b/src/assignees.ts @@ -0,0 +1,44 @@ +/** The subset of a Gitea `User` this module reads: just the login, if present. */ +interface AssigneeLike { + login?: string; +} + +/** + * The logins of an entity's current assignees, dropping any without one. The + * shared read side of fetch-then-patch: `issue edit` and `pr edit` both take the + * `assignees` off a freshly fetched entity and feed the result to + * {@link mergeAssignees}. + */ +export function assigneeLogins(assignees: AssigneeLike[] | undefined): string[] { + return (assignees ?? []).flatMap((assignee) => (assignee.login ? [assignee.login] : [])); +} + +/** + * The full assignee login list to PATCH under fetch-then-patch semantics + * (ADR 0007): the entity's current assignees with the requested additions + * appended and removals dropped. Matching is case-insensitive and the result is + * de-duplicated, order-preserving, so a login already assigned never lands in the + * list twice. Shared by `issue edit` and `pr edit`, whose PATCH bodies both + * replace the whole assignee list rather than adding or removing individual + * entries. + */ +export function mergeAssignees(current: string[], add: string[], remove: string[]): string[] { + const removeSet = new Set(remove.map((login) => login.toLowerCase())); + const seen = new Set(); + const result: string[] = []; + const push = (login: string): void => { + const key = login.toLowerCase(); + if (removeSet.has(key) || seen.has(key)) { + return; + } + seen.add(key); + result.push(login); + }; + for (const login of current) { + push(login); + } + for (const login of add) { + push(login); + } + return result; +} diff --git a/src/commands/issue.ts b/src/commands/issue.ts index 6997d82..2774fab 100644 --- a/src/commands/issue.ts +++ b/src/commands/issue.ts @@ -1,4 +1,5 @@ import type { Comment, CreateIssueOption, EditIssueOption, Issue, IssueMeta } from "gitea-js"; +import { assigneeLogins, mergeAssignees } from "../assignees.js"; import { BODY_TRUNCATE_LIMIT, truncateBody } from "../body.js"; import { requireBodySource, resolveBodySource } from "../body-source.js"; import { createClient, type GiteaClient } from "../client.js"; @@ -702,9 +703,9 @@ async function issueComment(deps: CliDeps, args: string[]): Promise { /** * The assignee list to PATCH: the issue's current assignees with the requested - * additions appended and removals dropped (fetch-then-patch, ADR 0007). Matching - * is case-insensitive and the result is de-duplicated, order-preserving, so a - * login that is already assigned never lands in the list twice. + * additions applied and removals dropped (fetch-then-patch, ADR 0007). The + * current logins are read off a fresh GET, then merged by the shared + * {@link mergeAssignees}. */ async function resolveAssignees( api: GiteaClient, @@ -714,26 +715,7 @@ async function resolveAssignees( remove: string[], ): Promise { const issue = await getIssue(api, context, number); - const removeSet = new Set(remove.map((login) => login.toLowerCase())); - const seen = new Set(); - const result: string[] = []; - const push = (login: string): void => { - const key = login.toLowerCase(); - if (removeSet.has(key) || seen.has(key)) { - return; - } - seen.add(key); - result.push(login); - }; - for (const assignee of issue.assignees ?? []) { - if (assignee.login) { - push(assignee.login); - } - } - for (const login of add) { - push(login); - } - return result; + return mergeAssignees(assigneeLogins(issue.assignees), add, remove); } async function issueEdit(deps: CliDeps, args: string[]): Promise { diff --git a/src/commands/pr.ts b/src/commands/pr.ts index 8a8a359..7274e6e 100644 --- a/src/commands/pr.ts +++ b/src/commands/pr.ts @@ -1,11 +1,14 @@ import type { Comment, CreatePullRequestOption, + EditPullRequestOption, PullRequest, PullReview, PullReviewComment, + PullReviewRequestOptions, Repository, } from "gitea-js"; +import { assigneeLogins, mergeAssignees } from "../assignees.js"; import { BODY_TRUNCATE_LIMIT, COMMENT_TRUNCATE_LIMIT, truncateBody } from "../body.js"; import { requireBodySource, resolveBodySource } from "../body-source.js"; import { createClient, type GiteaClient } from "../client.js"; @@ -47,11 +50,64 @@ commands: view Show a single pull request's details checks Show a pull request's CI check results create Create a pull request + edit Edit a pull request's title, body, labels, assignees, reviewers, milestone, or base + close Close a pull request + reopen Reopen a closed pull request comment Post a comment on a pull request Run \`gitea-axi pr --help\` for the flags of a command. `; +export const PR_EDIT_HELP = `usage: gitea-axi pr edit [flags] + +Edit a pull request in the current repository. At least one change is required. + +flags: + --title New title + --body New body + --body-file Read the new body from a file (mutually exclusive with --body) + --base Change the base branch to merge into + --add-label Add a label by name (repeatable) + --remove-label Remove a label by name (repeatable, case-insensitive) + --add-assignee Add an assignee (repeatable) + --remove-assignee Remove an assignee (repeatable) + --add-reviewer Request a review from a user (repeatable) + --remove-reviewer Cancel a requested review (repeatable) + --milestone Assign a milestone by name (case-insensitive) + --help Show this help + +global flags: + -R, --repo Override the repository detected from the git origin remote + --login Select a tea login profile by name +`; + +export const PR_CLOSE_HELP = `usage: gitea-axi pr close [flags] + +Close a pull request in the current repository. Closing an already-closed or +merged pull request is a no-op. + +flags: + --comment Post a comment when closing + --help Show this help + +global flags: + -R, --repo Override the repository detected from the git origin remote + --login Select a tea login profile by name +`; + +export const PR_REOPEN_HELP = `usage: gitea-axi pr reopen + +Reopen a closed pull request in the current repository. Reopening an +already-open pull request is a no-op. + +flags: + --help Show this help + +global flags: + -R, --repo Override the repository detected from the git origin remote + --login Select a tea login profile by name +`; + export const PR_VIEW_HELP = `usage: gitea-axi pr view [flags] Show a single pull request, including its CI checks and review summary. @@ -905,6 +961,258 @@ async function prComment(deps: CliDeps, args: string[]): Promise { }); } +/** + * The assignee list to PATCH: the pull request's current assignees with the + * requested additions applied and removals dropped (fetch-then-patch, ADR 0007). + * The current logins are read off a fresh GET, then merged by the shared + * {@link mergeAssignees}. + */ +async function resolvePullAssignees( + api: GiteaClient, + context: RepoContext, + number: number, + add: string[], + remove: string[], +): Promise { + const pull = await getPull(api, context, number); + return mergeAssignees(assigneeLogins(pull.assignees), add, remove); +} + +/** + * The state to report for a pull request in the close no-op: `merged` marks a + * merged pull request (whose `state` Gitea reports as `closed`), otherwise the + * raw state stands. + */ +function pullState(pull: PullRequest): string { + return pull.merged ? "merged" : (pull.state ?? "closed"); +} + +async function prEdit(deps: CliDeps, args: string[]): Promise { + if (args.includes("--help")) { + return PR_EDIT_HELP; + } + const { flags, lists, positionals } = parseFlags( + args, + { + "--title": { takesValue: true }, + "--body": { takesValue: true }, + "--body-file": { takesValue: true }, + "--base": { takesValue: true }, + "--add-label": { takesValue: true, repeatable: true }, + "--remove-label": { takesValue: true, repeatable: true }, + "--add-assignee": { takesValue: true, repeatable: true }, + "--remove-assignee": { takesValue: true, repeatable: true }, + "--add-reviewer": { takesValue: true, repeatable: true }, + "--remove-reviewer": { takesValue: true, repeatable: true }, + "--milestone": { takesValue: true }, + }, + "pr edit", + ); + const number = parsePositionalNumber(positionals, "pr edit", "pull request"); + const title = flagValue(flags, "--title"); + const body = resolveBodySource(deps, flags, "pr edit"); + const base = flagValue(flags, "--base"); + const milestoneName = flagValue(flags, "--milestone"); + const addLabels = lists["--add-label"] ?? []; + const removeLabels = lists["--remove-label"] ?? []; + const addAssignees = lists["--add-assignee"] ?? []; + const removeAssignees = lists["--remove-assignee"] ?? []; + const addReviewers = lists["--add-reviewer"] ?? []; + const removeReviewers = lists["--remove-reviewer"] ?? []; + + const changesAssignees = addAssignees.length > 0 || removeAssignees.length > 0; + const nothingToDo = + title === undefined && + body === undefined && + base === undefined && + milestoneName === undefined && + addLabels.length === 0 && + removeLabels.length === 0 && + !changesAssignees && + addReviewers.length === 0 && + removeReviewers.length === 0; + if (nothingToDo) { + throw axiError("pr edit requires at least one change", "VALIDATION_ERROR", [ + "Run `gitea-axi pr edit --help` to see the fields you can change", + ]); + } + + const context = await resolveRepoContext(deps); + const api = createClient(context); + + // Name resolution runs before any mutation: whether a milestone or label name + // is real does not depend on the pull request's state, so a typo is reported + // before a single change lands, never leaving the pull request half-edited. + const milestoneId = + milestoneName !== undefined ? await resolveMilestoneId(api, context, milestoneName) : undefined; + const removeLabelIds = await resolveLabelIds(api, context, removeLabels); + + // Title, body, base, milestone, and the recomputed assignee list travel in one + // PATCH — the reviewers are the exception, having no field on this body. + const payload: EditPullRequestOption = {}; + if (title !== undefined) { + payload.title = title; + } + if (body !== undefined) { + payload.body = body; + } + if (base !== undefined) { + payload.base = base; + } + if (milestoneId !== undefined) { + payload.milestone = milestoneId; + } + if (changesAssignees) { + payload.assignees = await resolvePullAssignees( + api, + context, + number, + addAssignees, + removeAssignees, + ); + } + if (Object.keys(payload).length > 0) { + try { + await api.repos.repoEditPullRequest(context.owner, context.name, number, payload); + } catch (error) { + throw classifyHttpError(error); + } + } + + // Label mutations use Gitea's dedicated endpoints (idempotent). `--add-label` + // passes names straight through — Gitea accepts them there, no lookup needed — + // while `--remove-label` resolved to ids above (mirrors `issue edit`). + if (addLabels.length > 0) { + try { + await api.repos.issueAddLabel(context.owner, context.name, number, { labels: addLabels }); + } catch (error) { + throw classifyHttpError(error); + } + } + for (const id of removeLabelIds) { + try { + await api.repos.issueRemoveLabel(context.owner, context.name, number, id); + } catch (error) { + // The label exists in the repo but is not applied to this pull request: + // Gitea answers 404, and the caller's intent (label absent) already holds, + // so it is silent success rather than an error. + if (httpStatus(error) === 404) { + continue; + } + throw classifyHttpError(error); + } + } + + // Reviewer mutations go through Gitea's dedicated requested-reviewers endpoints + // — `EditPullRequestOption` has no reviewers field, so fetch-then-patch is + // structurally impossible here (ADR 0007 amendment). Each direction is one call + // carrying the whole list. + if (addReviewers.length > 0) { + const options: PullReviewRequestOptions = { reviewers: addReviewers }; + try { + await api.repos.repoCreatePullReviewRequests(context.owner, context.name, number, options); + } catch (error) { + throw classifyHttpError(error); + } + } + if (removeReviewers.length > 0) { + const options: PullReviewRequestOptions = { reviewers: removeReviewers }; + try { + await api.repos.repoDeletePullReviewRequests(context.owner, context.name, number, options); + } catch (error) { + throw classifyHttpError(error); + } + } + + // The mutation ran, so the block is named for the action, not the entity. + return renderDetail({ + noun: "edited", + item: { number, status: "ok" }, + help: [suggestCommand(context, `pr view ${number}`, "to see the pull request in full")], + }); +} + +async function prClose(deps: CliDeps, args: string[]): Promise { + if (args.includes("--help")) { + return PR_CLOSE_HELP; + } + const { flags, positionals } = parseFlags(args, { "--comment": { takesValue: true } }, "pr close"); + const number = parsePositionalNumber(positionals, "pr close", "pull request"); + const comment = flagValue(flags, "--comment"); + + const context = await resolveRepoContext(deps); + const api = createClient(context); + + // Read the current state first: an already-closed or merged pull request + // short-circuits to the idempotent no-op below rather than issuing a redundant + // PATCH. A merged pull request has state `closed`, so this catches both. + const pull = await getPull(api, context, number); + if (pull.state === "closed") { + return renderDetail({ + noun: "pull_request", + item: { number, state: pullState(pull), already: true }, + help: [suggestCommand(context, `pr reopen ${number}`, "to reopen this pull request")], + }); + } + + try { + await api.repos.repoEditPullRequest(context.owner, context.name, number, { state: "closed" }); + } catch (error) { + throw classifyHttpError(error); + } + + // The comment is a second call after the close lands. A failure here is + // surfaced, never swallowed: the pull request is closed, but the caller must + // learn that the comment they asked for did not post. + if (comment !== undefined) { + try { + await api.repos.issueCreateComment(context.owner, context.name, number, { body: comment }); + } catch (error) { + throw classifyHttpError(error); + } + } + + return renderDetail({ + noun: "closed", + item: { number, status: "ok" }, + help: [suggestCommand(context, `pr reopen ${number}`, "to reopen this pull request")], + }); +} + +async function prReopen(deps: CliDeps, args: string[]): Promise { + if (args.includes("--help")) { + return PR_REOPEN_HELP; + } + const { positionals } = parseFlags(args, {}, "pr reopen"); + const number = parsePositionalNumber(positionals, "pr reopen", "pull request"); + + const context = await resolveRepoContext(deps); + const api = createClient(context); + + // Read the current state first: an already-open pull request short-circuits to + // the idempotent no-op below rather than issuing a redundant PATCH. + const pull = await getPull(api, context, number); + if (pull.state === "open") { + return renderDetail({ + noun: "pull_request", + item: { number, state: "open", already: true }, + help: [suggestCommand(context, `pr close ${number}`, "to close this pull request")], + }); + } + + try { + await api.repos.repoEditPullRequest(context.owner, context.name, number, { state: "open" }); + } catch (error) { + throw classifyHttpError(error); + } + + return renderDetail({ + noun: "reopened", + item: { number, status: "ok" }, + help: [suggestCommand(context, `pr view ${number}`, "to see the pull request in full")], + }); +} + export function prCommand(deps: CliDeps) { return async (args: string[]): Promise => { const [subcommand, ...rest] = args; @@ -923,6 +1231,15 @@ export function prCommand(deps: CliDeps) { if (subcommand === "create") { return prCreate(deps, rest); } + if (subcommand === "edit") { + return prEdit(deps, rest); + } + if (subcommand === "close") { + return prClose(deps, rest); + } + if (subcommand === "reopen") { + return prReopen(deps, rest); + } if (subcommand === "comment") { return prComment(deps, rest); } diff --git a/test/pr-close.test.ts b/test/pr-close.test.ts new file mode 100644 index 0000000..5c15ab7 --- /dev/null +++ b/test/pr-close.test.ts @@ -0,0 +1,107 @@ +import { afterEach, describe, expect, it } from "vitest"; +import { startFixtureServer, type FixtureServer } from "./fixture-server.js"; +import { runCliTest, testModeEnv } from "./harness.js"; + +const REPO_PATH = "/api/v1/repos/testowner/testrepo"; +const PR_PATH = `${REPO_PATH}/pulls/9`; +const COMMENTS_PATH = `${REPO_PATH}/issues/9/comments`; + +let server: FixtureServer; + +afterEach(async () => { + await server.close(); +}); + +describe("pr close", () => { + it("closes an open pull request and reports the action", async () => { + server = await startFixtureServer([ + { method: "GET", path: PR_PATH, body: { number: 9, state: "open" } }, + { method: "PATCH", path: PR_PATH, body: { number: 9, state: "closed" } }, + ]); + const { stdout, exitCode } = await runCliTest(["pr", "close", "9"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("closed:"); + expect(stdout).toContain("number: 9"); + expect(stdout).toContain("status: ok"); + const patch = server.requests.find((request) => request.method === "PATCH"); + expect(patch?.body).toEqual({ state: "closed" }); + }); + + it("posts a --comment after the close and reports success", async () => { + server = await startFixtureServer([ + { method: "GET", path: PR_PATH, body: { number: 9, state: "open" } }, + { method: "PATCH", path: PR_PATH, body: { number: 9, state: "closed" } }, + { method: "POST", path: COMMENTS_PATH, status: 201, body: { id: 1 } }, + ]); + const { exitCode } = await runCliTest(["pr", "close", "9", "--comment", "Superseded."], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + const post = server.requests.find((request) => request.method === "POST"); + expect(post?.body).toEqual({ body: "Superseded." }); + // The close lands before the comment. + const patchIndex = server.requests.findIndex((request) => request.method === "PATCH"); + const postIndex = server.requests.findIndex((request) => request.method === "POST"); + expect(patchIndex).toBeLessThan(postIndex); + }); + + it("surfaces a comment-post failure even though the pull request was closed", async () => { + server = await startFixtureServer([ + { method: "GET", path: PR_PATH, body: { number: 9, state: "open" } }, + { method: "PATCH", path: PR_PATH, body: { number: 9, state: "closed" } }, + { method: "POST", path: COMMENTS_PATH, status: 403, body: { message: "forbidden" } }, + ]); + const { stdout, exitCode } = await runCliTest(["pr", "close", "9", "--comment", "note"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(1); + expect(stdout).toContain("code: FORBIDDEN"); + // The close still happened. + expect(server.requests.some((request) => request.method === "PATCH")).toBe(true); + }); + + it("returns early with already: true on an already-closed pull request", async () => { + server = await startFixtureServer([ + { method: "GET", path: PR_PATH, body: { number: 9, state: "closed" } }, + ]); + const { stdout, exitCode } = await runCliTest(["pr", "close", "9"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("pull_request:"); + expect(stdout).toContain("state: closed"); + expect(stdout).toContain("already: true"); + expect(server.requests.some((request) => request.method === "PATCH")).toBe(false); + }); + + it("reports a merged pull request as state: merged without patching", async () => { + server = await startFixtureServer([ + { method: "GET", path: PR_PATH, body: { number: 9, state: "closed", merged: true } }, + ]); + const { stdout, exitCode } = await runCliTest(["pr", "close", "9"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("state: merged"); + expect(stdout).toContain("already: true"); + expect(server.requests.some((request) => request.method === "PATCH")).toBe(false); + }); + + it("prints help with --help without calling the API", async () => { + server = await startFixtureServer([]); + const { stdout, exitCode } = await runCliTest(["pr", "close", "--help"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("usage: gitea-axi pr close"); + expect(server.requests).toHaveLength(0); + }); +}); diff --git a/test/pr-edit.test.ts b/test/pr-edit.test.ts new file mode 100644 index 0000000..03d9d06 --- /dev/null +++ b/test/pr-edit.test.ts @@ -0,0 +1,227 @@ +import { afterEach, describe, expect, it } from "vitest"; +import { startFixtureServer, type FixtureServer } from "./fixture-server.js"; +import { runCliTest, tempFiles, testModeEnv } from "./harness.js"; + +const REPO_PATH = "/api/v1/repos/testowner/testrepo"; +const PR_PATH = `${REPO_PATH}/pulls/9`; +const LABELS_ENDPOINT = `${REPO_PATH}/issues/9/labels`; +const REPO_LABELS = `${REPO_PATH}/labels`; +const MILESTONES_PATH = `${REPO_PATH}/milestones`; +const REVIEWERS_PATH = `${PR_PATH}/requested_reviewers`; + +let server: FixtureServer; +const files = tempFiles(); + +afterEach(async () => { + await server.close(); + files.cleanup(); +}); + +/** The parsed body of the single PATCH the CLI sent to the pull request. */ +function patchedPull(): Record { + const patch = server.requests.find( + (request) => request.method === "PATCH" && request.path === PR_PATH, + ); + expect(patch, "expected a PATCH to the pull request").toBeDefined(); + return patch!.body as Record; +} + +function pull(fields: Record = {}): Record { + return { number: 9, state: "open", assignees: [], ...fields }; +} + +describe("pr edit", () => { + it("applies title, body, base, and milestone in one PATCH and reports the action", async () => { + server = await startFixtureServer([ + { + method: "GET", + path: MILESTONES_PATH, + query: { name: "v2.0" }, + body: [{ id: 8, title: "v2.0" }], + }, + { method: "PATCH", path: PR_PATH, body: pull() }, + ]); + const { stdout, exitCode } = await runCliTest( + [ + "pr", + "edit", + "9", + "--title", + "New title", + "--body", + "New body", + "--base", + "develop", + "--milestone", + "v2.0", + ], + { env: testModeEnv(server.url) }, + ); + + expect(exitCode).toBe(0); + expect(stdout).toContain("edited:"); + expect(stdout).toContain("number: 9"); + expect(stdout).toContain("status: ok"); + expect(patchedPull()).toEqual({ + title: "New title", + body: "New body", + base: "develop", + milestone: 8, + }); + }); + + it("reads the new body from --body-file", async () => { + const path = files.write("body.md", "Body from a file.\n"); + server = await startFixtureServer([{ method: "PATCH", path: PR_PATH, body: pull() }]); + const { exitCode } = await runCliTest(["pr", "edit", "9", "--body-file", path], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(patchedPull()).toEqual({ body: "Body from a file.\n" }); + }); + + it("posts --add-label names directly to the additive label endpoint", async () => { + server = await startFixtureServer([{ method: "POST", path: LABELS_ENDPOINT, body: [] }]); + const { exitCode } = await runCliTest( + ["pr", "edit", "9", "--add-label", "bug", "--add-label", "chore"], + { env: testModeEnv(server.url) }, + ); + + expect(exitCode).toBe(0); + const post = server.requests.find( + (request) => request.method === "POST" && request.path === LABELS_ENDPOINT, + ); + expect(post?.body).toEqual({ labels: ["bug", "chore"] }); + // No label lookup happens for additions — names go straight through. + expect(server.requests.some((request) => request.path === REPO_LABELS)).toBe(false); + }); + + it("resolves --remove-label to an id before deleting it", async () => { + server = await startFixtureServer([ + { method: "GET", path: REPO_LABELS, body: [{ id: 22, name: "Priority: High" }] }, + { method: "DELETE", path: `${LABELS_ENDPOINT}/22`, body: {} }, + ]); + const { exitCode } = await runCliTest(["pr", "edit", "9", "--remove-label", "priority: high"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect( + server.requests.some( + (request) => request.method === "DELETE" && request.path === `${LABELS_ENDPOINT}/22`, + ), + ).toBe(true); + }); + + it("treats a 404 removing an unapplied label as silent success", async () => { + server = await startFixtureServer([ + { method: "GET", path: REPO_LABELS, body: [{ id: 22, name: "wontfix" }] }, + { method: "DELETE", path: `${LABELS_ENDPOINT}/22`, status: 404, body: { message: "not found" } }, + ]); + const { stdout, exitCode } = await runCliTest(["pr", "edit", "9", "--remove-label", "wontfix"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("edited:"); + expect(stdout).toContain("status: ok"); + }); + + it("adds and removes assignees via fetch-then-patch, sending the full resulting list", async () => { + server = await startFixtureServer([ + { + method: "GET", + path: PR_PATH, + body: pull({ assignees: [{ login: "alice" }, { login: "bob" }] }), + }, + { method: "PATCH", path: PR_PATH, body: pull() }, + ]); + const { exitCode } = await runCliTest( + ["pr", "edit", "9", "--add-assignee", "carol", "--remove-assignee", "alice"], + { env: testModeEnv(server.url) }, + ); + + expect(exitCode).toBe(0); + expect(patchedPull()).toEqual({ assignees: ["bob", "carol"] }); + // Exactly one PATCH carries the whole recomputed list. + expect(server.requests.filter((request) => request.method === "PATCH")).toHaveLength(1); + }); + + it("requests a review via the requested-reviewers POST endpoint", async () => { + server = await startFixtureServer([{ method: "POST", path: REVIEWERS_PATH, body: [] }]); + const { exitCode } = await runCliTest(["pr", "edit", "9", "--add-reviewer", "dana"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + const post = server.requests.find( + (request) => request.method === "POST" && request.path === REVIEWERS_PATH, + ); + expect(post?.body).toEqual({ reviewers: ["dana"] }); + // No PATCH: reviewers do not travel on the edit body. + expect(server.requests.some((request) => request.method === "PATCH")).toBe(false); + }); + + it("cancels a requested review via the requested-reviewers DELETE endpoint", async () => { + server = await startFixtureServer([{ method: "DELETE", path: REVIEWERS_PATH, body: {} }]); + const { exitCode } = await runCliTest(["pr", "edit", "9", "--remove-reviewer", "dana"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + const del = server.requests.find( + (request) => request.method === "DELETE" && request.path === REVIEWERS_PATH, + ); + expect(del?.body).toEqual({ reviewers: ["dana"] }); + }); + + it("adds and removes reviewers in one POST and one DELETE", async () => { + server = await startFixtureServer([ + { method: "POST", path: REVIEWERS_PATH, body: [] }, + { method: "DELETE", path: REVIEWERS_PATH, body: {} }, + ]); + const { exitCode } = await runCliTest( + [ + "pr", + "edit", + "9", + "--add-reviewer", + "dana", + "--add-reviewer", + "erin", + "--remove-reviewer", + "frank", + ], + { env: testModeEnv(server.url) }, + ); + + expect(exitCode).toBe(0); + const post = server.requests.find((request) => request.method === "POST"); + const del = server.requests.find((request) => request.method === "DELETE"); + expect(post?.body).toEqual({ reviewers: ["dana", "erin"] }); + expect(del?.body).toEqual({ reviewers: ["frank"] }); + }); + + it("rejects an edit with no changes before calling the API", async () => { + server = await startFixtureServer([]); + const { stdout, exitCode } = await runCliTest(["pr", "edit", "9"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(2); + expect(stdout).toContain("code: VALIDATION_ERROR"); + expect(server.requests).toHaveLength(0); + }); + + it("prints help with --help without calling the API", async () => { + server = await startFixtureServer([]); + const { stdout, exitCode } = await runCliTest(["pr", "edit", "--help"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("usage: gitea-axi pr edit"); + expect(server.requests).toHaveLength(0); + }); +}); diff --git a/test/pr-reopen.test.ts b/test/pr-reopen.test.ts new file mode 100644 index 0000000..b37fa31 --- /dev/null +++ b/test/pr-reopen.test.ts @@ -0,0 +1,57 @@ +import { afterEach, describe, expect, it } from "vitest"; +import { startFixtureServer, type FixtureServer } from "./fixture-server.js"; +import { runCliTest, testModeEnv } from "./harness.js"; + +const REPO_PATH = "/api/v1/repos/testowner/testrepo"; +const PR_PATH = `${REPO_PATH}/pulls/9`; + +let server: FixtureServer; + +afterEach(async () => { + await server.close(); +}); + +describe("pr reopen", () => { + it("reopens a closed pull request and reports the action", async () => { + server = await startFixtureServer([ + { method: "GET", path: PR_PATH, body: { number: 9, state: "closed" } }, + { method: "PATCH", path: PR_PATH, body: { number: 9, state: "open" } }, + ]); + const { stdout, exitCode } = await runCliTest(["pr", "reopen", "9"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("reopened:"); + expect(stdout).toContain("number: 9"); + expect(stdout).toContain("status: ok"); + const patch = server.requests.find((request) => request.method === "PATCH"); + expect(patch?.body).toEqual({ state: "open" }); + }); + + it("returns early with already: true on an already-open pull request", async () => { + server = await startFixtureServer([ + { method: "GET", path: PR_PATH, body: { number: 9, state: "open" } }, + ]); + const { stdout, exitCode } = await runCliTest(["pr", "reopen", "9"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("pull_request:"); + expect(stdout).toContain("state: open"); + expect(stdout).toContain("already: true"); + expect(server.requests.some((request) => request.method === "PATCH")).toBe(false); + }); + + it("prints help with --help without calling the API", async () => { + server = await startFixtureServer([]); + const { stdout, exitCode } = await runCliTest(["pr", "reopen", "--help"], { + env: testModeEnv(server.url), + }); + + expect(exitCode).toBe(0); + expect(stdout).toContain("usage: gitea-axi pr reopen"); + expect(server.requests).toHaveLength(0); + }); +}); -- 2.47.3