proffesor-for-testing__agentic-qe/tests/unit/learning/pattern-store-regression.test.ts

/**
 * Regression tests for PatternStore — filter-adapter integration
 *
 * Validates that:
 * 1. The static import of filter-adapter resolves correctly
 * 2. Search without filter option behaves identically to pre-change
 * 3. Search with filter option applies filtering correctly
 */

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import {
  PatternStore,
  createPatternStore,
} from '../../../src/learning/pattern-store.js';
import type { MemoryBackend } from '../../../src/kernel/interfaces.js';

// ============================================================================
// Module resolution verification
// ============================================================================

describe('PatternStore — Regression: filter-adapter module resolution', () => {
  it('should import filter-adapter without errors', async () => {
    // This validates the static import chain:
    // pattern-store -> filter-adapter -> interfaces -> feature-flags
    const filterModule = await import('../../../src/integrations/ruvector/filter-adapter.js');
    expect(filterModule.applyFilterSync).toBeDefined();
    expect(typeof filterModule.applyFilterSync).toBe('function');
  });

  it('should import pattern-store without errors', async () => {
    const module = await import('../../../src/learning/pattern-store.js');
    expect(module.createPatternStore).toBeDefined();
    expect(module.PatternStore).toBeDefined();
  });

  it('applyFilterSync should pass through when filter is null', async () => {
    const { applyFilterSync } = await import('../../../src/integrations/ruvector/filter-adapter.js');
    const results = [{ pattern: { id: '1' }, similarity: 0.9 }] as any[];
    const filtered = applyFilterSync(results, null);
    expect(filtered).toBe(results); // Same reference — passthrough
  });

  it('applyFilterSync should pass through when filter is undefined', async () => {
    const { applyFilterSync } = await import('../../../src/integrations/ruvector/filter-adapter.js');
    const results = [{ pattern: { id: '1' }, similarity: 0.9 }] as any[];
    const filtered = applyFilterSync(results, undefined);
    expect(filtered).toBe(results);
  });
});

// ============================================================================
// Search behavior regression
// ============================================================================

function createMockMemoryBackend(): MemoryBackend {
  const storage = new Map<string, unknown>();
  return {
    get: vi.fn((key: string) => Promise.resolve(storage.get(key) ?? null)),
    set: vi.fn((key: string, value: unknown) => {
      storage.set(key, value);
      return Promise.resolve();
    }),
    delete: vi.fn((key: string) => { storage.delete(key); return Promise.resolve(); }),
    has: vi.fn((key: string) => Promise.resolve(storage.has(key))),
    keys: vi.fn(() => Promise.resolve(Array.from(storage.keys()))),
    search: vi.fn((pattern: string) => {
      const re = new RegExp(pattern.replace(/\*/g, '.*'));
      return Promise.resolve(Array.from(storage.keys()).filter(k => re.test(k)));
    }),
    clear: vi.fn(() => { storage.clear(); return Promise.resolve(); }),
    size: vi.fn(() => Promise.resolve(storage.size)),
    close: vi.fn(() => Promise.resolve()),
    getState: vi.fn(() => ({ type: 'memory', ready: true })),
  } as unknown as MemoryBackend;
}

describe('PatternStore — Regression: search without filter', () => {
  let memory: MemoryBackend;
  let store: PatternStore;

  beforeEach(async () => {
    memory = createMockMemoryBackend();
    store = createPatternStore(memory);
    await store.initialize();
  });

  afterEach(async () => {
    await store.dispose();
  });

  it('should search patterns without filter option (backward compatible)', async () => {
    // Store a pattern first
    const createResult = await store.create({
      patternType: 'test-template',
      name: 'Unit Test Pattern',
      description: 'A pattern for unit testing',
      context: { tags: ['unit', 'test'], testType: 'unit' },
      template: { type: 'code', content: 'test template', variables: [] },
    });
    expect(createResult.success).toBe(true);

    // Search without filter — should behave exactly as before
    const result = await store.search('unit test', { limit: 10 });
    expect(result.success).toBe(true);
    // Result may be empty if HNSW isn't initialized, but should not throw
  });

  it('should handle search with empty query', async () => {
    const result = await store.search('', { limit: 5 });
    expect(result.success).toBe(true);
  });
});