@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/tests/unit/services/search/search-cache.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SearchCacheService } from '../../../../src/services/search/search-cache.js';
+describe('SearchCacheService', () => {
+    const cacheService = new SearchCacheService();
+    describe('basic functionality', () => {
+        it('should initially have no cached data', () => {
+            const data = cacheService.get();
+            expect(data).toBeNull();
+            expect(cacheService.isValid()).toBe(false);
+        });
+        it('should set and retrieve cache data', () => {
+            const mockTools = [
+                { name: 'Tool 1', description: 'Description', serverName: 'test-server' }
+            ];
+            cacheService.set(mockTools);
+            const data = cacheService.get();
+            expect(data).toEqual(mockTools);
+            expect(cacheService.isValid()).toBe(true);
+        });
+        it('should invalidate cache', () => {
+            const mockTools = [
+                { name: 'Tool 1', description: 'Description', serverName: 'test-server' }
+            ];
+            cacheService.set(mockTools);
+            expect(cacheService.isValid()).toBe(true);
+            cacheService.invalidate();
+            expect(cacheService.get()).toBeNull();
+            expect(cacheService.isValid()).toBe(false);
+        });
+    });
+    describe('cache expiration', () => {
+        it('should invalidate cache after TTL', () => {
+            const mockTools = [
+                { name: 'Tool 1', description: 'Description', serverName: 'test-server' }
+            ];
+            cacheService.set(mockTools);
+            expect(cacheService.isValid()).toBe(true);
+            // Simulate TTL expiration
+            vi.useFakeTimers();
+            vi.advanceTimersByTime(31000);
+            expect(cacheService.isValid()).toBe(false);
+            expect(cacheService.get()).toBeNull();
+            vi.useRealTimers();
+        });
+        it('should return valid data before TTL expires', () => {
+            const mockTools = [
+                { name: 'Tool 1', description: 'Description', serverName: 'test-server' }
+            ];
+            cacheService.set(mockTools);
+            expect(cacheService.isValid()).toBe(true);
+            vi.useFakeTimers();
+            vi.advanceTimersByTime(25000);
+            expect(cacheService.isValid()).toBe(true);
+            expect(cacheService.get()).toEqual(mockTools);
+            vi.useRealTimers();
+        });
+    });
+});

package/dist/server/tests/unit/services/search/search-core.service.test.d.ts

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

package/dist/server/tests/unit/services/search/search-core.service.test.d.ts.map

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

