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

package/build/__tests__/assessment-runner/assessment-executor.test.js

@@ -0,0 +1,248 @@
+/**
+ * Assessment Executor Unit Tests
+ *
+ * Tests for runFullAssessment() orchestration logic.
+ */
+import { jest, describe, it, expect, beforeEach, afterEach, } from "@jest/globals";
+// Mock all dependencies with explicit any types for flexibility
+const mockLoadServerConfig = jest.fn();
+const mockConnectToServer = jest.fn();
+const mockLoadSourceFiles = jest.fn();
+const mockCreateCallToolWrapper = jest.fn();
+const mockBuildConfig = jest.fn();
+// Mock client with typed functions
+const mockClient = {
+    listTools: jest.fn(),
+    listResources: jest.fn(),
+    listPrompts: jest.fn(),
+    readResource: jest.fn(),
+    getPrompt: jest.fn(),
+    getServerVersion: jest.fn(),
+    getServerCapabilities: jest.fn(),
+    close: jest.fn(),
+};
+// Mock orchestrator
+const mockRunFullAssessment = jest.fn();
+const mockIsClaudeEnabled = jest.fn();
+const MockAssessmentOrchestrator = jest.fn().mockImplementation(() => ({
+    runFullAssessment: mockRunFullAssessment,
+    isClaudeEnabled: mockIsClaudeEnabled,
+}));
+// Mock state manager
+const mockStateExists = jest.fn();
+const mockStateGetSummary = jest.fn();
+const mockStateClear = jest.fn();
+const MockAssessmentStateManager = jest.fn().mockImplementation(() => ({
+    exists: mockStateExists,
+    getSummary: mockStateGetSummary,
+    clear: mockStateClear,
+}));
+// Mock JSONL event emitters
+const mockEmitServerConnected = jest.fn();
+const mockEmitToolDiscovered = jest.fn();
+const mockEmitToolsDiscoveryComplete = jest.fn();
+const mockEmitAssessmentComplete = jest.fn();
+const mockEmitModulesConfigured = jest.fn();
+jest.unstable_mockModule("../../lib/assessment-runner/server-config.js", () => ({
+    loadServerConfig: mockLoadServerConfig,
+}));
+jest.unstable_mockModule("../../lib/assessment-runner/server-connection.js", () => ({
+    connectToServer: mockConnectToServer,
+}));
+jest.unstable_mockModule("../../lib/assessment-runner/source-loader.js", () => ({
+    loadSourceFiles: mockLoadSourceFiles,
+}));
+jest.unstable_mockModule("../../lib/assessment-runner/tool-wrapper.js", () => ({
+    createCallToolWrapper: mockCreateCallToolWrapper,
+}));
+jest.unstable_mockModule("../../lib/assessment-runner/config-builder.js", () => ({
+    buildConfig: mockBuildConfig,
+}));
+jest.unstable_mockModule("../../../../client/lib/services/assessment/AssessmentOrchestrator.js", () => ({
+    AssessmentOrchestrator: MockAssessmentOrchestrator,
+    AssessmentContext: {},
+}));
+jest.unstable_mockModule("../../assessmentState.js", () => ({
+    AssessmentStateManager: MockAssessmentStateManager,
+}));
+jest.unstable_mockModule("../../lib/jsonl-events.js", () => ({
+    emitServerConnected: mockEmitServerConnected,
+    emitToolDiscovered: mockEmitToolDiscovered,
+    emitToolsDiscoveryComplete: mockEmitToolsDiscoveryComplete,
+    emitAssessmentComplete: mockEmitAssessmentComplete,
+    emitTestBatch: jest.fn(),
+    emitVulnerabilityFound: jest.fn(),
+    emitAnnotationMissing: jest.fn(),
+    emitAnnotationMisaligned: jest.fn(),
+    emitAnnotationReviewRecommended: jest.fn(),
+    emitAnnotationAligned: jest.fn(),
+    emitModulesConfigured: mockEmitModulesConfigured,
+}));
+jest.unstable_mockModule("fs", () => ({
+    existsSync: jest.fn().mockReturnValue(false),
+    readFileSync: jest.fn(),
+}));
+jest.unstable_mockModule("../../../../client/lib/lib/assessmentTypes.js", () => ({
+    MCPDirectoryAssessment: {},
+    ProgressEvent: {},
+}));
+// Import after mocking
+const { runFullAssessment } = await import("../../lib/assessment-runner/assessment-executor.js");
+describe("runFullAssessment", () => {
+    const defaultOptions = {
+        serverName: "test-server",
+        jsonOnly: true, // Suppress console output in tests
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Setup default mock returns
+        mockLoadServerConfig.mockReturnValue({
+            transport: "stdio",
+            command: "node",
+            args: ["server.js"],
+        });
+        mockConnectToServer.mockResolvedValue(mockClient);
+        mockClient.listTools.mockResolvedValue({
+            tools: [
+                { name: "tool1", description: "First tool" },
+                { name: "tool2", description: "Second tool" },
+            ],
+        });
+        mockClient.listResources.mockResolvedValue({ resources: [] });
+        mockClient.listPrompts.mockResolvedValue({ prompts: [] });
+        mockClient.getServerVersion.mockReturnValue({
+            name: "test-server",
+            version: "1.0.0",
+        });
+        mockClient.getServerCapabilities.mockReturnValue({});
+        mockClient.close.mockResolvedValue(undefined);
+        mockLoadSourceFiles.mockReturnValue({});
+        mockCreateCallToolWrapper.mockReturnValue(jest.fn());
+        mockBuildConfig.mockReturnValue({
+            assessmentCategories: { functionality: true, security: true },
+        });
+        mockRunFullAssessment.mockResolvedValue({
+            overallStatus: "PASS",
+            totalTestsRun: 10,
+            executionTime: 5000,
+        });
+        mockIsClaudeEnabled.mockReturnValue(false);
+        mockStateExists.mockReturnValue(false);
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe("orchestration flow", () => {
+        it("should load server config", async () => {
+            await runFullAssessment(defaultOptions);
+            expect(mockLoadServerConfig).toHaveBeenCalledWith("test-server", undefined);
+        });
+        it("should connect to server", async () => {
+            await runFullAssessment(defaultOptions);
+            expect(mockConnectToServer).toHaveBeenCalled();
+            expect(mockEmitServerConnected).toHaveBeenCalledWith("test-server", "stdio");
+        });
+        it("should discover tools via client.listTools()", async () => {
+            await runFullAssessment(defaultOptions);
+            expect(mockClient.listTools).toHaveBeenCalled();
+            expect(mockEmitToolDiscovered).toHaveBeenCalledTimes(2);
+            expect(mockEmitToolsDiscoveryComplete).toHaveBeenCalledWith(2);
+        });
+        it("should discover resources via client.listResources()", async () => {
+            mockClient.listResources.mockResolvedValue({
+                resources: [{ uri: "file://test.txt", name: "Test" }],
+            });
+            await runFullAssessment(defaultOptions);
+            expect(mockClient.listResources).toHaveBeenCalled();
+        });
+        it("should handle server with zero tools gracefully", async () => {
+            mockClient.listTools.mockResolvedValue({ tools: [] });
+            await runFullAssessment(defaultOptions);
+            expect(mockEmitToolsDiscoveryComplete).toHaveBeenCalledWith(0);
+        });
+        it("should handle resources not supported by server", async () => {
+            mockClient.listResources.mockRejectedValue(new Error("Resources not supported"));
+            // Should not throw
+            await expect(runFullAssessment(defaultOptions)).resolves.toBeDefined();
+        });
+        it("should handle prompts not supported by server", async () => {
+            mockClient.listPrompts.mockRejectedValue(new Error("Prompts not supported"));
+            // Should not throw
+            await expect(runFullAssessment(defaultOptions)).resolves.toBeDefined();
+        });
+    });
+    describe("configuration", () => {
+        it("should build config from options", async () => {
+            await runFullAssessment({
+                ...defaultOptions,
+                profile: "security",
+            });
+            expect(mockBuildConfig).toHaveBeenCalledWith(expect.objectContaining({ profile: "security" }));
+        });
+        it("should emit modules_configured event", async () => {
+            await runFullAssessment(defaultOptions);
+            expect(mockEmitModulesConfigured).toHaveBeenCalledWith(["functionality", "security"], [], "default");
+        });
+        it("should create AssessmentOrchestrator with config", async () => {
+            await runFullAssessment(defaultOptions);
+            expect(MockAssessmentOrchestrator).toHaveBeenCalledWith(expect.objectContaining({
+                assessmentCategories: { functionality: true, security: true },
+            }));
+        });
+    });
+    describe("source files", () => {
+        it("should load source files when sourceCodePath provided", async () => {
+            const fs = await import("fs");
+            fs.existsSync.mockReturnValue(true);
+            await runFullAssessment({
+                ...defaultOptions,
+                sourceCodePath: "/path/to/source",
+            });
+            expect(mockLoadSourceFiles).toHaveBeenCalledWith("/path/to/source");
+        });
+        it("should not load source files when path does not exist", async () => {
+            const fs = await import("fs");
+            fs.existsSync.mockReturnValue(false);
+            await runFullAssessment({
+                ...defaultOptions,
+                sourceCodePath: "/nonexistent",
+            });
+            expect(mockLoadSourceFiles).not.toHaveBeenCalled();
+        });
+    });
+    describe("cleanup", () => {
+        it("should close client connection on completion", async () => {
+            await runFullAssessment(defaultOptions);
+            expect(mockClient.close).toHaveBeenCalled();
+        });
+        it("should emit assessment complete event", async () => {
+            await runFullAssessment(defaultOptions);
+            expect(mockEmitAssessmentComplete).toHaveBeenCalledWith("PASS", 10, 5000, expect.stringContaining("inspector-full-assessment"));
+        });
+    });
+    describe("results", () => {
+        it("should return MCPDirectoryAssessment results", async () => {
+            const result = await runFullAssessment(defaultOptions);
+            expect(result).toEqual({
+                overallStatus: "PASS",
+                totalTestsRun: 10,
+                executionTime: 5000,
+            });
+        });
+    });
+    describe("state management", () => {
+        it("should check for existing state", async () => {
+            await runFullAssessment(defaultOptions);
+            expect(MockAssessmentStateManager).toHaveBeenCalledWith("test-server");
+            expect(mockStateExists).toHaveBeenCalled();
+        });
+        it("should clear state when --no-resume is set", async () => {
+            mockStateExists.mockReturnValue(true);
+            await runFullAssessment({
+                ...defaultOptions,
+                noResume: true,
+            });
+            expect(mockStateClear).toHaveBeenCalled();
+        });
+    });
+});

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

@@ -0,0 +1,289 @@
+/**
+ * Config Builder Unit Tests
+ *
+ * Tests for buildConfig() that transforms CLI options into AssessmentConfiguration.
+ */
+import { jest, describe, it, expect, beforeEach, afterEach, } from "@jest/globals";
+// Mock dependencies before importing
+jest.unstable_mockModule("../../profiles.js", () => ({
+    getProfileModules: jest.fn(),
+    resolveModuleNames: jest.fn((names) => names),
+    modulesToLegacyConfig: jest.fn(),
+}));
+jest.unstable_mockModule("../../../../client/lib/lib/assessmentTypes.js", () => ({
+    DEFAULT_ASSESSMENT_CONFIG: {
+        enableExtendedAssessment: false,
+        parallelTesting: false,
+        testTimeout: 10000,
+        enableSourceCodeAnalysis: false,
+    },
+    getAllModulesConfig: jest.fn(),
+    LogLevel: {},
+}));
+jest.unstable_mockModule("../../../../client/lib/services/assessment/lib/claudeCodeBridge.js", () => ({
+    FULL_CLAUDE_CODE_CONFIG: {
+        timeout: 60000,
+        maxRetries: 2,
+    },
+}));
+jest.unstable_mockModule("../../../../client/lib/services/assessment/config/performanceConfig.js", () => ({
+    loadPerformanceConfig: jest.fn(),
+}));
+// Import after mocking
+const { buildConfig } = await import("../../lib/assessment-runner/config-builder.js");
+const { getProfileModules, resolveModuleNames, modulesToLegacyConfig } = await import("../../profiles.js");
+const { getAllModulesConfig, DEFAULT_ASSESSMENT_CONFIG } = await import("../../../../client/lib/lib/assessmentTypes.js");
+const { loadPerformanceConfig } = await import("../../../../client/lib/services/assessment/config/performanceConfig.js");
+describe("buildConfig", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env = { ...originalEnv };
+        delete process.env.INSPECTOR_CLAUDE;
+        delete process.env.INSPECTOR_MCP_AUDITOR_URL;
+        delete process.env.LOG_LEVEL;
+        // Default mock returns
+        getAllModulesConfig.mockReturnValue({
+            functionality: true,
+            security: true,
+            temporal: true,
+        });
+        getProfileModules.mockReturnValue([
+            "functionality",
+            "security",
+        ]);
+        modulesToLegacyConfig.mockReturnValue({
+            functionality: true,
+            security: true,
+        });
+        resolveModuleNames.mockImplementation((names) => names);
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    describe("default configuration", () => {
+        it("should spread DEFAULT_ASSESSMENT_CONFIG", () => {
+            const result = buildConfig({ serverName: "test" });
+            // Config should include properties from DEFAULT_ASSESSMENT_CONFIG
+            expect(result.testTimeout).toBe(30000); // Overridden in buildConfig
+            expect(result.parallelTesting).toBe(true); // Overridden in buildConfig
+        });
+        it("should set enableExtendedAssessment true by default", () => {
+            const result = buildConfig({ serverName: "test" });
+            expect(result.enableExtendedAssessment).toBe(true);
+        });
+        it("should set enableExtendedAssessment false when fullAssessment is false", () => {
+            const result = buildConfig({ serverName: "test", fullAssessment: false });
+            expect(result.enableExtendedAssessment).toBe(false);
+        });
+    });
+    describe("source code analysis", () => {
+        it("should set enableSourceCodeAnalysis false when no sourceCodePath", () => {
+            const result = buildConfig({ serverName: "test" });
+            expect(result.enableSourceCodeAnalysis).toBe(false);
+        });
+        it("should set enableSourceCodeAnalysis true when sourceCodePath provided", () => {
+            const result = buildConfig({
+                serverName: "test",
+                sourceCodePath: "/path/to/source",
+            });
+            expect(result.enableSourceCodeAnalysis).toBe(true);
+        });
+    });
+    describe("profile-based module selection", () => {
+        it("should use getProfileModules when profile option is set", () => {
+            buildConfig({ serverName: "test", profile: "security" });
+            expect(getProfileModules).toHaveBeenCalledWith("security", {
+                hasSourceCode: false,
+                skipTemporal: undefined,
+            });
+        });
+        it("should pass hasSourceCode to getProfileModules", () => {
+            buildConfig({
+                serverName: "test",
+                profile: "full",
+                sourceCodePath: "/path",
+            });
+            expect(getProfileModules).toHaveBeenCalledWith("full", {
+                hasSourceCode: true,
+                skipTemporal: undefined,
+            });
+        });
+        it("should pass skipTemporal to getProfileModules", () => {
+            buildConfig({
+                serverName: "test",
+                profile: "security",
+                skipTemporal: true,
+            });
+            expect(getProfileModules).toHaveBeenCalledWith("security", {
+                hasSourceCode: false,
+                skipTemporal: true,
+            });
+        });
+        it("should convert profile modules to legacy config", () => {
+            getProfileModules.mockReturnValue([
+                "functionality",
+                "security",
+            ]);
+            buildConfig({ serverName: "test", profile: "quick" });
+            expect(modulesToLegacyConfig).toHaveBeenCalledWith([
+                "functionality",
+                "security",
+            ]);
+        });
+    });
+    describe("module filtering", () => {
+        it("should apply --only-modules whitelist filter", () => {
+            getAllModulesConfig.mockReturnValue({
+                functionality: true,
+                security: true,
+                temporal: true,
+                errorHandling: true,
+            });
+            resolveModuleNames.mockReturnValue(["functionality"]);
+            const result = buildConfig({
+                serverName: "test",
+                onlyModules: ["functionality"],
+            });
+            expect(resolveModuleNames).toHaveBeenCalledWith(["functionality"]);
+            // Only functionality should be true
+            expect(result.assessmentCategories?.functionality).toBe(true);
+            expect(result.assessmentCategories?.security).toBe(false);
+            expect(result.assessmentCategories?.temporal).toBe(false);
+        });
+        it("should apply --skip-modules blacklist filter", () => {
+            getAllModulesConfig.mockReturnValue({
+                functionality: true,
+                security: true,
+                temporal: true,
+            });
+            resolveModuleNames.mockReturnValue(["temporal"]);
+            const result = buildConfig({
+                serverName: "test",
+                skipModules: ["temporal"],
+            });
+            expect(resolveModuleNames).toHaveBeenCalledWith(["temporal"]);
+            // temporal should be disabled
+            expect(result.assessmentCategories?.functionality).toBe(true);
+            expect(result.assessmentCategories?.security).toBe(true);
+            expect(result.assessmentCategories?.temporal).toBe(false);
+        });
+    });
+    describe("Claude Code configuration", () => {
+        it("should not set claudeCode when claudeEnabled is false", () => {
+            const result = buildConfig({ serverName: "test", claudeEnabled: false });
+            expect(result.claudeCode).toBeUndefined();
+        });
+        it("should set claudeCode config when claudeEnabled is true", () => {
+            const result = buildConfig({ serverName: "test", claudeEnabled: true });
+            expect(result.claudeCode).toBeDefined();
+            expect(result.claudeCode?.enabled).toBe(true);
+            expect(result.claudeCode?.timeout).toBe(60000);
+            expect(result.claudeCode?.maxRetries).toBe(2);
+        });
+        it("should use HTTP transport when claudeHttp flag is set", () => {
+            const result = buildConfig({
+                serverName: "test",
+                claudeEnabled: true,
+                claudeHttp: true,
+            });
+            expect(result.claudeCode?.transport).toBe("http");
+            expect(result.claudeCode?.httpConfig?.baseUrl).toBe("http://localhost:8085");
+        });
+        it("should use HTTP transport when INSPECTOR_CLAUDE env is true", () => {
+            process.env.INSPECTOR_CLAUDE = "true";
+            const result = buildConfig({ serverName: "test", claudeEnabled: true });
+            expect(result.claudeCode?.transport).toBe("http");
+        });
+        it("should use custom mcpAuditorUrl when provided", () => {
+            const result = buildConfig({
+                serverName: "test",
+                claudeEnabled: true,
+                claudeHttp: true,
+                mcpAuditorUrl: "http://custom:9000",
+            });
+            expect(result.claudeCode?.httpConfig?.baseUrl).toBe("http://custom:9000");
+        });
+        it("should use INSPECTOR_MCP_AUDITOR_URL env when mcpAuditorUrl not provided", () => {
+            process.env.INSPECTOR_MCP_AUDITOR_URL = "http://env-url:8000";
+            const result = buildConfig({
+                serverName: "test",
+                claudeEnabled: true,
+                claudeHttp: true,
+            });
+            expect(result.claudeCode?.httpConfig?.baseUrl).toBe("http://env-url:8000");
+        });
+        it("should enable Claude features when claudeEnabled is true", () => {
+            const result = buildConfig({ serverName: "test", claudeEnabled: true });
+            expect(result.claudeCode?.features?.intelligentTestGeneration).toBe(true);
+            expect(result.claudeCode?.features?.aupSemanticAnalysis).toBe(true);
+            expect(result.claudeCode?.features?.annotationInference).toBe(true);
+            expect(result.claudeCode?.features?.documentationQuality).toBe(true);
+        });
+    });
+    describe("temporal configuration", () => {
+        it("should set temporalInvocations when option provided", () => {
+            const result = buildConfig({
+                serverName: "test",
+                temporalInvocations: 5,
+            });
+            expect(result.temporalInvocations).toBe(5);
+        });
+        it("should not set temporalInvocations when option not provided", () => {
+            const result = buildConfig({ serverName: "test" });
+            expect(result.temporalInvocations).toBeUndefined();
+        });
+    });
+    describe("performance configuration", () => {
+        it("should load performance config when path provided", () => {
+            loadPerformanceConfig.mockReturnValue({
+                batchFlushIntervalMs: 100,
+                securityBatchSize: 10,
+                functionalityBatchSize: 5,
+            });
+            buildConfig({
+                serverName: "test",
+                performanceConfigPath: "/path/to/perf.json",
+            });
+            expect(loadPerformanceConfig).toHaveBeenCalledWith("/path/to/perf.json");
+        });
+        it("should throw on invalid performance config file", () => {
+            loadPerformanceConfig.mockImplementation(() => {
+                throw new Error("Invalid config");
+            });
+            expect(() => buildConfig({
+                serverName: "test",
+                performanceConfigPath: "/invalid/path.json",
+            })).toThrow("Invalid config");
+        });
+    });
+    describe("pattern configuration", () => {
+        it("should set patternConfigPath when option provided", () => {
+            const result = buildConfig({
+                serverName: "test",
+                patternConfigPath: "/path/to/patterns.json",
+            });
+            expect(result.patternConfigPath).toBe("/path/to/patterns.json");
+        });
+    });
+    describe("logging configuration", () => {
+        it("should use logLevel from options when provided", () => {
+            const result = buildConfig({ serverName: "test", logLevel: "debug" });
+            expect(result.logging?.level).toBe("debug");
+        });
+        it("should use LOG_LEVEL env when options.logLevel not provided", () => {
+            process.env.LOG_LEVEL = "warn";
+            const result = buildConfig({ serverName: "test" });
+            expect(result.logging?.level).toBe("warn");
+        });
+        it("should default to info when no logLevel specified", () => {
+            const result = buildConfig({ serverName: "test" });
+            expect(result.logging?.level).toBe("info");
+        });
+        it("should prioritize options.logLevel over LOG_LEVEL env", () => {
+            process.env.LOG_LEVEL = "warn";
+            const result = buildConfig({ serverName: "test", logLevel: "error" });
+            expect(result.logging?.level).toBe("error");
+        });
+    });
+});

