Files
rea/tests/boundary/browser/runtimeFixtureReadiness.test.ts
T

201 lines
5.7 KiB
TypeScript

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();
}
});