@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

package/dist/server/tests/unit/services/instance-matcher.test.d.ts

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

package/dist/server/tests/unit/services/instance-matcher.test.d.ts.map

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

package/dist/server/tests/unit/services/instance-matcher.test.js

@@ -0,0 +1,256 @@
+import { describe, it, expect } from 'vitest';
+import { calculateMatchScore, filterEnabledInstances, sortByConnectionStatus, selectBestMatch } from '../../../src/services/hub-tools/instance-matcher.js';
+describe('InstanceMatcher', () => {
+    describe('calculateMatchScore', () => {
+        it('should return 1.0 for exact tag match', () => {
+            const instance = {
+                id: 'instance-1',
+                enabled: true,
+                args: [],
+                tags: { environment: 'dev', region: 'us-east' }
+            };
+            const requestedTags = { environment: 'dev', region: 'us-east' };
+            const score = calculateMatchScore(instance, requestedTags);
+            expect(score).toBe(1.0);
+        });
+        it('should return 0.5 for partial match (50% match)', () => {
+            const instance = {
+                id: 'instance-1',
+                enabled: true,
+                args: [],
+                tags: { environment: 'dev', region: 'us-east' }
+            };
+            const requestedTags = { environment: 'dev', region: 'eu-west' };
+            const score = calculateMatchScore(instance, requestedTags);
+            expect(score).toBe(0.5);
+        });
+        it('should return 0.0 for no matching tags', () => {
+            const instance = {
+                id: 'instance-1',
+                enabled: true,
+                args: [],
+                tags: { environment: 'prod', region: 'us-west' }
+            };
+            const requestedTags = { environment: 'dev', region: 'eu-west' };
+            const score = calculateMatchScore(instance, requestedTags);
+            expect(score).toBe(0.0);
+        });
+        it('should return 1.0 when no tags requested', () => {
+            const instance = {
+                id: 'instance-1',
+                enabled: true,
+                args: [],
+                tags: { environment: 'dev' }
+            };
+            const score = calculateMatchScore(instance, undefined);
+            expect(score).toBe(1.0);
+        });
+        it('should return 1.0 when instance has no tags but none requested', () => {
+            const instance = {
+                id: 'instance-1',
+                enabled: true,
+                args: [],
+                tags: {}
+            };
+            const score = calculateMatchScore(instance, undefined);
+            expect(score).toBe(1.0);
+        });
+        it('should return 0.0 when tags requested but instance has none', () => {
+            const instance = {
+                id: 'instance-1',
+                enabled: true,
+                args: [],
+                tags: {}
+            };
+            const requestedTags = { environment: 'dev' };
+            const score = calculateMatchScore(instance, requestedTags);
+            expect(score).toBe(0.0);
+        });
+        it('should handle empty requested tags object', () => {
+            const instance = {
+                id: 'instance-1',
+                enabled: true,
+                args: [],
+                tags: { environment: 'dev' }
+            };
+            const score = calculateMatchScore(instance, {});
+            expect(score).toBe(1.0);
+        });
+    });
+    describe('filterEnabledInstances', () => {
+        it('should return only enabled instances', () => {
+            const instances = [
+                { id: 'instance-1', enabled: true, args: [], tags: {} },
+                { id: 'instance-2', enabled: false, args: [], tags: {} },
+                { id: 'instance-3', enabled: true, args: [], tags: {} }
+            ];
+            const result = filterEnabledInstances(instances);
+            expect(result).toHaveLength(2);
+            expect(result.map((i) => i.id)).toEqual(['instance-1', 'instance-3']);
+        });
+        it('should handle empty array', () => {
+            const result = filterEnabledInstances([]);
+            expect(result).toEqual([]);
+        });
+        it('should default to enabled when field is missing', () => {
+            const instances = [
+                { id: 'instance-1', args: [], tags: {} } // No enabled field
+            ];
+            const result = filterEnabledInstances(instances);
+            expect(result).toHaveLength(1);
+        });
+    });
+    describe('sortByConnectionStatus', () => {
+        it('should prioritize connected instances first', () => {
+            const instances = [
+                { id: 'instance-1', enabled: true, args: [], tags: {}, connected: false },
+                { id: 'instance-2', enabled: true, args: [], tags: {}, connected: true },
+                { id: 'instance-3', enabled: true, args: [], tags: {}, connected: true }
+            ];
+            const result = sortByConnectionStatus(instances);
+            expect(result.map((i) => i.id)).toEqual(['instance-2', 'instance-3', 'instance-1']);
+        });
+        it('should preserve order among connected instances', () => {
+            const instances = [
+                { id: 'instance-1', enabled: true, args: [], tags: {}, connected: true },
+                { id: 'instance-2', enabled: true, args: [], tags: {}, connected: true }
+            ];
+            const result = sortByConnectionStatus(instances);
+            expect(result.map((i) => i.id)).toEqual(['instance-1', 'instance-2']);
+        });
+        it('should preserve order among disconnected instances', () => {
+            const instances = [
+                { id: 'instance-1', enabled: true, args: [], tags: {}, connected: false },
+                { id: 'instance-2', enabled: true, args: [], tags: {}, connected: false }
+            ];
+            const result = sortByConnectionStatus(instances);
+            expect(result.map((i) => i.id)).toEqual(['instance-1', 'instance-2']);
+        });
+        it('should handle empty array', () => {
+            const result = sortByConnectionStatus([]);
+            expect(result).toEqual([]);
+        });
+        it('should treat missing connected status as disconnected', () => {
+            const instances = [
+                { id: 'instance-1', enabled: true, args: [], tags: {}, connected: true },
+                { id: 'instance-2', enabled: true, args: [], tags: {} } // No connected field
+            ];
+            const result = sortByConnectionStatus(instances);
+            expect(result.map((i) => i.id)).toEqual(['instance-1', 'instance-2']);
+        });
+    });
+    describe('selectBestMatch', () => {
+        it('should select instance with highest match score', () => {
+            const instances = [
+                {
+                    id: 'instance-1',
+                    enabled: true,
+                    args: [],
+                    tags: { environment: 'dev', region: 'us-east' },
+                    connected: true
+                },
+                {
+                    id: 'instance-2',
+                    enabled: true,
+                    args: [],
+                    tags: { environment: 'dev', region: 'eu-west' },
+                    connected: true
+                },
+                {
+                    id: 'instance-3',
+                    enabled: true,
+                    args: [],
+                    tags: { environment: 'prod', region: 'us-west' },
+                    connected: true
+                }
+            ];
+            const requestedTags = { environment: 'dev', region: 'us-east' };
+            const result = selectBestMatch(instances, requestedTags);
+            expect(result?.id).toBe('instance-1');
+        });
+        it('should prioritize connected instance even with lower score', () => {
+            const instances = [
+                {
+                    id: 'instance-1',
+                    enabled: true,
+                    args: [],
+                    tags: { environment: 'dev' },
+                    connected: false
+                },
+                {
+                    id: 'instance-2',
+                    enabled: true,
+                    args: [],
+                    tags: { environment: 'prod' },
+                    connected: true
+                }
+            ];
+            const requestedTags = { environment: 'dev' };
+            const result = selectBestMatch(instances, requestedTags);
+            expect(result?.id).toBe('instance-2');
+        });
+        it('should return undefined when no instances match', () => {
+            const instances = [
+                {
+                    id: 'instance-1',
+                    enabled: true,
+                    args: [],
+                    tags: { environment: 'prod' },
+                    connected: false
+                },
+                {
+                    id: 'instance-2',
+                    enabled: true,
+                    args: [],
+                    tags: { environment: 'prod' },
+                    connected: false
+                }
+            ];
+            const requestedTags = { environment: 'dev' };
+            const result = selectBestMatch(instances, requestedTags);
+            expect(result).toBeUndefined();
+        });
+        it('should return undefined when no enabled instances', () => {
+            const instances = [
+                { id: 'instance-1', enabled: false, args: [], tags: {}, connected: true },
+                { id: 'instance-2', enabled: false, args: [], tags: {}, connected: true }
+            ];
+            const result = selectBestMatch(instances, undefined);
+            expect(result).toBeUndefined();
+        });
+        it('should return first connected instance when no tags requested', () => {
+            const instances = [
+                { id: 'instance-1', enabled: true, args: [], tags: {}, connected: false },
+                { id: 'instance-2', enabled: true, args: [], tags: {}, connected: true },
+                { id: 'instance-3', enabled: true, args: [], tags: {}, connected: true }
+            ];
+            const result = selectBestMatch(instances, undefined);
+            expect(result?.id).toBe('instance-2');
+        });
+        it('should handle empty array', () => {
+            const result = selectBestMatch([], undefined);
+            expect(result).toBeUndefined();
+        });
+        it('should select instance with higher score when scores are different', () => {
+            const instances = [
+                {
+                    id: 'instance-1',
+                    enabled: true,
+                    args: [],
+                    tags: { a: '1', b: '2', c: '3' },
+                    connected: true
+                },
+                {
+                    id: 'instance-2',
+                    enabled: true,
+                    args: [],
+                    tags: { a: '1', b: 'x', c: '3' },
+                    connected: true
+                }
+            ];
+            const requestedTags = { a: '1', b: '2', c: '3' };
+            const result = selectBestMatch(instances, requestedTags);
+            expect(result?.id).toBe('instance-1');
+        });
+    });
+});