@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/tests/unit/utils/config.test.js

@@ -29,9 +29,6 @@ describe('ConfigManager', () => {
         configManager = new ConfigManager(tempConfigPath);
     });
     afterEach(() => {
-        // Force garbage collection to ensure config manager instance is destroyed
-        // Since tests need to frequently create and destroy instances, don't set to null here
-        // Instead, let each test case create a new instance
         // Restore original environment variables
         process.env = { ...originalEnv };
         // Clean up temporary directory with retry mechanism to prevent permission issues
@@ -65,14 +62,14 @@ describe('ConfigManager', () => {
             const config = configManager.getConfig();
             // Verify default configuration
             expect(config).toBeDefined();
-            expect(config.version).toBe('1.0.0');
+            expect(config.version).toBe('1.1.0');
             expect(config.system.host).toBe('localhost');
             expect(config.system.port).toBe(7788);
             expect(config.servers).toEqual({});
         });
         it('should load existing config file', () => {
             const testConfig = {
-                version: '1.0.0',
+                version: '1.1.0',
                 system: {
                     host: 'test-host',
                     port: 8080,
@@ -80,10 +77,10 @@ describe('ConfigManager', () => {
                     theme: 'light',
                     logging: {
                         level: 'debug',
-                        rotation: {
-                            enabled: true,
-                            maxAge: '30d'
-                        }
+                        rotationAge: '30d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        apiDebug: false
                     }
                 },
                 security: {
@@ -92,23 +89,28 @@ describe('ConfigManager', () => {
                     connectionTimeout: 15000,
                     idleConnectionTimeout: 60000,
                     sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 900000,
                     maxConnections: 20
                 },
                 servers: {
                     'test-server': {
-                        command: 'test-command',
-                        args: ['arg1', 'arg2'],
-                        enabled: true,
-                        type: 'stdio',
-                        timeout: 30000
-                    }
-                },
-                observability: {
-                    tracing: {
-                        enabled: true,
-                        exporter: 'otlp',
-                        endpoint: 'http://test:4318/v1/traces',
-                        sampleRate: 0.5
+                        template: {
+                            command: 'test-command',
+                            args: ['arg1', 'arg2'],
+                            type: 'stdio',
+                            timeout: 30000,
+                            aggregatedTools: [],
+                            tags: {}
+                        },
+                        instances: [
+                            {
+                                id: 'test-server-1',
+                                enabled: true,
+                                args: [],
+                                tags: {}
+                            }
+                        ],
+                        tagDefinitions: []
                     }
                 }
             };
@@ -120,7 +122,7 @@ describe('ConfigManager', () => {
             expect(config.system.host).toBe('test-host');
             expect(config.system.port).toBe(8080);
             expect(config.servers['test-server']).toBeDefined();
-            expect(config.servers['test-server'].command).toBe('test-command');
+            expect(config.servers['test-server'].template.command).toBe('test-command');
         });
         it('should handle invalid config file gracefully', () => {
             // Write invalid JSON
@@ -128,20 +130,15 @@ describe('ConfigManager', () => {
             configManager = new ConfigManager(tempConfigPath);
             const config = configManager.getConfig();
             // Should fall back to default configuration
-            expect(config.version).toBe('1.0.0');
+            expect(config.version).toBe('1.1.0');
             expect(config.system.host).toBe('localhost');
         });
     });
     describe('Configuration Saving', () => {
-        it('should save config to file', () => {
-            console.log('[TEST] Starting "should save config to file" test');
-            console.log('[TEST] tempConfigPath:', tempConfigPath);
+        it('should save config to file', async () => {
             configManager = new ConfigManager(tempConfigPath);
-            // Log initial configuration
-            const initialConfig = configManager.getConfig();
-            console.log('[TEST] Initial config:', JSON.stringify(initialConfig));
             // Modify configuration
-            configManager.updateConfig({
+            await configManager.updateConfig({
                 system: {
                     host: 'new-host',
                     port: 9090,
@@ -152,24 +149,18 @@ describe('ConfigManager', () => {
                         rotationAge: '7d',
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             });
-            // Log in-memory configuration
-            const memoryConfig = configManager.getConfig();
-            console.log('[TEST] Memory config after update:', JSON.stringify(memoryConfig));
             // Verify file was created and contains correct content
             expect(fs.existsSync(tempConfigPath)).toBe(true);
             const savedContent = fs.readFileSync(tempConfigPath, 'utf-8');
-            console.log('[TEST] File content:', savedContent);
             const savedConfig = JSON.parse(savedContent);
-            console.log('[TEST] Parsed config from file:', JSON.stringify(savedConfig));
             expect(savedConfig.system.host).toBe('new-host');
             expect(savedConfig.system.port).toBe(9090);
-            console.log('[TEST] Test passed');
         });
-        it('should create config directory if it does not exist', () => {
+        it('should create config directory if it does not exist', async () => {
             const testRunId = `non-existent-dir-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`;
             const nonExistentPath = path.join(os.tmpdir(), testRunId, '.mcp-hub.json');
             // Ensure directory doesn't exist
@@ -191,7 +182,7 @@ describe('ConfigManager', () => {
             }
             configManager = new ConfigManager(nonExistentPath);
             // Modify configuration to trigger save
-            configManager.updateConfig({
+            await configManager.updateConfig({
                 system: {
                     host: 'test-host',
                     port: 7788,
@@ -202,7 +193,7 @@ describe('ConfigManager', () => {
                         rotationAge: '7d',
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             });
@@ -244,7 +235,7 @@ describe('ConfigManager', () => {
                         rotationAge: '7d',
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             };
@@ -259,72 +250,67 @@ describe('ConfigManager', () => {
             configManager = new ConfigManager(tempConfigPath);
         });
         it('should add a new server', async () => {
-            const serverConfig = {
+            const serverTemplate = {
                 command: 'test-command',
                 args: ['arg1'],
-                enabled: true,
                 type: 'stdio'
             };
-            await configManager.addServer('test-server', serverConfig);
+            await configManager.addServer('test-server', serverTemplate);
             const servers = configManager.getServers();
             expect(servers).toHaveLength(1);
             expect(servers[0].name).toBe('test-server');
-            expect(servers[0].config.command).toBe('test-command');
+            expect(servers[0].config.template.command).toBe('test-command');
+            expect(servers[0].config.instances).toHaveLength(1);
         });
         it('should validate server config when adding', async () => {
             const invalidServerConfig = {
                 command: 'test-command',
-                type: 'invalid-type' // Invalid type
+                type: 'invalid-type'
             };
             await expect(configManager.addServer('test-server', invalidServerConfig)).rejects.toThrow();
         });
-        it('should get server by name', () => {
+        it('should get server by name', async () => {
             const serverConfig = {
                 command: 'test-command',
-                enabled: true,
                 type: 'stdio'
             };
-            configManager.addServer('test-server', serverConfig);
+            await configManager.addServer('test-server', serverConfig);
             const server = configManager.getServerByName('test-server');
             expect(server).toBeDefined();
-            expect(server?.command).toBe('test-command');
+            expect(server?.template.command).toBe('test-command');
             const nonExistentServer = configManager.getServerByName('non-existent');
             expect(nonExistentServer).toBeUndefined();
         });
         it('should update existing server', async () => {
             const initialConfig = {
                 command: 'initial-command',
-                enabled: true,
                 type: 'stdio'
             };
             await configManager.addServer('test-server', initialConfig);
             const updates = {
-                command: 'updated-command',
-                enabled: false
+                command: 'updated-command'
             };
             await configManager.updateServer('test-server', updates);
             const updatedServer = configManager.getServerByName('test-server');
-            expect(updatedServer?.command).toBe('updated-command');
-            expect(updatedServer?.enabled).toBe(false);
+            expect(updatedServer?.template.command).toBe('updated-command');
         });
         it('should not update non-existent server', async () => {
-            await configManager.updateServer('non-existent', { enabled: false });
-            const server = configManager.getServerByName('non-existent');
-            expect(server).toBeUndefined();
+            const result = await configManager.updateServer('non-existent', { command: 'test' });
+            expect(result).toBeNull();
         });
         it('should remove server', async () => {
             await configManager.addServer('test-server', {
                 command: 'test-command',
-                enabled: true,
                 type: 'stdio'
             });
-            await configManager.removeServer('test-server');
+            const result = await configManager.removeServer('test-server');
+            expect(result).toBe(true);
             const server = configManager.getServerByName('test-server');
             expect(server).toBeUndefined();
         });
         it('should not remove non-existent server', async () => {
-            await configManager.removeServer('non-existent');
-            // Should not throw an exception
+            const result = await configManager.removeServer('non-existent');
+            expect(result).toBe(false);
         });
     });
     describe('Server Instance Management', () => {
@@ -335,125 +321,71 @@ describe('ConfigManager', () => {
             // Add server first
             await configManager.addServer('test-server', {
                 command: 'test-command',
-                enabled: true,
                 type: 'stdio'
             });
             const instanceConfig = {
-                pid: 12345
+                enabled: false
             };
             const instance = await configManager.addServerInstance('test-server', instanceConfig);
-            expect(instance.id).toBeDefined();
-            expect(instance.pid).toBe(12345);
-            expect(instance.timestamp).toBeDefined();
-            expect(instance.hash).toBeDefined();
+            expect(instance.id).toMatch(/^test-server-[0-9a-f]{8}(-[0-9]+)?$/);
+            expect(instance.enabled).toBe(false);
         });
         it('should add server instance with provided ID', async () => {
             await configManager.addServer('test-server', {
                 command: 'test-command',
-                enabled: true,
                 type: 'stdio'
             });
             const instanceConfig = {
                 id: 'custom-id',
-                timestamp: 1234567890,
-                hash: 'custom-hash',
-                pid: 12345
+                enabled: true,
+                args: ['--verbose'],
+                tags: { env: 'test' }
             };
             const instance = await configManager.addServerInstance('test-server', instanceConfig);
             expect(instance.id).toBe('custom-id');
-            expect(instance.timestamp).toBe(1234567890);
-            expect(instance.hash).toBe('custom-hash');
-            expect(instance.pid).toBe(12345);
-        });
-        it('should validate server instance config', async () => {
-            await configManager.addServer('test-server', {
-                command: 'test-command',
-                enabled: true,
-                type: 'stdio'
-            });
-            const invalidInstance = {
-                id: 'test-id',
-                timestamp: 'invalid-timestamp' // Should be a number
-            };
-            await expect(configManager.addServerInstance('test-server', invalidInstance)).rejects.toThrow();
+            expect(instance.enabled).toBe(true);
+            expect(instance.args).toEqual(['--verbose']);
+            expect(instance.tags).toEqual({ env: 'test' });
         });
-        it('should get server instances by name', () => {
-            const instances = configManager.getServerInstanceByName('non-existent');
+        it('should get server instances by name', async () => {
+            const instances = configManager.getServerInstancesByName('non-existent');
             expect(instances).toHaveLength(0);
             // Add server and instance
-            configManager.addServer('test-server', {
-                command: 'test-command',
-                enabled: true,
-                type: 'stdio'
-            });
-            configManager.addServerInstance('test-server', { pid: 12345 });
-            const testInstances = configManager.getServerInstanceByName('test-server');
-            expect(testInstances).toHaveLength(1);
-        });
-        it('should get all server instances', () => {
-            const allInstances = configManager.getServerInstances();
-            expect(Object.keys(allInstances)).toHaveLength(0);
-            // Add server and instance
-            configManager.addServer('server1', {
-                command: 'cmd1',
-                enabled: true,
-                type: 'stdio'
-            });
-            configManager.addServer('server2', {
-                command: 'cmd2',
-                enabled: true,
-                type: 'stdio'
-            });
-            configManager.addServerInstance('server1', { pid: 12345 });
-            configManager.addServerInstance('server2', { pid: 67890 });
-            const allInstancesAfter = configManager.getServerInstances();
-            expect(Object.keys(allInstancesAfter)).toHaveLength(2);
-            expect(allInstancesAfter.server1).toHaveLength(1);
-            expect(allInstancesAfter.server2).toHaveLength(1);
-        });
-        it('should get server by instance ID', async () => {
             await configManager.addServer('test-server', {
                 command: 'test-command',
-                enabled: true,
                 type: 'stdio'
             });
-            await configManager.addServerInstance('test-server', {
-                id: 'test-instance-id',
-                timestamp: Date.now(),
-                hash: 'test-hash',
-                pid: 12345
-            });
-            const result = configManager.getServerById('test-instance-id');
-            expect(result).toBeDefined();
-            expect(result?.name).toBe('test-server');
-            expect(result?.instance.id).toBe('test-instance-id');
-            expect(result?.config.command).toBe('test-command');
-            const nonExistent = configManager.getServerById('non-existent');
-            expect(nonExistent).toBeUndefined();
+            await configManager.addServerInstance('test-server', { enabled: true });
+            const testInstances = configManager.getServerInstancesByName('test-server');
+            expect(testInstances).toHaveLength(2); // Default instance + new one
         });
         it('should update server instance', async () => {
             await configManager.addServer('test-server', {
                 command: 'test-command',
-                enabled: true,
                 type: 'stdio'
             });
-            await configManager.addServerInstance('test-server', { pid: 12345 });
-            await configManager.updateServerInstance('test-server', 0, { pid: 54321 });
-            const instances = configManager.getServerInstanceByName('test-server');
-            expect(instances[0].pid).toBe(54321);
+            const instances = configManager.getServerInstancesByName('test-server');
+            const index = instances[0].index ?? 0;
+            const result = await configManager.updateServerInstance('test-server', index, {
+                enabled: false
+            });
+            expect(result).toBe(true);
+            const updatedInstances = configManager.getServerInstancesByName('test-server');
+            expect(updatedInstances[0].enabled).toBe(false);
         });
         it('should remove server instance', async () => {
             await configManager.addServer('test-server', {
                 command: 'test-command',
-                enabled: true,
                 type: 'stdio'
             });
-            await configManager.addServerInstance('test-server', { pid: 12345 });
-            await configManager.addServerInstance('test-server', { pid: 67890 });
-            await configManager.removeServerInstance('test-server', 0);
-            const instances = configManager.getServerInstanceByName('test-server');
-            expect(instances).toHaveLength(1);
-            expect(instances[0].pid).toBe(67890);
+            await configManager.addServerInstance('test-server', { id: 'instance-1', enabled: true });
+            await configManager.addServerInstance('test-server', { id: 'instance-2', enabled: true });
+            let instances = configManager.getServerInstancesByName('test-server');
+            expect(instances).toHaveLength(3); // Default + 2 added
+            const result = await configManager.removeServerInstance('test-server', 0);
+            expect(result).toBe(true);
+            instances = configManager.getServerInstancesByName('test-server');
+            expect(instances).toHaveLength(2);
         });
     });
     describe('Configuration Updates and Change Logging', () => {
@@ -472,7 +404,7 @@ describe('ConfigManager', () => {
                         rotationAge: '7d',
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 },
                 security: {
@@ -491,30 +423,6 @@ describe('ConfigManager', () => {
             expect(config.system.port).toBe(9090);
             expect(config.security.maxConcurrentConnections).toBe(100);
         });
-        it('should log configuration changes', async () => {
-            // Mock logger
-            const loggerInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
-            await configManager.updateConfig({
-                system: {
-                    host: 'new-host',
-                    port: 7788,
-                    language: 'zh',
-                    theme: 'system',
-                    logging: {
-                        level: 'info',
-                        rotationAge: '7d',
-                        jsonPretty: true,
-                        mcpCommDebug: false,
-                        sessionDebug: false
-                    }
-                }
-            });
-            // Verify logger is called (note: actual logging happens in logger module)
-            // Since logger is an external dependency, we primarily verify the configuration update itself
-            const config = configManager.getConfig();
-            expect(config.system.host).toBe('new-host');
-            loggerInfoSpy.mockRestore();
-        });
         it('should handle partial config updates', async () => {
             // Initial configuration
             const initialConfig = configManager.getConfig();
@@ -549,13 +457,13 @@ describe('ConfigManager', () => {
                         rotationAge: '7d',
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             });
             // Directly modify file content
             const fileConfig = {
-                version: '1.0.0',
+                version: '1.1.0',
                 system: {
                     host: 'file-host',
                     port: 7788,
@@ -566,7 +474,7 @@ describe('ConfigManager', () => {
                         rotationAge: '7d',
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 },
                 security: {
@@ -575,17 +483,11 @@ describe('ConfigManager', () => {
                     connectionTimeout: 30000,
                     idleConnectionTimeout: 300000,
                     sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 900000,
                     maxConnections: 50
                 },
                 servers: {},
-                observability: {
-                    tracing: {
-                        enabled: false,
-                        exporter: 'console',
-                        endpoint: 'http://localhost:4318/v1/traces',
-                        sampleRate: 1.0
-                    }
-                }
+                tagDefinitions: []
             };
             fs.writeFileSync(tempConfigPath, JSON.stringify(fileConfig, null, 2));
             // Synchronize configuration
@@ -601,11 +503,11 @@ describe('ConfigManager', () => {
             fs.mkdirSync(tempDir, { recursive: true });
             const testTempConfigPath = path.join(tempDir, '.mcp-hub.json');
             // Write initial configuration
-            fs.writeFileSync(testTempConfigPath, JSON.stringify({ version: '1.0.0' }));
+            fs.writeFileSync(testTempConfigPath, JSON.stringify({ version: '1.1.0' }));
             configManager = new ConfigManager(testTempConfigPath);
             const config = configManager.getConfig();
             expect(config).toBeDefined();
-            expect(config.version).toBe('1.0.0');
+            expect(config.version).toBe('1.1.0');
             // Clean up, add retry mechanism
             let retries = 3;
             while (retries > 0) {
@@ -627,7 +529,7 @@ describe('ConfigManager', () => {
             configManager = new ConfigManager(tempConfigPath);
             const config = configManager.getConfig();
             // Should fill in default values
-            expect(config.version).toBe('1.0.0');
+            expect(config.version).toBe('1.1.0');
             expect(config.system.host).toBe('localhost');
         });
     });