diff --git a/scripts/lib/browser-runtime-fixture-lifecycle.mjs b/scripts/lib/browser-runtime-fixture-lifecycle.mjs index d39617f58..3b3210b5b 100644 --- a/scripts/lib/browser-runtime-fixture-lifecycle.mjs +++ b/scripts/lib/browser-runtime-fixture-lifecycle.mjs @@ -9,10 +9,13 @@ import { createSystemProcessOwnershipHost } from "../../dist/process/ProcessOwne import { liveProcesses } from "../../dist/process/ProcessOwnershipProcessTree.js"; import { CdpConnection } from "../../dist/browser/CdpConnection.js"; import { waitForBrowserDevtoolsPort } from "../../dist/browser/BrowserProcessStartup.js"; +import { discoverCdpEndpoint } from "../../dist/browser/CdpEndpoint.js"; +import { BrowserObservationError } from "../../dist/domain/browserObservationError.js"; -/** Launch the synthetic fixture browser and await CDP in its own verified process group. */ +/** Admit the owned fixture only after CDP serves its requested page. */ export async function startRuntimeFixtureBrowser(executable, origin) { const profile = await mkdtemp(join(tmpdir(), "rea-real-web-runtime-")); + const deadline = performance.now() + 60_000; let owned; try { owned = await spawnOwnedProviderProcess({ @@ -50,7 +53,16 @@ export async function startRuntimeFixtureBrowser(executable, origin) { stderr: () => stderr, // Match the broader real-browser verifier's allowance for cold Chrome // startup on shared runners; early process failures still reject at once. - timeoutMs: 60_000, + timeoutMs: Math.max(1, deadline - performance.now()), + }); + // Port publication can precede a responsive discovery service and renderer. + // Both phases share the owned fixture's startup budget; public CDP calls + // retain their normal per-response deadlines and failure semantics. + await waitForRuntimeFixturePage({ + child: owned.process, + port, + origin, + deadline, }); return { port, @@ -65,17 +77,86 @@ export async function startRuntimeFixtureBrowser(executable, origin) { }, }; } catch (cause) { - if (owned !== undefined) await stopOwnedBrowser(owned, profile); - await rm(profile, { - recursive: true, - force: true, - maxRetries: 5, - retryDelay: 100, - }); + await closeRuntimeFixtureResources( + [ + async () => { + // Keep the profile when stopping its browser cannot be confirmed. + if (owned !== undefined) await stopOwnedBrowser(owned, profile); + await rm(profile, { + recursive: true, + force: true, + maxRetries: 5, + retryDelay: 100, + }); + }, + ], + cause, + ); throw cause; } } +async function waitForRuntimeFixturePage({ child, port, origin, deadline }) { + const controller = new AbortController(); + let lastFailure; + const onExit = () => + controller.abort( + new Error( + "Owned runtime fixture exited before CDP discovery became ready", + { cause: lastFailure }, + ), + ); + const onError = (cause) => controller.abort(cause); + const timer = setTimeout( + () => + controller.abort( + new Error( + "Owned runtime fixture page was not discoverable within its startup budget", + { cause: lastFailure }, + ), + ), + Math.max(1, deadline - performance.now()), + ); + child.once("exit", onExit); + child.once("error", onError); + try { + for (;;) { + if (child.exitCode !== null || child.signalCode !== null) onExit(); + controller.signal.throwIfAborted(); + try { + const discovery = await discoverCdpEndpoint( + `http://127.0.0.1:${port}`, + "list_browser_targets", + controller.signal, + ); + if ( + discovery.targets.some( + (target) => + target.type === "page" && + (target.url === origin || target.url.startsWith(`${origin}/`)), + ) + ) + return; + } catch (cause) { + controller.signal.throwIfAborted(); + // Only transient startup failures are retryable. Invalid protocol + // responses and payload-limit failures must remain visible immediately. + if ( + !(cause instanceof BrowserObservationError) || + !["timeout", "endpoint_unreachable"].includes(cause.reason) + ) + throw cause; + lastFailure = cause; + } + await new Promise((resolve) => setTimeout(resolve, 25)); + } + } finally { + clearTimeout(timer); + child.removeListener("exit", onExit); + child.removeListener("error", onError); + } +} + async function stopOwnedBrowser(owned, profile) { const child = owned.process; const exited = diff --git a/tests/boundary/browser/runtimeFixtureReadiness.test.ts b/tests/boundary/browser/runtimeFixtureReadiness.test.ts new file mode 100644 index 000000000..8a964e803 --- /dev/null +++ b/tests/boundary/browser/runtimeFixtureReadiness.test.ts @@ -0,0 +1,200 @@ +import { ChildProcess } from "node:child_process"; +import { createServer } from "node:http"; +import { setImmediate } from "node:timers/promises"; +import { afterEach, expect, it, vi } from "vitest"; +import { z } from "zod"; + +const mock = vi.hoisted(() => ({ spawn: vi.fn(), port: vi.fn() })); +vi.mock("../../../dist/process/ProviderProcess.js", () => ({ + spawnOwnedProviderProcess: mock.spawn, +})); +vi.mock("../../../dist/process/ProcessOwnershipObservation.js", () => ({ + createSystemProcessOwnershipHost: () => ({ listProcesses: async () => [] }), +})); +vi.mock("../../../dist/browser/BrowserProcessStartup.js", () => ({ + waitForBrowserDevtoolsPort: mock.port, +})); +afterEach(() => vi.restoreAllMocks()); + +interface FixtureLease { + readonly port: number; + close(): Promise; +} +type StartFixture = ( + executable: string, + origin: string, +) => Promise; + +const startFixture = async (): Promise => + z + .object({ + startRuntimeFixtureBrowser: z.custom( + (value) => typeof value === "function", + ), + }) + .parse( + await import( + new URL( + "../../../scripts/lib/browser-runtime-fixture-lifecycle.mjs", + import.meta.url, + ).href + ), + ).startRuntimeFixtureBrowser; + +const deferred = () => { + let resolve!: () => void; + const promise = new Promise((complete) => { + resolve = complete; + }); + return { promise, resolve }; +}; + +const fixture = async ( + mode: "empty targets" | "discovery timeout" | "malformed" | "exited", +) => { + let ready = false; + let requests = 0; + const listed = deferred(); + const published = deferred(); + const server = createServer((request, response) => { + requests += 1; + if (mode === "exited") { + listed.resolve(); + return; + } + if (mode === "malformed") { + response.end("{broken"); + return; + } + if (mode === "discovery timeout" && requests === 1) { + response.once("close", () => { + ready = true; + }); + return; + } + response.end( + JSON.stringify( + request.url === "/json/version" + ? { + Browser: "FixtureChrome/1", + "Protocol-Version": "1.3", + "User-Agent": "FixtureChrome", + "V8-Version": "1", + "WebKit-Version": "1", + webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/fixture`, + } + : ready + ? [{ id: "fixture", type: "page", title: "fixture", url: origin }] + : [], + ), + ); + if (request.url === "/json/list") listed.resolve(); + }); + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + const address = server.address(); + if (address === null || typeof address === "string") + throw new Error("Missing fixture address"); + const port = address.port; + const origin = `http://127.0.0.1:${port}`; + const child = new ChildProcess(); + let signalCode: NodeJS.Signals | null = null; + Object.defineProperty(child, "signalCode", { get: () => signalCode }); + vi.spyOn(child, "kill").mockImplementation(() => { + signalCode = "SIGTERM"; + child.emit("exit", null, "SIGTERM"); + return true; + }); + const cleanup = vi.fn(async () => ({ cleaned: true })); + mock.spawn.mockResolvedValue({ + process: child, + ownership: { processGroupId: 7 }, + cleanup, + }); + mock.port.mockImplementation(async () => { + published.resolve(); + return port; + }); + return { + origin, + listed: listed.promise, + published: published.promise, + cleanup, + exit: () => child.kill("SIGTERM"), + makeReady: () => { + ready = true; + }, + requests: () => requests, + close: async () => { + server.closeAllConnections(); + await new Promise((resolve) => server.close(() => resolve())); + }, + }; +}; + +it.each(["empty targets", "discovery timeout"] as const)( + "does not hand out the owned fixture while CDP has %s", + async (mode) => { + const start = await startFixture(); + const server = await fixture(mode); + const pending = start(process.execPath, server.origin); + let settled = false; + void pending.then( + () => { + settled = true; + }, + () => { + settled = true; + }, + ); + try { + await server.published; + await setImmediate(); + expect(settled).toBe(false); + if (mode === "empty targets") { + await server.listed; + expect(settled).toBe(false); + server.makeReady(); + } + await pending; + expect(server.requests()).toBeGreaterThanOrEqual(3); + } finally { + server.makeReady(); + await (await pending.catch(() => undefined))?.close(); + await server.close(); + } + }, +); + +it("preserves malformed discovery and closes the owned fixture", async () => { + const start = await startFixture(); + const server = await fixture("malformed"); + const pending = start(process.execPath, server.origin); + try { + await expect(pending).rejects.toMatchObject({ + reason: "invalid_endpoint_response", + }); + expect(server.requests()).toBe(1); + expect(server.cleanup).toHaveBeenCalledTimes(1); + } finally { + await (await pending.catch(() => undefined))?.close(); + await server.close(); + } +}); + +it("interrupts pending discovery when the owned fixture exits", async () => { + const start = await startFixture(); + const server = await fixture("exited"); + const pending = start(process.execPath, server.origin); + const rejected = expect(pending).rejects.toThrow( + "exited before CDP discovery", + ); + try { + await server.listed; + server.exit(); + await rejected; + expect(server.cleanup).toHaveBeenCalledTimes(1); + } finally { + await (await pending.catch(() => undefined))?.close(); + await server.close(); + } +});