Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

Add integration tests for MCP server lifecycle and config parsing

morlutod341f2645977
diff --git a/tests/integration/configIntegration.test.ts b/tests/integration/configIntegration.test.ts
new file mode 100644
index 000000000..893f6e3f5
--- /dev/null
+++ b/tests/integration/configIntegration.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+
+import { parseConfig } from "../../src/config.js";
+
+describe("configuration parsing integration", () => {
+ it("returns defaults when no environment variables are set", () => {
+ const result = parseConfig({});
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error("unreachable");
+ expect(result.value.hopperLauncherPath).toBe(
+ "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper",
+ );
+ expect(result.value.hopperTargetPath).toBeUndefined();
+ expect(result.value.hopperTargetKind).toBe("executable");
+ expect(result.value.hopperLoaderArgs).toEqual([]);
+ });
+
+ it("parses a complete target-bound configuration", () => {
+ const result = parseConfig({
+ HOPPER_TARGET_PATH: "/usr/bin/true",
+ HOPPER_TARGET_KIND: "executable",
+ HOPPER_LOADER_ARGS_JSON: '["-l","Mach-O","--aarch64"]',
+ });
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error("unreachable");
+ expect(result.value.hopperTargetPath).toBe("/usr/bin/true");
+ expect(result.value.hopperTargetKind).toBe("executable");
+ expect(result.value.hopperLoaderArgs).toEqual(["-l", "Mach-O", "--aarch64"]);
+ });
+
+ it("rejects target kind values outside the enum", () => {
+ const result = parseConfig({
+ HOPPER_TARGET_KIND: "archive",
+ });
+ expect(result.ok).toBe(false);
+ if (result.ok) throw new Error("unreachable");
+ expect(result.error.message).toContain("Invalid Hopper environment");
+ });
+
+ it("rejects invalid JSON in loader arguments", () => {
+ const result = parseConfig({
+ HOPPER_LOADER_ARGS_JSON: "not json",
+ });
+ expect(result.ok).toBe(false);
+ if (result.ok) throw new Error("unreachable");
+ expect(result.error.message).toContain("valid JSON");
+ });
+
+ it("rejects non-array types in loader arguments JSON", () => {
+ const result = parseConfig({
+ HOPPER_LOADER_ARGS_JSON: '"just a string"',
+ });
+ expect(result.ok).toBe(false);
+ if (result.ok) throw new Error("unreachable");
+ expect(result.error.message).toContain("array of strings");
+ });
+
+ it("allows overriding the launcher path while keeping other defaults", () => {
+ const result = parseConfig({
+ HOPPER_LAUNCHER_PATH: "/custom/hopper",
+ });
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error("unreachable");
+ expect(result.value.hopperLauncherPath).toBe("/custom/hopper");
+ expect(result.value.hopperTargetPath).toBeUndefined();
+ });
+
+ it("parses database target kind correctly", () => {
+ const result = parseConfig({
+ HOPPER_TARGET_PATH: "/path/to/file.hop",
+ HOPPER_TARGET_KIND: "database",
+ });
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error("unreachable");
+ expect(result.value.hopperTargetKind).toBe("database");
+ });
+});
diff --git a/tests/integration/serverIntegration.test.ts b/tests/integration/serverIntegration.test.ts
new file mode 100644
index 000000000..4fa247382
--- /dev/null
+++ b/tests/integration/serverIntegration.test.ts
@@ -0,0 +1,159 @@
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
+import type { CallToolResult } from "@modelcontextprotocol/server";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+ BinarySession,
+ type BinaryClient,
+} from "../../src/application/BinarySession.js";
+import type { HopperToolPort } from "../../src/application/HopperToolPort.js";
+import { HopperRemoteError } from "../../src/domain/errors.js";
+import { err, ok } from "../../src/domain/result.js";
+import { createServer } from "../../src/server/createServer.js";
+
+const resources: Array<{ close(): Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(
+ resources.splice(0).map(async (resource) => resource.close()),
+ );
+});
+
+const connect = async (hopper: HopperToolPort) => {
+ const server = createServer(hopper);
+ const client = new Client({
+ name: "integration-test",
+ version: "1.0.0",
+ });
+ const [clientTransport, serverTransport] =
+ InMemoryTransport.createLinkedPair();
+ resources.push(client, server);
+ await server.connect(serverTransport);
+ await client.connect(clientTransport);
+ return client;
+};
+
+const text = (result: CallToolResult): string => {
+ const content = result.content.find((item) => item.type === "text");
+ if (content?.type !== "text") throw new Error("missing text result");
+ return content.text;
+};
+
+describe("full MCP integration with multi-tool sequences", () => {
+ it("executes a realistic workflow: list methods, decompile selected, get xrefs", async () => {
+ const client = await connect({
+ callTool: (name, args) => {
+ switch (name) {
+ case "list_procedures":
+ return Promise.resolve(
+ ok({ "0x1000": "main", "0x2000": "helper" }),
+ );
+ case "procedure_pseudo_code":
+ return Promise.resolve(
+ ok(`pseudo for ${(args as { procedure: string }).procedure}`),
+ );
+ case "xrefs":
+ return Promise.resolve(ok(["0x1000"]));
+ default:
+ return Promise.resolve(ok(null));
+ }
+ },
+ });
+
+ const listResult = await client.callTool({
+ name: "list_procedures",
+ arguments: {},
+ });
+ expect(listResult.isError).not.toBe(true);
+ const procedures = JSON.parse(text(listResult));
+ expect(procedures).toEqual({ "0x1000": "main", "0x2000": "helper" });
+
+ const decompileResult = await client.callTool({
+ name: "procedure_pseudo_code",
+ arguments: { procedure: "0x1000" },
+ });
+ expect(text(decompileResult)).toBe("pseudo for 0x1000");
+
+ const xrefResult = await client.callTool({
+ name: "xrefs",
+ arguments: {},
+ });
+ expect(JSON.parse(text(xrefResult))).toEqual(["0x1000"]);
+ });
+
+ it("preserves the complete 42-tool inventory with a session", async () => {
+ const session = new BinarySession((_path) => ({
+ callTool: () => Promise.resolve(ok(null)),
+ close: () => Promise.resolve(),
+ } satisfies BinaryClient));
+ const server = createServer(
+ { callTool: () => Promise.resolve(ok(null)) },
+ session,
+ );
+ const client = new Client({
+ name: "integration-test",
+ version: "1.0.0",
+ });
+ const [clientTransport, serverTransport] =
+ InMemoryTransport.createLinkedPair();
+ resources.push(client, server);
+ await server.connect(serverTransport);
+ await client.connect(clientTransport);
+
+ const listed = await client.listTools();
+ expect(listed.tools).toHaveLength(42);
+ const names = listed.tools.map((t) => t.name);
+ expect(names).toContain("open_binary");
+ expect(names).toContain("close_binary");
+ expect(names).toContain("binary_session");
+ expect(names).toContain("binary_overview");
+ expect(names).toContain("batch_decompile");
+ });
+
+ it("preserves the 39-tool inventory without a session", async () => {
+ const client = await connect({
+ callTool: () => Promise.resolve(ok(null)),
+ });
+ const listed = await client.listTools();
+ expect(listed.tools).toHaveLength(39);
+ const names = listed.tools.map((t) => t.name);
+ expect(names).toContain("binary_overview");
+ expect(names).toContain("batch_decompile");
+ expect(names).not.toContain("open_binary");
+ });
+
+ it("propagates remote Hopper errors with structured content", async () => {
+ const client = await connect({
+ callTool: () =>
+ Promise.resolve(err(new HopperRemoteError(-32000, "bridge timeout"))),
+ });
+
+ const result = await client.callTool({
+ name: "list_documents",
+ arguments: {},
+ });
+ expect(result.isError).toBe(true);
+ expect(text(result)).toContain("HopperRemoteError");
+ expect(text(result)).toContain("bridge timeout");
+ });
+
+ it("handles concurrent tool calls without corruption", async () => {
+ const invocations: string[] = [];
+ const client = await connect({
+ callTool: (name) => {
+ invocations.push(name);
+ return Promise.resolve(ok({ handled: name }));
+ },
+ });
+
+ const results = await Promise.all([
+ client.callTool({ name: "list_procedures", arguments: {} }),
+ client.callTool({ name: "list_segments", arguments: {} }),
+ client.callTool({ name: "list_strings", arguments: {} }),
+ ]);
+
+ expect(results.every((r) => !r.isError)).toBe(true);
+ expect(invocations).toHaveLength(3);
+ expect(new Set(invocations).size).toBe(3);
+ });
+});