proffesor-for-testing__agentic-qe/tests/integration/agent-coordination.test.ts

import { jest } from '@jest/globals';
import { AgentCoordinator, CoordinationTopology } from '../../src/coordination/agent-coordinator';
import { MessageBus } from '../../src/communication/message-bus';
import { FleetManager } from '@core/fleet-manager';
import { TestGeneratorAgent } from '@agents/TestGeneratorAgent';
import { TestExecutorAgent } from '@agents/TestExecutorAgent';
import { CoverageAnalyzerAgent } from '@agents/CoverageAnalyzerAgent';
import { QualityGateAgent } from '@agents/QualityGateAgent';

// Integration tests for multi-agent coordination - London School TDD
// Mock the communication layer but test real agent interactions
const mockMessageBus = {
  publish: jest.fn(),
  subscribe: jest.fn(),
  unsubscribe: jest.fn(),
  getSubscribers: jest.fn(),
  broadcast: jest.fn()
} as jest.Mocked<MessageBus>;

const mockLogger = {
  info: jest.fn(),
  warn: jest.fn(),
  error: jest.fn(),
  debug: jest.fn()
};

const mockMetrics = {
  recordMetric: jest.fn(),
  incrementCounter: jest.fn(),
  recordTiming: jest.fn()
};

// Real agent instances for integration testing
let fleetManager: FleetManager;
let testGenerator: TestGeneratorAgent;
let testExecutor: TestExecutorAgent;
let coverageAnalyzer: CoverageAnalyzerAgent;
let qualityGate: QualityGateAgent;
let agentCoordinator: AgentCoordinator;

