test(mcp): consolidate debugger retirement evidence checks (#13014)

* test(mcp): consolidate debugger retirement evidence checks

* test(mcp): require server cancellation after debugger retirement
This commit is contained in:
morluto authored and GitHub committed 2026-11-21 06:40:39 +00:00
1 parent 91a68a8b7c
commit 72a8ae01a3
2 files changed
+88 -117

No files matched your search

@@ -21,10 +21,13 @@ import {
import { phaseGate } from "../../support/lifecycleHarness.js";
import { waitFor } from "../../support/testWait.js";
import { createMcpSchemaValidation } from "../../fixtures/mcpSchemaValidation.js";
import type { BinarySession } from "../../../src/application/binary/BinarySession.js";
import { ToolResultDelivery } from "../../../src/server/ToolResultDelivery.js";
import { parseMcpToolError } from "../../fixtures/mcpToolError.js";
const SESSION_ID = "00000000-0000-4000-8000-000000000001";
type RecordEvidence = (evidence: Evidence) => Result<"added", AnalysisError>;
type RecordEvidence = BinarySession["recordEvidence"];
/**
* The debugger operations each lifecycle regression drives, independent of
@@ -274,11 +277,9 @@ describe.each([RIZIN, GDB, CUTTER])(
retryCleanup: async () => ok(null),
...overrides,
};
const recorded: Evidence[] = [];
const server = debuggerTools.serve(operations, session, (evidence) => {
recorded.push(evidence);
return ok("added" as const);
});
const server = debuggerTools.serve(operations, session, (evidence) =>
session.recordEvidence(evidence),
);
const client = new Client(
{ name: "debugger-lifecycle", version: "1" },
{ jsonSchemaValidator: createMcpSchemaValidation() },
@@ -292,15 +293,16 @@ describe.each([RIZIN, GDB, CUTTER])(
InMemoryTransport.createLinkedPair();
await server.connect(serverTransport);
await client.connect(clientTransport);
return { client, recorded };
return { client, session };
};
it("retries a failed debugger cleanup before the next mutation and keeps it owned while it fails", async () => {
const detach = ownedDetachFailure(debuggerTools.command.name);
const completed = debuggerTools.evidence();
const execute = vi
.fn<Operations["execute"]>()
.mockResolvedValueOnce(err(detach.error))
.mockImplementation(async () => ok(debuggerTools.evidence()));
.mockResolvedValue(ok(completed));
const start = vi.fn<Operations["start"]>(async () => ok(null));
const retryCleanup = vi
.fn<Operations["retryCleanup"]>()
@@ -310,7 +312,7 @@ describe.each([RIZIN, GDB, CUTTER])(
return ok(null);
});
const operations = { execute, start, retryCleanup };
const { client } = await connect(operations);
const { client, session } = await connect(operations);
const next = operations[debuggerTools.next.runs as "execute" | "start"];
const failed = await client.callTool(debuggerTools.command);
@@ -327,6 +329,12 @@ describe.each([RIZIN, GDB, CUTTER])(
expect(admitted.isError ?? false, JSON.stringify(admitted)).toBe(false);
expect(retryCleanup).toHaveBeenCalledTimes(2);
expect(next).toHaveBeenCalledTimes(nextCalls + 1);
if (debuggerTools.next.runs === "execute") {
expect(admitted.structuredContent).toMatchObject({
evidence_id: completed.evidence_id,
});
expect(session.evidenceById(completed.evidence_id)).toEqual(completed);
}
});
it("keeps a completed command's Evidence when cancellation arrives during final cleanup", async () => {
@@ -348,23 +356,44 @@ describe.each([RIZIN, GDB, CUTTER])(
expect((await session.open(target)).ok).toBe(true);
const completed = debuggerTools.evidence();
const execute = vi.fn(async () => ok(completed));
const { client, recorded } = await connect({ execute }, session);
const { client } = await connect({ execute }, session);
const partial = vi.spyOn(
ToolResultDelivery.prototype,
"toPartialErrorToolResult",
);
onTestFinished(() => {
partial.mockRestore();
});
const controller = new AbortController();
const command = client
.callTool(debuggerTools.command, { signal: controller.signal })
.catch(() => undefined);
.catch((cause: unknown) => cause);
await retiring.reached(command, "analysis retirement close");
expect(execute).toHaveBeenCalledOnce();
expect(session.hasEvidence(completed.evidence_id)).toBe(false);
controller.abort();
await client.ping();
retiring.release();
await command;
// Retirement still completes, and the completed command's Evidence is
// retained through the session writer as the cancellation's partial.
expect(await command).toBeInstanceOf(Error);
// The SDK suppresses replies to cancelled calls. Observe the canonical
// server result so client rejection alone cannot satisfy the test.
await waitFor(() =>
expect(recorded.map(({ evidence_id }) => evidence_id)).toContain(
completed.evidence_id,
),
expect(session.hasEvidence(completed.evidence_id)).toBe(true),
);
expect(partial).toHaveBeenCalledOnce();
const delivery = partial.mock.results[0];
if (delivery?.type !== "return")
throw new Error("Missing server cancellation result");
expect(parseMcpToolError(delivery.value)).toMatchObject({
error: {
code: "cancelled",
details: {
partial_observation: { evidence_id: completed.evidence_id },
},
},
});
expect(session.evidenceById(completed.evidence_id)).toEqual(completed);
expect(session.activeTarget()).toBeUndefined();
});
@@ -1,14 +1,6 @@
import { unknownTarget } from "../../../src/domain/targetIdentity.js";
import type { CallToolResult } from "@modelcontextprotocol/server";
import { expect, it, vi } from "vitest";
import { phaseGate } from "../../support/lifecycleHarness.js";
import type { EvidenceMcpServer } from "../../../src/server/EvidenceMcpServer.js";
import {
registerServiceTools,
type GdbToolOptions,
} from "../../../src/server/serviceToolBindings.js";
import { createToolResultDelivery } from "../../../src/server/toolResult.js";
import { silentLogger } from "../../../src/logger.js";
import { createEvidence } from "../../../src/domain/evidence.js";
import { ok, err } from "../../../src/domain/result.js";
import { AnalysisInputError } from "../../../src/domain/analysisErrorCore.js";
@@ -27,101 +19,51 @@ import {
} from "../../fixtures/binarySession.js";
import { releaseOwnedCleanup } from "../../support/cleanupRelease.js";
it("compares cancellation before dispatch, during retirement, and an uncancelled control", async () => {
for (const mode of ["pre-aborted", "during-retirement", "control"] as const) {
const [target] = await createBinarySessionTargets();
const sessionRetirement = phaseGate();
let closes = 0;
const session = createTestBinarySession(
() =>
({
execute: async () => ok({ operation: "health", value: null }),
close: async () => {
closes++;
await sessionRetirement.hold();
return ok(null);
},
}) as never,
);
expect((await session.open(target)).ok).toBe(true);
const id = "00000000-0000-4000-8000-000000000001";
const evidence = createEvidence(
unknownTarget("not-observed"),
{ id: "gdb", name: "GDB", version: null },
{
predicateType: "rea.debugger.command-observation",
operation: "gdb_console",
parameters: { session_id: id, command: "info files" },
result: { command: "info files", completion_status: "complete" },
rawResult: { command: "info files" },
},
);
let handler!: (input: unknown, context: unknown) => Promise<CallToolResult>;
const server = {
delivery: createToolResultDelivery(undefined),
registerTool(name: string, _options: unknown, fn: typeof handler) {
if (name === "gdb_console") handler = fn;
},
} as unknown as EvidenceMcpServer;
const execute = vi.fn(async () => ok({ evidence }));
const manager = {
it("refuses a pre-cancelled debugger command before dispatch and retires the target for a later command", async () => {
const [target] = await createBinarySessionTargets();
const provider = { id: "fixture", name: "Fixture", version: null };
const close = vi.fn(async () => ok(null));
const session = createTestBinarySession(() => ({
execute: async (operation) =>
ok(createAnalysisExecution(operation, provider)),
close,
}));
const evidence = createEvidence(unknownTarget("not-observed"), provider, {
operation: "gdb_console",
parameters: { command: "info files" },
result: { completion_status: "complete" },
});
const execute = vi.fn(async () => ok(evidence));
const reason = { phase: "before-dispatch" };
const call = (signal?: AbortSignal) =>
runWithExternalMutationAdmission(
session,
"gdb_console",
signal,
execute,
retryCleanupFailures: async () => ok(null),
} as unknown as GdbToolOptions["manager"];
const record = vi.fn((value: typeof evidence) =>
session.recordEvidence(value),
(value) => value,
);
registerServiceTools(
server,
{ gdb: { manager, session } },
{ logger: silentLogger, recordEvidence: record },
);
const controller = new AbortController();
const reason = { phase: mode };
if (mode === "pre-aborted") controller.abort(reason);
try {
const pending = handler(
{ session_id: id, command: "info files", detail: "complete" },
{ mcpReq: { signal: controller.signal } },
);
if (mode !== "pre-aborted") {
await sessionRetirement.reached(pending, "session retirement");
expect(execute).toHaveBeenCalledTimes(1);
expect(record).not.toHaveBeenCalled();
if (mode === "during-retirement") controller.abort(reason);
}
sessionRetirement.release();
const result = await pending;
const body = result.structuredContent as any;
const observation = {
mode,
aborted: controller.signal.aborted,
executions: execute.mock.calls.length,
retirementCloses: closes,
recordings: record.mock.calls.length,
isError: result.isError === true,
code: body.error?.code ?? null,
hasEvidence: typeof body.evidence_id === "string",
stored: session.hasEvidence(evidence.evidence_id),
};
expect(observation).toEqual({
mode,
aborted: mode !== "control",
executions: mode === "pre-aborted" ? 0 : 1,
retirementCloses: mode === "pre-aborted" ? 0 : 1,
recordings: mode === "pre-aborted" ? 0 : 1,
isError: mode !== "control",
code: mode === "control" ? null : "cancelled",
hasEvidence: mode === "control",
stored: mode !== "pre-aborted",
});
if (mode === "during-retirement")
expect(record.mock.calls[0]?.[0]).toEqual(evidence);
} finally {
sessionRetirement.release();
await session.close();
}
expect((await session.open(target)).ok).toBe(true);
try {
expect(await call(AbortSignal.abort(reason))).toMatchObject({
ok: false,
error: {
_tag: "AnalysisCancelledError",
cause: reason,
operation: "gdb_console",
},
});
expect(execute).not.toHaveBeenCalled();
expect(close).not.toHaveBeenCalled();
expect(session.activeTarget()?.path).toBe(target);
expect(await call()).toEqual(ok(evidence));
expect(execute).toHaveBeenCalledOnce();
expect(close).toHaveBeenCalledOnce();
expect(session.activeTarget()).toBeUndefined();
} finally {
await session.close();
}
});