@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

package/dist/server/tests/unit/services/hub-tools/server-selector.test.js

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { hubManager } from '../../../../src/services/hub-manager.service.js';
+import { mcpConnectionManager } from '../../../../src/services/mcp-connection-manager.js';
+import { selectBestInstance, getServerDescription, hasValidId } from '../../../../src/services/hub-tools/server-selector.js';
+// Mock dependencies
+vi.mock('@services/hub-manager.service.js');
+vi.mock('@services/mcp-connection-manager.js');
+describe('server-selector', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('getServerDescription', () => {
+        it('should return provided description when available', () => {
+            const config = { description: 'My test server description' };
+            const result = getServerDescription(config, 'test-server');
+            expect(result).toBe('My test server description');
+        });
+        it('should return default description when config has no description', () => {
+            const config = {};
+            const result = getServerDescription(config, 'test-server');
+            expect(result).toBe('Connected MCP server: test-server');
+        });
+        it('should return default description when config is undefined', () => {
+            const result = getServerDescription(undefined, 'test-server');
+            expect(result).toBe('Connected MCP server: test-server');
+        });
+    });
+    describe('hasValidId', () => {
+        it('should return true for valid server object', () => {
+            const server = {
+                name: 'test-server',
+                config: { type: 'stdio' }
+            };
+            expect(hasValidId(server)).toBe(true);
+        });
+        it('should return false for null', () => {
+            expect(hasValidId(null)).toBe(false);
+        });
+        it('should return false for undefined', () => {
+            expect(hasValidId(undefined)).toBe(false);
+        });
+        it('should return false for non-object', () => {
+            expect(hasValidId('not-an-object')).toBe(false);
+        });
+        it('should return false when name is missing', () => {
+            expect(hasValidId({ config: { type: 'stdio' } })).toBe(false);
+        });
+        it('should return false when name is empty string', () => {
+            expect(hasValidId({ name: '', config: { type: 'stdio' } })).toBe(false);
+        });
+        it('should return false when config is missing', () => {
+            expect(hasValidId({ name: 'test-server' })).toBe(false);
+        });
+        it('should return false when config is not an object', () => {
+            expect(hasValidId({ name: 'test-server', config: 'not-an-object' })).toBe(false);
+        });
+    });
+    describe('selectBestInstance', () => {
+        it('should return undefined when no instances found', () => {
+            vi.mocked(hubManager.getServerInstanceByName).mockReturnValue([]);
+            const result = selectBestInstance('test-server');
+            expect(result).toBeUndefined();
+            expect(hubManager.getServerInstanceByName).toHaveBeenCalledWith('test-server');
+        });
+        it('should return undefined when server config not found', () => {
+            const mockInstance = { id: '1', timestamp: Date.now(), hash: 'hash1' };
+            vi.mocked(hubManager.getServerInstanceByName).mockReturnValue([mockInstance]);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(undefined);
+            const result = selectBestInstance('test-server');
+            expect(result).toBeUndefined();
+            expect(hubManager.getServerByName).toHaveBeenCalledWith('test-server');
+        });
+        it('should return single instance directly when only one instance', () => {
+            const mockInstance = { id: '1', timestamp: Date.now(), hash: 'hash1' };
+            const mockConfig = {
+                type: 'stdio',
+                command: 'test-command',
+                args: [],
+                enabled: true,
+                allowedTools: [],
+                timeout: 30000
+            };
+            vi.mocked(hubManager.getServerInstanceByName).mockReturnValue([mockInstance]);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockConfig);
+            const result = selectBestInstance('test-server');
+            expect(result).toEqual({
+                name: 'test-server',
+                config: mockConfig,
+                instance: mockInstance
+            });
+        });
+        it('should use InstanceMatcher for multi-instance selection', () => {
+            const mockInstance1 = { id: '1', timestamp: Date.now(), hash: 'hash1' };
+            const mockInstance2 = { id: '2', timestamp: Date.now(), hash: 'hash2' };
+            const mockConfig = {
+                type: 'stdio',
+                command: 'test-command',
+                args: [],
+                enabled: true,
+                allowedTools: [],
+                timeout: 30000
+            };
+            vi.mocked(hubManager.getServerInstanceByName).mockReturnValue([mockInstance1, mockInstance2]);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockConfig);
+            vi.mocked(mcpConnectionManager.getStatus).mockReturnValue({
+                connected: true,
+                lastCheck: Date.now(),
+                toolsCount: 0,
+                resourcesCount: 0
+            });
+            const result = selectBestInstance('test-server');
+            expect(result).toBeDefined();
+            expect(result?.name).toBe('test-server');
+            expect(result?.config).toEqual(mockConfig);
+            expect(mcpConnectionManager.getStatus).toHaveBeenCalledTimes(2);
+        });
+        it('should prioritize connected instances', () => {
+            const timestamp = Date.now();
+            const mockInstance1 = { id: '1', timestamp, hash: 'hash1' };
+            const mockInstance2 = { id: '2', timestamp, hash: 'hash2' };
+            const mockConfig = {
+                type: 'stdio',
+                command: 'test-command',
+                args: [],
+                enabled: true,
+                allowedTools: [],
+                timeout: 30000
+            };
+            vi.mocked(hubManager.getServerInstanceByName).mockReturnValue([mockInstance1, mockInstance2]);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockConfig);
+            vi.mocked(mcpConnectionManager.getStatus).mockImplementation((id) => {
+                return {
+                    connected: id === '2', // Second instance is connected
+                    lastCheck: Date.now(),
+                    toolsCount: 0,
+                    resourcesCount: 0
+                };
+            });
+            const result = selectBestInstance('test-server');
+            expect(result?.instance.id).toBe('2'); // Should select connected instance (id: 2)
+        });
+        it('should use tag matching when requested', () => {
+            const timestamp = Date.now();
+            const mockInstance1 = { id: '1', timestamp, hash: 'hash1' };
+            const mockInstance2 = { id: '2', timestamp, hash: 'hash2' };
+            const mockConfig = {
+                type: 'stdio',
+                command: 'test-command',
+                args: [],
+                enabled: true,
+                allowedTools: [],
+                timeout: 30000
+            };
+            vi.mocked(hubManager.getServerInstanceByName).mockReturnValue([mockInstance1, mockInstance2]);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockConfig);
+            vi.mocked(mcpConnectionManager.getStatus).mockReturnValue({
+                connected: true,
+                lastCheck: Date.now(),
+                toolsCount: 0,
+                resourcesCount: 0
+            });
+            const result = selectBestInstance('test-server', { tags: { environment: 'dev' } });
+            expect(result).toBeDefined();
+        });
+        it('should fall back to first instance when no match found', () => {
+            const timestamp = Date.now();
+            const mockInstance1 = { id: '1', timestamp, hash: 'hash1' };
+            const mockInstance2 = { id: '2', timestamp, hash: 'hash2' };
+            const mockConfig = {
+                type: 'stdio',
+                command: 'test-command',
+                args: [],
+                enabled: true,
+                allowedTools: [],
+                timeout: 30000
+            };
+            vi.mocked(hubManager.getServerInstanceByName).mockReturnValue([mockInstance1, mockInstance2]);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockConfig);
+            vi.mocked(mcpConnectionManager.getStatus).mockReturnValue({
+                connected: false, // Both instances are disconnected
+                lastCheck: Date.now(),
+                toolsCount: 0,
+                resourcesCount: 0
+            });
+            // With tags requested but no match (instances have no tags)
+            const result = selectBestInstance('test-server', { tags: { environment: 'dev' } });
+            expect(result?.instance.id).toBe('1'); // Should fall back to first instance
+        });
+    });
+});