package/dist/server/tests/unit/services/search/search-core.service.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SearchCoreService } from '../../../../src/services/search/search-core.service.js';
+// Create mock tool data
+const mockTools = [
+    {
+        name: 'MySQL Query',
+        description: 'Execute MySQL queries',
+        serverName: 'mysql-server'
+    },
+    {
+        name: 'PostgreSQL Query',
+        description: 'Execute PostgreSQL queries',
+        serverName: 'postgresql-server'
+    },
+    {
+        name: 'Redis Command',
+        description: 'Execute Redis commands',
+        serverName: 'redis-server'
+    }
+];
+describe('SearchCoreService', () => {
+    let searchService;
+    let mockGetAllTools;
+    beforeEach(() => {
+        searchService = new SearchCoreService();
+        // Mock mcpConnectionManager.getAllTools()
+        mockGetAllTools = vi
+            .spyOn(searchService, 'getToolsWithCache')
+            .mockImplementation(async () => mockTools);
+    });
+    describe('search()', () => {
+        it('should return all tools when query is empty', async () => {
+            const results = await searchService.search('');
+            expect(results).toBeInstanceOf(Array);
+            expect(results.length).toBe(3);
+            expect(results.every((r) => r.score === 1)).toBe(true);
+        });
+        it('should search tools by exact name match', async () => {
+            const results = await searchService.search('MySQL Query');
+            expect(results).toBeInstanceOf(Array);
+            expect(results.length).toBeGreaterThan(0);
+            expect(results[0].tool.name).toContain('MySQL');
+        });
+        it('should search tools by partial match', async () => {
+            const results = await searchService.search('Query');
+            expect(results).toBeInstanceOf(Array);
+            expect(results.length).toBe(2);
+            expect(results.every((r) => r.tool.name.includes('Query'))).toBe(true);
+        });
+        it('should respect limit and offset parameters', async () => {
+            const results = await searchService.search('', {
+                limit: 2,
+                offset: 1
+            });
+            expect(results).toBeInstanceOf(Array);
+            expect(results.length).toBe(2);
+        });
+        it('should return results sorted by score', async () => {
+            const results = await searchService.search('Query');
+            expect(results).toBeInstanceOf(Array);
+            expect(results.length).toBe(2);
+            expect(results[0].score).toBeGreaterThanOrEqual(results[1].score);
+        });
+    });
+    describe('search performance', () => {
+        it('should handle large tool lists efficiently', async () => {
+            // Create mock data with 200 tools
+            const largeMockTools = [];
+            for (let i = 1; i <= 200; i++) {
+                largeMockTools.push({
+                    name: `Tool ${i}`,
+                    description: `Description for tool ${i}`,
+                    serverName: 'test-server'
+                });
+            }
+            mockGetAllTools.mockImplementation(async () => largeMockTools);
+            const startTime = Date.now();
+            const results = await searchService.search('Tool');
+            const duration = Date.now() - startTime;
+            expect(duration).toBeLessThan(100);
+            expect(results.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/server/tests/unit/services/search/search-scorer.test.d.ts

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

package/dist/server/tests/unit/services/search/search-scorer.test.d.ts.map

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

package/dist/server/tests/unit/services/search/search-scorer.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest';
+import { SearchScorer } from '../../../../src/services/search/search-scorer.js';
+describe('SearchScorer', () => {
+    const scorer = new SearchScorer();
+    describe('scoreTool()', () => {
+        it('should score exact match with highest value', () => {
+            const tool = {
+                name: 'MySQL Query',
+                description: 'Execute MySQL queries',
+                serverName: 'mysql-server'
+            };
+            const score = scorer.scoreTool(tool, 'MySQL Query');
+            expect(score).toBeGreaterThan(scorer.scoreTool(tool, 'MySQL'));
+            expect(score).toBeGreaterThan(scorer.scoreTool(tool, 'Query'));
+        });
+        it('should score partial match with lower value', () => {
+            const tool = {
+                name: 'MySQL Query',
+                description: 'Execute MySQL queries',
+                serverName: 'mysql-server'
+            };
+            const exactScore = scorer.scoreTool(tool, 'MySQL Query');
+            const partialScore = scorer.scoreTool(tool, 'MySQL');
+            expect(partialScore).toBeLessThan(exactScore);
+            expect(partialScore).toBeGreaterThan(0);
+        });
+        it('should score description matches', () => {
+            const tool = {
+                name: 'Database Tool',
+                description: 'Execute MySQL queries',
+                serverName: 'mysql-server'
+            };
+            const nameScore = scorer.scoreTool(tool, 'Database');
+            const descScore = scorer.scoreTool(tool, 'MySQL');
+            expect(nameScore).toBeGreaterThan(descScore);
+        });
+        it('should score tag matches', () => {
+            const tool = {
+                name: 'Database Tool',
+                description: 'Execute MySQL queries',
+                serverName: 'mysql-server'
+            };
+            const tagScore = scorer.scoreTool(tool, 'mysql');
+            expect(tagScore).toBeGreaterThan(0);
+        });
+        it('should handle no matches', () => {
+            const tool = {
+                name: 'MySQL Query',
+                description: 'Execute MySQL queries',
+                serverName: 'mysql-server'
+            };
+            const score = scorer.scoreTool(tool, 'nonexistent');
+            expect(score).toBe(0);
+        });
+        it('should score tools with no description', () => {
+            const tool = {
+                name: 'MySQL Query',
+                description: '',
+                serverName: 'mysql-server'
+            };
+            const score = scorer.scoreTool(tool, 'MySQL');
+            expect(score).toBeGreaterThan(0);
+        });
+        it('should score tools with no tags', () => {
+            const tool = {
+                name: 'MySQL Query',
+                description: 'Execute MySQL queries',
+                serverName: 'mysql-server'
+            };
+            const score = scorer.scoreTool(tool, 'MySQL');
+            expect(score).toBeGreaterThan(0);
+        });
+    });
+    describe('score calculation', () => {
+        it('should weight name higher than description', () => {
+            const tool = {
+                name: 'MySQL Query',
+                description: 'Execute database queries',
+                serverName: 'mysql-server'
+            };
+            // Simulate cases where only name matches, only description matches
+            const nameMatch = scorer.scoreTool(tool, 'MySQL');
+            const descMatch = scorer.scoreTool(tool, 'database');
+            expect(nameMatch).toBeGreaterThan(descMatch);
+        });
+        it('should sum scores from multiple matches', () => {
+            const tool = {
+                name: 'MySQL Query',
+                description: 'Execute MySQL database queries',
+                serverName: 'mysql-server'
+            };
+            const singleMatch = scorer.scoreTool(tool, 'Query');
+            const multipleMatches = scorer.scoreTool(tool, 'MySQL');
+            expect(multipleMatches).toBeGreaterThan(singleMatch);
+        });
+    });
+});

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

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

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

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