From 4edb900bdd1211f76390b95cabc4a2c898198438 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Fri, 20 Nov 2026 09:14:54 -0500 Subject: [PATCH] test(mcp): consolidate shutdown and retry lifecycle checks (#12847) test(mcp): consolidate runtime shutdown and retry checks --- src/server/shutdownRegistration.test.ts | 191 +++--------------------- tests/boundary/mcp/shutdown.test.ts | 179 ++++++++-------------- 2 files changed, 82 insertions(+), 288 deletions(-) diff --git a/src/server/shutdownRegistration.test.ts b/src/server/shutdownRegistration.test.ts index fdb18a1e8c..343ed428e2 100644 --- a/src/server/shutdownRegistration.test.ts +++ b/src/server/shutdownRegistration.test.ts @@ -9,7 +9,6 @@ import { registerProcessShutdown, registerSignalShutdown, } from "../main/processShutdown.js"; -import type { McpServerHandle, RuntimeDependencies } from "../main/types.js"; import { createManagedBinarySession } from "../composition/binary.js"; it("registers only signals for a listener and reports the signal exit status", () => { @@ -37,8 +36,10 @@ it("names the signal that fired, passes none for stdin, and ignores stdin when t stdin: input, }); signals.emit("SIGINT"); + signals.emit("SIGTERM"); input.emit("end"); - expect(triggers).toEqual(["SIGINT", undefined]); + input.emit("close"); + expect(triggers).toEqual(["SIGINT", "SIGTERM", undefined, undefined]); withInput(); const signalsOnly = registerProcessShutdown( (signal) => triggers.push(signal), @@ -47,115 +48,26 @@ it("names the signal that fired, passes none for stdin, and ignores stdin when t signals.emit("SIGTERM"); input.emit("end"); input.emit("close"); - expect(triggers).toEqual(["SIGINT", undefined, "SIGTERM"]); + expect(triggers).toEqual([ + "SIGINT", + "SIGTERM", + undefined, + undefined, + "SIGTERM", + ]); signalsOnly(); signals.emit("SIGINT"); - expect(triggers).toEqual(["SIGINT", undefined, "SIGTERM"]); + expect(triggers).toEqual([ + "SIGINT", + "SIGTERM", + undefined, + undefined, + "SIGTERM", + ]); expect(input.listenerCount("end")).toBe(0); + expect(input.listenerCount("close")).toBe(0); }); -const shutdownEvents = ["SIGINT", "SIGTERM", "end", "close"] as const; - -const flush = async (): Promise => { - await new Promise((resolve) => setImmediate(resolve)); - await new Promise((resolve) => setImmediate(resolve)); -}; - -it.each(shutdownEvents)( - "retries failed cleanup after %s and unregisters every shutdown event on success", - async (event) => { - const signals = new EventEmitter(); - const input = new EventEmitter(); - const output: string[] = []; - const exitCodes: number[] = []; - let unregisterCount = 0; - let transportCloseCalls = 0; - let androidCloseCalls = 0; - let optionalCloseCalls = 0; - let sessionCloseCalls = 0; - const session = createManagedBinarySession(); - const originalSessionClose = session.close.bind(session); - session.close = async (...args) => { - sessionCloseCalls += 1; - return originalSessionClose(...args); - }; - const dependencies: RuntimeDependencies = { - env: {}, - serve: () => { - throw new Error("unused fixture transport"); - }, - writeStderr: (text) => output.push(text), - setExitCode: (code) => exitCodes.push(code), - registerShutdown: (handler) => { - const unregister = registerProcessShutdown(handler, { - signals, - stdin: input, - }); - return () => { - unregisterCount += 1; - unregister(); - }; - }, - }; - const handle: McpServerHandle = { - close: async () => { - transportCloseCalls += 1; - if (transportCloseCalls === 1) - throw new Error("first transport close failed"); - }, - }; - const lifecycle = createShutdown({ - handle, - closeAndroid: async () => { - androidCloseCalls += 1; - }, - closeOptionalProviders: async () => { - optionalCloseCalls += 1; - }, - session, - dependencies, - serverLogger: pino({ enabled: false }), - }); - - if (event === "SIGINT" || event === "SIGTERM") signals.emit(event); - else input.emit(event); - await flush(); - - expect([ - transportCloseCalls, - androidCloseCalls, - optionalCloseCalls, - ]).toEqual([1, 1, 1]); - expect(sessionCloseCalls).toBe(1); - expect(output).toHaveLength(1); - - if (event === "SIGINT" || event === "SIGTERM") signals.emit(event); - else input.emit(event); - await lifecycle.shutdown(); - - expect([ - transportCloseCalls, - androidCloseCalls, - optionalCloseCalls, - ]).toEqual([2, 1, 1]); - expect(sessionCloseCalls).toBe(1); - expect(unregisterCount).toBe(1); - expect(signals.listenerCount("SIGINT")).toBe(0); - expect(signals.listenerCount("SIGTERM")).toBe(0); - expect(input.listenerCount("end")).toBe(0); - expect(input.listenerCount("close")).toBe(0); - - signals.emit("SIGINT"); - input.emit("end"); - await flush(); - expect([ - transportCloseCalls, - androidCloseCalls, - optionalCloseCalls, - ]).toEqual([2, 1, 1]); - }, -); - it("keeps shared provider owners open when the transport preparation barrier fails", async () => { const events: string[] = []; let attempts = 0; @@ -205,73 +117,6 @@ it("keeps shared provider owners open when the transport preparation barrier fai ]); }); -it("joins concurrent shutdown events and retries only failed owners", async () => { - const signals = new EventEmitter(); - const input = new EventEmitter(); - const output: string[] = []; - let transportCloseCalls = 0; - let androidCloseCalls = 0; - let sessionCloseCalls = 0; - let releaseFirstClose: ((error: Error) => void) | undefined; - const session = createManagedBinarySession(); - const originalSessionClose = session.close.bind(session); - session.close = async (...args) => { - sessionCloseCalls += 1; - return originalSessionClose(...args); - }; - const dependencies: RuntimeDependencies = { - env: {}, - serve: () => { - throw new Error("unused fixture transport"); - }, - writeStderr: (text) => output.push(text), - setExitCode: () => undefined, - registerShutdown: (handler) => - registerProcessShutdown(handler, { signals, stdin: input }), - }; - const handle: McpServerHandle = { - close: async () => { - transportCloseCalls += 1; - if (transportCloseCalls === 1) - await new Promise((_resolve, reject) => { - releaseFirstClose = reject; - }); - }, - }; - createShutdown({ - handle, - closeAndroid: async () => { - androidCloseCalls += 1; - }, - session, - dependencies, - serverLogger: pino({ enabled: false }), - }); - - signals.emit("SIGINT"); - signals.emit("SIGTERM"); - await flush(); - expect([transportCloseCalls, androidCloseCalls, sessionCloseCalls]).toEqual([ - 1, 1, 1, - ]); - - if (releaseFirstClose === undefined) - throw new Error("First close attempt did not start"); - releaseFirstClose(new Error("first transport close failed")); - await flush(); - input.emit("end"); - await flush(); - - expect([transportCloseCalls, androidCloseCalls, sessionCloseCalls]).toEqual([ - 2, 1, 1, - ]); - expect(output.length).toBeGreaterThan(0); - expect(signals.listenerCount("SIGINT")).toBe(0); - expect(signals.listenerCount("SIGTERM")).toBe(0); - expect(input.listenerCount("end")).toBe(0); - expect(input.listenerCount("close")).toBe(0); -}); - it("latches the first startup signal, exits at once on a second, and hands the status over on release", () => { const signals = new EventEmitter(); const exits: number[] = []; diff --git a/tests/boundary/mcp/shutdown.test.ts b/tests/boundary/mcp/shutdown.test.ts index f5848cb4c7..939d637710 100644 --- a/tests/boundary/mcp/shutdown.test.ts +++ b/tests/boundary/mcp/shutdown.test.ts @@ -18,8 +18,11 @@ import { createEvidence } from "../../../src/domain/evidence.js"; import { createEvidenceBundle } from "../../../src/domain/evidenceBundle.js"; import { err, ok } from "../../../src/domain/result.js"; import { observed } from "../../fixtures/analysisExecution.js"; +import { phaseGate, settledCause } from "../../support/lifecycleHarness.js"; +import { waitFor } from "../../support/testWait.js"; import { createBinarySessionTargets, + createDeferred, createTestBinarySession, } from "../../fixtures/binarySession.js"; @@ -201,13 +204,16 @@ it("reports a typed binary cleanup failure and retains the client for retry", as expect((await session.close()).ok).toBe(true); }); -it("retries only failed cleanup owners after concurrent shutdown requests", async () => { - const requests: Array<() => void> = []; +it("joins stdin and signal shutdown, retaining investigation history until retry succeeds", async () => { + const stdin = new EventEmitter(); + const signals = new EventEmitter(); + const transport = phaseGate(); const logs: string[] = []; - const exitCodes: number[] = []; + const exitCode = createDeferred(); let unregisterCount = 0; let handleCalls = 0; let androidCalls = 0; + let optionalCalls = 0; let sessionCalls = 0; const dependencies: RuntimeDependencies = { env: {}, @@ -215,10 +221,11 @@ it("retries only failed cleanup owners after concurrent shutdown requests", asyn throw new Error("unused fixture transport"); }, writeStderr: () => undefined, - setExitCode: (code) => exitCodes.push(code), + setExitCode: exitCode.resolve, registerShutdown: (request) => { - requests.push(request); + const unregister = registerProcessShutdown(request, { signals, stdin }); return () => { + unregister(); unregisterCount += 1; }; }, @@ -276,13 +283,16 @@ it("retries only failed cleanup owners after concurrent shutdown requests", asyn handle: { close: async () => { handleCalls += 1; - if (handleCalls === 1) throw new Error("first handle close failed"); + if (handleCalls === 1) await transport.hold(); }, }, closeAndroid: async () => { androidCalls += 1; if (androidCalls === 1) throw new Error("first Android close failed"); }, + closeOptionalProviders: async () => { + optionalCalls += 1; + }, session, dependencies, serverLogger: pino( @@ -291,118 +301,57 @@ it("retries only failed cleanup owners after concurrent shutdown requests", asyn ), }); - const first = lifecycle.shutdown(); - const concurrent = lifecycle.shutdown(); - requests[0]?.(); - await expect(first).rejects.toBeInstanceOf(AggregateError); - await expect(concurrent).rejects.toBeInstanceOf(AggregateError); - await expect(first).rejects.toMatchObject({ - errors: [ + try { + expect(stdin.emit("end")).toBe(true); + await transport.reached(exitCode.promise, "transport cleanup"); + expect(signals.emit("SIGTERM")).toBe(true); + const first = settledCause(lifecycle.shutdown()); + const concurrent = settledCause(lifecycle.shutdown()); + transport.reject(new Error("first handle close failed")); + const failure = await first; + expect(failure).toBeInstanceOf(AggregateError); + expect(await concurrent).toBe(failure); + const causes = [ { message: "first handle close failed" }, { message: "first Android close failed" }, - ], - }); - await new Promise((resolve) => setImmediate(resolve)); - expect(exitCodes).toEqual([1]); - expect(logs.map((line) => JSON.parse(line))).toContainEqual( - expect.objectContaining({ - msg: "MCP shutdown rejected", - failure_cause: expect.objectContaining({ - errors: [ - expect.objectContaining({ message: "first handle close failed" }), - expect.objectContaining({ message: "first Android close failed" }), - ], - }), - }), - ); - expect([handleCalls, androidCalls, sessionCalls, unregisterCount]).toEqual([ - 1, 1, 1, 0, - ]); - // Engine cleanup succeeded, but the transport and Android owners failed. - // Investigation history remains available until their exact retries settle. - expect(session.activeTarget()).toBeUndefined(); - expect(session.exportEvidenceBundle()).toEqual(retained); - expect(session.listUnknowns()).toEqual([unknown.value]); + ]; + expect(failure).toMatchObject({ errors: causes }); + expect(await exitCode.promise).toBe(1); + const rejectionLog = logs + .map((line) => JSON.parse(line)) + .find((log) => log.msg === "MCP shutdown rejected"); + expect(rejectionLog).toMatchObject({ failure_cause: { errors: causes } }); + expect([ + handleCalls, + androidCalls, + optionalCalls, + sessionCalls, + unregisterCount, + ]).toEqual([1, 1, 1, 1, 0]); + expect(session.activeTarget()).toBeUndefined(); + expect(session.exportEvidenceBundle()).toEqual(retained); + expect(session.listUnknowns()).toEqual([unknown.value]); - await lifecycle.shutdown(); - expect([handleCalls, androidCalls, sessionCalls, unregisterCount]).toEqual([ - 2, 2, 1, 1, - ]); - expect(session.exportEvidenceBundle()).toEqual(createEvidenceBundle([])); - expect(session.listUnknowns()).toEqual([]); - await lifecycle.shutdown(); - expect([handleCalls, androidCalls, sessionCalls, unregisterCount]).toEqual([ - 2, 2, 1, 1, - ]); -}); - -it("retries failed MCP cleanup owners on a repeated signal and unregisters after success", async () => { - const signals = new EventEmitter(); - const stdin = new EventEmitter(); - const exitCodes: number[] = []; - let handleCalls = 0; - let androidCalls = 0; - let sessionCalls = 0; - let unregisterCalls = 0; - const dependencies: RuntimeDependencies = { - env: {}, - serve: () => { - throw new Error("unused fixture transport"); - }, - writeStderr: () => undefined, - setExitCode: (code) => exitCodes.push(code), - registerShutdown: (handler) => { - const unregister = registerProcessShutdown(handler, { signals, stdin }); - return () => { - unregisterCalls += 1; - unregister(); - }; - }, - }; - const session = createTestBinarySession(() => ({ - execute: async () => observed(null), - close: async () => { - sessionCalls += 1; - return ok(null); - }, - })); - const [target] = await createBinarySessionTargets(); - if (target === undefined) throw new Error("Missing fixture target"); - expect((await session.open(target)).ok).toBe(true); - createShutdown({ - handle: { - close: async () => { - handleCalls += 1; - if (handleCalls === 1) throw new Error("first handle close failed"); - }, - }, - closeAndroid: async () => { - androidCalls += 1; - if (androidCalls === 1) throw new Error("first Android close failed"); - }, - session, - dependencies, - serverLogger: pino({ enabled: false }), - }); - - signals.emit("SIGTERM"); - await new Promise((resolve) => setImmediate(resolve)); - expect([handleCalls, androidCalls, sessionCalls, unregisterCalls]).toEqual([ - 1, 1, 1, 0, - ]); - expect(exitCodes).toEqual([1]); - - signals.emit("SIGTERM"); - await new Promise((resolve) => setImmediate(resolve)); - expect([handleCalls, androidCalls, sessionCalls, unregisterCalls]).toEqual([ - 2, 2, 1, 1, - ]); - - signals.emit("SIGTERM"); - await new Promise((resolve) => setImmediate(resolve)); - expect([handleCalls, androidCalls, sessionCalls, unregisterCalls]).toEqual([ - 2, 2, 1, 1, - ]); + expect(signals.emit("SIGTERM")).toBe(true); + await waitFor(() => expect(unregisterCount).toBe(1)); + expect(signals.emit("SIGINT")).toBe(false); + expect(signals.emit("SIGTERM")).toBe(false); + expect(stdin.emit("end")).toBe(false); + expect(stdin.emit("close")).toBe(false); + await lifecycle.shutdown(); + expect([ + handleCalls, + androidCalls, + optionalCalls, + sessionCalls, + unregisterCount, + ]).toEqual([2, 2, 1, 1, 1]); + expect(session.exportEvidenceBundle()).toEqual(createEvidenceBundle([])); + expect(session.listUnknowns()).toEqual([]); + } finally { + transport.release(); + await settledCause(lifecycle.shutdown()); + } }); const idleShutdownDependencies = (): RuntimeDependencies => ({