mirror of
https://github.com/morluto/rea.git
synced 2026-11-22 06:25:44 +00:00
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:
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();
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
Reference in new issue
Block a user