describe('Agent Coordination Integration Tests - London School TDD', () => {
  beforeEach(async () => {
    jest.clearAllMocks();
    
    // Setup real agents with mocked dependencies
    fleetManager = new FleetManager({
      logger: mockLogger,
      messageBus: mockMessageBus,
      metrics: mockMetrics
    });
    
    testGenerator = new TestGeneratorAgent({
      logger: mockLogger,
      messageBus: mockMessageBus
    });

    testExecutor = new TestExecutorAgent({
      logger: mockLogger,
      messageBus: mockMessageBus,
      metrics: mockMetrics
    });

    coverageAnalyzer = new CoverageAnalyzerAgent({
      logger: mockLogger,
      messageBus: mockMessageBus,
      metrics: mockMetrics
    });

    qualityGate = new QualityGateAgent({
      logger: mockLogger,
      messageBus: mockMessageBus,
      metrics: mockMetrics
    });
    
    agentCoordinator = new AgentCoordinator({
      messageBus: mockMessageBus,
      logger: mockLogger,
      metrics: mockMetrics
    });
    
    // Initialize coordinator with agents
    await agentCoordinator.initialize({
      topology: CoordinationTopology.HIERARCHICAL,
      agents: {
        fleetManager,
        testGenerator,
        testExecutor,
        coverageAnalyzer,
        qualityGate
      }
    });
  });

  describe('Hierarchical Coordination Flow', () => {
    it('should coordinate complete TDD workflow across all agents', async () => {
      // Mock message bus to capture inter-agent communication
      const messages: any[] = [];
      mockMessageBus.publish.mockImplementation((channel, message) => {
        messages.push({ channel, message, timestamp: Date.now() });
        return Promise.resolve();
      });
      
      // Simulate TDD workflow initiation
      const workflowRequest = {
        workflowId: 'tdd-workflow-123',
        target: 'user-authentication-service',
        requirements: {
          testTypes: ['unit', 'integration', 'e2e'],
          coverageThreshold: 85,
          qualityGates: ['unit', 'integration']
        }
      };
      
      // Execute coordinated workflow
      const result = await agentCoordinator.executeWorkflow(workflowRequest);
      
      // Verify coordination sequence through message bus interactions
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'workflow.initiated',
        expect.objectContaining({
          workflowId: 'tdd-workflow-123',
          coordinator: 'agent-coordinator'
        })
      );
      
      // Verify fleet initialization message
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'fleet.initialize',
        expect.objectContaining({
          topology: 'hierarchical',
          workflowId: 'tdd-workflow-123'
        })
      );
      
      // Verify test generation coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'test-generation.start',
        expect.objectContaining({
          target: 'user-authentication-service',
          testTypes: ['unit', 'integration', 'e2e']
        })
      );
      
      // Verify test execution coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'test-execution.schedule',
        expect.objectContaining({
          workflowId: 'tdd-workflow-123',
          executionStrategy: 'parallel'
        })
      );
      
      // Verify coverage analysis coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'coverage.analyze',
        expect.objectContaining({
          threshold: 85,
          optimizationRequired: true
        })
      );
      
      // Verify quality gate coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'quality-gate.evaluate',
        expect.objectContaining({
          phases: ['unit', 'integration']
        })
      );
      
      expect(result.success).toBe(true);
      expect(result.coordinatedAgents).toBe(5);
      expect(mockLogger.info).toHaveBeenCalledWith(
        'TDD workflow coordination completed successfully'
      );
    });

    it('should handle agent failures and redistribute work', async () => {
      // Simulate test executor failure
      const failingExecutor = {
        ...testExecutor,
        execute: jest.fn().mockRejectedValue(new Error('Executor crashed'))
      };
      
      await agentCoordinator.registerAgent('test-executor-backup', failingExecutor);
      
      const workflowRequest = {
        workflowId: 'failure-recovery-test',
        target: 'resilient-service',
        requirements: { testTypes: ['unit'] }
      };
      
      const result = await agentCoordinator.executeWorkflow(workflowRequest);
      
      // Verify failure detection and recovery coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'agent.failure',
        expect.objectContaining({
          agentType: 'test-executor',
          error: 'Executor crashed',
          workflowId: 'failure-recovery-test'
        })
      );
      
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'agent.failover',
        expect.objectContaining({
          failedAgent: 'test-executor',
          backupAgent: 'test-executor-backup'
        })
      );
      
      expect(mockLogger.warn).toHaveBeenCalledWith(
        'Agent test-executor failed, activating backup agent'
      );
      
      expect(result.recovery).toEqual({
        failuresHandled: 1,
        backupsActivated: 1,
        workflowContinued: true
      });
    });
  });

  describe('Mesh Coordination Flow', () => {
    beforeEach(async () => {
      // Reconfigure for mesh topology
      await agentCoordinator.reconfigure({
        topology: CoordinationTopology.MESH
      });
    });

    it('should enable peer-to-peer agent communication', async () => {
      // Mock subscription callbacks
      const subscriptionCallbacks = new Map();
      mockMessageBus.subscribe.mockImplementation((channel, callback) => {
        subscriptionCallbacks.set(channel, callback);
        return 'subscription-id';
      });
      
      // Initiate peer communication
      await agentCoordinator.enablePeerCommunication();
      
      // Verify peer subscription setup
      expect(mockMessageBus.subscribe).toHaveBeenCalledWith(
        'peer.test-generator.coverage-request',
        expect.any(Function)
      );
      
      expect(mockMessageBus.subscribe).toHaveBeenCalledWith(
        'peer.test-executor.results-ready',
        expect.any(Function)
      );
      
      // Simulate peer message: test generator requesting coverage data
      const coverageRequestCallback = subscriptionCallbacks.get('peer.test-generator.coverage-request');
      await coverageRequestCallback({
        requestId: 'coverage-req-456',
        requester: 'test-generator',
        target: 'coverage-analyzer',
        data: { codeTarget: 'auth-module' }
      });
      
      // Verify peer response coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'peer.coverage-analyzer.coverage-response',
        expect.objectContaining({
          requestId: 'coverage-req-456',
          data: expect.any(Object)
        })
      );
      
      expect(mockLogger.debug).toHaveBeenCalledWith(
        'Peer communication established between test-generator and coverage-analyzer'
      );
    });

    it('should coordinate distributed test execution across multiple agents', async () => {
      const distributedTestSuite = {
        suiteId: 'distributed-suite-789',
        testPartitions: [
          { partition: 'unit-tests', assignedAgent: 'test-executor-1' },
          { partition: 'integration-tests', assignedAgent: 'test-executor-2' },
          { partition: 'e2e-tests', assignedAgent: 'test-executor-3' }
        ]
      };
      
      const result = await agentCoordinator.coordinateDistributedExecution(distributedTestSuite);
      
      // Verify partition coordination messages
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'distributed.execution.start',
        expect.objectContaining({
          suiteId: 'distributed-suite-789',
          partitions: 3,
          strategy: 'mesh-coordination'
        })
      );
      
      // Verify individual partition assignments
      distributedTestSuite.testPartitions.forEach(partition => {
        expect(mockMessageBus.publish).toHaveBeenCalledWith(
          `partition.${partition.assignedAgent}.execute`,
          expect.objectContaining({
            partition: partition.partition,
            suiteId: 'distributed-suite-789'
          })
        );
      });
      
      expect(result.distributedExecution).toEqual({
        partitionsCreated: 3,
        agentsCoordinated: 3,
        executionStrategy: 'mesh-parallel'
      });
    });
  });

  describe('Event-Driven Coordination', () => {
    it('should react to quality threshold breaches across agents', async () => {
      // Setup event listeners
      await agentCoordinator.setupEventListeners();
      
      // Simulate coverage analyzer detecting low coverage
      const lowCoverageEvent = {
        eventType: 'coverage.threshold.breach',
        data: {
          currentCoverage: 65,
          threshold: 80,
          target: 'payment-service',
          gaps: ['error-handling', 'edge-cases']
        },
        source: 'coverage-analyzer',
        timestamp: Date.now()
      };
      
      await agentCoordinator.handleEvent(lowCoverageEvent);
      
      // Verify cascade coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'coverage.breach.detected',
        expect.objectContaining({
          currentCoverage: 65,
          threshold: 80,
          actionRequired: true
        })
      );
      
      // Verify test generator activation
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'test-generation.coverage-improvement',
        expect.objectContaining({
          target: 'payment-service',
          focusAreas: ['error-handling', 'edge-cases'],
          priority: 'high'
        })
      );
      
      // Verify quality gate notification
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'quality-gate.coverage-alert',
        expect.objectContaining({
          target: 'payment-service',
          status: 'below-threshold'
        })
      );
      
      expect(mockLogger.warn).toHaveBeenCalledWith(
        'Coverage threshold breach detected for payment-service, initiating remediation'
      );
    });

    it('should coordinate test failure investigation across multiple agents', async () => {
      const testFailureEvent = {
        eventType: 'test.execution.failure',
        data: {
          testId: 'integration-test-auth-456',
          failureType: 'assertion-error',
          errorMessage: 'Expected 200 but got 500',
          affectedModules: ['auth-service', 'user-service'],
          stackTrace: 'at line 142...'
        },
        source: 'test-executor'
      };
      
      await agentCoordinator.handleEvent(testFailureEvent);
      
      // Verify failure investigation coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'failure.investigation.start',
        expect.objectContaining({
          testId: 'integration-test-auth-456',
          investigationId: expect.any(String),
          priority: 'medium'
        })
      );
      
      // Verify coverage analysis request
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'coverage.investigate.failure',
        expect.objectContaining({
          affectedModules: ['auth-service', 'user-service'],
          failureContext: expect.any(Object)
        })
      );
      
      // Verify test generation for failure case
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'test-generation.failure-reproduction',
        expect.objectContaining({
          originalTest: 'integration-test-auth-456',
          failureScenario: expect.any(Object)
        })
      );
      
      expect(mockMetrics.incrementCounter).toHaveBeenCalledWith(
        'coordination.failure-investigation.initiated'
      );
    });
  });

  describe('Load Balancing and Resource Management', () => {
    it('should balance workload across available agents', async () => {
      const heavyWorkload = {
        workloadId: 'load-test-heavy',
        totalTests: 1000,
        estimatedDuration: 300000, // 5 minutes
        resourceRequirements: {
          cpu: 80,
          memory: 4096,
          parallelism: 8
        }
      };
      
      const result = await agentCoordinator.balanceWorkload(heavyWorkload);
      
      // Verify load balancing coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'workload.analysis.start',
        expect.objectContaining({
          workloadId: 'load-test-heavy',
          totalTests: 1000,
          analysisType: 'load-balancing'
        })
      );
      
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'resource.allocation.request',
        expect.objectContaining({
          requiredResources: heavyWorkload.resourceRequirements,
          duration: 300000
        })
      );
      
      expect(result.loadBalancing).toEqual({
        agentsAllocated: expect.any(Number),
        workloadDistribution: expect.any(Object),
        estimatedParallelDuration: expect.any(Number)
      });
      
      expect(mockLogger.info).toHaveBeenCalledWith(
        'Workload balanced across available agents for optimal performance'
      );
    });

    it('should handle resource constraints and adapt coordination', async () => {
      // Simulate resource constraints
      const constrainedResources = {
        availableCpu: 40, // Low CPU
        availableMemory: 2048, // Low memory
        availableAgents: 2 // Limited agents
      };
      
      const workloadRequest = {
        workloadId: 'constrained-execution',
        requirements: {
          tests: 500,
          parallelism: 'max-available'
        }
      };
      
      const result = await agentCoordinator.adaptToConstraints(
        workloadRequest,
        constrainedResources
      );
      
      // Verify adaptive coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'coordination.adaptation.start',
        expect.objectContaining({
          constraints: constrainedResources,
          adaptationStrategy: 'resource-aware'
        })
      );
      
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'execution.strategy.modified',
        expect.objectContaining({
          originalStrategy: 'parallel',
          adaptedStrategy: 'sequential-batched',
          reason: 'resource-constraints'
        })
      );
      
      expect(result.adaptation).toEqual({
        strategyModified: true,
        resourceUtilization: expect.any(Number),
        estimatedImpact: expect.any(String)
      });
      
      expect(mockLogger.info).toHaveBeenCalledWith(
        'Coordination strategy adapted for resource constraints'
      );
    });
  });

  describe('Coordination Performance and Monitoring', () => {
    it('should monitor and report coordination efficiency', async () => {
      const monitoringConfig = {
        monitoringId: 'coord-efficiency-test',
        duration: 30000, // 30 seconds
        metrics: ['latency', 'throughput', 'resource-usage', 'success-rate']
      };
      
      const result = await agentCoordinator.startMonitoring(monitoringConfig);
      
      // Simulate some coordination activity
      await agentCoordinator.executeWorkflow({
        workflowId: 'monitored-workflow',
        target: 'monitoring-test-service'
      });
      
      const monitoringReport = await agentCoordinator.getMonitoringReport();
      
      // Verify monitoring coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'monitoring.coordination.start',
        expect.objectContaining({
          monitoringId: 'coord-efficiency-test',
          metricsTracked: 4
        })
      );
      
      expect(monitoringReport).toEqual({
        coordinationLatency: expect.any(Number),
        messageThroughput: expect.any(Number),
        resourceEfficiency: expect.any(Number),
        successRate: expect.any(Number),
        recommendations: expect.any(Array)
      });
      
      expect(mockMetrics.recordMetric).toHaveBeenCalledWith(
        'coordination.efficiency.measured',
        expect.objectContaining({
          duration: 30000,
          metricsCollected: 4
        })
      );
    });

    it('should detect and resolve coordination bottlenecks', async () => {
      // Simulate bottleneck: slow test generator
      const bottleneckScenario = {
        scenarioId: 'bottleneck-test',
        slowComponent: 'test-generator',
        expectedLatency: 1000,
        actualLatency: 5000
      };
      
      const result = await agentCoordinator.detectBottlenecks(bottleneckScenario);
      
      // Verify bottleneck detection
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'bottleneck.detected',
        expect.objectContaining({
          component: 'test-generator',
          latencyImpact: 4000,
          severity: 'high'
        })
      );
      
      // Verify mitigation coordination
      expect(mockMessageBus.publish).toHaveBeenCalledWith(
        'bottleneck.mitigation.start',
        expect.objectContaining({
          strategy: 'load-redistribution',
          targetComponent: 'test-generator'
        })
      );
      
      expect(result.bottleneckResolution).toEqual({
        bottlenecksDetected: 1,
        mitigationsApplied: 1,
        performanceImprovement: expect.any(Number)
      });
      
      expect(mockLogger.warn).toHaveBeenCalledWith(
        'Coordination bottleneck detected in test-generator, applying mitigation'
      );
    });
  });
});

// Integration test utilities
function createMockAgent(agentType: string, capabilities: string[]) {
  return {
    id: `mock-${agentType}-${Date.now()}`,
    type: agentType,
    capabilities,
    status: 'ready',
    execute: jest.fn().mockResolvedValue({ success: true }),
    getHealth: jest.fn().mockReturnValue({ status: 'healthy' }),
    getMetrics: jest.fn().mockReturnValue({ processed: 0, errors: 0 })
  };
}

function simulateNetworkLatency(ms: number) {
  return new Promise(resolve => setTimeout(resolve, ms));
}