🧪 Phase C テストケース仕様¶

1. VectorDatabaseService テストケース¶

1.1 createDocument() テスト¶

describe('VectorDatabaseService.createDocument', () => {
  // 正常系テスト
  test('should create document with valid data', async () => {
    const validDoc = {
      title: 'Test Document',
      content: 'This is test content for embedding generation.',
      metadata: { fileType: 'txt', size: 1024 }
    };
    const result = await vectorService.createDocument(validDoc);
    
    expect(result.id).toBeGreaterThan(0);
    expect(result.status).toBe('processing');
    expect(result.chunks).toBeGreaterThan(0);
  });
  
  // 境界値テスト
  test('should handle large documents (>10MB)', async () => {
    const largeDoc = { title: 'Large Doc', content: 'x'.repeat(10485760) };
    const result = await vectorService.createDocument(largeDoc);
    expect(result.chunks).toBeGreaterThan(100);
  });
  
  // 異常系テスト
  test('should reject empty content', async () => {
    const invalidDoc = { title: 'Empty', content: '' };
    await expect(vectorService.createDocument(invalidDoc))
      .rejects.toThrow('ValidationError');
  });
  
  test('should reject missing title', async () => {
    const invalidDoc = { content: 'Content without title' };
    await expect(vectorService.createDocument(invalidDoc))
      .rejects.toThrow('ValidationError');
  });
});

1.2 semanticSearch() テスト¶

describe('VectorDatabaseService.semanticSearch', () => {
  beforeEach(async () => {
    // テストデータ投入
    await seedTestDocuments();
  });
  
  // 正常系テスト
  test('should return relevant results for valid query', async () => {
    const results = await vectorService.semanticSearch('machine learning');
    
    expect(results.results).toHaveLength(10);
    expect(results.results[0].similarity).toBeGreaterThan(0.7);
    expect(results.searchTime).toBeLessThan(2000);
  });
  
  // パフォーマンステスト
  test('should complete search within 2 seconds', async () => {
    const startTime = Date.now();
    await vectorService.semanticSearch('complex technical query');
    const duration = Date.now() - startTime;
    expect(duration).toBeLessThan(2000);
  });
  
  // フィルタリングテスト
  test('should apply date range filters correctly', async () => {
    const options = {
      filters: {
        dateRange: [new Date('2025-01-01'), new Date('2025-06-01')]
      }
    };
    const results = await vectorService.semanticSearch('test', options);
    
    results.results.forEach(result => {
      expect(new Date(result.metadata.createdAt))
        .toBeWithinRange(options.filters.dateRange[0], options.filters.dateRange[1]);
    });
  });
  
  // 異常系テスト
  test('should handle empty query gracefully', async () => {
    const results = await vectorService.semanticSearch('');
    expect(results.results).toHaveLength(0);
  });
  
  test('should handle non-existent language queries', async () => {
    const results = await vectorService.semanticSearch('xyz123非存在クエリ');
    expect(results.results.length).toBeLessThanOrEqual(5);
  });
});

2. DocumentProcessingService テストケース¶

2.1 processFile() テスト¶

