test(web): control CDP teardown timing and consolidate cleanup proof (#13199)

This commit is contained in:
morluto authored and GitHub committed 2026-11-21 20:00:35 +00:00
1 parent 559956cf6b
commit 33d1c6ee44
3 files changed
+148 -163

No files matched your search

@@ -15,56 +15,109 @@ import { observeWebSessionInputSchema } from "../../../src/domain/browserSession
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
import { inspectElectronPageInputSchema } from "../../../src/domain/javascript/electronObservation.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
import { startFakeCdpBrowser } from "../../fixtures/fakeCdpBrowser.js";
import {
startFakeCdpBrowser,
type FakeCdpBrowser,
} from "../../fixtures/fakeCdpBrowser.js";
import { phaseArrival } from "../../support/lifecycleHarness.js";
import { waitFor } from "../../support/testWait.js";
it.each(["Page.disable", "Target.detachFromTarget"])(
"finishes caller cancellation even when %s has no response",
async (hangOnMethod) => {
const browser = await startFakeCdpBrowser({ hangOnMethod });
onTestFinished(async () => {
const releaseFixture = (
provider: CdpBrowserProvider | CdpElectronProvider,
browser: FakeCdpBrowser,
) =>
onTestFinished(async () => {
if (vi.isFakeTimers()) vi.useRealTimers();
try {
await provider.close();
} finally {
await browser.close();
});
const controller = new AbortController();
const result = await new CdpBrowserProvider().observeSession(
observeWebSessionInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 1_000,
}),
{
signal: controller.signal,
progress: {
report(update) {
if (update.completed === 1) controller.abort();
return Promise.resolve();
},
}
});
const expectReleasedSession = async (browser: FakeCdpBrowser) => {
const methods = browser.commands.map(({ method }) => method);
expect(methods).toContain("Target.detachFromTarget");
expect(methods).not.toContain("Target.closeTarget");
expect(methods).not.toContain("Browser.close");
await waitFor(() => expect(browser.activeConnectionCount()).toBe(0));
};
it.each([
{
name: "skips optional domain shutdown for an already cancelled session",
hangOnMethod: "Page.disable",
},
{
name: "closes a cancelled session when the detach reply never arrives",
hangOnMethod: "Target.detachFromTarget",
},
])("$name", async ({ hangOnMethod }) => {
const detach = phaseArrival();
const browser = await startFakeCdpBrowser({
hangOnMethod,
commandError({ method }) {
if (method === "Target.detachFromTarget") detach.arrive();
return undefined;
},
});
const provider = new CdpBrowserProvider();
releaseFixture(provider, browser);
const controller = new AbortController();
const stallsDetach = hangOnMethod === "Target.detachFromTarget";
if (stallsDetach)
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
const operation = provider.observeSession(
observeWebSessionInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 1_000,
}),
{
signal: controller.signal,
progress: {
async report(update) {
if (update.completed === 1) controller.abort();
},
},
);
expect(result).toMatchObject({
},
);
try {
if (stallsDetach) {
await detach.reached(operation, "stalled target detach");
expect(browser.activeConnectionCount()).toBe(1);
await vi.advanceTimersByTimeAsync(1_000);
}
expect(await operation).toMatchObject({
ok: false,
error: {
_tag: "AnalysisCancelledError",
operation: "observe_web_session",
},
});
const methods = browser.commands.map(({ method }) => method);
expect(methods).toContain("Target.detachFromTarget");
expect(methods).not.toContain("Target.closeTarget");
expect(methods).not.toContain("Browser.close");
await waitFor(() => expect(browser.activeConnectionCount()).toBe(0));
},
);
} finally {
if (stallsDetach) vi.useRealTimers();
}
expect(browser.commands.map(({ method }) => method)).not.toContain(
"Page.disable",
);
await expectReleasedSession(browser);
});
it("releases cleanup when cancellation arrives after capture completes", async () => {
const browser = await startFakeCdpBrowser({ hangOnMethod: "Page.disable" });
onTestFinished(async () => {
await browser.close();
const disabling = phaseArrival();
const browser = await startFakeCdpBrowser({
hangOnMethod: "Page.disable",
commandError({ method }) {
if (method === "Page.disable") disabling.arrive();
return undefined;
},
});
const provider = new CdpBrowserProvider();
releaseFixture(provider, browser);
const controller = new AbortController();
const pending = new CdpBrowserProvider().observeSession(
const pending = provider.observeSession(
observeWebSessionInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
@@ -73,11 +126,7 @@ it("releases cleanup when cancellation arrives after capture completes", async (
}),
{ signal: controller.signal },
);
await waitFor(() => {
expect(
browser.commands.some(({ method }) => method === "Page.disable"),
).toBe(true);
});
await disabling.reached(pending, "optional page shutdown");
controller.abort();
const result = await pending;
expect(result).toMatchObject({
@@ -87,13 +136,7 @@ it("releases cleanup when cancellation arrives after capture completes", async (
operation: "observe_web_session",
},
});
expect(browser.commands.map(({ method }) => method)).toContain(
"Target.detachFromTarget",
);
await waitFor(() => expect(browser.activeConnectionCount()).toBe(0));
const methods = browser.commands.map(({ method }) => method);
expect(methods).not.toContain("Target.closeTarget");
expect(methods).not.toContain("Browser.close");
await expectReleasedSession(browser);
expect((await fetch(`${browser.endpoint}/json/version`)).ok).toBe(true);
});
@@ -107,10 +150,7 @@ it("retains the page inspection when bundle cleanup is cancelled", async () => {
},
});
const provider = new CdpBrowserProvider();
onTestFinished(async () => {
await provider.close();
await browser.close();
});
releaseFixture(provider, browser);
const result = await provider.analyzeBundle(
analyzeWebBundleInputSchema.parse({
@@ -118,6 +158,7 @@ it("retains the page inspection when bundle cleanup is cancelled", async () => {
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
fetch_source_maps: false,
observation_ms: 0,
}),
{ signal: controller.signal },
);
@@ -136,7 +177,7 @@ it("retains the page inspection when bundle cleanup is cancelled", async () => {
await waitFor(() => expect(browser.activeConnectionCount()).toBe(0));
});
it("closes an Electron inspection session when cleanup is cancelled", async () => {
it("skips optional Electron shutdown after cancellation at the structural read", async () => {
const root = await createTestTempDirectory("rea-electron-cancel-");
const page = join(root, "index.html");
await writeFile(page, "<main>fixture</main>");
@@ -144,15 +185,14 @@ it("closes an Electron inspection session when cleanup is cancelled", async () =
electronFileUrl: pathToFileURL(page).href,
hangOnMethod: "Page.disable",
});
onTestFinished(async () => {
await browser.close();
});
const provider = new CdpElectronProvider();
releaseFixture(provider, browser);
const controller = new AbortController();
const pending = new CdpElectronProvider().inspectPage(
const result = await provider.inspectPage(
inspectElectronPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
target_id: "electron-page",
observation_ms: 1_000,
observation_ms: 0,
}),
{
signal: controller.signal,
@@ -164,14 +204,6 @@ it("closes an Electron inspection session when cleanup is cancelled", async () =
},
},
);
let timeoutId: ReturnType<typeof setTimeout> | undefined;
const timeout = new Promise<null>((resolveTimeout) => {
timeoutId = setTimeout(() => resolveTimeout(null), 2_000);
});
const result = await Promise.race([pending, timeout]);
if (timeoutId !== undefined) clearTimeout(timeoutId);
expect(result).not.toBeNull();
expect(result).toMatchObject({
ok: false,
error: {
@@ -181,10 +213,7 @@ it("closes an Electron inspection session when cleanup is cancelled", async () =
});
const methods = browser.commands.map(({ method }) => method);
expect(methods).not.toContain("Page.disable");
expect(methods).toContain("Target.detachFromTarget");
expect(methods).not.toContain("Target.closeTarget");
expect(methods).not.toContain("Browser.close");
await waitFor(() => expect(browser.activeConnectionCount()).toBe(0));
await expectReleasedSession(browser);
expect((await fetch(`${browser.endpoint}/json/version`)).ok).toBe(true);
});
@@ -202,11 +231,10 @@ it("classifies cancellation that arrives during final Electron detach", async ()
return { code: -32_000, message: "controlled detach rejection" };
},
});
onTestFinished(async () => {
await browser.close();
});
const provider = new CdpElectronProvider();
releaseFixture(provider, browser);
const result = await new CdpElectronProvider().inspectPage(
const result = await provider.inspectPage(
inspectElectronPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
target_id: "electron-page",
@@ -232,10 +260,7 @@ it("classifies cancellation that arrives during final Electron detach", async ()
});
const methods = browser.commands.map(({ method }) => method);
expect(methods).toContain("Page.getFrameTree");
expect(methods).toContain("Target.detachFromTarget");
expect(methods).not.toContain("Target.closeTarget");
expect(methods).not.toContain("Browser.close");
await waitFor(() => expect(browser.activeConnectionCount()).toBe(0));
await expectReleasedSession(browser);
expect((await fetch(`${browser.endpoint}/json/version`)).ok).toBe(true);
});
@@ -10,16 +10,7 @@ import { ProviderCleanupError } from "../../../src/domain/providerCleanupError.j
import { inspectElectronPageInputSchema } from "../../../src/domain/javascript/electronObservation.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
import { startFakeCdpBrowser } from "../../fixtures/fakeCdpBrowser.js";
const retryProviderCleanup = async (
provider: CdpElectronProvider,
): Promise<void> => {
const close = Reflect.get(provider, "close") as
| (() => Promise<void>)
| undefined;
expect(close).toBeTypeOf("function");
await close?.call(provider);
};
import { waitFor } from "../../support/testWait.js";
it.each([
["keeps a completed inspection", false],
@@ -47,11 +38,11 @@ it.each([
});
const provider = new CdpElectronProvider();
onTestFinished(async () => {
const closeProvider = Reflect.get(provider, "close") as
| (() => Promise<void>)
| undefined;
if (closeProvider !== undefined) await closeProvider.call(provider);
await browser.close();
try {
await provider.close();
} finally {
await browser.close();
}
});
const close = vi
@@ -62,43 +53,33 @@ it.each([
const terminate = vi
.spyOn(WebSocket.prototype, "terminate")
.mockImplementation(() => undefined);
let result:
| Awaited<ReturnType<CdpElectronProvider["inspectPage"]>>
| undefined;
try {
result = await provider.inspectPage(
const result = await provider
.inspectPage(
inspectElectronPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
target_id: "electron-page",
observation_ms: 0,
}),
);
} catch {
// The assertion below requires the provider to report cleanup as typed data.
} finally {
close.mockRestore();
terminate.mockRestore();
}
)
.finally(() => {
close.mockRestore();
terminate.mockRestore();
});
expect(result).toBeDefined();
if (result.ok) throw new Error("Expected cleanup failure");
if (failCapture) {
expect(result).toMatchObject({
ok: false,
error: {
_tag: "ProviderAdapterError",
cleanupIncomplete: true,
diagnostics: {
primary_error: { code: "unreadable_output" },
cleanup_error: expect.any(Object),
},
expect(result.error).toMatchObject({
_tag: "ProviderAdapterError",
cleanupIncomplete: true,
diagnostics: {
primary_error: { code: "unreadable_output" },
cleanup_error: expect.any(Object),
},
});
expect(browser.commands.map(({ method }) => method)).toContain(
"Page.getFrameTree",
);
} else {
expect(result).toMatchObject({ ok: false });
if (!result || result.ok) throw new Error("Expected cleanup failure");
expect(result.error).toBeInstanceOf(ProviderCleanupError);
expect(result.error).toMatchObject({
cleanupIncomplete: true,
@@ -114,7 +95,9 @@ it.each([
});
}
await retryProviderCleanup(provider);
expect(browser.activeConnectionCount()).toBe(1);
await provider.close();
await waitFor(() => expect(browser.activeConnectionCount()).toBe(0));
const methods = browser.commands.map(({ method }) => method);
expect(methods).not.toContain("Target.closeTarget");
expect(methods).not.toContain("Browser.close");
@@ -16,15 +16,6 @@ const cleanupFailure = (resource: string) =>
{ operation: "fixture_close" },
);
const closeFailure = async (close: () => Promise<void>): Promise<unknown> => {
try {
await close();
} catch (cause: unknown) {
return cause;
}
throw new Error("Expected close to fail");
};
const providers = [
{
name: "CdpBrowserProvider",
@@ -48,21 +39,31 @@ const providers = [
},
] as const;
it.each(providers)(
"$name keeps both close failures and completes only after both release",
async ({ providerId, operation, create, failSecondClose }) => {
it.each(
providers.flatMap((provider) =>
(["owned", "untyped"] as const).map((secondary) => ({
...provider,
secondary,
})),
),
)(
"$name reports both close failures with an $secondary secondary cause",
async ({ providerId, operation, create, failSecondClose, secondary }) => {
onTestFinished(() => {
vi.restoreAllMocks();
});
const transport = cleanupFailure("transport-handle");
const second = cleanupFailure("second-handle");
const second =
secondary === "owned"
? cleanupFailure("second-handle")
: new Error("untyped close failure");
vi.spyOn(CdpTargetSessionOwner.prototype, "close").mockRejectedValueOnce(
transport,
);
failSecondClose(second);
const provider = create();
const composite = await closeFailure(() => provider.close());
const composite = await provider.close().catch((cause: unknown) => cause);
if (!(composite instanceof ProviderCleanupError))
throw new Error("Expected a provider cleanup failure");
@@ -70,7 +71,10 @@ it.each(providers)(
providerId,
operation,
cleanupIncomplete: true,
cleanupResources: ["transport-handle", "second-handle"],
cleanupResources:
secondary === "owned"
? ["transport-handle", "second-handle"]
: ["transport-handle"],
});
expect(composite.cause).toBeInstanceOf(AggregateError);
expect((composite.cause as AggregateError).errors).toEqual([
@@ -79,37 +83,10 @@ it.each(providers)(
]);
releaseOwnedCleanup(transport);
expect(composite.cleanupIncomplete).toBe(true);
releaseOwnedCleanup(second);
expect(composite.cleanupIncomplete).toBe(false);
},
);
it.each(providers)(
"$name keeps an untyped close failure in the cause without owning its completion",
async ({ create, failSecondClose }) => {
onTestFinished(() => {
vi.restoreAllMocks();
});
const transport = cleanupFailure("transport-handle");
const untyped = new Error("untyped close failure");
vi.spyOn(CdpTargetSessionOwner.prototype, "close").mockRejectedValueOnce(
transport,
);
failSecondClose(untyped);
const provider = create();
const composite = await closeFailure(() => provider.close());
if (!(composite instanceof ProviderCleanupError))
throw new Error("Expected a provider cleanup failure");
expect(composite.cleanupResources).toEqual(["transport-handle"]);
expect((composite.cause as AggregateError).errors).toEqual([
transport,
untyped,
]);
expect(composite.cleanupIncomplete).toBe(true);
releaseOwnedCleanup(transport);
if (second instanceof ProviderCleanupError) {
expect(composite.cleanupIncomplete).toBe(true);
releaseOwnedCleanup(second);
}
expect(composite.cleanupIncomplete).toBe(false);
},
);