@bryan-thompson/inspector-assessment-cli 1.26.6 → 1.26.7

package/build/__tests__/assessment-runner/server-config.test.js

@@ -0,0 +1,249 @@
+/**
+ * Server Config Unit Tests
+ *
+ * Tests for loadServerConfig() that loads MCP server configuration.
+ */
+import { jest, describe, it, expect, beforeEach, } from "@jest/globals";
+import * as os from "os";
+import * as path from "path";
+// Mock fs module
+jest.unstable_mockModule("fs", () => ({
+    existsSync: jest.fn(),
+    readFileSync: jest.fn(),
+}));
+// Import after mocking
+const fs = await import("fs");
+const { loadServerConfig } = await import("../../lib/assessment-runner/server-config.js");
+describe("loadServerConfig", () => {
+    const mockExistsSync = fs.existsSync;
+    const mockReadFileSync = fs.readFileSync;
+    const homedir = os.homedir();
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExistsSync.mockReturnValue(false);
+    });
+    describe("config path resolution", () => {
+        it("should search explicit configPath first when provided", () => {
+            const configPath = "/custom/path/config.json";
+            mockExistsSync.mockImplementation((p) => p === configPath);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    myserver: { command: "node", args: ["server.js"] },
+                },
+            }));
+            const result = loadServerConfig("myserver", configPath);
+            expect(mockExistsSync).toHaveBeenCalledWith(configPath);
+            expect(result.transport).toBe("stdio");
+            expect(result.command).toBe("node");
+        });
+        it("should search ~/.config/mcp/servers/{serverName}.json", () => {
+            const expectedPath = path.join(homedir, ".config", "mcp", "servers", "testserver.json");
+            mockExistsSync.mockImplementation((p) => p === expectedPath);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                command: "python",
+                args: ["-m", "server"],
+            }));
+            const result = loadServerConfig("testserver");
+            expect(mockExistsSync).toHaveBeenCalledWith(expectedPath);
+            expect(result.command).toBe("python");
+        });
+        it("should search ~/.config/claude/claude_desktop_config.json", () => {
+            const claudePath = path.join(homedir, ".config", "claude", "claude_desktop_config.json");
+            mockExistsSync.mockImplementation((p) => p === claudePath);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    myserver: { command: "npx", args: ["-y", "@example/server"] },
+                },
+            }));
+            const result = loadServerConfig("myserver");
+            expect(mockExistsSync).toHaveBeenCalledWith(claudePath);
+            expect(result.command).toBe("npx");
+        });
+    });
+    describe("stdio transport configuration", () => {
+        it("should return stdio config from mcpServers.{name}.command", () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    testserver: {
+                        command: "node",
+                        args: ["index.js", "--port", "3000"],
+                        env: { NODE_ENV: "production" },
+                        cwd: "/app",
+                    },
+                },
+            }));
+            const result = loadServerConfig("testserver", "/config.json");
+            expect(result).toEqual({
+                transport: "stdio",
+                command: "node",
+                args: ["index.js", "--port", "3000"],
+                env: { NODE_ENV: "production" },
+                cwd: "/app",
+            });
+        });
+        it("should return stdio config from root-level command", () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                command: "python",
+                args: ["server.py"],
+            }));
+            const result = loadServerConfig("anyserver", "/server-config.json");
+            expect(result).toEqual({
+                transport: "stdio",
+                command: "python",
+                args: ["server.py"],
+                env: {},
+            });
+        });
+        it("should default args and env to empty when not provided", () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    simple: { command: "simple-server" },
+                },
+            }));
+            const result = loadServerConfig("simple", "/config.json");
+            expect(result.args).toEqual([]);
+            expect(result.env).toEqual({});
+        });
+    });
+    describe("http transport configuration", () => {
+        it("should return http config from mcpServers with transport:http", () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    httpserver: {
+                        transport: "http",
+                        url: "http://localhost:8080",
+                    },
+                },
+            }));
+            const result = loadServerConfig("httpserver", "/config.json");
+            expect(result).toEqual({
+                transport: "http",
+                url: "http://localhost:8080",
+            });
+        });
+        it("should return http config when only url is specified (infer http)", () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    urlserver: {
+                        url: "http://api.example.com/mcp",
+                    },
+                },
+            }));
+            const result = loadServerConfig("urlserver", "/config.json");
+            expect(result.transport).toBe("http");
+            expect(result.url).toBe("http://api.example.com/mcp");
+        });
+        it("should return http config from root-level url", () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                url: "http://root-server.com/api",
+            }));
+            const result = loadServerConfig("anyserver", "/root-config.json");
+            expect(result.transport).toBe("http");
+            expect(result.url).toBe("http://root-server.com/api");
+        });
+    });
+    describe("sse transport configuration", () => {
+        it("should return sse config from mcpServers with transport:sse", () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    sseserver: {
+                        transport: "sse",
+                        url: "http://localhost:3000/events",
+                    },
+                },
+            }));
+            const result = loadServerConfig("sseserver", "/config.json");
+            expect(result).toEqual({
+                transport: "sse",
+                url: "http://localhost:3000/events",
+            });
+        });
+        it("should return sse config from root-level transport:sse", () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                transport: "sse",
+                url: "http://sse-server.com/stream",
+            }));
+            const result = loadServerConfig("anyserver", "/sse-config.json");
+            expect(result.transport).toBe("sse");
+            expect(result.url).toBe("http://sse-server.com/stream");
+        });
+    });
+    describe("error handling", () => {
+        it('should throw "Invalid JSON" on malformed config file', () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue("{ invalid json }");
+            expect(() => loadServerConfig("server", "/bad.json")).toThrow(/Invalid JSON in config file/);
+        });
+        it('should throw "url is missing" when transport=http but no url', () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    nourl: {
+                        transport: "http",
+                    },
+                },
+            }));
+            expect(() => loadServerConfig("nourl", "/config.json")).toThrow(/'url' is missing/);
+        });
+        it('should throw "url is missing" when transport=sse but no url', () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                mcpServers: {
+                    nourl: {
+                        transport: "sse",
+                    },
+                },
+            }));
+            expect(() => loadServerConfig("nourl", "/config.json")).toThrow(/'url' is missing/);
+        });
+        it('should throw "url is missing" for root-level transport:http without url', () => {
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                transport: "http",
+            }));
+            expect(() => loadServerConfig("server", "/config.json")).toThrow(/'url' is missing/);
+        });
+        it('should throw "Server config not found" when server not in any path', () => {
+            mockExistsSync.mockReturnValue(false);
+            expect(() => loadServerConfig("nonexistent")).toThrow(/Server config not found for: nonexistent/);
+        });
+        it("should list all tried paths in error message", () => {
+            mockExistsSync.mockReturnValue(false);
+            try {
+                loadServerConfig("missing", "/custom/path.json");
+                fail("Should have thrown");
+            }
+            catch (e) {
+                const error = e;
+                expect(error.message).toContain("/custom/path.json");
+                expect(error.message).toContain(".config/mcp/servers/missing.json");
+                expect(error.message).toContain("claude_desktop_config.json");
+            }
+        });
+    });
+    describe("server not found in config file", () => {
+        it("should continue searching if server name not in mcpServers", () => {
+            const firstPath = "/first.json";
+            const secondPath = path.join(homedir, ".config", "mcp", "servers", "target.json");
+            mockExistsSync.mockImplementation((p) => p === firstPath || p === secondPath);
+            mockReadFileSync.mockImplementation((p) => {
+                if (p === firstPath) {
+                    return JSON.stringify({
+                        mcpServers: { other: { command: "other" } },
+                    });
+                }
+                return JSON.stringify({ command: "found" });
+            });
+            const result = loadServerConfig("target", firstPath);
+            expect(result.command).toBe("found");
+        });
+    });
+});

