mirror of
https://github.com/morluto/rea.git
synced 2026-11-21 14:05:49 +00:00
test(mcp): consolidate shutdown and retry lifecycle checks (#12847)
test(mcp): consolidate runtime shutdown and retry checks
This commit is contained in:
1 parent
18cd307b6e
commit
4edb900bdd
2 files changed
+82
-288
No files matched your search
@@ -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[] = [];
|
||||
|
||||
@@ -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 => ({
|
||||
|
||||
Reference in new issue
Block a user