@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/tests/unit/config/config-saver.test.js

@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { saveConfig } from '../../../src/config/config-saver.js';
+import * as fs from 'fs';
+import path from 'path';
+// Mock fs module
+vi.mock('fs');
+vi.mock('path');
+vi.mock('@utils/logger.js', () => ({
+    logger: {
+        debug: vi.fn(),
+        error: vi.fn()
+    }
+}));
+describe('ConfigSaver', () => {
+    const mockFs = vi.mocked(fs);
+    const mockPath = vi.mocked(path);
+    const testConfigPath = '/test/path/.mcp-hub.json';
+    const testDir = '/test/path';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockPath.dirname.mockReturnValue(testDir);
+        mockFs.existsSync.mockReturnValue(true);
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('saveConfig', () => {
+        it('should save configuration to disk', () => {
+            const config = {
+                version: '1.1.0',
+                system: {
+                    host: 'localhost',
+                    port: 7788
+                }
+            };
+            saveConfig(testConfigPath, config);
+            expect(mockPath.dirname).toHaveBeenCalledWith(testConfigPath);
+            expect(mockFs.existsSync).toHaveBeenCalledWith(testDir);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(testConfigPath, JSON.stringify(config, null, 2));
+        });
+        it('should create directory if it does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            const config = { version: '1.1.0' };
+            saveConfig(testConfigPath, config);
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith(testDir, { recursive: true });
+        });
+        it('should ignore errors during save', () => {
+            mockFs.writeFileSync.mockImplementation(() => {
+                throw new Error('Write failed');
+            });
+            const config = { version: '1.1.0' };
+            expect(() => saveConfig(testConfigPath, config)).not.toThrow();
+        });
+        it('should preserve empty string fields', () => {
+            const config = {
+                version: '1.1.0',
+                emptyField: '',
+                nonEmptyField: 'value'
+            };
+            saveConfig(testConfigPath, config);
+            const writtenContent = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenContent).toEqual(config);
+        });
+        it('should preserve empty array fields', () => {
+            const config = {
+                version: '1.1.0',
+                emptyArray: [],
+                nonEmptyArray: [1, 2, 3]
+            };
+            saveConfig(testConfigPath, config);
+            const writtenContent = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenContent).toEqual(config);
+        });
+        it('should preserve empty object fields', () => {
+            const config = {
+                version: '1.1.0',
+                emptyObject: {},
+                nonEmptyObject: { key: 'value' }
+            };
+            saveConfig(testConfigPath, config);
+            const writtenContent = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenContent).toEqual(config);
+        });
+        it('should preserve null and undefined fields', () => {
+            const config = {
+                version: '1.1.0',
+                nullField: null,
+                undefinedField: undefined,
+                validField: 'value'
+            };
+            saveConfig(testConfigPath, config);
+            const writtenContent = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenContent).toEqual({
+                version: '1.1.0',
+                nullField: null,
+                validField: 'value'
+            });
+        });
+        it('should preserve nested empty objects and arrays', () => {
+            const config = {
+                version: '1.1.0',
+                system: {
+                    host: 'localhost',
+                    port: 7788,
+                    emptyNested: {},
+                    emptyString: '',
+                    emptyArray: []
+                },
+                security: {
+                    emptyArray: [],
+                    maxConnections: 50
+                }
+            };
+            saveConfig(testConfigPath, config);
+            const writtenContent = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenContent).toEqual(config);
+        });
+        it('should preserve server configuration with empty collections', () => {
+            const config = {
+                version: '1.1.0',
+                servers: {
+                    'test-server': {
+                        template: {
+                            type: 'stdio',
+                            timeout: 60000,
+                            command: 'npx test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: []
+                        },
+                        instances: [
+                            {
+                                id: 'instance-1',
+                                enabled: true,
+                                args: [],
+                                env: {},
+                                headers: {},
+                                tags: {}
+                            }
+                        ]
+                    }
+                }
+            };
+            saveConfig(testConfigPath, config);
+            const writtenContent = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenContent).toEqual(config);
+        });
+        it('should handle complex real-world configuration with empty values', () => {
+            const realConfig = {
+                version: '1.1.0',
+                system: {
+                    host: 'localhost',
+                    port: 7788,
+                    language: 'zh',
+                    theme: 'system',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        extraField: '',
+                        debugOptions: {}
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    emptyConfig: []
+                },
+                servers: {
+                    'my-server': {
+                        template: {
+                            command: 'npx my-server',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            timeout: 60000,
+                            aggregatedTools: [],
+                            type: 'stdio'
+                        },
+                        instances: [
+                            {
+                                id: 'default',
+                                enabled: true,
+                                args: [],
+                                env: {},
+                                headers: {},
+                                tags: {}
+                            }
+                        ]
+                    }
+                },
+                emptySection: {}
+            };
+            saveConfig(testConfigPath, realConfig);
+            const writtenContent = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenContent).toEqual(realConfig);
+        });
+    });
+});

