test(browser): await discoverable fixture pages before runtime verification
This commit is contained in:
@@ -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 =
|
||||
|
||||
@@ -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<void>;
|
||||
}
|
||||
type StartFixture = (
|
||||
executable: string,
|
||||
origin: string,
|
||||
) => Promise<FixtureLease>;
|
||||
|
||||
const startFixture = async (): Promise<StartFixture> =>
|
||||
z
|
||||
.object({
|
||||
startRuntimeFixtureBrowser: z.custom<StartFixture>(
|
||||
(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<void>((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<void>((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<void>((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();
|
||||
}
|
||||
});
|
||||
Reference in New Issue
Block a user