proffesor-for-testing__agentic-qe/tests/integration/pipelines/AgentRegistry-SONA-Router.test.ts

/**
 * Integration Test: AgentRegistry → SONA → Router Pipeline
 *
 * Tests the full integration of:
 * - AgentRegistry spawning agents with SONA lifecycle hooks
 * - SONA lifecycle manager tracking agent execution
 * - AdaptiveModelRouter selecting appropriate models
 *
 * This validates the Phase 1-2 integration as a cohesive system.
 *
 * @module tests/integration/pipelines/AgentRegistry-SONA-Router
 */

import { AgentRegistry } from '../../../src/mcp/services/AgentRegistry';
import { AdaptiveModelRouter } from '../../../src/core/routing/AdaptiveModelRouter';
import {
  resetSONALifecycleManager,
  getSONALifecycleManager,
} from '../../../src/agents/SONALifecycleManager';
import { SwarmMemoryManager } from '../../../src/core/memory/SwarmMemoryManager';
import { EventBus } from '../../../src/core/EventBus';
import { AIModel, TaskComplexity } from '../../../src/core/routing/types';

// Mock dependencies that require external services
jest.mock('../../../src/utils/Database', () => ({
  Database: {
    getInstance: jest.fn(() => ({
      initialize: jest.fn().mockResolvedValue(undefined),
      run: jest.fn().mockResolvedValue(undefined),
      get: jest.fn().mockResolvedValue(undefined),
      all: jest.fn().mockResolvedValue([]),
      close: jest.fn().mockResolvedValue(undefined),
    })),
  },
}));

jest.mock('../../../src/utils/ruvllm-loader', () => ({
  isRuvLLMAvailable: jest.fn(() => true),
}));

// Mock fetch for router health checks
global.fetch = jest.fn() as jest.MockedFunction<typeof fetch>;

// Import mock for re-setup in beforeEach
import { isRuvLLMAvailable } from '../../../src/utils/ruvllm-loader';
const mockIsRuvLLMAvailable = isRuvLLMAvailable as jest.MockedFunction<typeof isRuvLLMAvailable>;

