proffesor-for-testing__agentic-qe/tests/integration/learning/transfer-protocol.test.ts

/**
 * Transfer Protocol Integration Test
 *
 * MISSION: Prove that the Transfer Protocol enables real cross-agent pattern sharing
 *
 * This test validates:
 * 1. Patterns can be transferred between compatible agents
 * 2. Compatibility scoring works correctly
 * 3. Transfer validation ensures pattern integrity
 * 4. Transfer requests are tracked and persisted
 */

import { TransferProtocol } from '../../../src/learning/transfer/TransferProtocol';
import { CompatibilityScorer, AgentProfile, PatternProfile } from '../../../src/learning/transfer/CompatibilityScorer';
import { TransferValidator, TransferRecord } from '../../../src/learning/transfer/TransferValidator';
import path from 'path';
import fs from 'fs/promises';
import Database from 'better-sqlite3';

describe('Transfer Protocol Integration', () => {
  const testDbPath = path.join(process.cwd(), '.test-data', 'transfer-protocol-test.db');
  let transferProtocol: TransferProtocol;

  beforeAll(async () => {
    // Ensure test directory exists
    await fs.mkdir(path.dirname(testDbPath), { recursive: true });
  });

  beforeEach(async () => {
    // Remove existing test database for fresh state
    try {
      await fs.unlink(testDbPath);
    } catch {
      // Database doesn't exist yet
    }
  });

  afterEach(async () => {
    if (transferProtocol) {
      transferProtocol.close();
    }
  });

  afterAll(async () => {
    // Final cleanup
    try {
      await fs.unlink(testDbPath);
    } catch {
      // Ignore
    }
  });

  describe('CompatibilityScorer', () => {
    let scorer: CompatibilityScorer;

    beforeEach(() => {
      scorer = new CompatibilityScorer();
    });

    it('should score high compatibility for same-framework agents', async () => {
      const sourceAgent: AgentProfile = {
        type: 'test-generator',
        capabilities: ['test-generation', 'code-analysis'],
        frameworks: ['jest', 'vitest'],
        taskTypes: ['unit-test', 'integration-test'],
        domain: 'testing',
      };

      const targetAgent: AgentProfile = {
        type: 'flaky-test-hunter',
        capabilities: ['test-analysis', 'stability-scoring'],
        frameworks: ['jest', 'cypress'],
        taskTypes: ['flaky-detection', 'test-repair'],
        domain: 'testing',
      };

      const pattern: PatternProfile = {
        id: 'pattern-1',
        type: 'testing',
        requiredCapabilities: ['test-analysis'],
        requiredFrameworks: ['jest'],
        applicableTaskTypes: ['unit-test'],
        domain: 'testing',
        complexity: 'medium',
        confidence: 0.85,
      };

      const report = await scorer.scoreCompatibility(pattern, sourceAgent, targetAgent);

      expect(report.overallScore).toBeGreaterThan(0.3); // Reasonable compatibility
      expect(report.overallScore).toBeLessThanOrEqual(1.0);
      expect(report.recommendation).toBeDefined();
    });

    it('should score low compatibility for incompatible frameworks', async () => {
      const sourceAgent: AgentProfile = {
        type: 'test-generator',
        capabilities: ['test-generation'],
        frameworks: ['jest'],
        taskTypes: ['unit-test'],
        domain: 'testing',
      };

      const targetAgent: AgentProfile = {
        type: 'performance-tester',
        capabilities: ['load-testing', 'benchmark'],
        frameworks: ['k6', 'artillery'],
        taskTypes: ['load-test', 'stress-test'],
        domain: 'performance',
      };

      const pattern: PatternProfile = {
        id: 'pattern-2',
        type: 'testing',
        requiredCapabilities: ['test-generation'],
        requiredFrameworks: ['jest'],
        applicableTaskTypes: ['unit-test'],
        domain: 'testing',
        complexity: 'low',
        confidence: 0.90,
      };

      const report = await scorer.scoreCompatibility(pattern, sourceAgent, targetAgent);

      expect(report.overallScore).toBeLessThan(0.7); // Lower compatibility
    });
  });

  describe('TransferValidator', () => {
    let validator: TransferValidator;

    beforeEach(() => {
      // Seed the patterns table before creating validator
      seedPatternData(testDbPath);
      validator = new TransferValidator({ dbPath: testDbPath });
    });

    afterEach(() => {
      validator.close();
    });

    it('should validate transfer record', async () => {
      const transferRecord: TransferRecord = {
        id: 'transfer-1',
        patternId: 'seeded-pattern-1', // Use seeded pattern
        sourceAgent: 'test-generator',
        targetAgent: 'coverage-analyzer',
        transferredAt: new Date(),
        originalContent: JSON.stringify({ type: 'pattern', description: 'Test pattern' }),
        transferredContent: JSON.stringify({ type: 'pattern', description: 'Test pattern' }),
        compatibilityScore: 0.85,
      };

      const report = await validator.validate(transferRecord);

      expect(report).toBeDefined();
      expect(report.patternId).toBe('seeded-pattern-1');
      expect(typeof report.passed).toBe('boolean');
      expect(typeof report.overallScore).toBe('number');
      expect(Array.isArray(report.checks)).toBe(true);
    });
  });

  describe('TransferProtocol', () => {
    beforeEach(() => {
      transferProtocol = new TransferProtocol({
        dbPath: testDbPath,
        debug: false,
      });
    });

    it('should create transfer requests', async () => {
      const request = await transferProtocol.createRequest({
        sourceAgent: 'test-generator',
        targetAgent: 'flaky-test-hunter',
        patternIds: ['pattern-1', 'pattern-2'],
        priority: 'medium',
        reason: 'Test pattern sharing',
      });

      expect(request).toBeDefined();
      expect(request.id).toBeDefined();
      expect(request.sourceAgent).toBe('test-generator');
      expect(request.targetAgent).toBe('flaky-test-hunter');
      expect(request.patternIds).toContain('pattern-1');
    });

    it('should get pending requests', async () => {
      // Create a request
      await transferProtocol.createRequest({
        sourceAgent: 'test-generator',
        targetAgent: 'coverage-analyzer',
        patternIds: ['pattern-a'],
        priority: 'high',
        reason: 'Coverage pattern transfer',
      });

      const pending = transferProtocol.getPendingRequests();

      expect(pending.length).toBeGreaterThanOrEqual(1);
      expect(pending[0].sourceAgent).toBe('test-generator');
    });

    it('should get transfer statistics', async () => {
      const stats = transferProtocol.getStats();

      expect(stats).toBeDefined();
      expect(typeof stats.totalRequests).toBe('number');
      expect(typeof stats.successfulTransfers).toBe('number');
      expect(typeof stats.failedTransfers).toBe('number');
      expect(typeof stats.overallSuccessRate).toBe('number');
      expect(typeof stats.averageCompatibilityScore).toBe('number');
    });

    it('should broadcast pattern to compatible agents', async () => {
      // First seed some pattern data
      seedPatternData(testDbPath);

      // Create fresh protocol after seeding
      transferProtocol.close();
      transferProtocol = new TransferProtocol({
        dbPath: testDbPath,
        debug: false,
      });

      const results = await transferProtocol.broadcastPattern('seeded-pattern-1', 'test-generator');

      expect(Array.isArray(results)).toBe(true);
      // Results may be empty if no compatible agents found
    });
  });

  describe('End-to-End Transfer Flow', () => {
    it('should complete full transfer lifecycle', async () => {
      // Seed pattern data
      seedPatternData(testDbPath);

      transferProtocol = new TransferProtocol({
        dbPath: testDbPath,
        debug: false,
      });

      // 1. Create transfer request
      const request = await transferProtocol.createRequest({
        sourceAgent: 'test-generator',
        targetAgent: 'flaky-test-hunter',
        patternIds: ['seeded-pattern-1'],
        priority: 'high',
        reason: 'E2E transfer test',
      });

      expect(request.id).toBeDefined();

      // 2. Check pending requests
      const pending = transferProtocol.getPendingRequests();
      expect(pending.some(r => r.id === request.id)).toBe(true);

      // 3. Execute transfer (if method available)
      // The protocol handles this internally via processRequest

      // 4. Check statistics
      const stats = transferProtocol.getStats();
      expect(stats.totalRequests).toBeGreaterThanOrEqual(1);
    });
  });
});

