dsh-pstack 0.2.0-beta.1 → 0.2.0-beta.3

package/dist/pstack/skills/poteto-mode/scripts/watch-pr/github.test.mjs

@@ -0,0 +1,521 @@
+import { expect } from "../expect.mjs";
+import "../support.mjs";
+import { parsePrNumber } from "./types.mjs";
+import { ChecksUnavailable, WatcherQueryError, buildReviewThreads, mapRollupNode, orderStack, parseFastCheck, parsePullRequest, parseReviewThreadPage, resolveChecks, resolveContext, resolveReviewThreads } from "./github.mjs";
+import { failedCheck, fakeReader, passingCheck, pendingCheck } from "./fakes.test-helper.mjs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { describe, it } from "node:test";
+// runtime/skills/poteto-mode/scripts/watch-pr/github.test.ts
+const githubModule = JSON.stringify(import.meta.dirname + (import.meta.url.endsWith(".ts") ? "/github.ts" : "/github.mjs"));
+const context = {
+	owner: "owner",
+	repo: "repo",
+	number: parsePrNumber(42)
+};
+describe("checks fallback chain", () => {
+	it("uses a non-empty fast-path result without a rollup query", async () => {
+		const reader = fakeReader({ fastPath: {
+			kind: "checks",
+			checks: [passingCheck("fast")]
+		} });
+		const read = await resolveChecks(reader, context);
+		expect(read.source).toBe("gh-pr-checks");
+		expect(read.checks.map((check) => check.name)).toEqual(["fast"]);
+		expect(reader.calls).toEqual(["checksFastPath"]);
+	});
+	it("paginates GraphQL when the fast path is unusable", async () => {
+		const reader = fakeReader({
+			fastPath: {
+				kind: "unusable",
+				exitCode: 8,
+				stderr: ""
+			},
+			rollupPages: [{
+				checks: [passingCheck("first")],
+				endCursor: "next"
+			}, {
+				checks: [failedCheck("second")],
+				endCursor: null
+			}]
+		});
+		const read = await resolveChecks(reader, context);
+		expect(read.source).toBe("graphql-rollup");
+		expect(read.checks.map((check) => check.name)).toEqual(["first", "second"]);
+		expect(reader.calls).toEqual([
+			"checksFastPath",
+			"checkRollupPage:null",
+			"checkRollupPage:next"
+		]);
+	});
+	it("falls back when valid fast-path JSON represented an empty list", async () => {
+		const reader = fakeReader({
+			fastPath: {
+				kind: "checks",
+				checks: []
+			},
+			rollupPages: [{
+				checks: [pendingCheck("fallback")],
+				endCursor: null
+			}]
+		});
+		expect((await resolveChecks(reader, context)).checks[0].name).toBe("fallback");
+		expect(reader.calls).toEqual(["checksFastPath", "checkRollupPage:null"]);
+	});
+	it("fails closed when both paths are empty", async () => {
+		const reader = fakeReader({ fastPath: {
+			kind: "unusable",
+			exitCode: 8,
+			stderr: "credential cannot read checks"
+		} });
+		await expect(resolveChecks(reader, context)).rejects.toBeInstanceOf(ChecksUnavailable);
+		expect(reader.calls).toEqual(["checksFastPath", "checkRollupPage:null"]);
+	});
+});
+describe("rollup node mapping", () => {
+	it("maps terminal and non-terminal CheckRun states fail closed", () => {
+		for (const [status, conclusion, kind, reportedState] of [
+			[
+				"IN_PROGRESS",
+				null,
+				"pending",
+				"PENDING"
+			],
+			[
+				"COMPLETED",
+				"SUCCESS",
+				"passed",
+				"SUCCESS"
+			],
+			[
+				"COMPLETED",
+				"NEUTRAL",
+				"skipped",
+				"NEUTRAL"
+			],
+			[
+				"COMPLETED",
+				"SKIPPED",
+				"skipped",
+				"SKIPPED"
+			],
+			[
+				"COMPLETED",
+				"ACTION_REQUIRED",
+				"failed",
+				"ACTION_REQUIRED"
+			],
+			[
+				"COMPLETED",
+				"TIMED_OUT",
+				"failed",
+				"FAILURE"
+			],
+			[
+				"COMPLETED",
+				"FUTURE_VALUE",
+				"failed",
+				"FAILURE"
+			]
+		]) expect(mapRollupNode({
+			__typename: "CheckRun",
+			name: "ci",
+			status,
+			conclusion
+		})).toMatchObject({
+			kind,
+			reportedState
+		});
+	});
+	it("classifies an in-progress Code Review Gate from the rollup as the gate", () => {
+		expect(mapRollupNode({
+			__typename: "CheckRun",
+			name: "Code Review Gate",
+			status: "IN_PROGRESS",
+			conclusion: null
+		})).toMatchObject({ kind: "code-review-gate" });
+		expect(mapRollupNode({
+			__typename: "StatusContext",
+			context: "Code Review Gate",
+			state: "PENDING"
+		})).toMatchObject({ kind: "code-review-gate" });
+	});
+	it("classifies a Code Review Gate waiting on an owner approval as the gate", () => {
+		expect(mapRollupNode({
+			__typename: "CheckRun",
+			name: "Code Review Gate",
+			status: "COMPLETED",
+			conclusion: "ACTION_REQUIRED",
+			description: "1 of 2 policies"
+		})).toMatchObject({
+			kind: "code-review-gate",
+			reportedState: "ACTION_REQUIRED"
+		});
+	});
+	it("classifies a fast-path Code Review Gate waiting on an owner approval as the gate", () => {
+		expect(parseFastCheck({
+			name: "Code Review Gate",
+			state: "ACTION_REQUIRED",
+			bucket: "fail"
+		})).toMatchObject({
+			kind: "code-review-gate",
+			reportedState: "ACTION_REQUIRED"
+		});
+		expect(parseFastCheck({
+			name: "ci",
+			state: "ACTION_REQUIRED",
+			bucket: "fail"
+		})).toMatchObject({
+			kind: "failed",
+			reportedState: "ACTION_REQUIRED"
+		});
+	});
+	it("maps StatusContext states and drops unknown typenames", () => {
+		expect(mapRollupNode({
+			__typename: "StatusContext",
+			context: "ci",
+			state: "EXPECTED"
+		})).toMatchObject({
+			kind: "pending",
+			reportedState: "PENDING"
+		});
+		expect(mapRollupNode({
+			__typename: "StatusContext",
+			context: "ci",
+			state: "FUTURE_VALUE"
+		})).toMatchObject({
+			kind: "failed",
+			reportedState: "FUTURE_VALUE"
+		});
+		expect(mapRollupNode({ __typename: "FutureNode" })).toBeNull();
+	});
+});
+describe("closed enum parsing", () => {
+	const rawPullRequest = {
+		mergeable: "MERGEABLE",
+		mergeStateStatus: "CLEAN",
+		reviewDecision: "APPROVED",
+		headRefOid: "head",
+		headRefName: "feature",
+		baseRefName: "main",
+		state: "OPEN",
+		mergedAt: null,
+		isDraft: false
+	};
+	it("accepts mergeStateStatus CONFLICTING", () => {
+		expect(parsePullRequest({
+			...rawPullRequest,
+			mergeStateStatus: "CONFLICTING"
+		}, context).mergeStateStatus).toBe("CONFLICTING");
+	});
+	it("reads gh's empty reviewDecision as no decision rather than a parse failure", () => {
+		expect(parsePullRequest({
+			...rawPullRequest,
+			reviewDecision: ""
+		}, context).reviewDecision).toBeNull();
+	});
+	it("still rejects an unknown reviewDecision", () => {
+		expect(() => parsePullRequest({
+			...rawPullRequest,
+			reviewDecision: "MAYBE"
+		}, context)).toThrow(WatcherQueryError);
+	});
+	it("rejects unknown enum values as retryable errors carrying the raw value", () => {
+		try {
+			parsePullRequest({
+				...rawPullRequest,
+				mergeStateStatus: "FUTURE_STATE"
+			}, context);
+			throw new Error("expected parser to throw");
+		} catch (error) {
+			expect(error).toBeInstanceOf(WatcherQueryError);
+			if (!(error instanceof WatcherQueryError)) throw error;
+			expect(error.failure).toMatchObject({
+				kind: "missing-key",
+				retryable: true,
+				rawValue: "\"FUTURE_STATE\""
+			});
+		}
+	});
+});
+it("annotates Bugbot threads with distinct review-pass counts", () => {
+	const threads = buildReviewThreads(parseReviewThreadPage({ data: { repository: { pullRequest: { reviewThreads: {
+		pageInfo: {
+			hasNextPage: false,
+			endCursor: null
+		},
+		nodes: [
+			{
+				id: "one",
+				isResolved: false,
+				comments: { nodes: [{
+					body: "RUN_ID: run-1",
+					createdAt: "now",
+					path: "a.ts",
+					line: 1,
+					author: { login: "bugbot" }
+				}] }
+			},
+			{
+				id: "two",
+				isResolved: false,
+				comments: { nodes: [{
+					body: "CURSOR_AUTOMATION_ID: run-2 severity high",
+					createdAt: "now",
+					path: null,
+					line: null,
+					author: { login: "cursor" }
+				}] }
+			},
+			{
+				id: "resolved",
+				isResolved: true,
+				comments: { nodes: [{
+					body: "RUN_ID: run-3",
+					createdAt: "now",
+					path: null,
+					line: null,
+					author: { login: "bugbot" }
+				}] }
+			}
+		]
+	} } } } }).threads);
+	expect(threads).toHaveLength(2);
+	expect(threads.map((thread) => thread.isBugbot)).toEqual([true, true]);
+	expect(threads.map((thread) => thread.bugbotReviewPasses)).toEqual([3, 3]);
+});
+describe("review thread pagination", () => {
+	const thread = (id, resolved = false) => ({
+		id,
+		firstComment: {
+			authorLogin: "someone",
+			body: "please fix",
+			path: "a.ts",
+			line: 1,
+			createdAt: "now"
+		},
+		resolved
+	});
+	it("keeps walking pages until the cursor is exhausted", async () => {
+		const reader = fakeReader({ threadPages: [
+			{
+				threads: [thread("one")],
+				endCursor: "next"
+			},
+			{
+				threads: [thread("two")],
+				endCursor: "last"
+			},
+			{
+				threads: [thread("three")],
+				endCursor: null
+			}
+		] });
+		const threads = await resolveReviewThreads(reader, context);
+		expect(threads.map((item) => item.id)).toEqual([
+			"one",
+			"two",
+			"three"
+		]);
+		expect(reader.calls).toEqual([
+			"reviewThreadPage:null",
+			"reviewThreadPage:next",
+			"reviewThreadPage:last"
+		]);
+	});
+	it("sees an unresolved thread that sits past the first page", async () => {
+		const reader = fakeReader({ threadPages: [{
+			threads: [thread("early", true)],
+			endCursor: "next"
+		}, {
+			threads: [thread("late")],
+			endCursor: null
+		}] });
+		const threads = await resolveReviewThreads(reader, context);
+		expect(threads.map((item) => item.id)).toEqual(["late"]);
+	});
+	it("stops after a single page when the cursor is exhausted", async () => {
+		const reader = fakeReader({ threadPages: [{
+			threads: [thread("only")],
+			endCursor: null
+		}] });
+		expect((await resolveReviewThreads(reader, context)).length).toBe(1);
+		expect(reader.calls).toEqual(["reviewThreadPage:null"]);
+	});
+	it("counts Bugbot review passes across every page", async () => {
+		const bugbot = (id, runId) => ({
+			id,
+			firstComment: {
+				authorLogin: "bugbot",
+				body: `RUN_ID: ${runId}`,
+				path: "a.ts",
+				line: 1,
+				createdAt: "now"
+			},
+			resolved: false
+		});
+		const reader = fakeReader({ threadPages: [{
+			threads: [bugbot("one", "run-1")],
+			endCursor: "next"
+		}, {
+			threads: [bugbot("two", "run-2")],
+			endCursor: null
+		}] });
+		const threads = await resolveReviewThreads(reader, context);
+		expect(threads.map((item) => item.bugbotReviewPasses)).toEqual([2, 2]);
+	});
+	it("drops resolved threads from later pages too", async () => {
+		const reader = fakeReader({ threadPages: [{
+			threads: [thread("one")],
+			endCursor: "next"
+		}, {
+			threads: [thread("two", true)],
+			endCursor: null
+		}] });
+		expect((await resolveReviewThreads(reader, context)).map((item) => item.id)).toEqual(["one"]);
+	});
+	it("rejects a page that omits pageInfo instead of assuming one page", async () => {
+		const response = { data: { repository: { pullRequest: { reviewThreads: { nodes: [] } } } } };
+		expect(() => parseReviewThreadPage(response)).toThrow(WatcherQueryError);
+	});
+});
+describe("context and stack discovery", () => {
+	it("returns a fully explicit context without any reader call", async () => {
+		const reader = fakeReader();
+		expect(await resolveContext({
+			reader,
+			owner: "explicit",
+			repo: "repo",
+			pr: context.number
+		})).toEqual({
+			owner: "explicit",
+			repo: "repo",
+			number: context.number
+		});
+		expect(reader.calls).toEqual([]);
+	});
+	it("uses the local origin before currentPr for an explicit number", async () => {
+		const reader = fakeReader({ origin: {
+			owner: "local",
+			repo: "checkout"
+		} });
+		expect(await resolveContext({
+			reader,
+			owner: null,
+			repo: null,
+			pr: context.number
+		})).toEqual({
+			owner: "local",
+			repo: "checkout",
+			number: context.number
+		});
+		expect(reader.calls).toEqual(["originRepo"]);
+	});
+	it("orders the connected stack bottom-to-top", () => {
+		const ordered = orderStack(context, [
+			{
+				number: parsePrNumber(41),
+				headRefName: "base-feature",
+				isCrossRepository: false,
+				baseRefName: "main"
+			},
+			{
+				number: context.number,
+				headRefName: "feature",
+				isCrossRepository: false,
+				baseRefName: "base-feature"
+			},
+			{
+				number: parsePrNumber(43),
+				headRefName: "upstack",
+				isCrossRepository: false,
+				baseRefName: "feature"
+			}
+		]);
+		expect(ordered.map((item) => Number(item.number))).toEqual([
+			41,
+			42,
+			43
+		]);
+	});
+	it("does not use a fork's same-named head as a stack parent", () => {
+		const ordered = orderStack(context, [{
+			number: parsePrNumber(41),
+			headRefName: "base-feature",
+			baseRefName: "main",
+			isCrossRepository: true
+		}, {
+			number: context.number,
+			headRefName: "feature",
+			baseRefName: "base-feature",
+			isCrossRepository: false
+		}]);
+		expect(ordered.map((item) => Number(item.number))).toEqual([42]);
+	});
+	it("does not attach upstream branch children to a fork head", () => {
+		const ordered = orderStack(context, [{
+			number: context.number,
+			headRefName: "feature",
+			baseRefName: "main",
+			isCrossRepository: true
+		}, {
+			number: parsePrNumber(43),
+			headRefName: "upstack",
+			baseRefName: "feature",
+			isCrossRepository: false
+		}]);
+		expect(ordered.map((item) => Number(item.number))).toEqual([42]);
+	});
+	it("terminates when an unrelated fork opens main against main", () => {
+		const program = `import { orderStack } from ${githubModule};
+      console.log(JSON.stringify(orderStack(${JSON.stringify(context)}, [
+        { number: 41, headRefName: "main", baseRefName: "main", isCrossRepository: true },
+        { number: 42, headRefName: "feature", baseRefName: "main", isCrossRepository: false }
+      ])));`;
+		const child = spawnSync(process.execPath, ["-e", program], {
+			encoding: "utf8",
+			timeout: 2e3
+		});
+		expect(child.error).toBeUndefined();
+		expect(child.status).toBe(0);
+		expect(JSON.parse(child.stdout).map((item) => item.number)).toEqual([42]);
+	});
+	it("requests and parses fork identity from gh before stack discovery", () => {
+		const directory = mkdtempSync(join(tmpdir(), "watch-pr-fork-"));
+		try {
+			writeFileSync(join(directory, "gh"), `#!/bin/sh
+case "$*" in
+  *number,headRefName,baseRefName,isCrossRepository*) ;;
+  *) exit 2 ;;
+esac
+printf '%s\\n' '[{"number":42,"headRefName":"feature","baseRefName":"main","isCrossRepository":true}]'
+`, { mode: 493 });
+			const program = `import { GhGitHubReader } from ${githubModule};
+        console.log(JSON.stringify(await new GhGitHubReader().openPullRequests({ owner: "owner", repo: "repo" })));`;
+			const child = spawnSync(process.execPath, ["-e", program], {
+				encoding: "utf8",
+				timeout: 2e3,
+				env: {
+					...process.env,
+					PATH: directory + ":" + process.env.PATH
+				}
+			});
+			expect(child.error).toBeUndefined();
+			expect(child.status).toBe(0);
+			expect(JSON.parse(child.stdout)).toEqual([{
+				number: 42,
+				headRefName: "feature",
+				baseRefName: "main",
+				isCrossRepository: true
+			}]);
+		} finally {
+			rmSync(directory, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+});
+export {};