describe('AgentRegistry → SONA → Router Integration', () => {
  let registry: AgentRegistry;
  let router: AdaptiveModelRouter;
  let memoryStore: SwarmMemoryManager;
  let eventBus: EventBus;
  let capturedEvents: Array<{ event: string; data: any }> = [];

  beforeEach(async () => {
    jest.clearAllMocks();
    resetSONALifecycleManager();
    capturedEvents = [];

    // Re-setup mocks after clearAllMocks (which clears implementations)
    mockIsRuvLLMAvailable.mockReturnValue(true);

    // Initialize infrastructure
    eventBus = new EventBus();
    memoryStore = new SwarmMemoryManager();
    await memoryStore.initialize();

    // Capture events for verification
    const eventsToCapture = [
      'router:initialized',
      'router:model-selected',
      'router:local-selected',
      'router:local-unavailable',
      'router:fallback-selected',
    ];

    for (const eventName of eventsToCapture) {
      eventBus.on(eventName, (data: any) => {
        capturedEvents.push({ event: eventName, data });
      });
    }

    // Initialize router with local preference
    router = new AdaptiveModelRouter(memoryStore, eventBus, {
      enabled: true,
      preferLocal: true,
      ruvllmEndpoint: 'http://localhost:8080',
      enableCostTracking: true,
      enableFallback: true,
    });

    // Initialize registry with SONA lifecycle
    registry = new AgentRegistry({
      maxAgents: 10,
      enableSONALifecycle: true,
      enableMetrics: true,
    });

    // Wait for async initialization
    await new Promise(resolve => setTimeout(resolve, 150));
  });

  afterEach(async () => {
    resetSONALifecycleManager();
  });

  describe('Full Pipeline Integration', () => {
    it('should spawn agent with SONA context and route to local model', async () => {
      // Mock RuvLLM as available
      const mockFetch = global.fetch as jest.MockedFunction<typeof fetch>;
      mockFetch.mockResolvedValue({ ok: true } as Response);

      // Spawn agent
      const agent = await registry.spawnAgent('test-generator', {
        name: 'Integration Test Agent',
        capabilities: ['unit-testing', 'coverage-analysis'],
      });

      expect(agent).toBeDefined();
      // Agent ID format: ${mcpType}-${id}-${timestamp}-${random}
      // e.g., "test-generator-1-1765819690722-6a5444f4c222017f"
      expect(agent.id).toMatch(/^test-generator-\d+-\d+-[a-f0-9]+$/);

      // Get SONA context (via lifecycle manager)
      const lifecycleManager = getSONALifecycleManager();
      const stats = lifecycleManager.getStatistics();

      // Note: SONA context creation is async and may not be immediate
      // The important thing is that the infrastructure is wired correctly
      expect(stats.ruvLLMAvailable).toBe(true);

      // Route a task to local model
      const task = {
        id: 'integration-task-1',
        type: 'qe-test-generator',
        description: 'Generate unit tests for UserService',
        data: { agentType: 'qe-test-generator' },
        priority: 1,
      };

      const selection = await router.selectModel(task);

      // Should route to local model (zero cost)
      expect(selection.model).toContain('ruvllm:');
      expect(selection.estimatedCost).toBe(0);
    });

    it('should fallback to cloud when local unavailable', async () => {
      // Mock RuvLLM as unavailable
      const mockFetch = global.fetch as jest.MockedFunction<typeof fetch>;
      mockFetch.mockRejectedValue(new Error('Connection refused'));

      const task = {
        id: 'integration-task-2',
        type: 'qe-coverage-analyzer',
        description: 'Analyze test coverage gaps',
        data: { agentType: 'qe-coverage-analyzer' },
        priority: 2,
      };

      const selection = await router.selectModel(task);

      // Should fallback to cloud model
      expect(selection.model).not.toContain('ruvllm:');
      expect(selection.estimatedCost).toBeGreaterThan(0);
    });

    it('should track cost across local and cloud routing', async () => {
      const mockFetch = global.fetch as jest.MockedFunction<typeof fetch>;

      // First request: RuvLLM available (free)
      mockFetch.mockResolvedValueOnce({ ok: true } as Response);
      const localTask = {
        id: 'cost-task-1',
        type: 'qe-test-generator',
        description: 'Simple test',
        data: {},
        priority: 1,
      };
      const localSelection = await router.selectModel(localTask);
      await router.trackCost(localSelection.model, 1000);

      // Second request: RuvLLM unavailable (cloud cost)
      mockFetch.mockRejectedValueOnce(new Error('Unavailable'));
      const cloudTask = {
        id: 'cost-task-2',
        type: 'qe-quality-gate',
        description: 'Complex validation',
        data: {},
        priority: 1,
      };
      const cloudSelection = await router.selectModel(cloudTask);
      await router.trackCost(cloudSelection.model, 2000);

      // Get stats
      const stats = await router.getStats();

      expect(stats).toBeDefined();
      // Stats structure will vary based on implementation
    });
  });

  describe('Model Selection by Task Complexity', () => {
    beforeEach(() => {
      const mockFetch = global.fetch as jest.MockedFunction<typeof fetch>;
      mockFetch.mockResolvedValue({ ok: true } as Response);
    });

    it('should select appropriate local model for simple tasks', async () => {
      const task = {
        id: 'simple-task',
        type: 'qe-test-generator',
        description: 'Add a simple unit test',
        data: {},
        priority: 3, // Low priority = simple
      };

      const analysis = {
        complexity: TaskComplexity.SIMPLE,
        estimatedTokens: 500,
        requiresReasoning: false,
        requiresSecurity: false,
        requiresPerformance: false,
        confidence: 0.9,
      };

      const selection = await router.routeToLocal(task, analysis);

      expect(selection).not.toBeNull();
      expect(selection?.model).toBe(AIModel.RUVLLM_LLAMA_3_2_1B);
    });

    it('should select larger local model for complex tasks', async () => {
      const task = {
        id: 'complex-task',
        type: 'qe-security-scanner',
        description: 'Full security audit with vulnerability analysis',
        data: {},
        priority: 1,
      };

      const analysis = {
        complexity: TaskComplexity.CRITICAL,
        estimatedTokens: 5000,
        requiresReasoning: true,
        requiresSecurity: true,
        requiresPerformance: false,
        confidence: 0.85,
      };

      const selection = await router.routeToLocal(task, analysis);

      expect(selection).not.toBeNull();
      expect(selection?.model).toBe(AIModel.RUVLLM_MISTRAL_7B);
    });

    it('should include privacy reasoning for security tasks', async () => {
      const task = {
        id: 'security-task',
        type: 'qe-security-scanner',
        description: 'Scan for vulnerabilities',
        data: {},
        priority: 1,
      };

      const analysis = {
        complexity: TaskComplexity.CRITICAL,
        estimatedTokens: 3000,
        requiresReasoning: true,
        requiresSecurity: true,
        requiresPerformance: false,
        confidence: 0.9,
      };

      const selection = await router.routeToLocal(task, analysis);

      expect(selection?.reasoning).toContain('Privacy-preserving');
      expect(selection?.reasoning).toContain('data stays local');
    });
  });

  describe('Event Emission', () => {
    it('should emit router:initialized event', async () => {
      // Router was initialized in beforeEach, check events
      await new Promise(resolve => setTimeout(resolve, 50));

      const initEvent = capturedEvents.find(e => e.event === 'router:initialized');
      expect(initEvent).toBeDefined();
    });

    it('should emit router:local-selected when routing locally', async () => {
      const mockFetch = global.fetch as jest.MockedFunction<typeof fetch>;
      mockFetch.mockResolvedValue({ ok: true } as Response);

      const task = {
        id: 'event-task',
        type: 'qe-test-generator',
        description: 'Test event emission',
        data: {},
        priority: 1,
      };

      await router.selectModel(task);

      const localEvent = capturedEvents.find(e => e.event === 'router:local-selected');
      expect(localEvent).toBeDefined();
      expect(localEvent?.data.task).toBe('event-task');
      expect(localEvent?.data.costSavings).toBeGreaterThanOrEqual(0);
    });

    it('should emit router:local-unavailable when RuvLLM is down', async () => {
      const mockFetch = global.fetch as jest.MockedFunction<typeof fetch>;
      mockFetch.mockRejectedValue(new Error('Connection refused'));

      const task = {
        id: 'unavailable-task',
        type: 'qe-test-generator',
        description: 'Test unavailability',
        data: {},
        priority: 1,
      };

      const analysis = {
        complexity: TaskComplexity.SIMPLE,
        estimatedTokens: 500,
        requiresReasoning: false,
        requiresSecurity: false,
        requiresPerformance: false,
        confidence: 0.9,
      };

      await router.routeToLocal(task, analysis);

      const unavailableEvent = capturedEvents.find(e => e.event === 'router:local-unavailable');
      expect(unavailableEvent).toBeDefined();
      expect(unavailableEvent?.data.reason).toContain('not reachable');
    });
  });

  describe('Fallback Chain', () => {
    it('should use fallback model when primary fails', () => {
      const task = {
        id: 'fallback-task',
        type: 'qe-test-generator',
        description: 'Test fallback',
        data: {},
        priority: 1,
      };

      // Simulate primary model failure
      const fallbackModel = router.getFallbackModel(AIModel.RUVLLM_LLAMA_3_2_1B, task);

      // Should return a valid fallback model
      expect(fallbackModel).toBeDefined();
      expect(typeof fallbackModel).toBe('string');
    });

    it('should track failure counts for fallback decisions', () => {
      const task = {
        id: 'failure-track-task',
        type: 'qe-test-generator',
        description: 'Test failure tracking',
        data: {},
        priority: 1,
      };

      // Fail same model multiple times
      router.getFallbackModel(AIModel.RUVLLM_LLAMA_3_2_1B, task);
      router.getFallbackModel(AIModel.RUVLLM_LLAMA_3_2_1B, task);
      router.getFallbackModel(AIModel.RUVLLM_LLAMA_3_2_1B, task);

      // Reset and verify
      router.resetFailures();
      // After reset, failures should be cleared (verified by behavior)
    });
  });

  describe('Configuration Changes', () => {
    it('should support enabling/disabling routing', async () => {
      // Disable routing
      router.setEnabled(false);

      const task = {
        id: 'disabled-task',
        type: 'qe-test-generator',
        description: 'Test disabled routing',
        data: {},
        priority: 1,
      };

      const selection = await router.selectModel(task);

      // Should use default model with minimal reasoning
      expect(selection.reasoning).toContain('routing disabled');
    });

    it('should support runtime config updates', () => {
      router.updateConfig({
        costThreshold: 0.001,
        maxRetries: 5,
      });

      // Config should be updated (verified by subsequent routing behavior)
      expect(true).toBe(true); // Config update doesn't throw
    });
  });

  describe('SONA Lifecycle Statistics', () => {
    it('should provide lifecycle statistics via lifecycle manager', async () => {
      const lifecycleManager = getSONALifecycleManager();
      const stats = lifecycleManager.getStatistics();

      expect(stats).toBeDefined();
      expect(typeof stats.totalAgents).toBe('number');
      expect(typeof stats.totalSuccessfulTasks).toBe('number');
      expect(typeof stats.totalFailedTasks).toBe('number');
      expect(typeof stats.averageSuccessRate).toBe('number');
      // ruvLLMAvailable should be true since we mocked isRuvLLMAvailable to return true
      expect(stats.ruvLLMAvailable).toBe(true);
    });
  });

  describe('Cost Dashboard Export', () => {
    it('should export cost dashboard data', async () => {
      const mockFetch = global.fetch as jest.MockedFunction<typeof fetch>;
      mockFetch.mockResolvedValue({ ok: true } as Response);

      // Route some tasks to generate cost data
      const task = {
        id: 'dashboard-task',
        type: 'qe-test-generator',
        description: 'Generate cost data',
        data: {},
        priority: 1,
      };

      await router.selectModel(task);
      await router.trackCost(AIModel.RUVLLM_LLAMA_3_2_1B, 1000);

      const dashboard = await router.exportCostDashboard();

      expect(dashboard).toBeDefined();
    });
  });

  describe('Complexity Analysis', () => {
    it('should analyze task complexity', async () => {
      const task = {
        id: 'complexity-task',
        type: 'qe-security-scanner',
        description: 'Complex security analysis requiring deep reasoning',
        data: { codeSize: 10000, requiresChainOfThought: true },
        priority: 1,
      };

      const complexity = await router.analyzeComplexity(task);

      expect(complexity).toBeDefined();
      expect(Object.values(TaskComplexity)).toContain(complexity);
    });
  });
});