memento-mcp-server 0.1.0

package/src/config/index.spec.ts

@@ -0,0 +1,339 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { mementoConfig, searchRankingWeights, defaultTags, validateConfig } from './index.js';
+
+// Mock dotenv
+vi.mock('dotenv', () => ({
+  config: vi.fn()
+}));
+
+describe('Config', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('mementoConfig', () => {
+    it('기본 설정값을 가져야 함', () => {
+      // 환경 변수 초기화
+      process.env = {};
+
+      // 모듈을 다시 로드하여 기본값 테스트
+      vi.resetModules();
+      const { mementoConfig: config } = require('./index.js');
+
+      expect(config.dbPath).toBe('./data/memory.db');
+      expect(config.serverName).toBe('memento-memory');
+      expect(config.serverVersion).toBe('0.1.0');
+      expect(config.port).toBe(3000);
+      expect(config.embeddingProvider).toBe('openai');
+      expect(config.embeddingDimensions).toBe(1536);
+      expect(config.searchDefaultLimit).toBe(10);
+      expect(config.searchMaxLimit).toBe(50);
+      expect(config.logLevel).toBe('info');
+      expect(config.nodeEnv).toBe('development');
+    });
+
+    it('환경 변수에서 설정값을 읽어야 함', () => {
+      process.env = {
+        DB_PATH: '/custom/db/path',
+        MCP_SERVER_NAME: 'custom-server',
+        MCP_SERVER_VERSION: '1.0.0',
+        MCP_SERVER_PORT: '8080',
+        EMBEDDING_PROVIDER: 'gemini',
+        OPENAI_API_KEY: 'test-openai-key',
+        GEMINI_API_KEY: 'test-gemini-key',
+        EMBEDDING_DIMENSIONS: '768',
+        SEARCH_DEFAULT_LIMIT: '20',
+        SEARCH_MAX_LIMIT: '100',
+        LOG_LEVEL: 'debug',
+        NODE_ENV: 'production'
+      };
+
+      vi.resetModules();
+      const { mementoConfig: config } = require('./index.js');
+
+      expect(config.dbPath).toBe('/custom/db/path');
+      expect(config.serverName).toBe('custom-server');
+      expect(config.serverVersion).toBe('1.0.0');
+      expect(config.port).toBe(8080);
+      expect(config.embeddingProvider).toBe('gemini');
+      expect(config.openaiApiKey).toBe('test-openai-key');
+      expect(config.geminiApiKey).toBe('test-gemini-key');
+      expect(config.embeddingDimensions).toBe(768);
+      expect(config.searchDefaultLimit).toBe(20);
+      expect(config.searchMaxLimit).toBe(100);
+      expect(config.logLevel).toBe('debug');
+      expect(config.nodeEnv).toBe('production');
+    });
+
+    it('망각 TTL 설정을 올바르게 가져야 함', () => {
+      process.env = {
+        FORGET_WORKING_TTL: '24',
+        FORGET_EPISODIC_TTL: '720', // 30일
+        FORGET_SEMANTIC_TTL: '-1',
+        FORGET_PROCEDURAL_TTL: '-1'
+      };
+
+      vi.resetModules();
+      const { mementoConfig: config } = require('./index.js');
+
+      expect(config.forgetTTL.working).toBe(24);
+      expect(config.forgetTTL.episodic).toBe(720);
+      expect(config.forgetTTL.semantic).toBe(-1);
+      expect(config.forgetTTL.procedural).toBe(-1);
+    });
+
+    it('기본 망각 TTL 설정을 가져야 함', () => {
+      process.env = {};
+
+      vi.resetModules();
+      const { mementoConfig: config } = require('./index.js');
+
+      expect(config.forgetTTL.working).toBe(48);
+      expect(config.forgetTTL.episodic).toBe(2160); // 90일
+      expect(config.forgetTTL.semantic).toBe(-1);
+      expect(config.forgetTTL.procedural).toBe(-1);
+    });
+  });
+
+  describe('searchRankingWeights', () => {
+    it('올바른 검색 랭킹 가중치를 가져야 함', () => {
+      expect(searchRankingWeights.relevance).toBe(0.50);
+      expect(searchRankingWeights.recency).toBe(0.20);
+      expect(searchRankingWeights.importance).toBe(0.20);
+      expect(searchRankingWeights.usage).toBe(0.10);
+      expect(searchRankingWeights.duplication_penalty).toBe(0.15);
+    });
+
+    it('가중치의 합이 1에 가까워야 함', () => {
+      const sum = Object.values(searchRankingWeights).reduce((a, b) => a + b, 0);
+      expect(sum).toBeCloseTo(1, 2);
+    });
+  });
+
+  describe('defaultTags', () => {
+    it('기본 태그 분류를 가져야 함', () => {
+      expect(defaultTags.tech).toContain('javascript');
+      expect(defaultTags.tech).toContain('typescript');
+      expect(defaultTags.tech).toContain('react');
+      expect(defaultTags.pref).toContain('coffee');
+      expect(defaultTags.pref).toContain('tea');
+      expect(defaultTags.task).toContain('bug-fix');
+      expect(defaultTags.task).toContain('feature');
+      expect(defaultTags.project).toContain('memento');
+    });
+
+    it('각 카테고리가 배열이어야 함', () => {
+      expect(Array.isArray(defaultTags.tech)).toBe(true);
+      expect(Array.isArray(defaultTags.pref)).toBe(true);
+      expect(Array.isArray(defaultTags.task)).toBe(true);
+      expect(Array.isArray(defaultTags.project)).toBe(true);
+    });
+  });
+
+  describe('validateConfig', () => {
+    it('유효한 설정에 대해 에러를 던지지 않아야 함', () => {
+      process.env = {
+        EMBEDDING_PROVIDER: 'openai',
+        OPENAI_API_KEY: 'test-key',
+        EMBEDDING_DIMENSIONS: '1536',
+        SEARCH_DEFAULT_LIMIT: '10',
+        SEARCH_MAX_LIMIT: '50'
+      };
+
+      vi.resetModules();
+      const { validateConfig: validate } = require('./index.js');
+
+      expect(() => validate()).not.toThrow();
+    });
+
+    it('OpenAI 제공자에 API 키가 없으면 에러를 던져야 함', () => {
+      process.env = {
+        EMBEDDING_PROVIDER: 'openai',
+        OPENAI_API_KEY: '',
+        EMBEDDING_DIMENSIONS: '1536',
+        SEARCH_DEFAULT_LIMIT: '10',
+        SEARCH_MAX_LIMIT: '50'
+      };
+
+      vi.resetModules();
+      const { validateConfig: validate } = require('./index.js');
+
+      expect(() => validate()).toThrow('OPENAI_API_KEY is required when using OpenAI embedding provider');
+    });
+
+    it('Gemini 제공자에 API 키가 없으면 에러를 던져야 함', () => {
+      process.env = {
+        EMBEDDING_PROVIDER: 'gemini',
+        GEMINI_API_KEY: '',
+        EMBEDDING_DIMENSIONS: '768',
+        SEARCH_DEFAULT_LIMIT: '10',
+        SEARCH_MAX_LIMIT: '50'
+      };
+
+      vi.resetModules();
+      const { validateConfig: validate } = require('./index.js');
+
+      expect(() => validate()).toThrow('GEMINI_API_KEY is required when using Gemini embedding provider');
+    });
+
+    it('프로덕션 환경에서 OpenAI API 키가 없으면 에러를 던져야 함', () => {
+      process.env = {
+        EMBEDDING_PROVIDER: 'openai',
+        OPENAI_API_KEY: '',
+        NODE_ENV: 'production',
+        EMBEDDING_DIMENSIONS: '1536',
+        SEARCH_DEFAULT_LIMIT: '10',
+        SEARCH_MAX_LIMIT: '50'
+      };
+
+      vi.resetModules();
+      const { validateConfig: validate } = require('./index.js');
+
+      expect(() => validate()).toThrow('OPENAI_API_KEY is required in production environment');
+    });
+
+    it('임베딩 차원이 0 이하면 에러를 던져야 함', () => {
+      process.env = {
+        EMBEDDING_PROVIDER: 'openai',
+        OPENAI_API_KEY: 'test-key',
+        EMBEDDING_DIMENSIONS: '0',
+        SEARCH_DEFAULT_LIMIT: '10',
+        SEARCH_MAX_LIMIT: '50'
+      };
+
+      vi.resetModules();
+      const { validateConfig: validate } = require('./index.js');
+
+      expect(() => validate()).toThrow('EMBEDDING_DIMENSIONS must be a positive number');
+    });
+
+    it('검색 제한이 0 이하면 에러를 던져야 함', () => {
+      process.env = {
+        EMBEDDING_PROVIDER: 'openai',
+        OPENAI_API_KEY: 'test-key',
+        EMBEDDING_DIMENSIONS: '1536',
+        SEARCH_DEFAULT_LIMIT: '0',
+        SEARCH_MAX_LIMIT: '50'
+      };
+
+      vi.resetModules();
+      const { validateConfig: validate } = require('./index.js');
+
+      expect(() => validate()).toThrow('Search limits must be positive numbers');
+    });
+
+    it('기본 검색 제한이 최대 검색 제한보다 크면 에러를 던져야 함', () => {
+      process.env = {
+        EMBEDDING_PROVIDER: 'openai',
+        OPENAI_API_KEY: 'test-key',
+        EMBEDDING_DIMENSIONS: '1536',
+        SEARCH_DEFAULT_LIMIT: '100',
+        SEARCH_MAX_LIMIT: '50'
+      };
+
+      vi.resetModules();
+      const { validateConfig: validate } = require('./index.js');
+
+      expect(() => validate()).toThrow('SEARCH_DEFAULT_LIMIT cannot be greater than SEARCH_MAX_LIMIT');
+    });
+
+    it('경량 임베딩 제공자는 API 키 없이도 통과해야 함', () => {
+      process.env = {
+        EMBEDDING_PROVIDER: 'lightweight',
+        EMBEDDING_DIMENSIONS: '512',
+        SEARCH_DEFAULT_LIMIT: '10',
+        SEARCH_MAX_LIMIT: '50'
+      };
+
+      vi.resetModules();
+      const { validateConfig: validate } = require('./index.js');
+
+      expect(() => validate()).not.toThrow();
+    });
+  });
+
+  describe('환경 변수 파싱', () => {
+    it('포트 번호를 올바르게 파싱해야 함', () => {
+      process.env.MCP_SERVER_PORT = '8080';
+
+      vi.resetModules();
+      const { mementoConfig: config } = require('./index.js');
+
+      expect(config.port).toBe(8080);
+      expect(typeof config.port).toBe('number');
+    });
+
+    it('잘못된 포트 번호에 대해 NaN을 처리해야 함', () => {
+      process.env.MCP_SERVER_PORT = 'invalid';
+
+      vi.resetModules();
+      const { mementoConfig: config } = require('./index.js');
+
+      expect(Number.isNaN(config.port)).toBe(true);
+    });
+
+    it('숫자 설정값들을 올바르게 파싱해야 함', () => {
+      process.env = {
+        EMBEDDING_DIMENSIONS: '768',
+        SEARCH_DEFAULT_LIMIT: '20',
+        SEARCH_MAX_LIMIT: '100',
+        FORGET_WORKING_TTL: '24'
+      };
+
+      vi.resetModules();
+      const { mementoConfig: config } = require('./index.js');
+
+      expect(config.embeddingDimensions).toBe(768);
+      expect(config.searchDefaultLimit).toBe(20);
+      expect(config.searchMaxLimit).toBe(100);
+      expect(config.forgetTTL.working).toBe(24);
+    });
+
+    it('빈 문자열에 대해 기본값을 사용해야 함', () => {
+      process.env = {
+        DB_PATH: '',
+        MCP_SERVER_NAME: '',
+        LOG_LEVEL: ''
+      };
+
+      vi.resetModules();
+      const { mementoConfig: config } = require('./index.js');
+
+      expect(config.dbPath).toBe('./data/memory.db');
+      expect(config.serverName).toBe('memento-memory');
+      expect(config.logLevel).toBe('info');
+    });
+  });
+
+  describe('설정 객체 구조', () => {
+    it('mementoConfig가 올바른 구조를 가져야 함', () => {
+      expect(mementoConfig).toHaveProperty('dbPath');
+      expect(mementoConfig).toHaveProperty('serverName');
+      expect(mementoConfig).toHaveProperty('serverVersion');
+      expect(mementoConfig).toHaveProperty('port');
+      expect(mementoConfig).toHaveProperty('embeddingProvider');
+      expect(mementoConfig).toHaveProperty('openaiApiKey');
+      expect(mementoConfig).toHaveProperty('geminiApiKey');
+      expect(mementoConfig).toHaveProperty('embeddingDimensions');
+      expect(mementoConfig).toHaveProperty('searchDefaultLimit');
+      expect(mementoConfig).toHaveProperty('searchMaxLimit');
+      expect(mementoConfig).toHaveProperty('forgetTTL');
+      expect(mementoConfig).toHaveProperty('logLevel');
+      expect(mementoConfig).toHaveProperty('nodeEnv');
+    });
+
+    it('forgetTTL이 올바른 구조를 가져야 함', () => {
+      expect(mementoConfig.forgetTTL).toHaveProperty('working');
+      expect(mementoConfig.forgetTTL).toHaveProperty('episodic');
+      expect(mementoConfig.forgetTTL).toHaveProperty('semantic');
+      expect(mementoConfig.forgetTTL).toHaveProperty('procedural');
+    });
+  });
+});