package/build/__tests__/assessment-runner/server-connection.test.js

@@ -0,0 +1,221 @@
+/**
+ * Server Connection Unit Tests
+ *
+ * Tests for connectToServer() that establishes MCP server connections.
+ */
+import { jest, describe, it, expect, beforeEach } from "@jest/globals";
+// Create mock transport classes
+const mockStdioTransport = {
+    stderr: {
+        on: jest.fn(),
+    },
+};
+const mockSSETransport = {};
+const mockHTTPTransport = {};
+const mockConnect = jest.fn();
+const mockClient = {
+    connect: mockConnect,
+};
+// Mock MCP SDK
+jest.unstable_mockModule("@modelcontextprotocol/sdk/client/index.js", () => ({
+    Client: jest.fn().mockImplementation(() => mockClient),
+}));
+jest.unstable_mockModule("@modelcontextprotocol/sdk/client/stdio.js", () => ({
+    StdioClientTransport: jest.fn().mockImplementation(() => mockStdioTransport),
+}));
+jest.unstable_mockModule("@modelcontextprotocol/sdk/client/sse.js", () => ({
+    SSEClientTransport: jest.fn().mockImplementation(() => mockSSETransport),
+}));
+jest.unstable_mockModule("@modelcontextprotocol/sdk/client/streamableHttp.js", () => ({
+    StreamableHTTPClientTransport: jest
+        .fn()
+        .mockImplementation(() => mockHTTPTransport),
+}));
+// Import after mocking
+const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
+const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const { connectToServer } = await import("../../lib/assessment-runner/server-connection.js");
+describe("connectToServer", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockConnect.mockResolvedValue(undefined);
+        mockStdioTransport.stderr.on.mockClear();
+    });
+    describe("HTTP transport", () => {
+        it("should create StreamableHTTPClientTransport for transport:http", async () => {
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            await connectToServer(config);
+            expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(expect.any(URL));
+            const urlArg = StreamableHTTPClientTransport.mock
+                .calls[0][0];
+            expect(urlArg.toString()).toBe("http://localhost:8080/");
+        });
+        it('should throw "URL required for HTTP transport" when url missing', async () => {
+            const config = {
+                transport: "http",
+                url: undefined,
+            };
+            await expect(connectToServer(config)).rejects.toThrow("URL required for HTTP transport");
+        });
+    });
+    describe("SSE transport", () => {
+        it("should create SSEClientTransport for transport:sse", async () => {
+            const config = {
+                transport: "sse",
+                url: "http://localhost:3000/events",
+            };
+            await connectToServer(config);
+            expect(SSEClientTransport).toHaveBeenCalledWith(expect.any(URL));
+            const urlArg = SSEClientTransport.mock.calls[0][0];
+            expect(urlArg.toString()).toBe("http://localhost:3000/events");
+        });
+        it('should throw "URL required for SSE transport" when url missing', async () => {
+            const config = {
+                transport: "sse",
+                url: undefined,
+            };
+            await expect(connectToServer(config)).rejects.toThrow("URL required for SSE transport");
+        });
+    });
+    describe("stdio transport", () => {
+        it("should create StdioClientTransport for transport:stdio", async () => {
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: ["server.js"],
+                env: { NODE_ENV: "test" },
+                cwd: "/app",
+            };
+            await connectToServer(config);
+            expect(StdioClientTransport).toHaveBeenCalledWith(expect.objectContaining({
+                command: "node",
+                args: ["server.js"],
+                cwd: "/app",
+                stderr: "pipe",
+            }));
+        });
+        it("should create StdioClientTransport when transport is undefined (default)", async () => {
+            const config = {
+                transport: "stdio",
+                command: "python",
+                args: ["-m", "server"],
+            };
+            await connectToServer(config);
+            expect(StdioClientTransport).toHaveBeenCalled();
+        });
+        it('should throw "Command required for stdio transport" when command missing', async () => {
+            const config = {
+                transport: "stdio",
+                command: undefined,
+            };
+            await expect(connectToServer(config)).rejects.toThrow("Command required for stdio transport");
+        });
+        it("should merge process.env with config.env", async () => {
+            const originalEnv = process.env;
+            process.env = { PATH: "/usr/bin", HOME: "/home/user" };
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+                env: { CUSTOM_VAR: "value" },
+            };
+            await connectToServer(config);
+            const callArg = StdioClientTransport.mock.calls[0][0];
+            expect(callArg.env).toEqual(expect.objectContaining({
+                PATH: "/usr/bin",
+                HOME: "/home/user",
+                CUSTOM_VAR: "value",
+            }));
+            process.env = originalEnv;
+        });
+        it("should setup stderr listener before connecting", async () => {
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await connectToServer(config);
+            // stderr.on should be called to capture error output
+            expect(mockStdioTransport.stderr.on).toHaveBeenCalledWith("data", expect.any(Function));
+        });
+    });
+    describe("Client creation", () => {
+        it("should create Client with correct info", async () => {
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            await connectToServer(config);
+            expect(Client).toHaveBeenCalledWith({ name: "mcp-assess-full", version: "1.0.0" }, { capabilities: {} });
+        });
+        it("should call client.connect with transport", async () => {
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            await connectToServer(config);
+            expect(mockConnect).toHaveBeenCalledWith(mockHTTPTransport);
+        });
+        it("should return connected client", async () => {
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            const result = await connectToServer(config);
+            expect(result).toBe(mockClient);
+        });
+    });
+    describe("connection error handling", () => {
+        it("should include stderr in error message on connection failure", async () => {
+            // Setup stderr capture
+            let stderrCallback = () => { };
+            mockStdioTransport.stderr.on.mockImplementation((event, cb) => {
+                if (event === "data") {
+                    stderrCallback = cb;
+                }
+            });
+            mockConnect.mockImplementation(async () => {
+                // Simulate stderr output before connection failure
+                stderrCallback(Buffer.from("Error: Module not found\n"));
+                throw new Error("Connection refused");
+            });
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: ["server.js"],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Failed to connect.*Module not found/s);
+        });
+        it("should provide helpful context in error message", async () => {
+            let stderrCallback = () => { };
+            mockStdioTransport.stderr.on.mockImplementation((event, cb) => {
+                if (event === "data") {
+                    stderrCallback = cb;
+                }
+            });
+            mockConnect.mockImplementation(async () => {
+                stderrCallback(Buffer.from("Missing API key"));
+                throw new Error("Process exited");
+            });
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Common causes/);
+        });
+        it("should throw simple error when no stderr captured", async () => {
+            mockConnect.mockRejectedValue(new Error("Connection timeout"));
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            await expect(connectToServer(config)).rejects.toThrow("Failed to connect to MCP server: Connection timeout");
+        });
+    });
+});