From 33d1c6ee44773c7874fe3aeea0bb2e016e108e72 Mon Sep 17 00:00:00 2001
From: morluto <76467478+morluto@users.noreply.github.com>
Date: Sat, 21 Nov 2026 15:00:35 -0500
Subject: [PATCH] test(web): control CDP teardown timing and consolidate
cleanup proof (#13199)
---
.../browser/cdpCleanupCancellation.test.ts | 179 ++++++++++--------
.../cdpProviderCleanupOwnership.test.ts | 63 +++---
.../cdpProviderCloseComposition.test.ts | 69 +++----
3 files changed, 148 insertions(+), 163 deletions(-)
diff --git a/tests/boundary/browser/cdpCleanupCancellation.test.ts b/tests/boundary/browser/cdpCleanupCancellation.test.ts
index 390d664745..bdc7b1775a 100644
--- a/tests/boundary/browser/cdpCleanupCancellation.test.ts
+++ b/tests/boundary/browser/cdpCleanupCancellation.test.ts
@@ -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, "fixture");
@@ -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 | undefined;
- const timeout = new Promise((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);
});
diff --git a/tests/boundary/browser/cdpProviderCleanupOwnership.test.ts b/tests/boundary/browser/cdpProviderCleanupOwnership.test.ts
index edb801456b..2dc03616db 100644
--- a/tests/boundary/browser/cdpProviderCleanupOwnership.test.ts
+++ b/tests/boundary/browser/cdpProviderCleanupOwnership.test.ts
@@ -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 => {
- const close = Reflect.get(provider, "close") as
- | (() => Promise)
- | 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)
- | 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>
- | 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");
diff --git a/tests/boundary/browser/cdpProviderCloseComposition.test.ts b/tests/boundary/browser/cdpProviderCloseComposition.test.ts
index 5efeda6801..6acb6a82df 100644
--- a/tests/boundary/browser/cdpProviderCloseComposition.test.ts
+++ b/tests/boundary/browser/cdpProviderCloseComposition.test.ts
@@ -16,15 +16,6 @@ const cleanupFailure = (resource: string) =>
{ operation: "fixture_close" },
);
-const closeFailure = async (close: () => Promise): Promise => {
- 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);
},
);