/**
 * Helper to seed test pattern data
 */
function seedPatternData(dbPath: string): void {
  const db = new Database(dbPath);

  // Create patterns table matching SwarmMemoryManager schema (used by TransferProtocol)
  db.exec(`
    CREATE TABLE IF NOT EXISTS patterns (
      id TEXT PRIMARY KEY,
      pattern TEXT NOT NULL,
      confidence REAL NOT NULL,
      usage_count INTEGER NOT NULL DEFAULT 0,
      metadata TEXT,
      ttl INTEGER NOT NULL DEFAULT 86400000,
      expires_at INTEGER,
      created_at INTEGER NOT NULL,
      agent_id TEXT,
      domain TEXT DEFAULT 'general'
    )
  `);

  // Create transfer tables if not exist
  db.exec(`
    CREATE TABLE IF NOT EXISTS transfer_requests (
      id TEXT PRIMARY KEY,
      source_agent TEXT NOT NULL,
      target_agent TEXT NOT NULL,
      pattern_ids TEXT NOT NULL,
      priority TEXT DEFAULT 'medium',
      reason TEXT,
      requested_at INTEGER NOT NULL,
      requested_by TEXT,
      status TEXT DEFAULT 'pending',
      result TEXT
    )
  `);

  db.exec(`
    CREATE TABLE IF NOT EXISTS transfer_registry (
      id TEXT PRIMARY KEY,
      pattern_id TEXT NOT NULL,
      source_agent TEXT NOT NULL,
      target_agent TEXT NOT NULL,
      transfer_id TEXT NOT NULL,
      compatibility_score REAL,
      validation_passed INTEGER DEFAULT 0,
      transferred_at INTEGER NOT NULL,
      status TEXT DEFAULT 'active'
    )
  `);

  const now = Date.now();

  // Seed patterns using correct schema
  const insertPattern = db.prepare(`
    INSERT OR REPLACE INTO patterns
    (id, pattern, confidence, usage_count, metadata, created_at, agent_id, domain)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
  `);

  insertPattern.run(
    'seeded-pattern-1',
    JSON.stringify({
      description: 'Test isolation pattern for Jest',
      template: 'describe("...", () => { beforeEach(() => {}); it("...", () => {}); });',
    }),
    0.85,
    10,
    JSON.stringify({ framework: 'jest', type: 'testing' }),
    now,
    'test-generator',
    'unit-testing'
  );

  insertPattern.run(
    'seeded-pattern-2',
    JSON.stringify({
      description: 'Mock pattern for external dependencies',
      template: 'jest.mock("...", () => ({ ... }));',
    }),
    0.90,
    15,
    JSON.stringify({ framework: 'jest', type: 'mocking' }),
    now,
    'test-generator',
    'mocking'
  );

  db.close();
}