@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/tests/unit/domains/code-intelligence/semantic-analyzer.test.ts

@@ -1,584 +0,0 @@
-/**
- * Agentic QE v3 - Semantic Analyzer Service Unit Tests
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-  SemanticAnalyzerService,
-  SemanticAnalyzerConfig,
-} from '../../../../src/domains/code-intelligence/services/semantic-analyzer';
-import { MemoryBackend, VectorSearchResult } from '../../../../src/kernel/interfaces';
-import { IEmbeddingProvider, EMBEDDING_CONFIG } from '../../../../src/shared/embeddings';
-
-/**
- * Mock Embedding Provider for testing
- * Generates deterministic pseudo-embeddings without requiring Ollama
- */
-function createMockEmbeddingProvider(): IEmbeddingProvider {
-  return {
-    async embed(text: string): Promise<number[]> {
-      // Generate deterministic embedding based on text content
-      const embedding = new Array(EMBEDDING_CONFIG.DIMENSIONS).fill(0);
-      for (let i = 0; i < text.length && i < embedding.length; i++) {
-        embedding[i] = text.charCodeAt(i) / 1000;
-      }
-      // Normalize
-      const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0)) || 1;
-      return embedding.map((v) => v / magnitude);
-    },
-    async healthCheck(): Promise<boolean> {
-      return true;
-    },
-    getDimensions(): number {
-      return EMBEDDING_CONFIG.DIMENSIONS;
-    },
-  };
-}
-
-/**
- * Mock Memory Backend for testing
- */
-function createMockMemoryBackend(): MemoryBackend {
-  const storage = new Map<string, unknown>();
-  const vectors = new Map<string, { embedding: number[]; metadata: unknown }>();
-
-  return {
-    initialize: vi.fn().mockResolvedValue(undefined),
-    dispose: vi.fn().mockResolvedValue(undefined),
-    set: vi.fn(async (key: string, value: unknown) => {
-      storage.set(key, value);
-    }),
-    get: vi.fn(async <T>(key: string): Promise<T | undefined> => {
-      return storage.get(key) as T | undefined;
-    }),
-    delete: vi.fn(async (key: string): Promise<boolean> => {
-      return storage.delete(key);
-    }),
-    has: vi.fn(async (key: string): Promise<boolean> => {
-      return storage.has(key);
-    }),
-    search: vi.fn(async (pattern: string, limit?: number): Promise<string[]> => {
-      const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-      const matches: string[] = [];
-      for (const key of storage.keys()) {
-        if (regex.test(key)) {
-          matches.push(key);
-          if (limit && matches.length >= limit) break;
-        }
-      }
-      return matches;
-    }),
-    vectorSearch: vi.fn(async (_embedding: number[], k: number): Promise<VectorSearchResult[]> => {
-      const results: VectorSearchResult[] = [];
-      let count = 0;
-      for (const [key, data] of vectors.entries()) {
-        if (count >= k) break;
-        results.push({
-          key,
-          score: 0.95 - count * 0.05,
-          metadata: data.metadata,
-        });
-        count++;
-      }
-      return results;
-    }),
-    storeVector: vi.fn(async (key: string, embedding: number[], metadata?: unknown) => {
-      vectors.set(key, { embedding, metadata });
-    }),
-  };
-}
-
-describe('SemanticAnalyzerService', () => {
-  let service: SemanticAnalyzerService;
-  let mockMemory: MemoryBackend;
-  let mockEmbeddingProvider: IEmbeddingProvider;
-
-  beforeEach(() => {
-    mockMemory = createMockMemoryBackend();
-    mockEmbeddingProvider = createMockEmbeddingProvider();
-    // Use mock embedding provider to avoid Ollama dependency in tests
-    service = new SemanticAnalyzerService(mockMemory, {
-      embeddingProvider: mockEmbeddingProvider,
-      useNomicEmbeddings: false, // Disable Nomic to use mock provider
-    });
-  });
-
-  describe('search', () => {
-    beforeEach(async () => {
-      // Pre-index some code
-      await service.indexCode('src/utils.ts', `
-        export function calculateSum(a: number, b: number): number {
-          return a + b;
-        }
-      `);
-      await service.indexCode('src/math.ts', `
-        export class MathOperations {
-          add(x: number, y: number) { return x + y; }
-          subtract(x: number, y: number) { return x - y; }
-        }
-      `);
-    });
-
-    it('should perform semantic search and return results', async () => {
-      const result = await service.search({
-        query: 'function that adds numbers',
-        type: 'semantic',
-        limit: 5,
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.searchTime).toBeGreaterThanOrEqual(0);
-        expect(result.value.total).toBeGreaterThanOrEqual(0);
-      }
-    });
-
-    it('should perform exact search for literal matches', async () => {
-      await service.indexCode('src/test.ts', 'const exactMatch = "findMe";');
-
-      const result = await service.search({
-        query: 'findMe',
-        type: 'exact',
-        limit: 10,
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.results.length).toBeGreaterThanOrEqual(0);
-      }
-    });
-
-    it('should perform fuzzy search for approximate matches', async () => {
-      await service.indexCode('src/handler.ts', 'function handleUserRequest() {}');
-
-      const result = await service.search({
-        query: 'handle user',
-        type: 'fuzzy',
-        limit: 10,
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.results).toBeDefined();
-      }
-    });
-
-    it('should filter results by scope', async () => {
-      await service.indexCode('src/api/routes.ts', 'export const routes = [];');
-      await service.indexCode('lib/helpers.ts', 'export const helpers = [];');
-
-      const result = await service.search({
-        query: 'export',
-        type: 'exact',
-        scope: ['src/api'],
-        limit: 10,
-      });
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should apply search filters', async () => {
-      await service.indexCode('src/big-file.ts', 'x'.repeat(1000));
-
-      const result = await service.search({
-        query: 'code',
-        type: 'semantic',
-        filters: [{ field: 'size', operator: 'gt', value: 500 }],
-        limit: 10,
-      });
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should return error for unknown search type', async () => {
-      const result = await service.search({
-        query: 'test',
-        // @ts-expect-error - testing invalid type
-        type: 'invalid',
-        limit: 10,
-      });
-
-      expect(result.success).toBe(false);
-    });
-
-    it('should respect result limit', async () => {
-      // Index multiple files
-      for (let i = 0; i < 20; i++) {
-        await service.indexCode(`src/file${i}.ts`, `const value${i} = ${i};`);
-      }
-
-      const result = await service.search({
-        query: 'const',
-        type: 'exact',
-        limit: 5,
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.results.length).toBeLessThanOrEqual(5);
-      }
-    });
-  });
-
-  describe('indexCode', () => {
-    it('should index code content successfully', async () => {
-      const result = await service.indexCode(
-        'src/service.ts',
-        'export class UserService { getUser() { return null; } }'
-      );
-
-      expect(result.success).toBe(true);
-      expect(mockMemory.storeVector).toHaveBeenCalled();
-      expect(mockMemory.set).toHaveBeenCalled();
-    });
-
-    it('should generate embeddings for indexed code', async () => {
-      await service.indexCode('src/test.ts', 'const test = "value";');
-
-      expect(mockMemory.storeVector).toHaveBeenCalledWith(
-        expect.stringContaining('code-intelligence:semantic:code'),
-        expect.any(Array),
-        expect.objectContaining({
-          file: 'src/test.ts',
-        })
-      );
-    });
-
-    it('should extract and store code metadata', async () => {
-      const code = `
-        export class TestClass {
-          async fetchData() {
-            return fetch('/api');
-          }
-        }
-      `;
-
-      await service.indexCode('src/test-class.ts', code);
-
-      expect(mockMemory.set).toHaveBeenCalledWith(
-        expect.stringContaining('content'),
-        expect.objectContaining({
-          file: 'src/test-class.ts',
-          metadata: expect.objectContaining({
-            hasClasses: true,
-          }),
-        }),
-        expect.any(Object)
-      );
-    });
-
-    it('should handle indexing errors gracefully', async () => {
-      const errorMemory = createMockMemoryBackend();
-      errorMemory.storeVector = vi.fn().mockRejectedValue(new Error('Storage failed'));
-
-      const errorService = new SemanticAnalyzerService(errorMemory, {
-        embeddingProvider: mockEmbeddingProvider,
-        useNomicEmbeddings: false,
-      });
-      const result = await errorService.indexCode('src/error.ts', 'code');
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('findSimilar', () => {
-    beforeEach(async () => {
-      await service.indexCode('src/add.ts', 'function add(a, b) { return a + b; }');
-      await service.indexCode('src/sum.ts', 'const sum = (x, y) => x + y;');
-    });
-
-    it('should find semantically similar code', async () => {
-      const result = await service.findSimilar(
-        'function addition(x, y) { return x + y; }',
-        5
-      );
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(Array.isArray(result.value)).toBe(true);
-      }
-    });
-
-    it('should filter results below minimum score threshold', async () => {
-      const lowScoreMemory = createMockMemoryBackend();
-      lowScoreMemory.vectorSearch = vi.fn().mockResolvedValue([
-        { key: 'k1', score: 0.3, metadata: { file: 'f1.ts' } }, // Below threshold
-        { key: 'k2', score: 0.8, metadata: { file: 'f2.ts' } }, // Above threshold
-      ]);
-
-      const lowScoreService = new SemanticAnalyzerService(lowScoreMemory, {
-        embeddingProvider: mockEmbeddingProvider,
-        useNomicEmbeddings: false,
-      });
-      await lowScoreService.indexCode('f2.ts', 'code');
-
-      const result = await lowScoreService.findSimilar('test code', 10);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        // Results with score < 0.5 (default minScore) should be filtered
-        for (const r of result.value) {
-          expect(r.score).toBeGreaterThanOrEqual(0.5);
-        }
-      }
-    });
-
-    it('should return code snippets with highlights', async () => {
-      const result = await service.findSimilar('function add', 3);
-
-      expect(result.success).toBe(true);
-      if (result.success && result.value.length > 0) {
-        expect(result.value[0]).toHaveProperty('snippet');
-        expect(result.value[0]).toHaveProperty('highlights');
-      }
-    });
-
-    it('should handle empty results gracefully', async () => {
-      const emptyMemory = createMockMemoryBackend();
-      emptyMemory.vectorSearch = vi.fn().mockResolvedValue([]);
-
-      const emptyService = new SemanticAnalyzerService(emptyMemory, {
-        embeddingProvider: mockEmbeddingProvider,
-        useNomicEmbeddings: false,
-      });
-      const result = await emptyService.findSimilar('unique code', 5);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value).toEqual([]);
-      }
-    });
-  });
-
-  describe('analyze', () => {
-    it('should extract programming concepts from code', async () => {
-      const code = `
-        export async function processData(items: Item[]): Promise<Result[]> {
-          return items.map(item => transform(item));
-        }
-      `;
-
-      const result = await service.analyze(code);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.concepts).toContain('asynchronous');
-        expect(result.value.concepts).toContain('modular');
-        expect(result.value.concepts).toContain('collection-processing');
-      }
-    });
-
-    it('should detect design patterns', async () => {
-      const singletonCode = `
-        class Database {
-          private static instance: Database;
-          static getInstance(): Database {
-            if (!this.instance) {
-              this.instance = new Database();
-            }
-            return this.instance;
-          }
-        }
-      `;
-
-      const result = await service.analyze(singletonCode);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.patterns).toContain('singleton');
-      }
-    });
-
-    it('should calculate cyclomatic complexity', async () => {
-      const complexCode = `
-        function process(x) {
-          if (x > 0) {
-            if (x > 10) {
-              return 'large';
-            } else {
-              return 'medium';
-            }
-          } else if (x === 0) {
-            return 'zero';
-          } else {
-            return 'negative';
-          }
-        }
-      `;
-
-      const result = await service.analyze(complexCode);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.complexity.cyclomatic).toBeGreaterThan(1);
-      }
-    });
-
-    it('should calculate cognitive complexity', async () => {
-      const nestedCode = `
-        function nested(a, b, c) {
-          if (a) {
-            for (let i = 0; i < 10; i++) {
-              if (b) {
-                while (c) {
-                  // deeply nested
-                }
-              }
-            }
-          }
-        }
-      `;
-
-      const result = await service.analyze(nestedCode);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.complexity.cognitive).toBeGreaterThan(0);
-      }
-    });
-
-    it('should calculate Halstead metrics', async () => {
-      const code = `
-        function calculate(a, b, c) {
-          const sum = a + b;
-          const product = sum * c;
-          return product / 2;
-        }
-      `;
-
-      const result = await service.analyze(code);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        const halstead = result.value.complexity.halstead;
-        expect(halstead).toHaveProperty('vocabulary');
-        expect(halstead).toHaveProperty('length');
-        expect(halstead).toHaveProperty('difficulty');
-        expect(halstead).toHaveProperty('effort');
-        expect(halstead).toHaveProperty('time');
-        expect(halstead).toHaveProperty('bugs');
-      }
-    });
-
-    it('should extract dependencies from imports', async () => {
-      const code = `
-        import { useState } from 'react';
-        import axios from 'axios';
-        const fs = require('fs');
-      `;
-
-      const result = await service.analyze(code);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.dependencies).toContain('react');
-        expect(result.value.dependencies).toContain('axios');
-        expect(result.value.dependencies).toContain('fs');
-      }
-    });
-
-    it('should generate improvement suggestions', async () => {
-      // Code with high complexity and no error handling
-      const code = `
-        async function complexFunction(a, b, c, d, e, f) {
-          if (a) { if (b) { if (c) { if (d) { if (e) { if (f) {
-            return Promise.resolve('deep');
-          }}}}}}
-          return a || b || c || d || e || f;
-        }
-      `.repeat(10);
-
-      const result = await service.analyze(code);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.value.suggestions.length).toBeGreaterThan(0);
-      }
-    });
-
-    it('should use cache for repeated analysis', async () => {
-      const code = 'const cached = "test";';
-
-      // First analysis
-      await service.analyze(code);
-
-      // Second analysis (should use cache)
-      const result = await service.analyze(code);
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('getEmbedding', () => {
-    it('should generate embedding vector of correct dimension', async () => {
-      const embedding = await service.getEmbedding('test code');
-
-      expect(Array.isArray(embedding)).toBe(true);
-      expect(embedding.length).toBe(EMBEDDING_CONFIG.DIMENSIONS); // 768 for Nomic
-    });
-
-    it('should generate normalized embeddings', async () => {
-      const embedding = await service.getEmbedding('normalize test');
-
-      // Check magnitude is approximately 1 (normalized)
-      const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0));
-      expect(magnitude).toBeCloseTo(1, 5);
-    });
-
-    it('should cache embeddings when caching is enabled', async () => {
-      const code = 'const cacheTest = 1;';
-
-      const embedding1 = await service.getEmbedding(code);
-      const embedding2 = await service.getEmbedding(code);
-
-      expect(embedding1).toEqual(embedding2);
-    });
-
-    it('should generate different embeddings for different code', async () => {
-      const embedding1 = await service.getEmbedding('function add(a, b) { return a + b; }');
-      const embedding2 = await service.getEmbedding('class User { constructor(name) { this.name = name; } }');
-
-      // Embeddings should be different
-      expect(embedding1).not.toEqual(embedding2);
-    });
-  });
-
-  describe('configuration', () => {
-    it('should use custom configuration', () => {
-      const customConfig: Partial<SemanticAnalyzerConfig> = {
-        embeddingDimension: 512,
-        minScore: 0.7,
-        maxResults: 50,
-        enableCaching: false,
-        embeddingProvider: mockEmbeddingProvider,
-        useNomicEmbeddings: false,
-      };
-
-      const customService = new SemanticAnalyzerService(mockMemory, customConfig);
-      expect(customService).toBeDefined();
-    });
-
-    it('should respect minScore filter in search', async () => {
-      const strictMemory = createMockMemoryBackend();
-      strictMemory.vectorSearch = vi.fn().mockResolvedValue([
-        { key: 'low', score: 0.3, metadata: { file: 'low.ts' } },
-        { key: 'high', score: 0.9, metadata: { file: 'high.ts' } },
-      ]);
-
-      const strictService = new SemanticAnalyzerService(strictMemory, {
-        minScore: 0.8,
-        embeddingProvider: mockEmbeddingProvider,
-        useNomicEmbeddings: false,
-      });
-      await strictService.indexCode('high.ts', 'code');
-
-      const result = await strictService.findSimilar('query', 10);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        // Only results above minScore should be returned
-        expect(result.value.every(r => r.score >= 0.8)).toBe(true);
-      }
-    });
-  });
-});