diff --git a/README.md b/README.md index d13a217..a97e395 100644 --- a/README.md +++ b/README.md @@ -7,13 +7,15 @@ small set of /vouch commands from maintainers to manage the allowlist. ## How it works Each run sweeps the repository: it fetches the allowlist and blocklist, -enumerates all open pull requests through the API, and comments on and closes -every one whose author is neither on the list nor has write (or admin, or +enumerates open pull requests opened within the last 24 hours, and comments +on and closes every one whose author is neither on the list nor has write (or admin, or maintain) access to the repository. Write access is checked with the [collaborator permission API](https://docs.github.com/en/rest/collaborators/collaborators#get-repository-permissions-for-a-user), which reflects grants from teams and organization base permissions, so -maintainers never need to be listed. +maintainers never need to be listed. Pull requests older than 24 hours are +never closed, so enabling the action (or revoking/blocking someone) does not +close long-standing PRs. An optional blocklist, in the same repository as the allowlist, names accounts that are unwelcome to contribute. Their PRs are closed with a @@ -40,8 +42,8 @@ commenting on a pull request: | Comment | Effect | |-----------------------------------------|--------| | `/vouch allow` or just `/vouch` | Add the PR author to the allowlist, and reopen the PR if it was closed before the comment. | -| `/vouch revoke` | Remove the PR author from the allowlist. The next sweep closes their open PRs. | -| `/vouch block` | Add the PR author to the blocklist (requires `blocklist-path`). The next sweep closes their open PRs with `blocked-message`. | +| `/vouch revoke` | Remove the PR author from the allowlist. The next sweep closes their open PRs opened in the last 24 hours. | +| `/vouch block` | Add the PR author to the blocklist (requires `blocklist-path`). The next sweep closes their open PRs opened in the last 24 hours with `blocked-message`. | Revoking means the author needs a new vouch; blocking is a stronger judgment that the account is unwelcome. There is no command to unblock: maintainers @@ -97,12 +99,33 @@ into `.github/workflows/`. | `allowlist-path` | yes | Path to the allowlist within `permissions-repo`. | | `blocklist-path` | no | Path to the blocklist within `permissions-repo`. The blocklist is off when empty. | | `vouch-team` | no | `org/team-slug` whose members can `/vouch`. Vouching is off when empty. | -| `message` | yes | Comment posted before closing. `{author}` is replaced with the PR author's login. | +| `message` | yes | Comment posted before closing. `{author}` is replaced with the PR author's login. Hard-wrapped lines in a paragraph are joined, so wrap freely and separate paragraphs with a blank line. | | `blocked-message` | if `blocklist-path` | Comment posted before closing a blocked author's PR. `{author}` is substituted as in `message`. | | `token` | no | Token used to list, comment on, and close PRs. Defaults to `github.token`. | +| `dry-run` | no | `true` to change nothing (no comments, closes, reopens, or list commits) and only print the audit log of what would be done. Defaults to `false`. | Output `closed` is a JSON array of the PR numbers closed by this run. +Each run ends its log with an audit log of every write it made, one line per +action, printed even if the run fails partway: + +```text +Audit log: 4 action(s) taken. + 2026-11-20T10:00:01.123Z commit file=org/gov:approved.txt sha=3f9c... pr=https://github.com/org/proj/pull/7 message="allow newbie by maint" + 2026-11-20T10:00:01.456Z reopen pr=https://github.com/org/proj/pull/7 via=https://github.com/org/proj/pull/7#issuecomment-1 + 2026-11-20T10:00:02.789Z comment pr=https://github.com/org/proj/pull/9 author=mallory url=https://github.com/org/proj/pull/9#issuecomment-2 + 2026-11-20T10:00:03.012Z close pr=https://github.com/org/proj/pull/9 author=mallory reason=not-approved +``` + +`reason` is `not-approved` or `blocked`. For a `commit`, `pr` is the PR +carrying the `/vouch` comment. + +With `dry-run: true`, the header reads `Audit log (dry run): N action(s) +would be taken.` and entries omit `sha` and the comment `url`, which only +exist once the write is made. Within a dry run, list changes from vouches +are applied in memory, so the PRs it reports it would close are those a +real run would close. The `closed` output is always `[]`. + If the allowlist cannot be fetched or is empty, or `blocklist-path` is set but cannot be fetched, the action fails rather than closing anything. An empty blocklist is fine. diff --git a/action.yml b/action.yml index f54267e..de2eb12 100644 --- a/action.yml +++ b/action.yml @@ -46,7 +46,8 @@ inputs: message: description: > Comment posted on each pull request before closing it. "{author}" is - replaced with the PR author's login. + replaced with the PR author's login. Hard-wrapped lines within a + paragraph are joined; separate paragraphs with a blank line. required: true blocked-message: description: > @@ -63,6 +64,13 @@ inputs: required: false default: ${{ github.token }} + dry-run: + description: > + When "true", make no changes to pull requests, the allowlist, or the + blocklist; only print the audit log of actions a real run would take. + required: false + default: "false" + outputs: closed: description: JSON array of the pull request numbers that were closed. diff --git a/src/lib.js b/src/lib.js index e469a0e..b09249e 100644 --- a/src/lib.js +++ b/src/lib.js @@ -14,8 +14,30 @@ export function isApproved(logins, author) { return logins.has(author.toLowerCase()); } +// Lines that must keep their own line: blank, indented (code), lists, +// headings, quotes, tables, fences, and rules. +const STANDALONE = /^(\s*$|\s|[-*+>#|]|\d+[.)]\s|```|~~~)/; + +// GitHub renders every newline in a comment as a line break, so lines +// hard-wrapped in YAML are joined back into flowing paragraphs. +export function unwrap(text) { + const out = []; + let fenced = false; + for (const line of text.replace(/\r\n/g, "\n").split("\n")) { + const fence = /^(```|~~~)/.test(line); + const prev = out.length ? out[out.length - 1] : null; + if (!fenced && !fence && prev !== null && !STANDALONE.test(prev) && !STANDALONE.test(line)) { + out[out.length - 1] = `${prev} ${line.trim()}`; + } else { + out.push(line); + } + if (fence) fenced = !fenced; + } + return out.join("\n"); +} + export function renderMessage(template, author) { - return template.replaceAll("{author}", author); + return unwrap(template).replaceAll("{author}", author); } export function appendLogin(text, login) { diff --git a/src/main.js b/src/main.js index 29bdf85..b192a25 100644 --- a/src/main.js +++ b/src/main.js @@ -15,6 +15,9 @@ import { // skipped scheduled runs don't miss any. const VOUCH_LOOKBACK_MS = 24 * 60 * 60 * 1000; +// Only PRs opened this recently are closed; older ones are left alone. +const CLOSE_MAX_AGE_MS = 24 * 60 * 60 * 1000; + function input(name, { required = false } = {}) { const value = (process.env[`INPUT_${name.toUpperCase()}`] ?? "").trim(); if (required && !value) throw new Error(`Input required and not supplied: ${name}`); @@ -27,6 +30,24 @@ function setOutput(name, value) { } } +// Records a write the run made, for the audit log printed at exit. +function audit(ctx, action, details) { + ctx.audit.push({ time: new Date().toISOString(), action, ...details }); +} + +function printAudit(ctx) { + const entries = ctx.audit; + console.log( + ctx.dryRun + ? `Audit log (dry run): ${entries.length} action(s) would be taken.` + : `Audit log: ${entries.length} action(s) taken.`, + ); + for (const { time, action, ...details } of entries) { + const fields = Object.entries(details).map(([k, v]) => `${k}=${v}`); + console.log(` ${time} ${action} ${fields.join(" ")}`); + } +} + async function github(token, url, { method = "GET", body, allow404 = false } = {}) { const res = await fetch(url, { method, @@ -78,29 +99,46 @@ async function readList(ctx, path) { return { path, text, sha: file.sha, logins: parseList(text) }; } -async function writeList(ctx, list, text, message) { - const res = await github(ctx.permsToken, contentsUrl(ctx.apiUrl, ctx.permsRepo, list.path), { - method: "PUT", - body: { - message, - content: Buffer.from(text).toString("base64"), - sha: list.sha, - ...(ctx.permsRef && { branch: ctx.permsRef }), - }, - }); +function prUrl(ctx, number) { + return `${ctx.serverUrl}/${ctx.repo}/pull/${number}`; +} + +// In dry-run, only the in-memory list changes, so later decisions in the +// run match what a real run would do. +async function writeList(ctx, list, text, message, pr) { + if (!ctx.dryRun) { + const res = await github(ctx.permsToken, contentsUrl(ctx.apiUrl, ctx.permsRepo, list.path), { + method: "PUT", + body: { + message, + content: Buffer.from(text).toString("base64"), + sha: list.sha, + ...(ctx.permsRef && { branch: ctx.permsRef }), + }, + }); + list.sha = (await res.json()).content.sha; + } list.text = text; - list.sha = (await res.json()).content.sha; list.logins = parseList(text); + audit(ctx, "commit", { + file: `${ctx.permsRepo}:${list.path}`, + ...(!ctx.dryRun && { sha: list.sha }), + pr: prUrl(ctx, pr), + message: JSON.stringify(message.split("\n")[0]), + }); } -async function reopen(ctx, number) { - console.log(`Reopening #${number}.`); +async function reopen(ctx, number, via) { + console.log(`${ctx.dryRun ? "Would reopen" : "Reopening"} #${number}.`); try { - await github(ctx.token, `${ctx.repoUrl}/pulls/${number}`, { - method: "PATCH", - body: { state: "open" }, - }); + if (!ctx.dryRun) { + await github(ctx.token, `${ctx.repoUrl}/pulls/${number}`, { + method: "PATCH", + body: { state: "open" }, + }); + } + audit(ctx, "reopen", { pr: prUrl(ctx, number), via }); } catch (err) { // e.g. the head branch was deleted; don't let one PR block the sweep. console.log(`::warning::Could not reopen #${number}: ${err.message}`); @@ -188,6 +226,7 @@ async function processVouches(ctx, allow, block) { block, appendLogin(block.text, author), `block ${author} by ${blockVouch.c.user.login}\n\nVia: ${blockVouch.c.html_url}`, + blockVouch.pr.number, ); } if (!last) continue; @@ -204,6 +243,7 @@ async function processVouches(ctx, allow, block) { allow, removeLogin(allow.text, author), `revoke ${author} by ${last.c.user.login}\n\nVia: ${last.c.html_url}`, + last.pr.number, ); continue; } @@ -214,6 +254,7 @@ async function processVouches(ctx, allow, block) { allow, appendLogin(allow.text, author), `allow ${author} by ${last.c.user.login}\n\nVia: ${last.c.html_url}`, + last.pr.number, ); } const reopened = new Set(); @@ -221,7 +262,7 @@ async function processVouches(ctx, allow, block) { if (reopened.has(pr.number)) continue; if (pr.state === "closed" && !pr.merged && Date.parse(pr.closed_at) < Date.parse(c.created_at)) { reopened.add(pr.number); - await reopen(ctx, pr.number); + await reopen(ctx, pr.number, c.html_url); } } } @@ -231,23 +272,44 @@ async function processVouches(ctx, allow, block) { async function closeUnapproved(ctx, allow, block) { const writers = new Map(); const closed = []; - for (const pr of await paginate(ctx.token, `${ctx.repoUrl}/pulls?state=open&per_page=100`)) { + const cutoff = Date.now() - CLOSE_MAX_AGE_MS; + let url = `${ctx.repoUrl}/pulls?state=open&sort=created&direction=desc&per_page=100`; + const recent = []; + while (url) { + const res = await github(ctx.token, url); + const page = await res.json(); + const fresh = page.filter((pr) => Date.parse(pr.created_at) >= cutoff); + recent.push(...fresh); + // Newest first, so a page with any old PR is the last one we need. + url = fresh.length === page.length ? nextLink(res.headers.get("link")) : null; + } + for (const pr of recent) { const author = pr.user.login; const blocked = block !== null && isApproved(block.logins, author); if (!blocked && isApproved(allow.logins, author)) continue; if (!writers.has(author)) writers.set(author, await hasWriteAccess(ctx, author)); if (writers.get(author)) continue; console.log( - `Closing #${pr.number}: ${author} is ${blocked ? "blocked" : "not an approved contributor"}.`, + `${ctx.dryRun ? "Would close" : "Closing"} #${pr.number}: ` + + `${author} is ${blocked ? "blocked" : "not an approved contributor"}.`, ); - await github(ctx.token, `${ctx.repoUrl}/issues/${pr.number}/comments`, { + const reason = blocked ? "blocked" : "not-approved"; + const url = prUrl(ctx, pr.number); + if (ctx.dryRun) { + audit(ctx, "comment", { pr: url, author }); + audit(ctx, "close", { pr: url, author, reason }); + continue; + } + const res = await github(ctx.token, `${ctx.repoUrl}/issues/${pr.number}/comments`, { method: "POST", body: { body: renderMessage(blocked ? ctx.blockedMessage : ctx.message, author) }, }); + audit(ctx, "comment", { pr: url, author, url: (await res.json()).html_url }); await github(ctx.token, `${ctx.repoUrl}/pulls/${pr.number}`, { method: "PATCH", body: { state: "closed" }, }); + audit(ctx, "close", { pr: url, author, reason }); closed.push(pr.number); } return closed; @@ -258,9 +320,16 @@ async function closeUnapproved(ctx, allow, block) { async function run() { const apiUrl = process.env.GITHUB_API_URL ?? "https://api.github.com"; const token = input("token", { required: true }); + const dryRun = input("dry-run") || "false"; + if (dryRun !== "true" && dryRun !== "false") { + throw new Error(`dry-run must be "true" or "false", got "${dryRun}"`); + } const ctx = { apiUrl, + serverUrl: process.env.GITHUB_SERVER_URL ?? "https://github.com", + repo: process.env.GITHUB_REPOSITORY, repoUrl: `${apiUrl}/repos/${process.env.GITHUB_REPOSITORY}`, + dryRun: dryRun === "true", token, message: input("message", { required: true }), permsRepo: input("permissions-repo", { required: true }), @@ -269,7 +338,17 @@ async function run() { allowPath: input("allowlist-path", { required: true }), blockPath: input("blocklist-path"), vouchTeam: input("vouch-team"), + audit: [], }; + try { + await sweep(ctx); + } finally { + // Also on failure, so partial runs are accounted for. + printAudit(ctx); + } +} + +async function sweep(ctx) { if (ctx.blockPath) ctx.blockedMessage = input("blocked-message", { required: true }); parsePair(ctx.permsRepo, "permissions-repo"); @@ -283,7 +362,9 @@ async function run() { if (ctx.vouchTeam) await processVouches(ctx, allow, block); const closed = await closeUnapproved(ctx, allow, block); - console.log(closed.length ? `Closed ${closed.length} pull request(s).` : "Nothing to close."); + if (!ctx.dryRun) { + console.log(closed.length ? `Closed ${closed.length} pull request(s).` : "Nothing to close."); + } setOutput("closed", JSON.stringify(closed)); } diff --git a/test/lib.test.js b/test/lib.test.js index ff11140..a44529c 100644 --- a/test/lib.test.js +++ b/test/lib.test.js @@ -27,6 +27,42 @@ test("renderMessage substitutes every {author}", () => { assert.equal(renderMessage("Hi @{author}, {author}!", "bob"), "Hi @bob, bob!"); }); +test("renderMessage joins hard-wrapped paragraphs", () => { + const template = + "Thanks @{author} for your contribution, but\nthis bot is closing this PR.\n\n" + + "See [the contributing\ndocs](https://example.com).\n"; + assert.equal( + renderMessage(template, "bob"), + "Thanks @bob for your contribution, but this bot is closing this PR.\n\n" + + "See [the contributing docs](https://example.com).\n", + ); +}); + +test("renderMessage keeps block markdown on its own lines", () => { + const template = [ + "# Closed", + "Intro line one", + "line two:", + "- item one", + "- item two", + "1. first", + "> quoted", + "| a | b |", + "|---|---|", + "```", + "code line", + "more code", + "```", + " indented code", + "after", + "", + ].join("\n"); + assert.equal( + renderMessage(template, "bob"), + template.replace("Intro line one\nline two:", "Intro line one line two:"), + ); +}); + test("parsePair", () => { assert.deepEqual(parsePair("org/repo.name", "x"), ["org", "repo.name"]); assert.throws(() => parsePair("org", "x"), /x must be/); diff --git a/test/main.test.js b/test/main.test.js index aa36676..06cd1cc 100644 --- a/test/main.test.js +++ b/test/main.test.js @@ -18,6 +18,9 @@ const b64 = (s) => Buffer.from(s).toString("base64"); // team: vouch-team member logins (null: team endpoint 404s) // comments: issue comments returned by /issues/comments // pulls: PR number -> PR object for GET /pulls/:n +// fail: "METHOD /path" requests that get a 500 +// dryRun: value of the dry-run input +// serverUrl: GITHUB_SERVER_URL (undefined: unset) async function runAction({ pages = [[]], list, @@ -31,10 +34,20 @@ async function runAction({ team = [], comments = [], pulls = {}, + fail = [], + dryRun = "", + serverUrl, }) { const requests = []; let n = 0; - const pageData = pages.map((p) => p.map((login) => ({ number: ++n, user: { login } }))); + // Each entry is a login, or [login, ageInHours] (default: 1 hour old). + const pageData = pages.map((p) => + p.map((e) => { + const [login, hours = 1] = Array.isArray(e) ? e : [e]; + const created_at = new Date(Date.now() - hours * 3600e3).toISOString(); + return { number: ++n, created_at, user: { login } }; + }), + ); const files = { "approved.txt": { text: list, sha: "sha0", status: listStatus }, "blocked.txt": { text: block, sha: "sha0", status: blockStatus }, @@ -48,6 +61,7 @@ async function runAction({ const base = `http://127.0.0.1:${server.address().port}`; const url = new URL(req.url, base); const path = url.pathname; + if (fail.includes(`${req.method} ${path}`)) return res.writeHead(500).end("{}"); const file = files[/^\/repos\/org\/gov\/contents\/(.*)$/.exec(path)?.[1]]; if (file) { if (req.method === "PUT") { @@ -84,6 +98,11 @@ async function runAction({ if (path === "/repos/org/proj/issues/comments") { return res.writeHead(200, json).end(JSON.stringify(comments)); } + const posted = /^\/repos\/org\/proj\/issues\/(\d+)\/comments$/.exec(path); + if (req.method === "POST" && posted) { + const html_url = `https://github.com/org/proj/pull/${posted[1]}#issuecomment-c${posted[1]}`; + return res.writeHead(201, json).end(JSON.stringify({ html_url })); + } res.writeHead(200, json).end("{}"); }); }); @@ -107,9 +126,11 @@ async function runAction({ INPUT_MESSAGE: "Sorry @{author}", "INPUT_BLOCKED-MESSAGE": blockedMessage, INPUT_TOKEN: "pr-tok", + "INPUT_DRY-RUN": dryRun, + ...(serverUrl && { GITHUB_SERVER_URL: serverUrl }), }; - const code = await new Promise((resolve) => { - execFile(process.execPath, [MAIN], { env }, (err) => resolve(err ? err.code : 0)); + const [code, stdout] = await new Promise((resolve) => { + execFile(process.execPath, [MAIN], { env }, (err, out) => resolve([err ? err.code : 0, out])); }); server.close(); const writes = requests @@ -122,6 +143,12 @@ async function runAction({ listText: files["approved.txt"].text, blockText: files["blocked.txt"].text, output: readFileSync(outputPath, "utf8"), + // Audit entries with the timestamp stripped. + audit: stdout + .split("\n") + .filter((l) => /^ \d{4}-\S+Z /.test(l)) + .map((l) => l.trim().replace(/^\S+ /, "")), + stdout, }; } @@ -159,6 +186,25 @@ test("authors with write access are never closed", async () => { assert.equal(output, "closed=[4,5]\n"); }); +test("PRs opened more than 24 hours ago are not closed", async () => { + const { code, requests, writes, output } = await runAction({ + pages: [["mallory", ["eve", 23]], [["oldie", 25]], ["unreached"]], + list: "alice\n", + }); + assert.equal(code, 0); + assert.deepEqual(writes.map(([m, u]) => [m, u]), [ + ["POST", "/repos/org/proj/issues/1/comments"], + ["PATCH", "/repos/org/proj/pulls/1"], + ["POST", "/repos/org/proj/issues/2/comments"], + ["PATCH", "/repos/org/proj/pulls/2"], + ]); + assert.equal(output, "closed=[1,2]\n"); + // Newest-first ordering lets us stop at the first page with an old PR. + const lists = requests.filter((r) => r.url.startsWith("/repos/org/proj/pulls?")); + assert.equal(lists.length, 2); + assert.match(lists[0].url, /sort=created&direction=desc/); +}); + test("listed authors skip the permission lookup", async () => { const { requests } = await runAction({ pages: [["alice"]], list: "alice\n" }); assert.ok(!requests.some((r) => r.url.includes("/collaborators/"))); @@ -514,3 +560,100 @@ test("manually blocked authors: allow is ignored", async () => { }); assert.deepEqual(writes, []); }); + +test("audit log: closes", async () => { + const { audit, stdout } = await runAction({ + pages: [["alice", "mallory", "eve"]], + list: "alice\n", + block: "eve\n", + }); + assert.match(stdout, /Audit log: 4 action\(s\) taken\./); + assert.deepEqual(audit, [ + "comment pr=https://github.com/org/proj/pull/2 author=mallory url=https://github.com/org/proj/pull/2#issuecomment-c2", + "close pr=https://github.com/org/proj/pull/2 author=mallory reason=not-approved", + "comment pr=https://github.com/org/proj/pull/3 author=eve url=https://github.com/org/proj/pull/3#issuecomment-c3", + "close pr=https://github.com/org/proj/pull/3 author=eve reason=blocked", + ]); +}); + +test("audit log: commits and reopens", async () => { + const { audit } = await runAction({ + list: "alice\n", + vouchTeam: "org/maintainers", + team: ["maint"], + comments: [comment(1, "maint", "/vouch allow")], + pulls: { 7: closedPr }, + }); + assert.deepEqual(audit, [ + 'commit file=org/gov:approved.txt sha=sha1 pr=https://github.com/org/proj/pull/7 message="allow newbie by maint"', + "reopen pr=https://github.com/org/proj/pull/7 via=https://github.com/org/proj/pull/7#issuecomment-1", + ]); +}); + +test("audit log: nothing done", async () => { + const { audit, stdout } = await runAction({ pages: [["alice"]], list: "alice\n" }); + assert.match(stdout, /Audit log: 0 action\(s\) taken\./); + assert.deepEqual(audit, []); +}); + +test("audit log: printed when the run fails partway", async () => { + const { code, audit, stdout } = await runAction({ + pages: [["mallory", "eve"]], + list: "alice\n", + fail: ["PATCH /repos/org/proj/pulls/2"], + }); + assert.equal(code, 1); + assert.match(stdout, /::error::PATCH .* 500/); + assert.deepEqual(audit, [ + "comment pr=https://github.com/org/proj/pull/1 author=mallory url=https://github.com/org/proj/pull/1#issuecomment-c1", + "close pr=https://github.com/org/proj/pull/1 author=mallory reason=not-approved", + "comment pr=https://github.com/org/proj/pull/2 author=eve url=https://github.com/org/proj/pull/2#issuecomment-c2", + ]); +}); + +test("dry run: no writes, audit lists what would happen", async () => { + const { code, requests, writes, audit, stdout, output, listText, blockText } = await runAction({ + dryRun: "true", + serverUrl: "https://ghe.example", + pages: [["alice", "newbie", "mallory", "eve"]], + list: "alice\nrevoked\n", + block: "eve\n", + vouchTeam: "org/maintainers", + team: ["maint"], + comments: [ + comment(1, "maint", "/vouch allow", 7), + comment(2, "maint", "/vouch revoke", 8), + comment(3, "maint", "/vouch block", 9), + ], + pulls: { + 7: closedPr, + 8: { ...closedPr, number: 8, user: { login: "revoked" } }, + 9: { ...closedPr, number: 9, user: { login: "spammer" } }, + }, + }); + assert.equal(code, 0); + assert.deepEqual(writes, []); + assert.ok(requests.every((r) => r.method === "GET")); + assert.equal(listText, "alice\nrevoked\n"); + assert.equal(blockText, "eve\n"); + assert.match(stdout, /Audit log \(dry run\): 8 action\(s\) would be taken\./); + const pr = (n) => `https://ghe.example/org/proj/pull/${n}`; + assert.deepEqual(audit, [ + `commit file=org/gov:approved.txt pr=${pr(7)} message="allow newbie by maint"`, + `reopen pr=${pr(7)} via=https://github.com/org/proj/pull/7#issuecomment-1`, + `commit file=org/gov:approved.txt pr=${pr(8)} message="revoke revoked by maint"`, + `commit file=org/gov:blocked.txt pr=${pr(9)} message="block spammer by maint"`, + // newbie was allowed in memory, so PR 2 is not closed. + `comment pr=${pr(3)} author=mallory`, + `close pr=${pr(3)} author=mallory reason=not-approved`, + `comment pr=${pr(4)} author=eve`, + `close pr=${pr(4)} author=eve reason=blocked`, + ]); + assert.equal(output, "closed=[]\n"); +}); + +test("dry run: invalid value fails", async () => { + const { code, requests } = await runAction({ dryRun: "yes", list: "alice\n" }); + assert.equal(code, 1); + assert.equal(requests.length, 0); +});