Files
reverse-engineering-anything/tests/boundary/mcp/enhancedTools.inputValidation.test.ts
T
morluto 104b1a35b4 fix(contracts): refuse empty address and procedure selectors in the contracts (#10753)
* fix(contracts): refuse empty address and procedure selectors in the contracts

* refactor(cli): project decompile from its contract with --file-offset as an alternative selector (#10756)

* refactor(cli): project search from its contracts with --kind choosing the operation (#10761)

* refactor(cli): project search from its contracts with --kind choosing the operation

* fix(cli): check operation choices' option rules and bind errors to the selected contract

* test(cli): group operation-choice checks in their own block

* refactor(cli): project decompile-all from its contract onto a native session target (#10778)

* refactor(cli): project decompile-all from its contract onto a native session target

* refactor(cli): project native Mach-O, Swift and native UI commands from their contracts

* fix(cli): read search, decompile-all and native utility contracts from their groups so startup stays lazy

* test(cli): drop the empty-selector admission mismatches the contracts now refuse
2026-11-15 22:03:37 +08:00

73 lines
2.6 KiB
TypeScript

import { parseMcpToolError } from "../../fixtures/mcpToolError.js";
import { afterEach, describe, expect, it } from "vitest";
import { closeEnhancedToolResources, connect } from "./enhancedToolsHarness.js";
import { observed as ok } from "../../fixtures/analysisExecution.js";
afterEach(closeEnhancedToolResources);
describe("enhanced MCP input validation", () => {
it("lets the SDK reject misspelled tool inputs", async () => {
const client = await connect({ execute: () => Promise.resolve(ok([])) });
const valid = await client.callTool({
name: "trace_feature",
arguments: { query: "needle" },
});
expect(valid.isError).not.toBe(true);
const misspelled = await client.callTool({
name: "trace_feature",
arguments: { query: "needle", unrecognized_option: true },
});
expect(misspelled.isError).toBe(true);
expect(misspelled.structuredContent).toBeUndefined();
const nestedMisspelled = await client.callTool({
name: "analyze_function",
arguments: {
procedure: "0x1",
collection_offset: { commentz: 1 },
},
});
expect(nestedMisspelled.isError).toBe(true);
expect(nestedMisspelled.structuredContent).toBeUndefined();
});
it("refuses empty address and procedure selectors before the provider runs", async () => {
const calls: string[] = [];
const client = await connect({
execute: (name) => {
calls.push(name);
return Promise.resolve(ok([]));
},
});
for (const [name, selector] of [
["xrefs", { address: "" }],
["read_function_instructions", { procedure: "" }],
["procedure_references", { procedure: "" }],
["procedure_pseudo_code", { procedure: "" }],
["set_comment", { address: "", comment: "x" }],
] as const) {
const result = await client.callTool({ name, arguments: selector });
expect(result.isError, name).toBe(true);
}
expect(calls).toEqual([]);
const omitted = await client.callTool({ name: "xrefs", arguments: {} });
expect(omitted.isError).not.toBe(true);
expect(calls).toEqual(["xrefs"]);
});
it("returns a typed tool error for malformed Hopper boundary values", async () => {
const client = await connect({
execute: () => Promise.resolve(ok(["not", "a", "procedure", "map"])),
});
const result = await client.callTool({
name: "analyze_swift_types",
arguments: {},
});
expect(result.isError).toBe(true);
const text = result.content.find((item) => item.type === "text");
expect(text?.type === "text" ? text.text : "").toBe(
JSON.stringify(parseMcpToolError(result)),
);
});
});