describe('DocumentProcessingService.processFile', () => {
  // PDF処理テスト
  test('should process PDF file correctly', async () => {
    const pdfBuffer = await readTestFile('sample.pdf');
    const mockFile = createMockFile(pdfBuffer, 'sample.pdf', 'application/pdf');
    
    const result = await docService.processFile(mockFile);
    
    expect(result.document.title).toBe('sample.pdf');
    expect(result.chunks.length).toBeGreaterThan(0);
    expect(result.metadata.pages).toBeGreaterThan(0);
  });
  
  // DOCX処理テスト
  test('should process DOCX file correctly', async () => {
    const docxBuffer = await readTestFile('sample.docx');
    const mockFile = createMockFile(docxBuffer, 'sample.docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
    
    const result = await docService.processFile(mockFile);
    
    expect(result.document.summary).toBeDefined();
    expect(result.metadata.words).toBeGreaterThan(0);
  });
  
  // チャンク分割テスト
  test('should chunk content with proper overlap', async () => {
    const longContent = 'word '.repeat(2000);
    const mockFile = createMockFile(Buffer.from(longContent), 'long.txt', 'text/plain');
    
    const result = await docService.processFile(mockFile, { 
      chunkSize: 1000, 
      overlap: 200 
    });
    
    expect(result.chunks.length).toBeGreaterThan(1);
    // オーバーラップ検証
    expect(result.chunks[1].content).toContain(
      result.chunks[0].content.slice(-200)
    );
  });
  
  // ファイルサイズ制限テスト
  test('should reject files larger than limit', async () => {
    const largeBuffer = Buffer.alloc(100 * 1024 * 1024); // 100MB
    const mockFile = createMockFile(largeBuffer, 'large.pdf', 'application/pdf');
    
    await expect(docService.processFile(mockFile))
      .rejects.toThrow('File size exceeds limit');
  });
  
  // 不正ファイル形式テスト
  test('should reject unsupported file types', async () => {
    const mockFile = createMockFile(Buffer.from('content'), 'file.xyz', 'application/unknown');
    
    await expect(docService.processFile(mockFile))
      .rejects.toThrow('Unsupported file type');
  });
});

3. RAGQueryService テストケース¶

3.1 generateAnswer() テスト¶

describe('RAGQueryService.generateAnswer', () => {
  // 正常回答生成テスト
  test('should generate coherent answer with context', async () => {
    const query = 'What is machine learning?';
    const context = [
      { content: 'Machine learning is a subset of AI...', relevance: 0.9 },
      { content: 'ML algorithms learn from data...', relevance: 0.8 }
    ];
    
    const result = await ragService.generateAnswer(query, context);
    
    expect(result.answer).toContain('machine learning');
    expect(result.confidence).toBeGreaterThan(0.7);
    expect(result.sources.length).toBeGreaterThan(0);
  });
  
  // トークン制限テスト
  test('should respect token limits', async () => {
    const longQuery = 'explain '.repeat(1000);
    const result = await ragService.generateAnswer(longQuery, [], { maxTokens: 100 });
    
    expect(result.tokens.completion).toBeLessThanOrEqual(100);
  });
  
  // コンテキスト不足テスト
  test('should handle insufficient context gracefully', async () => {
    const result = await ragService.generateAnswer('specific technical question', []);
    
    expect(result.answer).toContain('insufficient information');
    expect(result.confidence).toBeLessThan(0.5);
  });
});

4. API エンドポイント統合テスト¶

4.1 Document Upload API テスト¶

describe('POST /api/documents/upload', () => {
  test('should upload and process document successfully', async () => {
    const response = await request(app)
      .post('/api/documents/upload')
      .attach('file', 'test/fixtures/sample.pdf')
      .field('title', 'Test Document')
      .expect(200);
    
    expect(response.body.success).toBe(true);
    expect(response.body.document.id).toBeDefined();
    expect(response.body.processing.jobId).toBeDefined();
  });
  
  test('should reject unauthorized requests', async () => {
    await request(app)
      .post('/api/documents/upload')
      .attach('file', 'test/fixtures/sample.pdf')
      .expect(401);
  });
  
  test('should validate file size limits', async () => {
    const largeFile = Buffer.alloc(51 * 1024 * 1024); // 51MB
    
    await request(app)
      .post('/api/documents/upload')
      .attach('file', largeFile, 'large.pdf')
      .set('Authorization', 'Bearer ' + validToken)
      .expect(413);
  });
});

4.2 Semantic Search API テスト¶

describe('POST /api/search/semantic', () => {
  beforeEach(async () => {
    await seedSearchTestData();
  });
  
  test('should return search results with relevance scores', async () => {
    const response = await request(app)
      .post('/api/search/semantic')
      .set('Authorization', 'Bearer ' + validToken)
      .send({ query: 'artificial intelligence' })
      .expect(200);
    
    expect(response.body.results).toBeArray();
    expect(response.body.results[0].similarity).toBeGreaterThan(0.5);
    expect(response.body.metadata.searchTime).toBeLessThan(2000);
  });
  
  test('should apply pagination correctly', async () => {
    const response = await request(app)
      .post('/api/search/semantic')
      .set('Authorization', 'Bearer ' + validToken)
      .send({ 
        query: 'test',
        options: { limit: 5 }
      })
      .expect(200);
    
    expect(response.body.results).toHaveLength(5);
  });
});

4.3 Chat API テスト¶

describe('POST /api/chat/message', () => {
  test('should generate RAG-enhanced response', async () => {
    const response = await request(app)
      .post('/api/chat/message')
      .set('Authorization', 'Bearer ' + validToken)
      .send({
        message: 'Tell me about machine learning',
        context: { useRAG: true, maxSources: 3 }
      })
      .expect(200);
    
    expect(response.body.response).toBeDefined();
    expect(response.body.sources.length).toBeLessThanOrEqual(3);
    expect(response.body.sessionId).toBeDefined();
  });
  
  test('should maintain session continuity', async () => {
    // 最初のメッセージ
    const firstResponse = await request(app)
      .post('/api/chat/message')
      .set('Authorization', 'Bearer ' + validToken)
      .send({ message: 'Hello' })
      .expect(200);
    
    const sessionId = firstResponse.body.sessionId;
    
    // フォローアップメッセージ
    const followupResponse = await request(app)
      .post('/api/chat/message')
      .set('Authorization', 'Bearer ' + validToken)
      .send({ 
        message: 'What did I just say?',
        sessionId: sessionId
      })
      .expect(200);
    
    expect(followupResponse.body.response).toContain('Hello');
  });
});

5. パフォーマンステスト¶

5.1 負荷テスト¶

describe('Performance Tests', () => {
  test('should handle 50 concurrent search requests', async () => {
    const promises = Array.from({ length: 50 }, () =>
      request(app)
        .post('/api/search/semantic')
        .set('Authorization', 'Bearer ' + validToken)
        .send({ query: 'test query' })
    );
    
    const startTime = Date.now();
    const responses = await Promise.all(promises);
    const duration = Date.now() - startTime;
    
    expect(responses.every(r => r.status === 200)).toBe(true);
    expect(duration).toBeLessThan(10000); // 10秒以内
  });
  
  test('should maintain response time under load', async () => {
    const batchSize = 10;
    const batches = 5;
    
    for (let i = 0; i < batches; i++) {
      const batchPromises = Array.from({ length: batchSize }, () =>
        request(app)
          .post('/api/search/semantic')
          .set('Authorization', 'Bearer ' + validToken)
          .send({ query: `batch ${i} query` })
      );
      
      const startTime = Date.now();
      await Promise.all(batchPromises);
      const duration = Date.now() - startTime;
      
      expect(duration / batchSize).toBeLessThan(200); // 平均200ms以下
    }
  });
});

6. セキュリティテスト¶

6.1 認証・認可テスト¶

describe('Security Tests', () => {
  test('should reject requests without valid token', async () => {
    await request(app)
      .post('/api/documents/upload')
      .expect(401);
  });
  
  test('should prevent SQL injection in search queries', async () => {
    const maliciousQuery = "'; DROP TABLE documents; --";
    
    const response = await request(app)
      .post('/api/search/semantic')
      .set('Authorization', 'Bearer ' + validToken)
      .send({ query: maliciousQuery })
      .expect(200);
    
    // データベースが正常であることを確認
    expect(response.body.results).toBeDefined();
  });
  
  test('should sanitize file upload inputs', async () => {
    const response = await request(app)
      .post('/api/documents/upload')
      .set('Authorization', 'Bearer ' + validToken)
      .attach('file', Buffer.from('<script>alert("xss")</script>'), '../../../etc/passwd.txt')
      .expect(400);
    
    expect(response.body.error).toContain('Invalid file name');
  });
});

7. データ整合性テスト¶

7.1 並行処理テスト¶

describe('Data Consistency Tests', () => {
  test('should handle concurrent document uploads', async () => {
    const uploads = Array.from({ length: 5 }, (_, i) =>
      request(app)
        .post('/api/documents/upload')
        .set('Authorization', 'Bearer ' + validToken)
        .attach('file', Buffer.from(`Content ${i}`), `doc${i}.txt`)
    );
    
    const responses = await Promise.all(uploads);
    const documentIds = responses.map(r => r.body.document.id);
    
    // 重複IDがないことを確認
    expect(new Set(documentIds).size).toBe(documentIds.length);
  });
  
  test('should maintain embedding consistency after updates', async () => {
    const docId = await createTestDocument();
    const originalEmbeddings = await getDocumentEmbeddings(docId);
    
    await vectorService.updateEmbeddings(docId);
    const updatedEmbeddings = await getDocumentEmbeddings(docId);
    
    expect(updatedEmbeddings.length).toBe(originalEmbeddings.length);
  });
});

8. エラーハンドリングテスト¶

8.1 サービス障害テスト¶

describe('Error Handling Tests', () => {
  test('should handle database connection failures gracefully', async () => {
    // データベース接続を一時的に切断
    await disconnectDatabase();
    
    const response = await request(app)
      .post('/api/search/semantic')
      .set('Authorization', 'Bearer ' + validToken)
      .send({ query: 'test' })
      .expect(503);
    
    expect(response.body.error).toBe('ServiceUnavailable');
    
    // 接続復旧
    await reconnectDatabase();
  });
  
  test('should handle OpenAI API failures', async () => {
    // OpenAI APIをモック化してエラーを発生させる
    mockOpenAI.embeddings.create.mockRejectedValue(new Error('API Error'));
    
    const response = await request(app)
      .post('/api/search/semantic')
      .set('Authorization', 'Bearer ' + validToken)
      .send({ query: 'test' })
      .expect(500);
    
    expect(response.body.error).toBe('EmbeddingError');
  });
});

📊 テスト実行計画¶

1. 開発フェーズ別テスト¶

• Group A完了後: VectorDatabaseService + CacheService テスト
• Group B完了後: DocumentProcessingService テスト
• Group C完了後: RAGQueryService + SearchController テスト
• Group D完了後: ChatController + API統合テスト
• Group E完了後: AnalyticsService + パフォーマンステスト

2. テスト実行コマンド¶

# 単体テスト実行
npm test

# カバレッジ付きテスト
npm run test:coverage

# 統合テスト実行
npm run test:integration

# パフォーマンステスト実行
npm run test:performance

# 全テスト実行
npm run test:all

3. 成功基準¶

• Unit Test Coverage: > 60%
• Integration Test: 全API正常動作
• Performance Test: 応答時間 < 2秒
• Load Test: 50並行ユーザー対応
• Security Test: 脆弱性0件

これらのテストケースにより、Phase C実装の品質と信頼性が保証されます！ 🧪✅