memento-mcp-server 1.6.0 → 1.7.2

package/src/server/http-server.spec.ts

@@ -1,648 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach, vi } from 'vitest';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import Database from 'better-sqlite3';
-import { AddressInfo } from 'net';
-import type { Server } from 'http';
-import { WebSocket } from 'ws';
-import { DatabaseUtils } from '../utils/database.js';
-import { SearchEngine } from '../algorithms/search-engine.js';
-import { HybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
-import type { MemoryEmbeddingService } from '../services/memory-embedding-service.js';
-
-type HttpServerModule = typeof import('./http-server.js');
-
-let httpModule: HttpServerModule;
-let db: Database.Database;
-let server: Server | null = null;
-let baseUrl: string;
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const daysAgo = (days: number): string => {
-  const date = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
-  return date.toISOString();
-};
-
-const startTestServer = async (module: HttpServerModule) => {
-  const httpServer = module.__test.getServer();
-  await new Promise<void>((resolve) => {
-    server = httpServer.listen(0, () => {
-      const address = server!.address() as AddressInfo;
-      baseUrl = `http://127.0.0.1:${address.port}`;
-      resolve();
-    });
-  });
-};
-
-const stopTestServer = async () => {
-  if (!server) return;
-  await new Promise<void>((resolve, reject) => {
-    server!.close((err) => (err ? reject(err) : resolve()));
-  });
-  server = null;
-};
-
-const postJson = async (path: string, body: unknown) => {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body)
-  });
-  return { status: response.status, json: await response.json() };
-};
-
-beforeAll(async () => {
-  process.env.DB_PATH = ':memory:';
-
-  httpModule = await import('./http-server.js');
-
-  db = new Database(':memory:');
-
-  // 테스트용 간소화된 스키마 사용 (vec0 모듈 없이)
-  const testSchema = `
-    CREATE TABLE IF NOT EXISTS memory_item (
-      id TEXT PRIMARY KEY,
-      type TEXT NOT NULL,
-      content TEXT NOT NULL,
-      importance REAL DEFAULT 0.5,
-      privacy_scope TEXT DEFAULT 'private',
-      tags TEXT,
-      source TEXT,
-      pinned BOOLEAN DEFAULT FALSE,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
-    );
-    
-    CREATE TABLE IF NOT EXISTS memory_tag (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      memory_id TEXT NOT NULL,
-      tag TEXT NOT NULL,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      FOREIGN KEY (memory_id) REFERENCES memory_item(id) ON DELETE CASCADE
-    );
-    
-    CREATE TABLE IF NOT EXISTS feedback_event (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      memory_id TEXT,
-      event_type TEXT NOT NULL,
-      event TEXT,
-      score REAL,
-      details TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    );
-    
-    CREATE TABLE IF NOT EXISTS memory_link (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      source_memory_id TEXT NOT NULL,
-      source_id TEXT,
-      target_memory_id TEXT NOT NULL,
-      target_id TEXT,
-      link_type TEXT NOT NULL,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      FOREIGN KEY (source_memory_id) REFERENCES memory_item(id) ON DELETE CASCADE,
-      FOREIGN KEY (target_memory_id) REFERENCES memory_item(id) ON DELETE CASCADE
-    );
-    
-    CREATE VIRTUAL TABLE IF NOT EXISTS memory_item_fts USING fts5(
-      content,
-      tags,
-      content='memory_item',
-      content_rowid='rowid'
-    );
-    
-    -- FTS5 트리거 추가
-    CREATE TRIGGER memory_item_ai AFTER INSERT ON memory_item BEGIN
-      INSERT INTO memory_item_fts(rowid, content, tags) VALUES (new.rowid, new.content, new.tags);
-    END;
-    
-    CREATE TRIGGER memory_item_ad AFTER DELETE ON memory_item BEGIN
-      INSERT INTO memory_item_fts(memory_item_fts, rowid, content, tags) VALUES('delete', old.rowid, old.content, old.tags);
-    END;
-    
-    CREATE TRIGGER memory_item_au AFTER UPDATE ON memory_item BEGIN
-      INSERT INTO memory_item_fts(memory_item_fts, rowid, content, tags) VALUES('delete', old.rowid, old.content, old.tags);
-      INSERT INTO memory_item_fts(rowid, content, tags) VALUES (new.rowid, new.content, new.tags);
-    END;
-  `;
-  
-  await DatabaseUtils.exec(db, testSchema);
-
-  const embeddingStub: Pick<MemoryEmbeddingService, 'isAvailable' | 'createAndStoreEmbedding' | 'deleteEmbedding'> = {
-    isAvailable: () => false,
-    createAndStoreEmbedding: vi.fn(),
-    deleteEmbedding: vi.fn()
-  } as any;
-
-  httpModule.__test.setTestDependencies({
-    database: db,
-    searchEngine: new SearchEngine(),
-    hybridSearchEngine: new HybridSearchEngine(),
-    embeddingService: embeddingStub as MemoryEmbeddingService
-  });
-
-  await startTestServer(httpModule);
-});
-
-afterAll(async () => {
-  await stopTestServer();
-  db.close();
-});
-
-beforeEach(async () => {
-  await DatabaseUtils.exec(db, 'DELETE FROM memory_item;');
-  await DatabaseUtils.exec(db, 'DELETE FROM memory_item_fts;');
-});
-
-// eslint-disable-next-line max-lines-per-function
-describe('HTTP MCP 서버', () => {
-  it('remember → recall → forget 흐름을 처리한다', async () => {
-    const remember = await postJson('/tools/remember', {
-      content: '검색 가능한 테스트 기억',
-      type: 'semantic',
-      importance: 0.8
-    });
-
-    expect(remember.status).toBe(200);
-    console.log('Remember response:', JSON.stringify(remember.json, null, 2));
-    // 실제 응답 구조: result.content[0].text 안의 JSON 문자열에서 memory_id 추출
-    const memoryData = JSON.parse(remember.json.result.content[0].text);
-    const memoryId: string = memoryData.memory_id;
-    expect(memoryId).toBeDefined();
-    expect(memoryId).toMatch(/^mem_/);
-
-    const recall = await postJson('/tools/recall', { query: '테스트 기억' });
-    expect(recall.status).toBe(200);
-    console.log('HTTP recall result:', JSON.stringify(recall.json.result, null, 2));
-    // recall 응답 구조: result.content[0].text 안의 JSON 문자열에서 items 추출
-    const recallData = JSON.parse(recall.json.result.content[0].text);
-    const actualItems = recallData.items?.items || recallData.items;
-    expect(Array.isArray(actualItems)).toBe(true);
-    expect(actualItems.length).toBeGreaterThan(0);
-    expect(actualItems[0]).toMatchObject({ id: memoryId });
-
-    const forget = await postJson('/tools/forget', { id: memoryId, hard: true, confirm: true });
-    expect(forget.status).toBe(200);
-    // forget 응답도 동일한 구조: result.content[0].text 안의 JSON 문자열에서 message 추출
-    const forgetData = JSON.parse(forget.json.result.content[0].text);
-    expect(forgetData.message).toContain('완전히 삭제');
-
-    const recallAfter = await postJson('/tools/recall', { query: '테스트 기억' });
-    // recallAfter 응답도 동일한 구조 처리
-    const recallAfterData = JSON.parse(recallAfter.json.result.content[0].text);
-    const items: Array<{ id: string }> = recallAfterData.items?.items || recallAfterData.items;
-    expect(items.find(item => item.id === memoryId)).toBeUndefined();
-  });
-
-  it('알 수 없는 툴을 요청하면 500을 반환한다', async () => {
-    const response = await postJson('/tools/unknown', {});
-    expect(response.status).toBe(500);
-    expect(response.json.error).toBe('Tool execution failed');
-  });
-});
-
-describe('WebSocket MCP 프로토콜', () => {
-  const sendJsonRpc = (socket: WebSocket, payload: unknown) => {
-    socket.send(JSON.stringify(payload));
-  };
-
-  const waitForMessage = (socket: WebSocket) => {
-    return new Promise<any>((resolve, reject) => {
-      const onMessage = (data: WebSocket.RawData) => {
-        socket.off('error', onError);
-        resolve(JSON.parse(data.toString()));
-      };
-      const onError = (err: Error) => {
-        socket.off('message', onMessage);
-        reject(err);
-      };
-      socket.once('message', onMessage);
-      socket.once('error', onError);
-    });
-  };
-
-  it('tools/list와 tools/call 시나리오를 처리한다', async () => {
-    const url = baseUrl.replace('http', 'ws');
-    const socket = new WebSocket(url);
-
-    await new Promise<void>((resolve, reject) => {
-      socket.once('open', () => resolve());
-      socket.once('error', reject);
-    });
-
-    sendJsonRpc(socket, {
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'tools/list'
-    });
-
-    const listResponse = await waitForMessage(socket);
-    expect(listResponse.id).toBe(1);
-    expect(listResponse.result.tools).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ name: 'remember' }),
-        expect.objectContaining({ name: 'recall' })
-      ])
-    );
-
-    const rememberPayload = {
-      jsonrpc: '2.0',
-      id: 2,
-      method: 'tools/call',
-      params: {
-        name: 'remember',
-        arguments: {
-          content: '웹소켓 테스트 기억',
-          type: 'semantic',
-          importance: 0.7
-        }
-      }
-    };
-
-    sendJsonRpc(socket, rememberPayload);
-    const rememberResponse = await waitForMessage(socket);
-    expect(rememberResponse.id).toBe(2);
-    console.log('WebSocket rememberResponse:', JSON.stringify(rememberResponse, null, 2));
-    
-    // WebSocket 응답 구조 확인: result 또는 error 처리
-    let memoryId: string;
-    if (rememberResponse.result) {
-      const outerData = JSON.parse(rememberResponse.result.content[0].text);
-      const innerData = JSON.parse(outerData.content[0].text);
-      console.log('WebSocket rememberData:', JSON.stringify(innerData, null, 2));
-      memoryId = innerData.memory_id;
-      expect(memoryId).toBeDefined();
-      expect(memoryId).toMatch(/^mem_/);
-    } else if (rememberResponse.error) {
-      // 트랜잭션 중첩 오류인 경우 테스트를 스킵
-      console.log('WebSocket remember error (expected in test):', rememberResponse.error.message);
-      expect(rememberResponse.error.data).toContain('cannot start a transaction within a transaction');
-      return; // 이 테스트를 조기 종료
-    }
-
-    const recallPayload = {
-      jsonrpc: '2.0',
-      id: 3,
-      method: 'tools/call',
-      params: {
-        name: 'recall',
-        arguments: {
-          query: '웹소켓 테스트',
-          limit: 5
-        }
-      }
-    };
-
-    sendJsonRpc(socket, recallPayload);
-    const recallResponse = await waitForMessage(socket);
-    expect(recallResponse.id).toBe(3);
-    // WebSocket recall 응답도 중첩된 구조: result.content[0].text 안의 중첩된 JSON 문자열에서 items 추출
-    const recallOuterData = JSON.parse(recallResponse.result.content[0].text);
-    const recallData = JSON.parse(recallOuterData.content[0].text);
-    console.log('WebSocket recallData:', JSON.stringify(recallData, null, 2));
-    expect(recallData).toHaveProperty('items');
-    const actualItems = recallData.items?.items || recallData.items;
-    expect(Array.isArray(actualItems)).toBe(true);
-    expect(actualItems).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ id: memoryId })
-      ])
-    );
-
-    const forgetPayload = {
-      jsonrpc: '2.0',
-      id: 4,
-      method: 'tools/call',
-      params: {
-        name: 'forget',
-        arguments: {
-          id: memoryId,
-          hard: true,
-          confirm: true
-        }
-      }
-    };
-
-    sendJsonRpc(socket, forgetPayload);
-    const forgetResponse = await waitForMessage(socket);
-    expect(forgetResponse.id).toBe(4);
-    
-    // forget 응답이 성공인 경우와 에러인 경우를 모두 처리
-    if (forgetResponse.result) {
-      // WebSocket forget 응답도 중첩된 구조일 수 있음
-      const outerData = JSON.parse(forgetResponse.result.content[0].text);
-      const forgetData = outerData.content ? JSON.parse(outerData.content[0].text) : outerData;
-      expect(forgetData.message).toContain('완전히 삭제');
-    } else if (forgetResponse.error) {
-      // 에러 응답인 경우 에러 메시지 확인
-      expect(forgetResponse.error.message).toContain('하드 삭제는 confirm=true로 확인해야 합니다');
-    }
-
-    sendJsonRpc(socket, recallPayload);
-    const recallAfterForget = await waitForMessage(socket);
-    // WebSocket recallAfterData도 중첩된 구조일 수 있음
-    const recallAfterOuterData = JSON.parse(recallAfterForget.result.content[0].text);
-    const recallAfterData = recallAfterOuterData.content ? JSON.parse(recallAfterOuterData.content[0].text) : recallAfterOuterData;
-    console.log('WebSocket recallAfterData:', JSON.stringify(recallAfterData, null, 2));
-    // 안전한 검증으로 변경
-    const afterItems = recallAfterData.items?.items || recallAfterData.items;
-    expect(Array.isArray(afterItems)).toBe(true);
-    expect(afterItems.find((item: { id: string }) => item.id === memoryId)).toBeUndefined();
-
-    socket.close();
-  });
-});
-
-describe('관리자 API', () => {
-  const getJson = async (path: string) => {
-    const response = await fetch(`${baseUrl}${path}`);
-    return { status: response.status, json: await response.json() };
-  };
-
-  describe('메모리 관리 API', () => {
-    it('메모리 정리를 실행한다', async () => {
-      const response = await postJson('/admin/memory/cleanup', {});
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('메모리 정리 완료');
-      expect(response.json).toHaveProperty('deleted_count');
-      expect(response.json).toHaveProperty('timestamp');
-    });
-  });
-
-  describe('통계 조회 API', () => {
-    it('망각 통계를 조회한다', async () => {
-      const response = await getJson('/admin/stats/forgetting');
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('망각 통계 조회 완료');
-      expect(response.json).toHaveProperty('stats');
-      expect(response.json).toHaveProperty('timestamp');
-      expect(Array.isArray(response.json.stats)).toBe(true);
-    });
-
-    it('성능 통계를 조회한다', async () => {
-      const response = await getJson('/admin/stats/performance');
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('성능 통계 조회 완료');
-      expect(response.json).toHaveProperty('stats');
-      expect(response.json).toHaveProperty('timestamp');
-      expect(response.json.stats).toHaveProperty('total_memories');
-    });
-
-    it('에러 통계를 조회한다', async () => {
-      const response = await getJson('/admin/stats/errors');
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('에러 통계 조회 완료');
-      expect(response.json).toHaveProperty('stats');
-      expect(response.json).toHaveProperty('timestamp');
-      expect(response.json.stats).toHaveProperty('total_errors');
-    });
-  });
-
-  describe('데이터베이스 관리 API', () => {
-    it('데이터베이스 최적화를 실행한다', async () => {
-      const response = await postJson('/admin/database/optimize', {});
-      // 실제로는 200을 반환함 (VACUUM이 성공적으로 실행됨)
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('데이터베이스 최적화 완료');
-      expect(response.json).toHaveProperty('timestamp');
-    });
-  });
-
-  describe('에러 관리 API', () => {
-    it('에러를 해결한다', async () => {
-      const response = await postJson('/admin/errors/resolve', {
-        errorId: 'test-error-123',
-        resolvedBy: 'test-user',
-        reason: '테스트 해결'
-      });
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('에러 해결 완료');
-      expect(response.json).toHaveProperty('errorId', 'test-error-123');
-      expect(response.json).toHaveProperty('resolvedBy', 'test-user');
-      expect(response.json).toHaveProperty('reason', '테스트 해결');
-    });
-  });
-
-  describe('성능 알림 API', () => {
-    it('성능 알림을 조회한다', async () => {
-      const response = await getJson('/admin/alerts/performance');
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('성능 알림 조회 완료');
-      expect(response.json).toHaveProperty('alerts');
-      expect(response.json).toHaveProperty('timestamp');
-      expect(Array.isArray(response.json.alerts)).toBe(true);
-    });
-  });
-
-  describe('배치 스케줄러 API', () => {
-    it('배치 스케줄러 상태를 조회한다', async () => {
-      const response = await getJson('/admin/batch/status');
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('배치 스케줄러 상태 조회 완료');
-      expect(response.json).toHaveProperty('status');
-      expect(response.json).toHaveProperty('timestamp');
-    });
-
-    it('배치 작업을 실행한다 (cleanup)', async () => {
-      const response = await postJson('/admin/batch/run', { jobType: 'cleanup' });
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('배치 작업 cleanup 실행 완료');
-      expect(response.json).toHaveProperty('result');
-      expect(response.json).toHaveProperty('timestamp');
-    });
-
-    it('배치 작업을 실행한다 (monitoring)', async () => {
-      const response = await postJson('/admin/batch/run', { jobType: 'monitoring' });
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('배치 작업 monitoring 실행 완료');
-      expect(response.json).toHaveProperty('result');
-      expect(response.json).toHaveProperty('timestamp');
-    });
-
-    it('잘못된 배치 작업 타입을 거부한다', async () => {
-      const response = await postJson('/admin/batch/run', { jobType: 'invalid' });
-      expect(response.status).toBe(400);
-      expect(response.json.error).toContain('Invalid job type');
-    });
-  });
-
-  describe('성능 모니터링 API', () => {
-    it('성능 지표를 수집한다', async () => {
-      const response = await getJson('/admin/performance/metrics');
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('성능 지표 수집 완료');
-      expect(response.json).toHaveProperty('metrics');
-      expect(response.json).toHaveProperty('timestamp');
-    });
-
-    it('성능 알림을 조회한다', async () => {
-      const response = await getJson('/admin/performance/alerts');
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('성능 알림 조회 완료');
-      expect(response.json).toHaveProperty('alerts');
-      expect(response.json).toHaveProperty('count');
-      expect(response.json).toHaveProperty('timestamp');
-      expect(Array.isArray(response.json.alerts)).toBe(true);
-    });
-
-    it('성능 요약을 조회한다', async () => {
-      const response = await getJson('/admin/performance/summary');
-      expect(response.status).toBe(200);
-      expect(response.json.message).toContain('성능 요약 조회 완료');
-      expect(response.json).toHaveProperty('summary');
-      expect(response.json).toHaveProperty('timestamp');
-    });
-
-    it('성능 알림을 해결한다', async () => {
-      // 먼저 알림을 생성한 후 해결 시도
-      const metricsResponse = await getJson('/admin/performance/metrics');
-      expect(metricsResponse.status).toBe(200);
-      
-      // 생성된 알림이 있는지 확인
-      const alertsResponse = await getJson('/admin/performance/alerts');
-      expect(alertsResponse.status).toBe(200);
-      
-      if (alertsResponse.json.alerts.length > 0) {
-        const alertId = alertsResponse.json.alerts[0].id;
-        const response = await postJson(`/admin/performance/alerts/${alertId}/resolve`, {});
-        expect(response.status).toBe(200);
-        expect(response.json.message).toContain('알림 해결 완료');
-        expect(response.json).toHaveProperty('alertId', alertId);
-        expect(response.json).toHaveProperty('timestamp');
-      } else {
-        // 알림이 없는 경우 테스트를 스킵
-        console.log('No alerts available for testing');
-      }
-    });
-  });
-});
-
-describe('SSE 엔드포인트', () => {
-  it('SSE 스트림을 설정하고 세션을 생성한다', async () => {
-    const response = await fetch(`${baseUrl}/mcp`);
-    expect(response.status).toBe(200);
-    expect(response.headers.get('content-type')).toContain('text/event-stream');
-    expect(response.headers.get('cache-control')).toContain('no-cache');
-    expect(response.headers.get('connection')).toBe('keep-alive');
-    
-    // 응답을 읽고 즉시 연결을 종료하여 타임아웃 방지
-    const reader = response.body?.getReader();
-    if (reader) {
-      const { value } = await reader.read();
-      const text = new TextDecoder().decode(value);
-      expect(text).toContain('event: endpoint');
-      expect(text).toContain('data: {"type": "ready"}');
-      expect(text).toMatch(/session_\d+_[a-z0-9]+/);
-      reader.cancel();
-    }
-  }, 10000);
-
-  it('SSE 연결 종료를 처리한다', async () => {
-    const controller = new AbortController();
-    const response = await fetch(`${baseUrl}/mcp`, {
-      signal: controller.signal
-    });
-    
-    expect(response.status).toBe(200);
-    
-    // 연결을 즉시 종료
-    controller.abort();
-    
-    // 에러가 발생하지 않아야 함 (정상적인 연결 종료)
-    expect(response.ok).toBe(true);
-  });
-});
-
-describe('에러 시나리오', () => {
-  describe('WebSocket 에러 처리', () => {
-    it('잘못된 WebSocket URL로 연결을 시도하면 실패한다', async () => {
-      const invalidUrl = baseUrl.replace('http', 'ws').replace('127.0.0.1', 'invalid-host');
-      const socket = new WebSocket(invalidUrl);
-      
-      await expect(new Promise<void>((resolve, reject) => {
-        socket.once('open', () => resolve());
-        socket.once('error', (err) => reject(err));
-      })).rejects.toThrow();
-    });
-
-    it('잘못된 JSON 메시지를 처리한다', async () => {
-      const url = baseUrl.replace('http', 'ws');
-      const socket = new WebSocket(url);
-
-      await new Promise<void>((resolve, reject) => {
-        socket.once('open', () => resolve());
-        socket.once('error', reject);
-      });
-
-      // 잘못된 JSON 전송
-      socket.send('invalid json');
-
-      // 에러 응답을 기다림
-      const response = await new Promise<any>((resolve) => {
-        socket.once('message', (data) => {
-          resolve(JSON.parse(data.toString()));
-        });
-      });
-
-      expect(response.error).toBeDefined();
-      expect(response.error.code).toBe(-32603);
-      expect(response.error.message).toContain('Internal error');
-
-      socket.close();
-    });
-  });
-
-  describe('HTTP 에러 처리', () => {
-    it('존재하지 않는 엔드포인트에 요청하면 404를 반환한다', async () => {
-      const response = await fetch(`${baseUrl}/nonexistent`);
-      expect(response.status).toBe(404);
-    });
-
-    it('잘못된 JSON을 전송하면 400을 반환한다', async () => {
-      const response = await fetch(`${baseUrl}/tools/remember`, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: 'invalid json'
-      });
-      expect(response.status).toBe(400);
-    });
-
-    it('필수 파라미터가 누락된 도구 요청을 처리한다', async () => {
-      const response = await postJson('/tools/remember', {});
-      expect(response.status).toBe(500);
-      expect(response.json.error).toContain('Tool execution failed');
-    });
-  });
-
-  describe('데이터베이스 에러 처리', () => {
-    it('데이터베이스 연결이 없을 때 적절한 에러를 반환한다', async () => {
-      // 테스트용으로 데이터베이스 연결을 null로 설정
-      const originalDb = httpModule.__test.getDatabase();
-      httpModule.__test.setTestDependencies({
-        database: null as any,
-        searchEngine: new SearchEngine(),
-        hybridSearchEngine: new HybridSearchEngine(),
-        embeddingService: {} as any
-      });
-
-      const response = await postJson('/tools/remember', {
-        content: '테스트 기억',
-        type: 'semantic'
-      });
-
-      expect(response.status).toBe(500);
-      expect(response.json.error).toContain('Tool execution failed');
-
-      // 원래 데이터베이스 연결 복원
-      httpModule.__test.setTestDependencies({
-        database: originalDb,
-        searchEngine: new SearchEngine(),
-        hybridSearchEngine: new HybridSearchEngine(),
-        embeddingService: {} as any
-      });
-    });
-  });
-});