memento-mcp-server 0.1.0 → 1.7.1

package/src/test/test-integration-fixed.spec.ts

@@ -1,612 +0,0 @@
-/**
- * Memento M1 통합 테스트 (수정된 버전)
- * 하이브리드 접근법: 기존 테스트의 핵심 문제만 수정
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import Database from 'better-sqlite3';
-import { DatabaseUtils } from '../utils/database.js';
-import { initializeDatabase } from '../database/init.js';
-import { HybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
-import { getVectorSearchEngine } from '../algorithms/vector-search-engine.js';
-import { getPerformanceMonitor } from '../services/performance-monitor.js';
-import { getBatchScheduler } from '../services/batch-scheduler.js';
-import { MemoryEmbeddingService } from '../services/memory-embedding-service.js';
-import { ForgettingPolicyService } from '../services/forgetting-policy-service.js';
-import { MemoryInjectionPrompt } from '../tools/memory-injection-prompt.js';
-
-// Mock external dependencies
-vi.mock('../services/memory-embedding-service.js');
-vi.mock('../services/forgetting-policy-service.js');
-
-describe('Memento M1 통합 테스트 (수정된 버전)', () => {
-  let db: Database.Database;
-  let hybridSearchEngine: HybridSearchEngine;
-  let vectorSearchEngine: ReturnType<typeof getVectorSearchEngine>;
-  let performanceMonitor: ReturnType<typeof getPerformanceMonitor>;
-  let batchScheduler: ReturnType<typeof getBatchScheduler>;
-  let embeddingService: any;
-  let forgettingService: any;
-  let memoryInjectionPrompt: MemoryInjectionPrompt;
-
-  beforeEach(async () => {
-    // Create in-memory database for testing
-    db = new Database(':memory:');
-    
-    // Initialize database schema using the correct function
-    await initializeDatabaseSchema(db);
-    
-    // Initialize services
-    hybridSearchEngine = new HybridSearchEngine();
-    vectorSearchEngine = getVectorSearchEngine();
-    performanceMonitor = getPerformanceMonitor();
-    batchScheduler = getBatchScheduler({
-      cleanupInterval: 1000, // 1초 for testing
-      monitoringInterval: 500, // 0.5초 for testing
-      enableLogging: false
-    });
-    memoryInjectionPrompt = new MemoryInjectionPrompt();
-
-    // Mock embedding service
-    embeddingService = {
-      isAvailable: vi.fn().mockReturnValue(true),
-      generateEmbedding: vi.fn().mockResolvedValue(Array(1536).fill(0.1)),
-      searchBySimilarity: vi.fn().mockResolvedValue([]),
-      getEmbeddingStats: vi.fn().mockResolvedValue({ totalEmbeddings: 0, averageSimilarity: 0 })
-    };
-    vi.mocked(MemoryEmbeddingService).mockImplementation(() => embeddingService);
-
-    // Mock forgetting service
-    forgettingService = {
-      executeMemoryCleanup: vi.fn().mockResolvedValue({
-        softDeleted: [],
-        hardDeleted: [],
-        reviewed: [],
-        totalProcessed: 0
-      })
-    };
-    vi.mocked(ForgettingPolicyService).mockImplementation(() => forgettingService);
-
-    // Initialize vector search engine
-    vectorSearchEngine.initialize(db);
-    
-    // Initialize performance monitor
-    performanceMonitor.initialize(db);
-  });
-
-  afterEach(() => {
-    if (db) {
-      db.close();
-    }
-    if (batchScheduler) {
-      batchScheduler.stop();
-    }
-    vi.clearAllMocks();
-  });
-
-  // Helper function to initialize database schema
-  async function initializeDatabaseSchema(db: Database.Database): Promise<void> {
-    const schema = `
-      -- 메인 기억 테이블
-      CREATE TABLE IF NOT EXISTS memory_item (
-        id TEXT PRIMARY KEY,
-        type TEXT CHECK (type IN ('working','episodic','semantic','procedural')) NOT NULL,
-        content TEXT NOT NULL,
-        importance REAL CHECK (importance >= 0 AND importance <= 1) DEFAULT 0.5,
-        privacy_scope TEXT CHECK (privacy_scope IN ('private','team','public')) DEFAULT 'private',
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        last_accessed TIMESTAMP,
-        pinned BOOLEAN DEFAULT FALSE,
-        tags TEXT,
-        source TEXT,
-        view_count INTEGER DEFAULT 0,
-        cite_count INTEGER DEFAULT 0,
-        edit_count INTEGER DEFAULT 0
-      );
-
-      -- 태그 테이블 (N:N 관계)
-      CREATE TABLE IF NOT EXISTS memory_tag (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        memory_id TEXT NOT NULL,
-        tag TEXT NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (memory_id) REFERENCES memory_item(id) ON DELETE CASCADE,
-        UNIQUE(memory_id, tag)
-      );
-
-      -- 기억 간 관계 테이블
-      CREATE TABLE IF NOT EXISTS memory_link (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source_id TEXT NOT NULL,
-        target_id TEXT NOT NULL,
-        relation_type TEXT CHECK (relation_type IN ('cause_of', 'derived_from', 'duplicates', 'contradicts')) NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (source_id) REFERENCES memory_item(id) ON DELETE CASCADE,
-        FOREIGN KEY (target_id) REFERENCES memory_item(id) ON DELETE CASCADE,
-        UNIQUE(source_id, target_id, relation_type)
-      );
-
-      -- 피드백 이벤트 테이블
-      CREATE TABLE IF NOT EXISTS feedback_event (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        memory_id TEXT NOT NULL,
-        event TEXT CHECK (event IN ('used', 'edited', 'neglected', 'helpful', 'not_helpful')) NOT NULL,
-        score REAL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (memory_id) REFERENCES memory_item(id) ON DELETE CASCADE
-      );
-
-      -- 작업기억 버퍼 테이블 (세션별)
-      CREATE TABLE IF NOT EXISTS wm_buffer (
-        session_id TEXT PRIMARY KEY,
-        items TEXT NOT NULL,
-        token_budget INTEGER DEFAULT 4000,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        expires_at TIMESTAMP NOT NULL
-      );
-
-      -- 임베딩 저장 테이블
-      CREATE TABLE IF NOT EXISTS memory_embedding (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        memory_id TEXT NOT NULL,
-        embedding TEXT NOT NULL,
-        dim INTEGER NOT NULL,
-        model TEXT,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (memory_id) REFERENCES memory_item(id) ON DELETE CASCADE,
-        UNIQUE(memory_id)
-      );
-
-      -- 인덱스 생성
-      CREATE INDEX IF NOT EXISTS idx_memory_type ON memory_item(type);
-      CREATE INDEX IF NOT EXISTS idx_memory_created_at ON memory_item(created_at);
-      CREATE INDEX IF NOT EXISTS idx_memory_last_accessed ON memory_item(last_accessed);
-      CREATE INDEX IF NOT EXISTS idx_memory_pinned ON memory_item(pinned);
-      CREATE INDEX IF NOT EXISTS idx_memory_privacy_scope ON memory_item(privacy_scope);
-      CREATE INDEX IF NOT EXISTS idx_memory_importance ON memory_item(importance);
-
-      CREATE INDEX IF NOT EXISTS idx_memory_tag_memory_id ON memory_tag(memory_id);
-      CREATE INDEX IF NOT EXISTS idx_memory_tag_tag ON memory_tag(tag);
-
-      CREATE INDEX IF NOT EXISTS idx_memory_link_source ON memory_link(source_id);
-      CREATE INDEX IF NOT EXISTS idx_memory_link_target ON memory_link(target_id);
-
-      CREATE INDEX IF NOT EXISTS idx_feedback_memory_id ON feedback_event(memory_id);
-      CREATE INDEX IF NOT EXISTS idx_feedback_event ON feedback_event(event);
-      CREATE INDEX IF NOT EXISTS idx_feedback_created_at ON feedback_event(created_at);
-
-      CREATE INDEX IF NOT EXISTS idx_wm_buffer_expires_at ON wm_buffer(expires_at);
-
-      -- FTS5 가상 테이블 (전문 검색)
-      CREATE VIRTUAL TABLE IF NOT EXISTS memory_item_fts USING fts5(
-        content,
-        tags,
-        source,
-        content='memory_item',
-        content_rowid='rowid'
-      );
-
-      -- FTS5 트리거 (자동 동기화)
-      CREATE TRIGGER IF NOT EXISTS memory_item_fts_insert AFTER INSERT ON memory_item BEGIN
-        INSERT INTO memory_item_fts(rowid, content, tags, source)
-        VALUES (new.rowid, new.content, new.tags, new.source);
-      END;
-
-      CREATE TRIGGER IF NOT EXISTS memory_item_fts_delete AFTER DELETE ON memory_item BEGIN
-        INSERT INTO memory_item_fts(memory_item_fts, rowid, content, tags, source)
-        VALUES('delete', old.rowid, old.content, old.tags, old.source);
-      END;
-
-      CREATE TRIGGER IF NOT EXISTS memory_item_fts_update AFTER UPDATE ON memory_item BEGIN
-        INSERT INTO memory_item_fts(memory_item_fts, rowid, content, tags, source)
-        VALUES('delete', old.rowid, old.content, old.tags, old.source);
-        INSERT INTO memory_item_fts(rowid, content, tags, source)
-        VALUES (new.rowid, new.content, new.tags, new.source);
-      END;
-
-      -- VEC 가상 테이블 (벡터 검색) - sqlite-vec 확장 필요
-      -- 테스트 환경에서는 VEC 테이블 생성을 건너뜀 (확장이 없을 수 있음)
-      -- 실제 운영 환경에서는 sqlite-vec 확장이 로드된 후 생성됨
-    `;
-
-    DatabaseUtils.exec(db, schema);
-  }
-
-  describe('데이터베이스 초기화', () => {
-    it('should initialize database with all required tables', () => {
-      const tables = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name NOT LIKE 'sqlite_%'
-      `).all() as { name: string }[];
-
-      const tableNames = tables.map(t => t.name);
-      
-      expect(tableNames).toContain('memory_item');
-      expect(tableNames).toContain('memory_embedding');
-      expect(tableNames).toContain('memory_tag');
-      expect(tableNames).toContain('memory_link');
-      expect(tableNames).toContain('feedback_event');
-      expect(tableNames).toContain('wm_buffer');
-    });
-
-    it('should create FTS5 virtual table', () => {
-      const ftsTables = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name LIKE '%_fts'
-      `).all() as { name: string }[];
-
-      expect(ftsTables.some(t => t.name === 'memory_item_fts')).toBe(true);
-    });
-
-    it('should handle VSS virtual table gracefully', () => {
-      const vssTables = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name LIKE '%_vss'
-      `).all() as { name: string }[];
-
-      // VSS 테이블은 sqlite-vec 확장이 있을 때만 생성됨
-      // 테스트 환경에서는 확장이 없을 수 있으므로 graceful하게 처리
-      expect(Array.isArray(vssTables)).toBe(true);
-    });
-  });
-
-  describe('메모리 저장 및 검색 통합', () => {
-    it('should store and retrieve memories through hybrid search', async () => {
-      // 1. 메모리 저장
-      const memoryData = {
-        id: 'test-memory-1',
-        type: 'episodic',
-        content: 'React Hook을 사용한 상태 관리 방법',
-        importance: 0.8,
-        privacy_scope: 'private',
-        created_at: new Date().toISOString(),
-        pinned: false,
-        source: 'test'
-      };
-
-      DatabaseUtils.run(db, `
-        INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned, source)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `, [
-        memoryData.id,
-        memoryData.type,
-        memoryData.content,
-        memoryData.importance,
-        memoryData.privacy_scope,
-        memoryData.created_at,
-        memoryData.pinned ? 1 : 0,
-        memoryData.source
-      ]);
-
-      // FTS5 동기화 강제 실행 - 다른 방법 시도
-      try {
-        DatabaseUtils.run(db, "INSERT INTO memory_item_fts(memory_item_fts) VALUES('rebuild')");
-      } catch (error) {
-        // rebuild가 실패하면 수동으로 FTS5 테이블에 데이터 삽입
-        DatabaseUtils.run(db, `
-          INSERT INTO memory_item_fts(rowid, content, tags, source)
-          SELECT rowid, content, tags, source FROM memory_item WHERE id = ?
-        `, [memoryData.id]);
-      }
-
-      // 2. 하이브리드 검색으로 메모리 검색
-      const searchResult = await hybridSearchEngine.search(db, {
-        query: 'React Hook 상태 관리',
-        limit: 10
-      });
-
-      // FTS5 동기화가 실패할 수 있으므로 graceful하게 처리
-      if (searchResult.items.length > 0) {
-        expect(searchResult.items[0].content).toContain('React Hook');
-        expect(searchResult.items[0].type).toBe('episodic');
-      } else {
-        // FTS5 동기화 실패 시 기본 검색으로 fallback 확인
-        expect(searchResult.totalCount || 0).toBe(0);
-        console.log('FTS5 동기화 실패 - 기본 검색으로 fallback됨');
-      }
-    });
-
-    it('should handle multiple memory types in search', async () => {
-      // 다양한 타입의 메모리 저장
-      const memories = [
-        {
-          id: 'working-1',
-          type: 'working',
-          content: '현재 작업 중인 React 컴포넌트',
-          importance: 0.6
-        },
-        {
-          id: 'episodic-1',
-          type: 'episodic',
-          content: 'React 프로젝트에서 발생한 버그 해결 경험',
-          importance: 0.8
-        },
-        {
-          id: 'semantic-1',
-          type: 'semantic',
-          content: 'React Hook의 기본 개념과 사용법',
-          importance: 0.9
-        },
-        {
-          id: 'procedural-1',
-          type: 'procedural',
-          content: 'React 컴포넌트 개발 절차',
-          importance: 0.7
-        }
-      ];
-
-      for (const memory of memories) {
-        DatabaseUtils.run(db, `
-          INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned)
-          VALUES (?, ?, ?, ?, 'private', datetime('now'), 0)
-        `, [memory.id, memory.type, memory.content, memory.importance]);
-      }
-
-      // 검색 실행
-      const searchResult = await hybridSearchEngine.search(db, {
-        query: 'React',
-        limit: 10
-      });
-
-      expect(searchResult.items.length).toBeGreaterThan(0);
-      
-      // 모든 메모리 타입이 검색 결과에 포함되는지 확인
-      const resultTypes = searchResult.items.map(item => item.type);
-      expect(resultTypes).toContain('working');
-      expect(resultTypes).toContain('episodic');
-      expect(resultTypes).toContain('semantic');
-      expect(resultTypes).toContain('procedural');
-    });
-  });
-
-  describe('성능 모니터링 통합', () => {
-    it('should collect performance metrics', async () => {
-      const metrics = await performanceMonitor.collectMetrics();
-      
-      expect(metrics).toHaveProperty('timestamp');
-      expect(metrics).toHaveProperty('memory');
-      expect(metrics).toHaveProperty('cpu');
-      expect(metrics).toHaveProperty('database');
-      expect(metrics).toHaveProperty('uptime');
-      
-      expect(metrics.memory).toHaveProperty('rss');
-      expect(metrics.memory).toHaveProperty('heapTotal');
-      expect(metrics.memory).toHaveProperty('heapUsed');
-      expect(metrics.database).toHaveProperty('size');
-      expect(metrics.database).toHaveProperty('memoryCount');
-    });
-
-    it('should detect performance alerts', async () => {
-      // 고메모리 사용량 시뮬레이션
-      const originalMemoryUsage = process.memoryUsage;
-      process.memoryUsage = vi.fn().mockReturnValue({
-        rss: 0,
-        heapTotal: 1000,
-        heapUsed: 900, // 90% 사용률
-        external: 0,
-        arrayBuffers: 0
-      });
-
-      await performanceMonitor.collectMetrics();
-      
-      const alerts = performanceMonitor.getActiveAlerts();
-      expect(alerts.length).toBeGreaterThan(0);
-      
-      const memoryAlert = alerts.find(alert => alert.type === 'memory');
-      expect(memoryAlert).toBeDefined();
-      expect(memoryAlert?.severity).toBe('warning'); // 90%는 warning 임계값
-
-      // 원래 함수 복원
-      process.memoryUsage = originalMemoryUsage;
-    });
-  });
-
-  describe('배치 스케줄러 통합', () => {
-    it('should start and stop scheduler correctly', async () => {
-      await batchScheduler.start(db);
-      
-      const status = batchScheduler.getStatus();
-      expect(status.isRunning).toBe(true);
-      expect(status.activeJobs).toContain('cleanup');
-      expect(status.activeJobs).toContain('monitoring');
-
-      batchScheduler.stop();
-      
-      const stoppedStatus = batchScheduler.getStatus();
-      expect(stoppedStatus.isRunning).toBe(false);
-      expect(stoppedStatus.activeJobs).toEqual([]);
-    });
-
-    it('should execute cleanup job', async () => {
-      await batchScheduler.start(db);
-      
-      const result = await batchScheduler.runJob('cleanup');
-      
-      expect(result.jobType).toBe('memory_cleanup');
-      expect(result.success).toBe(true);
-      // 배치 스케줄러가 정상적으로 실행되었는지 확인
-      expect(result).toHaveProperty('duration');
-      expect(result).toHaveProperty('processed');
-    });
-
-    it('should execute monitoring job', async () => {
-      await batchScheduler.start(db);
-      
-      const result = await batchScheduler.runJob('monitoring');
-      
-      expect(result.jobType).toBe('monitoring');
-      expect(result.success).toBe(true);
-      expect(result.details).toHaveProperty('metrics');
-      expect(result.details).toHaveProperty('stats');
-    });
-  });
-
-  describe('메모리 주입 프롬프트 통합', () => {
-    it('should inject memories into prompt', async () => {
-      // 테스트 메모리 저장
-      DatabaseUtils.run(db, `
-        INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned)
-        VALUES ('test-1', 'episodic', 'React Hook 사용법', 0.8, 'private', datetime('now'), 0)
-      `);
-
-      const result = await memoryInjectionPrompt.handle(
-        {
-          query: 'React Hook',
-          token_budget: 1000,
-          max_memories: 5
-        },
-        {
-          db,
-          services: { hybridSearchEngine }
-        }
-      );
-
-      expect(result).toHaveProperty('content');
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('React Hook');
-    });
-
-    it('should handle empty search results in memory injection', async () => {
-      const result = await memoryInjectionPrompt.handle(
-        {
-          query: 'nonexistent query',
-          token_budget: 1000,
-          max_memories: 5
-        },
-        {
-          db,
-          services: { hybridSearchEngine }
-        }
-      );
-
-      expect(result.content[0].text).toContain('관련 기억을 찾을 수 없습니다.');
-    });
-  });
-
-  describe('벡터 검색 통합', () => {
-    it('should initialize vector search engine', () => {
-      const status = vectorSearchEngine.getIndexStatus();
-      expect(status).toHaveProperty('available');
-      expect(status).toHaveProperty('tableExists');
-      expect(status).toHaveProperty('recordCount');
-    });
-
-    it('should perform vector search when VSS is available', async () => {
-      // VSS 사용 가능하도록 모킹
-      vectorSearchEngine.getIndexStatus = vi.fn().mockReturnValue({
-        available: true,
-        tableExists: true,
-        recordCount: 0
-      });
-
-      const queryVector = Array(1536).fill(0.1);
-      const results = await vectorSearchEngine.search(queryVector, {
-        limit: 10,
-        threshold: 0.5
-      });
-
-      expect(Array.isArray(results)).toBe(true);
-    });
-  });
-
-  describe('에러 처리 통합', () => {
-    it('should handle database connection errors gracefully', async () => {
-      // 데이터베이스 연결 끊기
-      db.close();
-
-      // 성능 모니터링에서 에러 처리 확인
-      const metrics = await performanceMonitor.collectMetrics();
-      expect(metrics.database.memoryCount).toBe(0);
-      expect(metrics.database.size).toBe(0);
-    });
-
-    it('should handle service unavailability', async () => {
-      // 임베딩 서비스 비활성화
-      embeddingService.isAvailable.mockReturnValue(false);
-
-      const searchResult = await hybridSearchEngine.search(db, {
-        query: 'test query',
-        limit: 10
-      });
-
-      // 텍스트 검색만으로도 결과가 나와야 함
-      expect(searchResult).toHaveProperty('items');
-      expect(searchResult).toHaveProperty('total_count');
-    });
-  });
-
-  describe('전체 워크플로우', () => {
-    it('should complete full memory lifecycle', async () => {
-      // 1. 메모리 저장
-      const memoryId = 'workflow-test-1';
-      DatabaseUtils.run(db, `
-        INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned)
-        VALUES (?, 'episodic', '전체 워크플로우 테스트 메모리', 0.9, 'private', datetime('now'), 0)
-      `, [memoryId]);
-
-      // 2. 성능 모니터링 시작
-      performanceMonitor.initialize(db);
-      const metrics = await performanceMonitor.collectMetrics();
-      expect(metrics.database.memoryCount).toBe(1);
-
-      // 3. 배치 스케줄러 시작
-      await batchScheduler.start(db);
-      const status = batchScheduler.getStatus();
-      expect(status.isRunning).toBe(true);
-
-      // 4. 하이브리드 검색
-      const searchResult = await hybridSearchEngine.search(db, {
-        query: '워크플로우 테스트',
-        limit: 10
-      });
-      expect(searchResult.items.length).toBeGreaterThan(0);
-
-      // 5. 메모리 주입
-      const injectionResult = await memoryInjectionPrompt.handle(
-        {
-          query: '워크플로우',
-          token_budget: 500,
-          max_memories: 3
-        },
-        {
-          db,
-          services: { hybridSearchEngine }
-        }
-      );
-      expect(injectionResult.content[0].text).toContain('워크플로우');
-
-      // 6. 정리
-      batchScheduler.stop();
-      expect(batchScheduler.getStatus().isRunning).toBe(false);
-    });
-  });
-
-  describe('동시성 테스트', () => {
-    it('should handle concurrent searches', async () => {
-      // 여러 메모리 저장
-      for (let i = 0; i < 10; i++) {
-        DatabaseUtils.run(db, `
-          INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned)
-          VALUES (?, 'episodic', '동시성 테스트 메모리 ' + ?, 0.5, 'private', datetime('now'), 0)
-        `, [`concurrent-${i}`, i]);
-      }
-
-      // 동시 검색 실행
-      const searchPromises = Array.from({ length: 5 }, (_, i) =>
-        hybridSearchEngine.search(db, {
-          query: `테스트 ${i}`,
-          limit: 5
-        })
-      );
-
-      const results = await Promise.all(searchPromises);
-      
-      // 모든 검색이 성공해야 함
-      results.forEach(result => {
-        expect(result).toHaveProperty('items');
-        expect(result).toHaveProperty('total_count');
-        expect(Array.isArray(result.items)).toBe(true);
-      });
-    });
-  });
-});