package/src/config/index.ts

@@ -0,0 +1,106 @@
+/**
+ * Memento MCP Server 설정 관리
+ */
+
+import { config } from 'dotenv';
+import type { MementoConfig, EmbeddingProvider } from '../types/index.js';
+
+// 환경 변수 로드
+config();
+
+export const mementoConfig: MementoConfig = {
+  // 데이터베이스 설정
+  dbPath: process.env.DB_PATH || './data/memory.db',
+  
+  // MCP 서버 설정
+  serverName: process.env.MCP_SERVER_NAME || 'memento-memory',
+  serverVersion: process.env.MCP_SERVER_VERSION || '0.1.0',
+  port: parseInt(process.env.MCP_SERVER_PORT || '3000', 10),
+  
+  // 임베딩 설정
+  embeddingProvider: (process.env.EMBEDDING_PROVIDER as EmbeddingProvider) || 'minilm',
+  openaiApiKey: process.env.OPENAI_API_KEY || undefined,
+  openaiModel: process.env.OPENAI_MODEL || 'text-embedding-3-small',
+  geminiApiKey: process.env.GEMINI_API_KEY || undefined,
+  geminiModel: process.env.GEMINI_MODEL || 'text-embedding-004',
+  embeddingDimensions: parseInt(process.env.EMBEDDING_DIMENSIONS || '384', 10), // MiniLM 기본값
+  
+  // 검색 설정
+  searchDefaultLimit: parseInt(process.env.SEARCH_DEFAULT_LIMIT || '10', 10),
+  searchMaxLimit: parseInt(process.env.SEARCH_MAX_LIMIT || '50', 10),
+  
+  // 망각 정책 설정 (시간 단위: 시간)
+  forgetTTL: {
+    working: parseInt(process.env.FORGET_WORKING_TTL || '48', 10),
+    episodic: parseInt(process.env.FORGET_EPISODIC_TTL || '2160', 10), // 90일
+    semantic: parseInt(process.env.FORGET_SEMANTIC_TTL || '-1', 10),   // 무기한
+    procedural: parseInt(process.env.FORGET_PROCEDURAL_TTL || '-1', 10) // 무기한
+  },
+  
+  // 로깅 설정
+  logLevel: process.env.LOG_LEVEL || 'info',
+  logFile: process.env.LOG_FILE || undefined,
+  
+  // 개발 설정
+  nodeEnv: process.env.NODE_ENV || 'development'
+};
+
+// 검색 랭킹 가중치 (Memento-Goals.md 참조)
+export const searchRankingWeights = {
+  relevance: 0.50,
+  recency: 0.20,
+  importance: 0.20,
+  usage: 0.10,
+  duplication_penalty: 0.15
+};
+
+// 기본 태그 분류
+export const defaultTags = {
+  tech: ['javascript', 'typescript', 'react', 'node', 'sqlite', 'mcp'],
+  pref: ['coffee', 'tea', 'morning', 'evening'],
+  task: ['ads-settlement', 'bug-fix', 'feature', 'refactor'],
+  project: ['memento', 'mcp-server', 'ai-agent']
+};
+
+// 유효성 검사
+export function validateConfig(): void {
+  // 임베딩 제공자별 API 키 검증
+  if (mementoConfig.embeddingProvider === 'openai' && !mementoConfig.openaiApiKey) {
+    throw new Error('OPENAI_API_KEY is required when using OpenAI embedding provider');
+  }
+  
+  if (mementoConfig.embeddingProvider === 'gemini' && !mementoConfig.geminiApiKey) {
+    throw new Error('GEMINI_API_KEY is required when using Gemini embedding provider');
+  }
+  
+  // 유효한 임베딩 제공자 확인
+  const validProviders = ['tfidf', 'lightweight', 'minilm', 'openai', 'gemini'];
+  if (!validProviders.includes(mementoConfig.embeddingProvider)) {
+    throw new Error(`Invalid embedding provider: ${mementoConfig.embeddingProvider}. Must be one of: ${validProviders.join(', ')}`);
+  }
+  
+  // 차원 수 검증 (제공자별 권장값)
+  const providerDimensions = {
+    tfidf: 512,
+    minilm: 384,
+    openai: 1536,
+    gemini: 768
+  };
+  
+  const expectedDimensions = providerDimensions[mementoConfig.embeddingProvider as keyof typeof providerDimensions];
+  if (mementoConfig.embeddingDimensions !== expectedDimensions) {
+    console.warn(`⚠️ 권장 차원 수와 다릅니다. ${mementoConfig.embeddingProvider}는 ${expectedDimensions}차원을 권장합니다.`);
+  }
+  
+  if (mementoConfig.embeddingDimensions <= 0) {
+    throw new Error('EMBEDDING_DIMENSIONS must be a positive number');
+  }
+  
+  if (mementoConfig.searchDefaultLimit <= 0 || mementoConfig.searchMaxLimit <= 0) {
+    throw new Error('Search limits must be positive numbers');
+  }
+  
+  if (mementoConfig.searchDefaultLimit > mementoConfig.searchMaxLimit) {
+    throw new Error('SEARCH_DEFAULT_LIMIT cannot be greater than SEARCH_MAX_LIMIT');
+  }
+}

