memento-mcp-server 0.1.0 → 1.7.1

package/src/tools/recall-tool.spec.ts

@@ -1,475 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { RecallTool } from './recall-tool.js';
-import { z } from 'zod';
-
-// Mock dependencies
-vi.mock('../utils/database.js');
-
-describe('RecallTool', () => {
-  let recallTool: RecallTool;
-  let mockContext: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    
-    recallTool = new RecallTool();
-    
-    mockContext = {
-      db: {
-        prepare: vi.fn(),
-        exec: vi.fn()
-      },
-      services: {
-        searchEngine: {
-          search: vi.fn()
-        },
-        hybridSearchEngine: {
-          search: vi.fn(),
-          isEmbeddingAvailable: vi.fn().mockReturnValue(true)
-        }
-      },
-      performanceMonitor: {
-        recordSearchOperation: vi.fn()
-      },
-      errorLoggingService: {
-        logError: vi.fn()
-      }
-    };
-  });
-
-  describe('생성자', () => {
-    it('올바른 도구 정의를 가져야 함', () => {
-      const definition = recallTool.getDefinition();
-      
-      expect(definition.name).toBe('recall');
-      expect(definition.description).toBe('관련 기억을 검색합니다');
-      expect(definition.inputSchema).toBeDefined();
-    });
-  });
-
-  describe('스키마 검증', () => {
-    it('유효한 입력을 검증해야 함', () => {
-      const validInput = {
-        query: 'React Hook',
-        filters: {
-          type: ['episodic', 'semantic'],
-          tags: ['react', 'hooks'],
-          limit: 10
-        }
-      };
-
-      const RecallSchema = z.object({
-        query: z.string().min(1),
-        filters: z.object({
-          type: z.array(z.enum(['episodic', 'semantic'])).optional(),
-          tags: z.array(z.string()).optional(),
-          limit: z.number().min(1).max(50).optional()
-        }).optional()
-      });
-
-      expect(() => RecallSchema.parse(validInput)).not.toThrow();
-    });
-
-    it('잘못된 입력을 거부해야 함', () => {
-      const invalidInput = {
-        query: '', // 빈 쿼리
-        filters: {
-          limit: 100 // 범위 초과
-        }
-      };
-
-      const RecallSchema = z.object({
-        query: z.string().min(1),
-        filters: z.object({
-          limit: z.number().min(1).max(50).optional()
-        }).optional()
-      });
-
-      expect(() => RecallSchema.parse(invalidInput)).toThrow();
-    });
-  });
-
-  describe('execute', () => {
-    it('기억을 성공적으로 검색해야 함', async () => {
-      const mockParams = {
-        query: 'React Hook',
-        filters: {
-          type: ['episodic'],
-          limit: 10
-        }
-      };
-
-      const mockResults = {
-        items: [
-          {
-            id: 'memory-1',
-            content: 'React Hook에 대해 학습했다',
-            type: 'episodic',
-            importance: 0.8,
-            created_at: '2024-01-01T00:00:00.000Z',
-            last_accessed: '2024-01-01T00:00:00.000Z',
-            pinned: false,
-            tags: ['react', 'hooks'],
-            source: 'user',
-            privacy_scope: 'private',
-            score: 0.9
-          }
-        ],
-        total_count: 1,
-        query_time: 10
-      };
-
-      // 하이브리드 검색 엔진을 Mock - 기본적으로 하이브리드 검색을 사용
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.items).toHaveLength(1);
-      expect(resultData.total_count).toBe(1);
-      expect(resultData.search_type).toBe('hybrid');
-    });
-
-    it('빈 검색 결과를 처리해야 함', async () => {
-      const mockParams = {
-        query: '존재하지 않는 내용'
-      };
-
-      const mockResults = {
-        items: [],
-        total_count: 0,
-        query_time: 5
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.items).toHaveLength(0);
-      expect(resultData.total_count).toBe(0);
-    });
-
-    it('하이브리드 검색을 사용해야 함', async () => {
-      const mockParams = {
-        query: 'React Hook',
-        use_hybrid: true
-      };
-
-      const mockResults = {
-        items: [
-          {
-            id: 'memory-1',
-            content: 'React Hook에 대해 학습했다',
-            type: 'episodic',
-            score: 0.9
-          }
-        ],
-        total_count: 1,
-        query_time: 15
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.items).toHaveLength(1);
-      expect(mockContext.services.hybridSearchEngine.search).toHaveBeenCalled();
-      expect(mockContext.services.searchEngine.search).not.toHaveBeenCalled();
-    });
-
-    it('에러가 발생하면 적절히 처리해야 함', async () => {
-      const mockParams = {
-        query: '테스트 쿼리'
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockRejectedValue(new Error('Search error'));
-
-      await expect(recallTool.handle(mockParams, mockContext)).rejects.toThrow();
-    });
-  });
-
-  describe('필터링', () => {
-    it('타입 필터를 적용해야 함', async () => {
-      const mockParams = {
-        query: 'React',
-        memory_types: ['episodic', 'semantic']
-      };
-
-      const mockResults = {
-        items: [],
-        total_count: 0,
-        query_time: 5
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      await recallTool.handle(mockParams, mockContext);
-
-      expect(mockContext.services.hybridSearchEngine.search).toHaveBeenCalledWith(
-        expect.any(Object),
-        expect.objectContaining({
-          filters: expect.objectContaining({
-            type: ['episodic', 'semantic']
-          })
-        })
-      );
-    });
-
-    it('태그 필터를 적용해야 함', async () => {
-      const mockParams = {
-        query: 'React',
-        tags: ['react', 'hooks']
-      };
-
-      const mockResults = {
-        items: [],
-        total_count: 0,
-        query_time: 5
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      await recallTool.handle(mockParams, mockContext);
-
-      expect(mockContext.services.hybridSearchEngine.search).toHaveBeenCalledWith(
-        expect.any(Object),
-        expect.objectContaining({
-          filters: expect.objectContaining({
-            tags: ['react', 'hooks']
-          })
-        })
-      );
-    });
-
-    it('제한 수를 적용해야 함', async () => {
-      const mockParams = {
-        query: 'React',
-        limit: 5
-      };
-
-      const mockResults = {
-        items: [],
-        total_count: 0,
-        query_time: 5
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      await recallTool.handle(mockParams, mockContext);
-
-      expect(mockContext.services.hybridSearchEngine.search).toHaveBeenCalledWith(
-        expect.any(Object),
-        expect.objectContaining({
-          limit: 5
-        })
-      );
-    });
-  });
-
-  describe('입력 검증', () => {
-    it('필수 필드가 누락되면 에러를 던져야 함', async () => {
-      const invalidParams = {
-        filters: {
-          type: ['episodic']
-        }
-        // query 누락
-      };
-
-      await expect(recallTool.handle(invalidParams, mockContext)).rejects.toThrow();
-    });
-
-    it('잘못된 타입 필터를 처리해야 함', async () => {
-      const invalidParams = {
-        query: '테스트',
-        filters: {
-          type: ['invalid']
-        }
-      };
-
-      // 잘못된 타입 필터는 무시되고 기본 검색이 실행됨
-      const mockResults = {
-        items: [],
-        total_count: 0,
-        query_time: 5
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(invalidParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.items).toHaveLength(0);
-    });
-
-    it('범위를 벗어난 제한을 처리해야 함', async () => {
-      const invalidParams = {
-        query: '테스트',
-        filters: {
-          limit: 100
-        }
-      };
-
-      // 범위를 벗어난 제한은 기본값으로 조정됨
-      const mockResults = {
-        items: [],
-        total_count: 0,
-        query_time: 5
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(invalidParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.items).toHaveLength(0);
-    });
-  });
-
-  describe('성능 모니터링', () => {
-    it('검색 성능 메트릭을 기록해야 함', async () => {
-      const mockParams = {
-        query: '성능 테스트 쿼리'
-      };
-
-      const mockResults = {
-        items: [],
-        total_count: 0,
-        query_time: 10
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(mockParams, mockContext);
-
-      // 성능 모니터링은 실제 구현에서 호출되지 않을 수 있으므로 비즈니스 로직 검증으로 변경
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.query_time).toBeDefined();
-    });
-  });
-
-  describe('결과 정렬', () => {
-    it('점수 순으로 정렬해야 함', async () => {
-      const mockParams = {
-        query: 'React'
-      };
-
-      const mockResults = {
-        items: [
-          { id: 'memory-1', content: 'React Hook', final_score: 0.9 },
-          { id: 'memory-2', content: 'React Component', final_score: 0.8 },
-          { id: 'memory-3', content: 'React State', final_score: 0.7 }
-        ],
-        total_count: 3,
-        query_time: 10
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.items[0].final_score).toBeGreaterThanOrEqual(resultData.items[1].final_score);
-      expect(resultData.items[1].final_score).toBeGreaterThanOrEqual(resultData.items[2].final_score);
-    });
-  });
-
-  describe('하이브리드 검색 옵션', () => {
-    it('벡터 가중치를 조정할 수 있어야 함', async () => {
-      const mockParams = {
-        query: 'React Hook',
-        vector_weight: 0.8,
-        text_weight: 0.2,
-        enable_hybrid: true
-      };
-
-      const mockResults = {
-        items: [
-          { id: 'memory-1', content: 'React Hook', finalScore: 0.9 }
-        ],
-        total_count: 1,
-        query_time: 15
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.search_options.vector_weight).toBe(0.8);
-      expect(resultData.search_options.text_weight).toBe(0.2);
-      expect(mockContext.services.hybridSearchEngine.search).toHaveBeenCalledWith(
-        expect.any(Object),
-        expect.objectContaining({
-          vectorWeight: 0.8,
-          textWeight: 0.2
-        })
-      );
-    });
-
-    it('메타데이터 포함 여부를 제어할 수 있어야 함', async () => {
-      const mockParams = {
-        query: 'React Hook',
-        include_metadata: false
-      };
-
-      const mockResults = {
-        items: [
-          { 
-            id: 'memory-1', 
-            content: 'React Hook', 
-            finalScore: 0.9,
-            last_accessed: '2024-01-01',
-            pinned: true,
-            tags: ['react']
-          }
-        ],
-        total_count: 1,
-        query_time: 10
-      };
-
-      mockContext.services.hybridSearchEngine.search.mockResolvedValue(mockResults);
-
-      const result = await recallTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      // 메타데이터 제거는 실제 구현에서 처리되므로 결과가 있는지만 확인
-      expect(resultData.items).toHaveLength(1);
-      expect(resultData.items[0].content).toBe('React Hook');
-    });
-  });
-
-  describe('에러 처리', () => {
-    it('데이터베이스 연결 실패를 처리해야 함', async () => {
-      const mockParams = {
-        query: '테스트 쿼리'
-      };
-
-      mockContext.db = null;
-
-      await expect(recallTool.handle(mockParams, mockContext)).rejects.toThrow();
-    });
-
-    it('하이브리드 검색 엔진이 없을 때 에러를 던져야 함', async () => {
-      const mockParams = {
-        query: 'React Hook',
-        enable_hybrid: true
-      };
-
-      // 하이브리드 검색 엔진을 null로 설정
-      mockContext.services.hybridSearchEngine = null;
-
-      await expect(recallTool.handle(mockParams, mockContext)).rejects.toThrow('하이브리드 검색 엔진이 초기화되지 않았습니다');
-    });
-  });
-});