@capagents/forgeqe 0.0.0-stage → 1.0.0

package/src/code/prtests.ts

@@ -0,0 +1,103 @@
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+
+import type { CodeEvent } from "../types.ts"
+import type { AppConfig } from "../config.ts"
+import { findTests, type TestSelection, type TestsRun } from "./find.ts"
+import { analyzeImpact, changedBetween, impactSelection, testsForWorkItems, type Impact } from "./impact.ts"
+import { fetchPr, fetchPrBranches, resolvePr, type Platform, type PrInfo } from "./prreview.ts"
+import type { OpencodeSession, openSession } from "./runtime.ts"
+import type { runTestCommand } from "./testrun.ts"
+
+/**
+ * The tests a pull request (or the commits since a base branch) can break: the impact analysis, then either the
+ * find-tests agent, which reads the candidates and the tests and gives an exact selection with list and run commands,
+ * or (agent: false, for CI) a selection of the impacted test files with a run command built for Playwright or pytest.
+ * The tests run from the working tree, so in CI check the pull request's branch out first.
+ */
+export type PrTests = {
+  selection: TestSelection | null
+  impact: Impact
+  pr?: PrInfo
+  /** Something the user should know: the working tree is not the PR's head, or no test was found. */
+  notes: string[]
+}
+
+export async function selectPrTests(opts: {
+  config: AppConfig
+  repo: string
+  pr?: string
+  platform?: Platform
+  /** Without pr: the branch to compare HEAD with (default: the remote's default branch). */
+  base?: string
+  agent: boolean
+  signal?: AbortSignal
+  onEvent?: (e: CodeEvent) => void
+  open?: (o: Parameters<typeof openSession>[0]) => Promise<OpencodeSession>
+  runTest?: typeof runTestCommand
+}): Promise<PrTests> {
+  const emit = opts.onEvent || (() => {})
+  const notes: string[] = []
+  let root = path.resolve(opts.repo)
+  let changed: string[]
+  let pr: PrInfo | undefined
+  if (opts.pr) {
+    const r = await resolvePr(root, opts.pr, opts.platform)
+    root = r.root
+    emit({ type: "code", kind: "info", text: `Reading pull request ${r.ref.number}…` })
+    pr = await fetchPr(r.ref, opts.config, root)
+    const { base, dropRefs } = await fetchPrBranches(root, r.remote, pr)
+    try {
+      changed = changedBetween(root, base, pr.headSha)
+    } finally {
+      await dropRefs()
+    }
+    const head = spawnSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).stdout.trim()
+    if (head && head !== pr.headSha) notes.push(`The working tree is at ${head.slice(0, 10)}, not the pull request's head ${pr.headSha.slice(0, 10)}: the tests run as they are here, so check out ${pr.sourceBranch} to run the pull request's own versions (and any tests it adds).`)
+  } else {
+    const base = opts.base || defaultBase(root)
+    changed = changedBetween(root, base)
+    notes.push(`Changes since ${base}.`)
+  }
+  const mapped = pr?.workItemIds?.length ? await testsForWorkItems(opts.config, root, pr.workItemIds) : []
+  const impact = analyzeImpact(root, changed, mapped)
+  emit({ type: "code", kind: "info", text: `${changed.length} changed files; ${impact.tests.length} tests reach them${impact.untested.length ? `; no test reaches ${impact.untested.length}` : ""}` })
+  const what = pr ? `pull request ${pr.ref.number} "${pr.title}"` : "the changes since the base branch"
+  if (!opts.agent) {
+    if (!impact.tests.length) return { selection: null, impact, pr, notes: [...notes, "No test reaches the changed files."] }
+    const selection = impactSelection(opts.config, root, `tests affected by ${what}`, impact)
+    if (!selection) notes.push("The impacted tests are not Playwright or pytest files in one project, so there is no run command without the find-tests agent: run it with the agent, or run the files listed.")
+    return { selection, impact, pr, notes }
+  }
+  const request = [
+    `The tests that ${what} can break.`,
+    pr?.description ? `What it does: ${pr.description.slice(0, 600)}` : "",
+    `Changed files: ${changed.slice(0, 80).join(", ")}${changed.length > 80 ? `, and ${changed.length - 80} more` : ""}.`,
+    impact.tests.length ? `Candidates from the imports and names (check each; keep the ones that exercise what changed): ${impact.tests.map((t) => `${t.file} (${t.reasons.join("; ")})`).join("; ")}.` : "",
+    "Also add tests that drive the changed behaviour through the UI without importing the changed files (a page whose markup or route changed). Leave out tests that only share a helper the change does not alter.",
+  ]
+    .filter(Boolean)
+    .join("\n")
+  const selection = await findTests({ config: opts.config, repo: root, request, signal: opts.signal, onEvent: emit, open: opts.open, runTest: opts.runTest })
+  return { selection, impact, pr, notes }
+}
+
+/** origin/HEAD's branch (origin/main), or origin/main. */
+function defaultBase(repo: string): string {
+  const r = spawnSync("git", ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], { cwd: repo, encoding: "utf8" })
+  return r.status === 0 && r.stdout.trim() ? r.stdout.trim() : "origin/main"
+}
+
+/** The run's results as a pull request comment. */
+export function resultsMarkdown(run: TestsRun, what: string): string {
+  const failed = run.tests.filter((t) => t.status === "failed")
+  const mark = run.status === "passed" ? "✅" : "❌"
+  return [
+    `### ${mark} ForgeQE: tests affected by ${what}`,
+    "",
+    `${run.counts.passed} passed, ${run.counts.failed} failed${run.counts.skipped ? `, ${run.counts.skipped} skipped` : ""} in ${run.seconds}s${run.status === "timed out" ? " (timed out)" : ""}.`,
+    ...(failed.length ? ["", "| Failed test | Message |", "|---|---|", ...failed.slice(0, 25).map((t) => `| ${t.name.replace(/\|/g, "\\|")} | ${(t.message || "").replace(/\|/g, "\\|").slice(0, 200)} |`)] : []),
+    "",
+    `Command: \`${run.command}\``,
+  ].join("\n")
+}