@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/tests/unit/services/hub-manager-service.test.js

@@ -0,0 +1,140 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { HubManagerService } from '../../../src/services/hub-manager.service.js';
+import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { configManager } from '../../../src/config/config-manager.js';
+// Mock dependencies
+vi.mock('@config/config-manager.js', () => ({
+    ConfigManager: vi.fn(),
+    configManager: {
+        addServer: vi.fn(),
+        getServers: vi.fn(),
+        getServerById: vi.fn(),
+        getServerByName: vi.fn(),
+        updateServer: vi.fn(),
+        removeServer: vi.fn(),
+        addServerInstance: vi.fn(),
+        getServerInstanceByName: vi.fn(),
+        updateServerInstance: vi.fn(),
+        removeServerInstance: vi.fn()
+    }
+}));
+vi.mock('@services/mcp-connection-manager.js', () => ({
+    mcpConnectionManager: {
+        connect: vi.fn(),
+        disconnect: vi.fn(() => Promise.resolve())
+    }
+}));
+vi.mock('@utils/logger.js', () => ({
+    logger: {
+        info: vi.fn(),
+        error: vi.fn(),
+        warn: vi.fn()
+    },
+    LOG_MODULES: {}
+}));
+describe('HubManagerService', () => {
+    let service;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        service = new HubManagerService(configManager);
+    });
+    it('should auto-connect when adding an enabled server instance', async () => {
+        const serverName = 'Test Server';
+        const serverBaseConfig = {
+            type: 'stdio',
+            command: 'node',
+            args: [],
+            enabled: true,
+            allowedTools: [],
+            timeout: 30000
+        };
+        const serverInstanceConfig = {
+            id: 'test-server',
+            timestamp: Date.now(),
+            hash: 'test-hash'
+        };
+        vi.mocked(configManager.addServer).mockResolvedValue(serverBaseConfig);
+        vi.mocked(configManager.addServerInstance).mockResolvedValue(serverInstanceConfig);
+        vi.mocked(configManager.getServerByName).mockReturnValue(serverBaseConfig);
+        await service.addServer(serverName, serverBaseConfig);
+        await service.addServerInstance(serverName, serverInstanceConfig);
+        expect(configManager.addServer).toHaveBeenCalledWith(serverName, serverBaseConfig);
+        expect(configManager.addServerInstance).toHaveBeenCalledWith(serverName, serverInstanceConfig);
+        expect(mcpConnectionManager.connect).toHaveBeenCalled();
+    });
+    it('should NOT auto-connect when adding a disabled server instance', async () => {
+        const serverName = 'Disabled Server';
+        const serverBaseConfig = {
+            type: 'stdio',
+            command: 'node',
+            args: [],
+            enabled: false,
+            allowedTools: [],
+            timeout: 30000
+        };
+        const serverInstanceConfig = {
+            id: 'test-server-disabled',
+            name: serverName,
+            timestamp: Date.now(),
+            hash: 'test-hash'
+        };
+        vi.mocked(configManager.addServer).mockResolvedValue(serverBaseConfig);
+        vi.mocked(configManager.addServerInstance).mockResolvedValue(serverInstanceConfig);
+        vi.mocked(configManager.getServerByName).mockReturnValue(serverBaseConfig);
+        await service.addServer(serverName, serverBaseConfig);
+        await service.addServerInstance(serverName, serverInstanceConfig);
+        expect(configManager.addServer).toHaveBeenCalledWith(serverName, serverBaseConfig);
+        expect(configManager.addServerInstance).toHaveBeenCalledWith(serverName, serverInstanceConfig);
+        expect(mcpConnectionManager.connect).not.toHaveBeenCalled();
+    });
+    it('should call disconnect when removing a server', async () => {
+        const serverName = 'Test Server';
+        const serverConfig = {
+            type: 'stdio',
+            command: 'node',
+            args: [],
+            enabled: true,
+            allowedTools: [],
+            timeout: 30000
+        };
+        vi.mocked(configManager.getServerByName).mockReturnValue(serverConfig);
+        vi.mocked(configManager.removeServer).mockResolvedValue();
+        vi.mocked(configManager.getServerInstanceByName).mockReturnValue([
+            {
+                id: 'test-server-instance',
+                timestamp: Date.now(),
+                hash: 'test-hash'
+            }
+        ]);
+        await service.removeServer(serverName);
+        expect(configManager.removeServer).toHaveBeenCalledWith(serverName);
+        expect(mcpConnectionManager.disconnect).toHaveBeenCalledWith('test-server-instance');
+    });
+    it('should get server by name', async () => {
+        const serverName = 'Test Server';
+        const serverBaseConfig = {
+            type: 'stdio',
+            command: 'test',
+            args: [],
+            enabled: true,
+            allowedTools: [],
+            timeout: 30000
+        };
+        vi.mocked(configManager.getServerByName).mockReturnValue(serverBaseConfig);
+        const server = service.getServerByName(serverName);
+        expect(server).toEqual(serverBaseConfig);
+        expect(configManager.getServerByName).toHaveBeenCalledWith(serverName);
+    });
+    it('should get server instances', async () => {
+        const serverName = 'Test Server';
+        const serverInstanceConfig = {
+            id: 'test-instance',
+            timestamp: Date.now(),
+            hash: 'test-hash'
+        };
+        vi.mocked(configManager.getServerInstanceByName).mockReturnValue([serverInstanceConfig]);
+        const instances = service.getServerInstanceByName(serverName);
+        expect(instances).toEqual([serverInstanceConfig]);
+        expect(configManager.getServerInstanceByName).toHaveBeenCalledWith(serverName);
+    });
+});