package/src/database/init.spec.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { initializeDatabase } from './init.js';
+import Database from 'better-sqlite3';
+import { readFileSync } from 'fs';
+import { mementoConfig } from '../config/index.js';
+
+// Mock dependencies
+vi.mock('better-sqlite3');
+vi.mock('fs');
+vi.mock('../config/index.js', () => ({
+  mementoConfig: {
+    dbPath: './test-data/test.db'
+  }
+}));
+
+// Mock file system
+const mockMkdirSync = vi.fn();
+const mockExistsSync = vi.fn();
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: mockExistsSync,
+  mkdirSync: mockMkdirSync
+}));
+
+// Mock path and url modules
+vi.mock('path', () => ({
+  join: vi.fn((...args) => args.join('/')),
+  dirname: vi.fn((path) => path.split('/').slice(0, -1).join('/'))
+}));
+
+vi.mock('url', () => ({
+  fileURLToPath: vi.fn(() => '/test/path/init.js')
+}));
+
+describe('Database Init', () => {
+  let mockDb: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    // Mock database instance
+    mockDb = {
+      pragma: vi.fn(),
+      loadExtension: vi.fn(),
+      exec: vi.fn(),
+      close: vi.fn(),
+      prepare: vi.fn().mockReturnValue({
+        run: vi.fn(),
+        all: vi.fn(),
+        get: vi.fn()
+      })
+    };
+
+    vi.mocked(Database).mockImplementation(() => mockDb);
+    mockExistsSync.mockReturnValue(false);
+    mockMkdirSync.mockImplementation(() => {});
+    vi.mocked(readFileSync).mockReturnValue('CREATE TABLE test (id INTEGER PRIMARY KEY);');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('initializeDatabase', () => {
+    it('데이터베이스를 성공적으로 초기화해야 함', () => {
+      const result = initializeDatabase();
+
+      expect(result).toBe(mockDb);
+      expect(Database).toHaveBeenCalledWith('./test-data/test.db');
+    });
+
+    it('데이터 디렉토리를 생성해야 함', () => {
+      mockExistsSync.mockReturnValue(false);
+
+      initializeDatabase();
+
+      expect(mockMkdirSync).toHaveBeenCalledWith('./test-data', { recursive: true });
+    });
+
+    it('디렉토리가 이미 존재하면 생성하지 않아야 함', () => {
+      mockExistsSync.mockReturnValue(true);
+
+      initializeDatabase();
+
+      expect(mockMkdirSync).not.toHaveBeenCalled();
+    });
+
+    it('WAL 모드를 활성화해야 함', () => {
+      initializeDatabase();
+
+      expect(mockDb.pragma).toHaveBeenCalledWith('journal_mode = WAL');
+    });
+
+    it('외래키 제약 조건을 활성화해야 함', () => {
+      initializeDatabase();
+
+      expect(mockDb.pragma).toHaveBeenCalledWith('foreign_keys = ON');
+    });
+
+    it('프로덕션 환경에서 FTS5 확장을 로드하지 않아야 함', () => {
+      process.env.NODE_ENV = 'production';
+
+      initializeDatabase();
+
+      expect(mockDb.loadExtension).not.toHaveBeenCalled();
+    });
+
+    it('Docker 환경에서 FTS5 확장을 로드하지 않아야 함', () => {
+      process.env.DOCKER = 'true';
+
+      initializeDatabase();
+
+      expect(mockDb.loadExtension).not.toHaveBeenCalled();
+    });
+
+    it('로컬 환경에서 FTS5 확장을 로드해야 함', () => {
+      process.env.NODE_ENV = 'development';
+      process.env.DOCKER = 'false';
+
+      initializeDatabase();
+
+      expect(mockDb.loadExtension).toHaveBeenCalledWith('fts5');
+    });
+
+    it('FTS5 로드 실패 시 경고를 출력해야 함', () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      mockDb.loadExtension.mockImplementation(() => {
+        throw new Error('FTS5 not available');
+      });
+
+      initializeDatabase();
+
+      expect(consoleSpy).toHaveBeenCalledWith('⚠️ FTS5 확장을 로드할 수 없습니다. 텍스트 검색 기능이 제한될 수 있습니다.');
+    });
+
+    it('스키마 파일을 읽고 실행해야 함', () => {
+      initializeDatabase();
+
+      expect(readFileSync).toHaveBeenCalled();
+      expect(mockDb.exec).toHaveBeenCalledWith('CREATE TABLE test (id INTEGER PRIMARY KEY);');
+    });
+
+    it('스키마 파일 읽기 실패 시 에러를 던져야 함', () => {
+      vi.mocked(readFileSync).mockImplementation(() => {
+        throw new Error('File not found');
+      });
+
+      expect(() => initializeDatabase()).toThrow('스키마 파일을 읽을 수 없습니다');
+    });
+
+    it('데이터베이스 초기화 실패 시 에러를 던져야 함', () => {
+      vi.mocked(Database).mockImplementation(() => {
+        throw new Error('Database connection failed');
+      });
+
+      expect(() => initializeDatabase()).toThrow('Database connection failed');
+    });
+
+    it('디렉토리 생성 실패 시 에러를 무시해야 함', () => {
+      mockExistsSync.mockReturnValue(false);
+      mockMkdirSync.mockImplementation(() => {
+        throw new Error('Permission denied');
+      });
+
+      // 에러가 발생하지 않아야 함
+      expect(() => initializeDatabase()).not.toThrow();
+    });
+
+    it('환경 변수에 따라 다른 동작을 해야 함', () => {
+      process.env.NODE_ENV = 'test';
+      process.env.DOCKER = 'false';
+
+      initializeDatabase();
+
+      expect(mockDb.loadExtension).toHaveBeenCalledWith('fts5');
+    });
+  });
+
+  describe('데이터베이스 설정', () => {
+    it('올바른 데이터베이스 경로를 사용해야 함', () => {
+      initializeDatabase();
+
+      expect(Database).toHaveBeenCalledWith('./test-data/test.db');
+    });
+
+    it('데이터베이스 연결 후 설정을 적용해야 함', () => {
+      initializeDatabase();
+
+      expect(mockDb.pragma).toHaveBeenCalledWith('journal_mode = WAL');
+      expect(mockDb.pragma).toHaveBeenCalledWith('foreign_keys = ON');
+    });
+  });
+
+  describe('에러 처리', () => {
+    it('스키마 실행 실패 시 에러를 던져야 함', () => {
+      mockDb.exec.mockImplementation(() => {
+        throw new Error('SQL execution failed');
+      });
+
+      expect(() => initializeDatabase()).toThrow('데이터베이스 초기화에 실패했습니다');
+    });
+
+    it('데이터베이스 연결 실패 시 적절한 에러를 던져야 함', () => {
+      vi.mocked(Database).mockImplementation(() => {
+        throw new Error('Connection failed');
+      });
+
+      expect(() => initializeDatabase()).toThrow('Connection failed');
+    });
+  });
+
+  describe('환경별 동작', () => {
+    it('개발 환경에서 FTS5를 로드해야 함', () => {
+      process.env.NODE_ENV = 'development';
+      delete process.env.DOCKER;
+
+      initializeDatabase();
+
+      expect(mockDb.loadExtension).toHaveBeenCalledWith('fts5');
+    });
+
+    it('프로덕션 환경에서 FTS5를 로드하지 않아야 함', () => {
+      process.env.NODE_ENV = 'production';
+
+      initializeDatabase();
+
+      expect(mockDb.loadExtension).not.toHaveBeenCalled();
+    });
+
+    it('Docker 환경에서 FTS5를 로드하지 않아야 함', () => {
+      process.env.DOCKER = 'true';
+
+      initializeDatabase();
+
+      expect(mockDb.loadExtension).not.toHaveBeenCalled();
+    });
+  });
+});