package/build/__tests__/assessment-runner/index.test.js

@@ -0,0 +1,41 @@
+/**
+ * Assessment Runner Index Unit Tests
+ *
+ * Tests for the facade module exports.
+ */
+import { describe, it, expect } from "@jest/globals";
+// Import the barrel/facade module
+import * as assessmentRunner from "../../lib/assessment-runner/index.js";
+describe("assessment-runner index exports", () => {
+    describe("function exports", () => {
+        it("should export all 6 public functions", () => {
+            expect(typeof assessmentRunner.loadServerConfig).toBe("function");
+            expect(typeof assessmentRunner.loadSourceFiles).toBe("function");
+            expect(typeof assessmentRunner.connectToServer).toBe("function");
+            expect(typeof assessmentRunner.createCallToolWrapper).toBe("function");
+            expect(typeof assessmentRunner.buildConfig).toBe("function");
+            expect(typeof assessmentRunner.runFullAssessment).toBe("function");
+        });
+        it("should export exactly 6 functions", () => {
+            const functionNames = Object.keys(assessmentRunner).filter((key) => typeof assessmentRunner[key] ===
+                "function");
+            expect(functionNames).toHaveLength(6);
+            expect(functionNames.sort()).toEqual([
+                "buildConfig",
+                "connectToServer",
+                "createCallToolWrapper",
+                "loadServerConfig",
+                "loadSourceFiles",
+                "runFullAssessment",
+            ]);
+        });
+    });
+    describe("type exports", () => {
+        // Type exports are compile-time only, but we can verify
+        // the module structure doesn't break TypeScript compilation
+        it("should export module without errors", () => {
+            // If we got here, the module exported successfully
+            expect(assessmentRunner).toBeDefined();
+        });
+    });
+});