package/dist/server/tests/unit/config/config.schema.test.d.ts

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

package/dist/server/tests/unit/config/config.schema.test.d.ts.map

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

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

@@ -0,0 +1,347 @@
+import { describe, it, expect } from 'vitest';
+import { TagDefinitionSchema, ServerInstanceSchema, ServerInstanceUpdateSchema, ServerTemplateSchema, ServerConfigSchema, SystemConfigSchema, isLegacyV1Config } from '../../../src/config/config.schema.js';
+describe('Config Schema (v1.1)', () => {
+    describe('TagDefinitionSchema', () => {
+        it('should validate a valid tag definition', () => {
+            const tagDef = {
+                key: 'environment',
+                description: 'Deployment environment',
+                type: 'enum',
+                values: ['dev', 'staging', 'prod']
+            };
+            const result = TagDefinitionSchema.safeParse(tagDef);
+            expect(result.success).toBe(true);
+        });
+        it('should use default values for optional fields', () => {
+            const tagDef = {
+                key: 'simple-tag'
+            };
+            const result = TagDefinitionSchema.safeParse(tagDef);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.type).toBe('string');
+            }
+        });
+        it('should reject invalid tag types', () => {
+            const tagDef = {
+                key: 'test',
+                type: 'invalid-type'
+            };
+            const result = TagDefinitionSchema.safeParse(tagDef);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('ServerInstanceSchema', () => {
+        it('should validate a valid server instance', () => {
+            const instance = {
+                id: 'instance-1',
+                enabled: true,
+                args: ['--verbose'],
+                env: { NODE_ENV: 'development' },
+                headers: {},
+                tags: { environment: 'dev', region: 'us-east' }
+            };
+            const result = ServerInstanceSchema.safeParse(instance);
+            expect(result.success).toBe(true);
+        });
+        it('should use default values for optional fields', () => {
+            const instance = {
+                id: 'instance-1'
+            };
+            const result = ServerInstanceSchema.safeParse(instance);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.enabled).toBe(true);
+                expect(result.data.args).toEqual([]);
+                expect(result.data.env).toEqual({});
+                expect(result.data.headers).toEqual({});
+                expect(result.data.tags).toEqual({});
+            }
+        });
+        it('should reject instances without id', () => {
+            const instance = {
+                enabled: true
+            };
+            const result = ServerInstanceSchema.safeParse(instance);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('ServerTemplateSchema', () => {
+        it('should validate a valid server template', () => {
+            const template = {
+                command: 'npx my-server',
+                args: ['--config', 'default.json'],
+                env: { LOG_LEVEL: 'info' },
+                headers: {},
+                type: 'stdio',
+                timeout: 60000,
+                aggregatedTools: ['tool1', 'tool2'],
+                description: 'My MCP server template'
+            };
+            const result = ServerTemplateSchema.safeParse(template);
+            expect(result.success).toBe(true);
+        });
+        it('should use default values', () => {
+            const template = {};
+            const result = ServerTemplateSchema.safeParse(template);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.type).toBe('stdio');
+                expect(result.data.timeout).toBe(60000);
+                expect(result.data.args).toEqual([]);
+                expect(result.data.env).toEqual({});
+                expect(result.data.headers).toEqual({});
+                expect(result.data.aggregatedTools).toEqual([]);
+            }
+        });
+    });
+    describe('ServerConfigSchema', () => {
+        it('should validate a complete server configuration', () => {
+            const serverConfig = {
+                template: {
+                    command: 'npx my-server',
+                    args: [],
+                    env: {},
+                    headers: {},
+                    type: 'stdio',
+                    timeout: 60000,
+                    aggregatedTools: []
+                },
+                instances: [
+                    {
+                        id: 'instance-1',
+                        enabled: true,
+                        args: [],
+                        env: {},
+                        headers: {},
+                        tags: { environment: 'dev' }
+                    },
+                    {
+                        id: 'instance-2',
+                        enabled: false,
+                        args: [],
+                        env: {},
+                        headers: {},
+                        tags: { environment: 'prod' }
+                    }
+                ],
+                tagDefinitions: [
+                    {
+                        key: 'environment',
+                        type: 'enum',
+                        values: ['dev', 'prod']
+                    }
+                ]
+            };
+            const result = ServerConfigSchema.safeParse(serverConfig);
+            expect(result.success).toBe(true);
+        });
+        it('should validate all instance selection strategies', () => {
+            const strategies = [
+                'random',
+                'round-robin',
+                'tag-match-unique'
+            ];
+            for (const strategy of strategies) {
+                const serverConfig = {
+                    template: {
+                        command: 'npx my-server',
+                        instanceSelectionStrategy: strategy
+                    }
+                };
+                const result = ServerConfigSchema.safeParse(serverConfig);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.template.instanceSelectionStrategy).toBe(strategy);
+                }
+            }
+        });
+        it('should reject invalid instance selection strategies', () => {
+            const serverConfig = {
+                template: {
+                    command: 'npx my-server',
+                    instanceSelectionStrategy: 'invalid-strategy'
+                }
+            };
+            const result = ServerConfigSchema.safeParse(serverConfig);
+            expect(result.success).toBe(false);
+        });
+        it('should use defaults for empty instances and tagDefinitions', () => {
+            const serverConfig = {
+                template: {
+                    command: 'npx my-server'
+                }
+            };
+            const result = ServerConfigSchema.safeParse(serverConfig);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.instances).toEqual([]);
+                expect(result.data.tagDefinitions).toEqual([]);
+                expect(result.data.template.instanceSelectionStrategy).toBeUndefined();
+            }
+        });
+    });
+    describe('Type Guards', () => {
+        describe('isLegacyV1Config', () => {
+            it('should recognize v1 config by version', () => {
+                const config = {
+                    version: '1.0.0',
+                    servers: {}
+                };
+                expect(isLegacyV1Config(config)).toBe(true);
+            });
+            it('should not recognize v1.1 config', () => {
+                const config = {
+                    version: '1.1.0',
+                    servers: {}
+                };
+                expect(isLegacyV1Config(config)).toBe(false);
+            });
+            it('should handle null/undefined', () => {
+                expect(isLegacyV1Config(null)).toBe(false);
+                expect(isLegacyV1Config(undefined)).toBe(false);
+            });
+        });
+    });
+    describe('SystemConfigSchema', () => {
+        it('should validate a complete system configuration', () => {
+            const config = {
+                version: '1.1.0',
+                system: {
+                    host: 'localhost',
+                    port: 7788,
+                    language: 'zh',
+                    theme: 'system',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        apiDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    maxConnections: 50
+                },
+                servers: {},
+                tagDefinitions: []
+            };
+            const result = SystemConfigSchema.safeParse(config);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('ServerInstanceUpdateSchema (Regression Test)', () => {
+        it('should NOT add default values when parsing empty object', () => {
+            const updates = {};
+            const result = ServerInstanceUpdateSchema.safeParse(updates);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                // Should NOT have default values - only the fields that were provided
+                expect(result.data).toEqual({});
+                expect(result.data.args).toBeUndefined();
+                expect(result.data.env).toBeUndefined();
+                expect(result.data.headers).toBeUndefined();
+                expect(result.data.tags).toBeUndefined();
+                expect(result.data.enabled).toBeUndefined();
+            }
+        });
+        it('should preserve only the provided fields (displayName only)', () => {
+            const updates = { displayName: 'My Updated Instance' };
+            const result = ServerInstanceUpdateSchema.safeParse(updates);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.displayName).toBe('My Updated Instance');
+                expect(result.data.args).toBeUndefined();
+                expect(result.data.env).toBeUndefined();
+                expect(result.data.headers).toBeUndefined();
+                expect(result.data.tags).toBeUndefined();
+            }
+        });
+        it('should preserve only the provided fields (env only)', () => {
+            const updates = { env: { NEW_KEY: 'new-value' } };
+            const result = ServerInstanceUpdateSchema.safeParse(updates);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.env).toEqual({ NEW_KEY: 'new-value' });
+                expect(result.data.args).toBeUndefined();
+                expect(result.data.headers).toBeUndefined();
+                expect(result.data.tags).toBeUndefined();
+                expect(result.data.displayName).toBeUndefined();
+            }
+        });
+        it('should preserve only the provided fields (args only)', () => {
+            const updates = { args: ['--new-arg'] };
+            const result = ServerInstanceUpdateSchema.safeParse(updates);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.args).toEqual(['--new-arg']);
+                expect(result.data.env).toBeUndefined();
+                expect(result.data.headers).toBeUndefined();
+                expect(result.data.tags).toBeUndefined();
+            }
+        });
+        it('should work correctly with object merge (preventing regression)', () => {
+            // Simulate the original instance with existing values
+            const originalInstance = {
+                id: 'instance-1',
+                enabled: true,
+                args: ['--existing-arg'],
+                env: { EXISTING_KEY: 'existing-value' },
+                headers: { 'X-Existing': 'header' },
+                tags: { existing: 'tag' }
+            };
+            // User only wants to update displayName
+            const updates = { displayName: 'Updated Name' };
+            const parsedUpdates = ServerInstanceUpdateSchema.parse(updates);
+            // Merge should NOT overwrite existing env/args/headers/tags
+            const mergedInstance = {
+                ...originalInstance,
+                ...parsedUpdates
+            };
+            // Verify existing fields are preserved
+            expect(mergedInstance.args).toEqual(['--existing-arg']);
+            expect(mergedInstance.env).toEqual({ EXISTING_KEY: 'existing-value' });
+            expect(mergedInstance.headers).toEqual({ 'X-Existing': 'header' });
+            expect(mergedInstance.tags).toEqual({ existing: 'tag' });
+            expect(mergedInstance.displayName).toBe('Updated Name');
+        });
+        it('should work correctly when updating env without affecting args', () => {
+            const originalInstance = {
+                id: 'instance-1',
+                enabled: true,
+                args: ['--keep-this'],
+                env: { KEEP_THIS: 'value' },
+                headers: {},
+                tags: {}
+            };
+            const updates = { env: { NEW_KEY: 'new-value' } };
+            const parsedUpdates = ServerInstanceUpdateSchema.parse(updates);
+            const mergedInstance = {
+                ...originalInstance,
+                ...parsedUpdates
+            };
+            // args should still be preserved
+            expect(mergedInstance.args).toEqual(['--keep-this']);
+            // env should be updated
+            expect(mergedInstance.env).toEqual({ NEW_KEY: 'new-value' });
+        });
+        it('should NOT fill in defaults when using ServerInstanceSchema.partial() [demonstrating the bug]', () => {
+            // This test demonstrates the bug we're fixing
+            const updates = { displayName: 'Test' };
+            const result = ServerInstanceSchema.partial().safeParse(updates);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                // ServerInstanceSchema.partial() WILL add default values!
+                // This is the bug - it adds args: [], env: {}, etc.
+                expect(result.data.args).toEqual([]);
+                expect(result.data.env).toEqual({});
+                expect(result.data.headers).toEqual({});
+                expect(result.data.tags).toEqual({});
+            }
+        });
+    });
+});