package/dist/server/tests/unit/services/hub-manager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hub-manager.test.d.ts.map

package/dist/server/tests/unit/services/hub-manager.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub-manager.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/services/hub-manager.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import Fastify from 'fastify';
+import { webServerRoutes } from '../../../src/api/web/servers.js';
+import { hubManager } from '../../../src/services/hub-manager.service.js';
+// Mock hubManager
+vi.mock('@services/hub-manager.service.js', () => ({
+    hubManager: {
+        getAllServers: vi.fn(),
+        getServerById: vi.fn(),
+        getServerByName: vi.fn(),
+        getServerInstances: vi.fn(),
+        getServerInstanceByName: vi.fn(),
+        addServer: vi.fn(),
+        addServerInstance: vi.fn(),
+        updateServer: vi.fn(),
+        updateServerInstance: vi.fn(),
+        removeServer: vi.fn(),
+        removeServerInstance: vi.fn()
+    }
+}));
+describe('Server API Routes', () => {
+    let app;
+    beforeEach(async () => {
+        app = Fastify();
+        app.register(webServerRoutes);
+        await app.ready();
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        app.close();
+    });
+    it('GET /api/servers should return all servers', async () => {
+        const mockServers = [
+            {
+                id: '1',
+                name: 'test',
+                config: {
+                    type: 'stdio',
+                    command: 'test',
+                    args: [],
+                    enabled: true,
+                    allowedTools: [],
+                    timeout: 30000
+                }
+            }
+        ];
+        vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+        const response = await app.inject({
+            method: 'GET',
+            url: '/web/servers'
+        });
+        expect(response.statusCode).toBe(200);
+        expect(JSON.parse(response.payload)).toEqual(mockServers);
+    });
+    it('POST /api/servers should add a server', async () => {
+        const newServer = {
+            name: 'New Server',
+            config: {
+                command: 'node',
+                args: [],
+                env: {},
+                enabled: true
+            }
+        };
+        const createdServer = {
+            type: 'stdio',
+            command: 'node',
+            args: [],
+            env: {},
+            enabled: true,
+            allowedTools: [],
+            timeout: 30000
+        };
+        vi.mocked(hubManager.addServer).mockReturnValue(Promise.resolve(createdServer));
+        const response = await app.inject({
+            method: 'POST',
+            url: '/web/servers',
+            payload: newServer
+        });
+        expect(response.statusCode).toBe(201);
+        expect(JSON.parse(response.payload)).toEqual({
+            name: newServer.name,
+            config: createdServer
+        });
+    });
+    it('POST /api/servers should validate input', async () => {
+        const invalidServer = {
+            name: '', // Empty name invalid
+            command: 'node'
+        };
+        const response = await app.inject({
+            method: 'POST',
+            url: '/web/servers',
+            payload: invalidServer
+        });
+        expect(response.statusCode).toBe(400);
+    });
+});

package/dist/server/tests/unit/services/hub-tools.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hub-tools.service.test.d.ts.map

package/dist/server/tests/unit/services/hub-tools.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub-tools.service.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/services/hub-tools.service.test.ts"],"names":[],"mappings":""}