@deimoscloud/coreai 0.1.9 → 0.1.10

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

@@ -1,433 +0,0 @@
-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);
-  });
-});