@deimoscloud/coreai 0.1.0

package/src/adapters/mcp/registry.test.ts

@@ -0,0 +1,433 @@
+import { McpRegistry, createRegistry } from './registry.js';
+import type { McpServerDefinition } from './types.js';
+import { McpError } from './types.js';
+
+describe('McpRegistry', () => {
+  let registry: McpRegistry;
+
+  beforeEach(() => {
+    registry = createRegistry({
+      maxRetries: 1,
+      retryDelay: 10,
+    });
+  });
+
+  afterEach(async () => {
+    await registry.disconnectAll();
+  });
+
+  describe('constructor', () => {
+    it('should create a registry with default options', () => {
+      const reg = new McpRegistry();
+      expect(reg).toBeInstanceOf(McpRegistry);
+      expect(reg.getServerNames()).toEqual([]);
+    });
+
+    it('should accept custom options', () => {
+      const reg = new McpRegistry({
+        autoConnect: true,
+        maxRetries: 5,
+        retryDelay: 2000,
+      });
+      expect(reg).toBeInstanceOf(McpRegistry);
+    });
+  });
+
+  describe('registerServer', () => {
+    it('should register a server definition', () => {
+      const definition: McpServerDefinition = {
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+        enabled: true,
+      };
+
+      registry.registerServer(definition);
+
+      expect(registry.getServerNames()).toContain('test-server');
+      const entry = registry.getServer('test-server');
+      expect(entry).toBeDefined();
+      expect(entry?.status).toBe('disconnected');
+    });
+
+    it('should set disabled status if enabled is false', () => {
+      const definition: McpServerDefinition = {
+        name: 'disabled-server',
+        config: { transport: 'stdio', command: 'test' },
+        enabled: false,
+      };
+
+      registry.registerServer(definition);
+
+      const entry = registry.getServer('disabled-server');
+      expect(entry?.status).toBe('disabled');
+    });
+
+    it('should throw if server already registered', () => {
+      const definition: McpServerDefinition = {
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      };
+
+      registry.registerServer(definition);
+
+      expect(() => registry.registerServer(definition)).toThrow(McpError);
+    });
+
+    it('should emit serversChanged event', () => {
+      let emittedServers: string[] = [];
+      registry.on('serversChanged', (servers) => {
+        emittedServers = servers;
+      });
+
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      expect(emittedServers).toEqual(['test-server']);
+    });
+  });
+
+  describe('unregisterServer', () => {
+    it('should remove a registered server', async () => {
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      await registry.unregisterServer('test-server');
+
+      expect(registry.getServerNames()).not.toContain('test-server');
+    });
+
+    it('should do nothing if server not found', async () => {
+      await expect(registry.unregisterServer('nonexistent')).resolves.toBeUndefined();
+    });
+
+    it('should emit serversChanged event', async () => {
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      let eventEmitted = false;
+      registry.on('serversChanged', () => {
+        eventEmitted = true;
+      });
+
+      await registry.unregisterServer('test-server');
+
+      expect(eventEmitted).toBe(true);
+    });
+  });
+
+  describe('connect error handling', () => {
+    it('should throw if server not registered', async () => {
+      await expect(registry.connect('nonexistent')).rejects.toThrow(McpError);
+    });
+
+    it('should throw if server is disabled', async () => {
+      registry.registerServer({
+        name: 'disabled-server',
+        config: { transport: 'stdio', command: 'test' },
+        enabled: false,
+      });
+
+      await expect(registry.connect('disabled-server')).rejects.toThrow(McpError);
+    });
+  });
+
+  describe('getClient', () => {
+    it('should return null for disconnected server', () => {
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      const client = registry.getClient('test-server');
+      expect(client).toBeNull();
+    });
+
+    it('should return null for unknown server', () => {
+      const client = registry.getClient('nonexistent');
+      expect(client).toBeNull();
+    });
+  });
+
+  describe('getConnectedServers', () => {
+    it('should return empty array when no servers connected', () => {
+      registry.registerServer({
+        name: 'disconnected',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      const connected = registry.getConnectedServers();
+      expect(connected).toEqual([]);
+    });
+  });
+
+  describe('getAllTools', () => {
+    it('should return empty map when no servers connected', () => {
+      registry.registerServer({
+        name: 'server-1',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      const allTools = registry.getAllTools();
+      expect(allTools.size).toBe(0);
+    });
+  });
+
+  describe('findServersForAdapter', () => {
+    it('should find servers that provide a specific adapter type', () => {
+      registry.registerServer({
+        name: 'github-server',
+        config: { transport: 'stdio', command: 'github' },
+      });
+
+      // Manually set up the entry as if it were connected
+      const entry = registry.getServer('github-server');
+      if (entry) {
+        entry.status = 'connected';
+        entry.mappings = [
+          { toolName: 'create_pr', adapterType: 'git', method: 'createPullRequest' },
+        ];
+      }
+
+      const servers = registry.findServersForAdapter('git');
+      expect(servers).toContain('github-server');
+    });
+
+    it('should return empty array if no servers match', () => {
+      const servers = registry.findServersForAdapter('documentation');
+      expect(servers).toEqual([]);
+    });
+  });
+
+  describe('getStatus', () => {
+    it('should return registry status summary', () => {
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      const status = registry.getStatus();
+
+      expect(status.totalServers).toBe(1);
+      expect(status.connectedServers).toBe(0);
+      expect(status.servers['test-server']).toBeDefined();
+      expect(status.servers['test-server'].status).toBe('disconnected');
+    });
+
+    it('should include lastError when present', () => {
+      registry.registerServer({
+        name: 'error-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      // Manually set an error
+      const entry = registry.getServer('error-server');
+      if (entry) {
+        entry.status = 'error';
+        entry.lastError = new Error('Connection failed');
+      }
+
+      const status = registry.getStatus();
+      expect(status.servers['error-server'].lastError).toBe('Connection failed');
+    });
+
+    it('should not include lastError when not present', () => {
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      const status = registry.getStatus();
+      expect(status.servers['test-server'].lastError).toBeUndefined();
+    });
+  });
+
+  describe('callTool error handling', () => {
+    it('should throw if server not registered', async () => {
+      await expect(registry.callTool('nonexistent', 'tool')).rejects.toThrow(McpError);
+    });
+
+    it('should throw if server not connected', async () => {
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      await expect(registry.callTool('test-server', 'tool')).rejects.toThrow(McpError);
+    });
+  });
+
+  describe('getMappings', () => {
+    it('should return empty array for disconnected server', () => {
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      const mappings = registry.getMappings('test-server');
+      expect(mappings).toEqual([]);
+    });
+
+    it('should return empty array for unknown server', () => {
+      const mappings = registry.getMappings('nonexistent');
+      expect(mappings).toEqual([]);
+    });
+  });
+
+  describe('getTools', () => {
+    it('should return empty array for disconnected server', () => {
+      registry.registerServer({
+        name: 'test-server',
+        config: { transport: 'stdio', command: 'test' },
+      });
+
+      const tools = registry.getTools('test-server');
+      expect(tools).toEqual([]);
+    });
+
+    it('should return empty array for unknown server', () => {
+      const tools = registry.getTools('nonexistent');
+      expect(tools).toEqual([]);
+    });
+  });
+});
+
+describe('createRegistry', () => {
+  it('should create a registry instance', () => {
+    const registry = createRegistry();
+    expect(registry).toBeInstanceOf(McpRegistry);
+  });
+
+  it('should accept options', () => {
+    const registry = createRegistry({ maxRetries: 5 });
+    expect(registry).toBeInstanceOf(McpRegistry);
+  });
+});
+
+describe('McpRegistry with simulated connections', () => {
+  let registry: McpRegistry;
+
+  beforeEach(() => {
+    registry = createRegistry();
+  });
+
+  afterEach(async () => {
+    await registry.disconnectAll();
+  });
+
+  it('should track multiple servers', () => {
+    registry.registerServer({
+      name: 'server-1',
+      config: { transport: 'stdio', command: 'test1' },
+    });
+    registry.registerServer({
+      name: 'server-2',
+      config: { transport: 'stdio', command: 'test2' },
+    });
+    registry.registerServer({
+      name: 'server-3',
+      config: { transport: 'stdio', command: 'test3' },
+      enabled: false,
+    });
+
+    expect(registry.getServerNames()).toHaveLength(3);
+
+    const allServers = registry.getAllServers();
+    expect(allServers.size).toBe(3);
+    expect(allServers.get('server-3')?.status).toBe('disabled');
+  });
+
+  it('should emit events on server registration', () => {
+    let eventCount = 0;
+    registry.on('serversChanged', () => {
+      eventCount++;
+    });
+
+    registry.registerServer({
+      name: 'server-1',
+      config: { transport: 'stdio', command: 'test1' },
+    });
+
+    registry.registerServer({
+      name: 'server-2',
+      config: { transport: 'stdio', command: 'test2' },
+    });
+
+    expect(eventCount).toBe(2);
+  });
+
+  it('should return mappings for manually configured server', () => {
+    registry.registerServer({
+      name: 'jira-server',
+      config: { transport: 'stdio', command: 'jira' },
+    });
+
+    const entry = registry.getServer('jira-server');
+    if (entry) {
+      entry.status = 'connected';
+      entry.mappings = [
+        { toolName: 'get_issue', adapterType: 'issue_tracker', method: 'getIssue' },
+        { toolName: 'create_issue', adapterType: 'issue_tracker', method: 'createIssue' },
+      ];
+    }
+
+    const mappings = registry.getMappings('jira-server');
+    expect(mappings).toHaveLength(2);
+    expect(mappings[0].adapterType).toBe('issue_tracker');
+  });
+
+  it('should group mappings by adapter type across servers', () => {
+    registry.registerServer({
+      name: 'github-server',
+      config: { transport: 'stdio', command: 'github' },
+    });
+    registry.registerServer({
+      name: 'jira-server',
+      config: { transport: 'stdio', command: 'jira' },
+    });
+
+    const githubEntry = registry.getServer('github-server');
+    if (githubEntry) {
+      githubEntry.status = 'connected';
+      githubEntry.mappings = [
+        { toolName: 'create_pr', adapterType: 'git', method: 'createPullRequest' },
+        { toolName: 'get_issue', adapterType: 'issue_tracker', method: 'getIssue' },
+      ];
+    }
+
+    const jiraEntry = registry.getServer('jira-server');
+    if (jiraEntry) {
+      jiraEntry.status = 'connected';
+      jiraEntry.mappings = [
+        { toolName: 'jira_get_issue', adapterType: 'issue_tracker', method: 'getIssue' },
+      ];
+    }
+
+    const grouped = registry.getAllMappingsByAdapter();
+
+    expect(grouped.has('git')).toBe(true);
+    expect(grouped.has('issue_tracker')).toBe(true);
+
+    const gitMappings = grouped.get('git');
+    expect(gitMappings?.has('github-server')).toBe(true);
+
+    const issueTrackerMappings = grouped.get('issue_tracker');
+    expect(issueTrackerMappings?.has('github-server')).toBe(true);
+    expect(issueTrackerMappings?.has('jira-server')).toBe(true);
+  });
+
+  it('should handle getAllMappingsByAdapter with no connected servers', () => {
+    registry.registerServer({
+      name: 'server-1',
+      config: { transport: 'stdio', command: 'test1' },
+    });
+
+    const grouped = registry.getAllMappingsByAdapter();
+    expect(grouped.size).toBe(0);
+  });
+});