From 96d88a67c31da87bf470629e9c90fcddb8d275fc Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Sat, 21 Nov 2026 12:41:50 -0500 Subject: [PATCH] test(mcp): consolidate browser provider probe ownership checks (#13166) --- .../browserScenarioProbeLifecycle.test.ts | 230 +++++++++--------- 1 file changed, 112 insertions(+), 118 deletions(-) diff --git a/tests/boundary/process/browserScenarioProbeLifecycle.test.ts b/tests/boundary/process/browserScenarioProbeLifecycle.test.ts index 7614e0e6df..2fa52f58b3 100644 --- a/tests/boundary/process/browserScenarioProbeLifecycle.test.ts +++ b/tests/boundary/process/browserScenarioProbeLifecycle.test.ts @@ -10,14 +10,25 @@ import type { RuntimeDependencies } from "../../../src/main/types.js"; import { createToolResultDelivery } from "../../../src/server/toolResult.js"; import { createTestBinarySession } from "../../fixtures/binarySession.js"; -it("keeps the shared browser scenario provider open when the SDK discards its discovery probe", async () => { +import { controlledCleanup } from "../../support/lifecycleHarness.js"; + +const openTransport = async ( + serve: RuntimeDependencies["serve"], + refuseCleanup = false, +) => { const session = createTestBinarySession(() => { throw new Error("Unexpected deep provider"); }); - const scenarioClose = vi - .fn<() => Promise>() - .mockRejectedValueOnce(new Error("Scenario cleanup failed")) - .mockResolvedValue(undefined); + const scenarioFailure = new Error("Scenario cleanup failed"); + const activeFailure = new Error("Fuse preflight cleanup failed"); + const scenario = controlledCleanup({ + refused: refuseCleanup, + failure: scenarioFailure, + }); + const active = controlledCleanup({ + refused: refuseCleanup, + failure: activeFailure, + }); const browserObservation = createBrowserObservationProvider(); const browserClose = vi .spyOn(browserObservation, "close") @@ -35,12 +46,8 @@ it("keeps the shared browser scenario provider open when the SDK discards its di captureScenario: async () => { throw new Error("Unexpected scenario capture"); }, - close: scenarioClose, + close: scenario.close, }; - const activeClose = vi - .fn<() => Promise>() - .mockRejectedValueOnce(new Error("Fuse preflight cleanup failed")) - .mockResolvedValue(undefined); const electronActiveObservation = { identity: () => ({ id: "active-electron", @@ -50,127 +57,114 @@ it("keeps the shared browser scenario provider open when the SDK discards its di capture: async () => { throw new Error("Unexpected Electron capture"); }, - close: activeClose, + close: active.close, }; - const factories: Parameters[0][] = []; - const runtime: RuntimeDependencies = { - env: {}, - serve: (factory) => { - factories.push(factory); - return { close: async () => undefined }; + const transport = await startMcpTransport( + { + env: {}, + serve, + writeStderr: () => undefined, + setExitCode: () => undefined, + registerShutdown: () => () => undefined, }, - writeStderr: () => undefined, - setExitCode: () => undefined, - registerShutdown: () => () => undefined, - }; - const transport = await startMcpTransport(runtime, session, { - logger: silentLogger, - serverLogger: silentLogger, - environment: runtime.env, - delivery: createToolResultDelivery(STDIO_DEFAULT_MAX_BUFFER_SIZE), - loadOptionalProviders: async () => ({ - browserObservation, - browserScenarioCapture, - electronObservation, - electronActiveObservation, - }), - }); - if (!transport.ok) throw new Error("Transport failed"); - const factory = factories[0]; - if (factory === undefined) throw new Error("Missing SDK server factory"); - try { - const probe = await factory({ era: "modern" }); - await probe.close(); - const replacement = await factory({ era: "legacy" }); - await replacement.close(); - expect(browserClose).not.toHaveBeenCalled(); - expect(scenarioClose).not.toHaveBeenCalled(); - expect(electronClose).not.toHaveBeenCalled(); - expect(activeClose).not.toHaveBeenCalled(); - - await expect(transport.closeOptionalProviders()).rejects.toMatchObject({ - errors: [ - expect.objectContaining({ message: "Scenario cleanup failed" }), - expect.objectContaining({ message: "Fuse preflight cleanup failed" }), - ], - }); - expect(browserClose).toHaveBeenCalledTimes(1); - expect(scenarioClose).toHaveBeenCalledTimes(1); - expect(activeClose).toHaveBeenCalledTimes(1); - expect(electronClose).toHaveBeenCalledTimes(1); - await transport.closeOptionalProviders(); - await transport.closeOptionalProviders(); - expect(browserClose).toHaveBeenCalledTimes(1); - expect(scenarioClose).toHaveBeenCalledTimes(2); - expect(activeClose).toHaveBeenCalledTimes(2); - expect(electronClose).toHaveBeenCalledTimes(1); - } finally { - await transport.closeAndroid(); - await session.close(); - } -}); - -it("closes optional providers when MCP server startup throws", async () => { - const session = createTestBinarySession(() => { - throw new Error("Unexpected deep provider"); - }); - const scenarioClose = vi.fn(async () => undefined); - const browserObservation = createBrowserObservationProvider(); - const browserClose = vi - .spyOn(browserObservation, "close") - .mockResolvedValue(undefined); - const electronObservation = createElectronObservationProvider({}); - const electronClose = vi - .spyOn(electronObservation, "close") - .mockResolvedValue(undefined); - const browserScenarioCapture: BrowserScenarioCapturePort = { - identity: () => ({ - id: "fake-browser", - name: "Fake browser", - version: "1", - }), - captureScenario: async () => { - throw new Error("Unexpected scenario capture"); - }, - close: scenarioClose, - }; - const runtime: RuntimeDependencies = { - env: {}, - serve: () => { - throw new Error("Server startup failed"); - }, - writeStderr: () => undefined, - setExitCode: () => undefined, - registerShutdown: () => () => undefined, - }; - try { - const transport = await startMcpTransport(runtime, session, { + session, + { logger: silentLogger, serverLogger: silentLogger, - environment: runtime.env, + environment: {}, delivery: createToolResultDelivery(STDIO_DEFAULT_MAX_BUFFER_SIZE), loadOptionalProviders: async () => ({ browserObservation, browserScenarioCapture, electronObservation, + electronActiveObservation, }), + }, + ); + const allowCleanup = () => { + scenario.allow(); + active.allow(); + }; + return { + transport, + allowCleanup, + failures: [scenarioFailure, activeFailure], + attempts: () => ({ + browser: browserClose.mock.calls.length, + scenario: scenario.attempts, + electron: electronClose.mock.calls.length, + active: active.attempts, + }), + close: async () => { + allowCleanup(); + try { + await transport.handle.close(); + } finally { + await Promise.all([ + transport.closeAndroid(), + transport.closeOptionalProviders(), + session.close(), + ]); + } + }, + }; +}; + +it("keeps the shared browser scenario provider open when the SDK discards its discovery probe", async () => { + let factory: Parameters[0] | undefined; + const fixture = await openTransport((create) => { + factory = create; + return { close: async () => undefined }; + }, true); + try { + const { transport } = fixture; + if (!transport.ok || factory === undefined) + throw new Error("Expected SDK server factory after transport startup"); + for (const era of ["modern", "legacy"] as const) { + const server = await factory({ era }); + await server.close(); + expect(fixture.attempts()).toEqual({ + browser: 0, + scenario: 0, + electron: 0, + active: 0, + }); + } + await expect(transport.closeOptionalProviders()).rejects.toMatchObject({ + errors: fixture.failures, + }); + expect(fixture.attempts()).toEqual({ + browser: 1, + scenario: 1, + electron: 1, + active: 1, }); - expect(transport).toMatchObject({ - ok: false, - cancelled: false, - handle: { close: expect.any(Function) }, - closeAndroid: expect.any(Function), - closeOptionalProviders: expect.any(Function), - }); - // Failed admission still returns partial owners for idempotent retries. - await transport.handle.close(); + fixture.allowCleanup(); await transport.closeOptionalProviders(); - await transport.closeAndroid(); - expect(browserClose).toHaveBeenCalledTimes(1); - expect(scenarioClose).toHaveBeenCalledTimes(1); - expect(electronClose).toHaveBeenCalledTimes(1); + await transport.closeOptionalProviders(); + expect(fixture.attempts()).toEqual({ + browser: 1, + scenario: 2, + electron: 1, + active: 2, + }); } finally { - await session.close(); + await fixture.close(); + } +}); + +it("closes optional providers when MCP server startup throws", async () => { + const fixture = await openTransport(() => { + throw new Error("Server startup failed"); + }); + try { + expect(fixture.transport).toMatchObject({ ok: false, cancelled: false }); + const released = { browser: 1, scenario: 1, electron: 1, active: 1 }; + expect(fixture.attempts()).toEqual(released); + await fixture.close(); + expect(fixture.attempts()).toEqual(released); + } finally { + await fixture.close(); } });