test(mcp): consolidate shutdown and retry lifecycle checks (#12847)

test(mcp): consolidate runtime shutdown and retry checks
This commit is contained in:
morluto authored and GitHub committed 2026-11-20 09:14:54 -05:00
1 parent 18cd307b6e
commit 4edb900bdd
2 files changed
+82 -288

No files matched your search

+18 -173
View File
@@ -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<void> => {
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<never>((_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[] = [];
+64 -115
View File
@@ -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<number>();
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 => ({