test(mcp): consolidate browser provider probe ownership checks (#13166)

This commit is contained in:
morluto authored and GitHub committed 2026-11-21 17:41:50 +00:00
1 parent b5ba2f0f6e
commit 96d88a67c3
1 file changed
+112 -118
@@ -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<void>>()
.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<void>>()
.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<RuntimeDependencies["serve"]>[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<RuntimeDependencies["serve"]>[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();
}
});