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