@claude-flow/cli 3.0.0-alpha.13 → 3.0.0-alpha.14

package/__tests__/mcp-client.test.ts

@@ -1,480 +0,0 @@
-/**
- * V3 CLI MCP Client Tests
- * Tests for MCP tool invocation with proper mocking
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-  callMCPTool,
-  getToolMetadata,
-  listMCPTools,
-  hasTool,
-  getToolCategories,
-  validateToolInput,
-  MCPClientError
-} from '../src/mcp-client.js';
-
-// Mock MCP tool modules - correct paths matching mcp-client.ts imports
-vi.mock('../src/mcp-tools/agent-tools.js', () => ({
-  agentTools: [
-    {
-      name: 'agent/spawn',
-      description: 'Spawn a new agent',
-      category: 'agent',
-      inputSchema: {
-        type: 'object',
-        required: ['agentType'],
-        properties: {
-          agentType: { type: 'string' },
-          id: { type: 'string' },
-          config: { type: 'object' }
-        }
-      },
-      handler: vi.fn(async (input) => ({
-        agentId: input.id || 'test-agent',
-        agentType: input.agentType,
-        status: 'active',
-        createdAt: new Date().toISOString()
-      }))
-    },
-    {
-      name: 'agent/list',
-      description: 'List all agents',
-      category: 'agent',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          status: { type: 'string' },
-          limit: { type: 'number' }
-        }
-      },
-      handler: vi.fn(async () => ({
-        agents: [
-          { id: 'agent-1', agentType: 'coder', status: 'active', createdAt: '2024-01-01T00:00:00Z' },
-          { id: 'agent-2', agentType: 'tester', status: 'idle', createdAt: '2024-01-01T00:01:00Z' }
-        ],
-        total: 2
-      }))
-    },
-    {
-      name: 'agent/terminate',
-      description: 'Terminate an agent',
-      category: 'agent',
-      inputSchema: {
-        type: 'object',
-        required: ['agentId'],
-        properties: {
-          agentId: { type: 'string' },
-          graceful: { type: 'boolean' }
-        }
-      },
-      handler: vi.fn(async (input) => ({
-        agentId: input.agentId,
-        terminated: true,
-        terminatedAt: new Date().toISOString()
-      }))
-    }
-  ]
-}));
-
-vi.mock('../src/mcp-tools/swarm-tools.js', () => ({
-  swarmTools: [
-    {
-      name: 'swarm/init',
-      description: 'Initialize a swarm',
-      category: 'swarm',
-      inputSchema: {
-        type: 'object',
-        required: ['topology'],
-        properties: {
-          topology: { type: 'string' },
-          maxAgents: { type: 'number' }
-        }
-      },
-      handler: vi.fn(async (input) => ({
-        swarmId: 'swarm-test',
-        topology: input.topology,
-        initializedAt: new Date().toISOString(),
-        config: {
-          topology: input.topology,
-          maxAgents: input.maxAgents || 15,
-          currentAgents: 0
-        }
-      }))
-    }
-  ]
-}));
-
-vi.mock('../src/mcp-tools/memory-tools.js', () => ({
-  memoryTools: [
-    {
-      name: 'memory/store',
-      description: 'Store data in memory',
-      category: 'memory',
-      inputSchema: {
-        type: 'object',
-        required: ['key', 'value'],
-        properties: {
-          key: { type: 'string' },
-          value: { type: 'string' },
-          namespace: { type: 'string' }
-        }
-      },
-      handler: vi.fn(async (input) => ({
-        key: input.key,
-        stored: true,
-        timestamp: new Date().toISOString()
-      }))
-    }
-  ]
-}));
-
-vi.mock('../src/mcp-tools/config-tools.js', () => ({
-  configTools: [
-    {
-      name: 'config/get',
-      description: 'Get configuration value',
-      category: 'config',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          key: { type: 'string' }
-        }
-      },
-      handler: vi.fn(async (input) => ({
-        key: input.key,
-        value: 'test-value'
-      }))
-    }
-  ]
-}));
-
-describe('MCP Client', () => {
-  describe('callMCPTool', () => {
-    it('should call agent/spawn tool successfully', async () => {
-      const result = await callMCPTool('agent/spawn', {
-        agentType: 'coder',
-        id: 'test-coder-1'
-      });
-
-      expect(result).toMatchObject({
-        agentId: 'test-coder-1',
-        agentType: 'coder',
-        status: 'active'
-      });
-      expect(result.createdAt).toBeDefined();
-    });
-
-    it('should call agent/list tool successfully', async () => {
-      const result = await callMCPTool<{ agents: unknown[]; total: number }>('agent/list', {
-        status: 'active',
-        limit: 10
-      });
-
-      expect(result.agents).toHaveLength(2);
-      expect(result.total).toBe(2);
-      expect(result.agents[0]).toHaveProperty('id');
-      expect(result.agents[0]).toHaveProperty('agentType');
-    });
-
-    it('should call agent/terminate tool successfully', async () => {
-      const result = await callMCPTool('agent/terminate', {
-        agentId: 'agent-1',
-        graceful: true
-      });
-
-      expect(result).toMatchObject({
-        agentId: 'agent-1',
-        terminated: true
-      });
-      expect(result.terminatedAt).toBeDefined();
-    });
-
-    it('should call swarm/init tool successfully', async () => {
-      const result = await callMCPTool('swarm/init', {
-        topology: 'hierarchical-mesh',
-        maxAgents: 15
-      });
-
-      expect(result).toMatchObject({
-        swarmId: 'swarm-test',
-        topology: 'hierarchical-mesh'
-      });
-      expect(result.config).toMatchObject({
-        topology: 'hierarchical-mesh',
-        maxAgents: 15
-      });
-    });
-
-    it('should call memory/store tool successfully', async () => {
-      const result = await callMCPTool('memory/store', {
-        key: 'test-key',
-        value: 'test-value',
-        namespace: 'default'
-      });
-
-      expect(result).toMatchObject({
-        key: 'test-key',
-        stored: true
-      });
-      expect(result.timestamp).toBeDefined();
-    });
-
-    it('should call config/get tool successfully', async () => {
-      const result = await callMCPTool('config/get', {
-        key: 'swarm.topology'
-      });
-
-      expect(result).toMatchObject({
-        key: 'swarm.topology',
-        value: 'test-value'
-      });
-    });
-
-    it('should throw MCPClientError for non-existent tool', async () => {
-      await expect(
-        callMCPTool('nonexistent/tool', {})
-      ).rejects.toThrow(MCPClientError);
-
-      await expect(
-        callMCPTool('nonexistent/tool', {})
-      ).rejects.toThrow('MCP tool not found: nonexistent/tool');
-    });
-
-    it('should wrap handler errors in MCPClientError', async () => {
-      // This test verifies error wrapping behavior
-      // Since our mock is already defined at module level, we need to test
-      // the error case by temporarily replacing the tool registry
-
-      // We can't easily test this with the current mock setup, so we'll test
-      // that a non-existent tool throws the correct error type
-      try {
-        await callMCPTool('nonexistent/tool', {});
-        expect.fail('Should have thrown MCPClientError');
-      } catch (error) {
-        expect(error).toBeInstanceOf(MCPClientError);
-        expect((error as MCPClientError).toolName).toBe('nonexistent/tool');
-      }
-    });
-
-    it('should pass context to tool handler', async () => {
-      const context = { userId: 'test-user', sessionId: 'test-session' };
-
-      const result = await callMCPTool('agent/spawn', {
-        agentType: 'coder'
-      }, context);
-
-      expect(result).toBeDefined();
-      // Tool should have access to context
-    });
-
-    it('should handle empty input object', async () => {
-      const result = await callMCPTool('agent/list', {});
-
-      expect(result).toHaveProperty('agents');
-      expect(result).toHaveProperty('total');
-    });
-  });
-
-  describe('getToolMetadata', () => {
-    it('should return metadata for existing tool', () => {
-      const metadata = getToolMetadata('agent/spawn');
-
-      expect(metadata).toBeDefined();
-      expect(metadata?.name).toBe('agent/spawn');
-      expect(metadata?.description).toBe('Spawn a new agent');
-      expect(metadata?.category).toBe('agent');
-      expect(metadata?.inputSchema).toBeDefined();
-      expect(metadata).not.toHaveProperty('handler');
-    });
-
-    it('should return undefined for non-existent tool', () => {
-      const metadata = getToolMetadata('nonexistent/tool');
-
-      expect(metadata).toBeUndefined();
-    });
-
-    it('should not include handler in metadata', () => {
-      const metadata = getToolMetadata('agent/spawn');
-
-      expect(metadata).toBeDefined();
-      expect(metadata).not.toHaveProperty('handler');
-    });
-
-    it('should return complete metadata structure', () => {
-      const metadata = getToolMetadata('swarm/init');
-
-      expect(metadata).toMatchObject({
-        name: 'swarm/init',
-        description: expect.any(String),
-        category: 'swarm',
-        inputSchema: expect.any(Object)
-      });
-    });
-  });
-
-  describe('listMCPTools', () => {
-    it('should list all available tools', () => {
-      const tools = listMCPTools();
-
-      expect(tools.length).toBeGreaterThan(0);
-      expect(tools.every(t => t.name && t.description)).toBe(true);
-    });
-
-    it('should filter tools by category', () => {
-      const agentTools = listMCPTools('agent');
-
-      expect(agentTools.length).toBeGreaterThan(0);
-      expect(agentTools.every(t => t.category === 'agent')).toBe(true);
-    });
-
-    it('should return empty array for non-existent category', () => {
-      const tools = listMCPTools('nonexistent');
-
-      expect(tools).toEqual([]);
-    });
-
-    it('should not include handlers in listed tools', () => {
-      const tools = listMCPTools();
-
-      expect(tools.every(t => !('handler' in t))).toBe(true);
-    });
-
-    it('should include all metadata fields', () => {
-      const tools = listMCPTools();
-
-      tools.forEach(tool => {
-        expect(tool).toHaveProperty('name');
-        expect(tool).toHaveProperty('description');
-        expect(tool).toHaveProperty('inputSchema');
-        expect(tool).toHaveProperty('category');
-      });
-    });
-  });
-
-  describe('hasTool', () => {
-    it('should return true for existing tool', () => {
-      expect(hasTool('agent/spawn')).toBe(true);
-      expect(hasTool('agent/list')).toBe(true);
-      expect(hasTool('swarm/init')).toBe(true);
-    });
-
-    it('should return false for non-existent tool', () => {
-      expect(hasTool('nonexistent/tool')).toBe(false);
-      expect(hasTool('invalid')).toBe(false);
-    });
-
-    it('should be case-sensitive', () => {
-      expect(hasTool('agent/spawn')).toBe(true);
-      expect(hasTool('Agent/Spawn')).toBe(false);
-    });
-  });
-
-  describe('getToolCategories', () => {
-    it('should return all unique categories', () => {
-      const categories = getToolCategories();
-
-      expect(categories).toContain('agent');
-      expect(categories).toContain('swarm');
-      expect(categories).toContain('memory');
-      expect(categories).toContain('config');
-    });
-
-    it('should return sorted categories', () => {
-      const categories = getToolCategories();
-      const sorted = [...categories].sort();
-
-      expect(categories).toEqual(sorted);
-    });
-
-    it('should not contain duplicates', () => {
-      const categories = getToolCategories();
-      const unique = [...new Set(categories)];
-
-      expect(categories).toEqual(unique);
-    });
-  });
-
-  describe('validateToolInput', () => {
-    it('should validate required fields', () => {
-      const result = validateToolInput('agent/spawn', {
-        agentType: 'coder',
-        id: 'test-1'
-      });
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toBeUndefined();
-    });
-
-    it('should detect missing required fields', () => {
-      const result = validateToolInput('agent/spawn', {
-        id: 'test-1'
-        // Missing required 'agentType'
-      });
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toBeDefined();
-      expect(result.errors).toContain('Missing required field: agentType');
-    });
-
-    it('should return invalid for non-existent tool', () => {
-      const result = validateToolInput('nonexistent/tool', {});
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain("Tool 'nonexistent/tool' not found");
-    });
-
-    it('should validate multiple required fields', () => {
-      const result = validateToolInput('agent/terminate', {
-        // Missing required 'agentId'
-        graceful: true
-      });
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('Missing required field: agentId');
-    });
-
-    it('should pass with all required fields present', () => {
-      const result = validateToolInput('agent/terminate', {
-        agentId: 'agent-1',
-        graceful: true
-      });
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toBeUndefined();
-    });
-
-    it('should allow optional fields to be missing', () => {
-      const result = validateToolInput('swarm/init', {
-        topology: 'hierarchical'
-        // maxAgents is optional
-      });
-
-      expect(result.valid).toBe(true);
-    });
-  });
-
-  describe('MCPClientError', () => {
-    it('should create error with tool name', () => {
-      const error = new MCPClientError('Test error', 'test/tool');
-
-      expect(error.message).toBe('Test error');
-      expect(error.toolName).toBe('test/tool');
-      expect(error.name).toBe('MCPClientError');
-    });
-
-    it('should include cause error', () => {
-      const cause = new Error('Original error');
-      const error = new MCPClientError('Wrapper error', 'test/tool', cause);
-
-      expect(error.cause).toBe(cause);
-    });
-
-    it('should be instanceof Error', () => {
-      const error = new MCPClientError('Test', 'tool');
-
-      expect(error instanceof Error).toBe(true);
-      expect(error instanceof MCPClientError).toBe(true);
-    });
-  });
-});