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

/**
 * Integration Test Suite: Agent Coordination
 * Tests multi-agent communication, task distribution, and coordination protocols
 */

const { spawn } = require('child_process');
const fs = require('fs').promises;
const path = require('path');

describe('Agent Coordination Integration Tests', () => {
  let testWorkspace;

  beforeAll(async () => {
    testWorkspace = path.join(__dirname, '../../.test-workspace');
    await fs.mkdir(testWorkspace, { recursive: true });

    // Initialize Claude Flow memory for coordination
    await execCommand('npx claude-flow@alpha memory store "test-workspace" "' + testWorkspace + '" --namespace "aqe-test"');
  });

  afterAll(async () => {
    // Cleanup test workspace
    await fs.rmdir(testWorkspace, { recursive: true, force: true });
  });

  describe('Multi-Agent Task Distribution', () => {
    test('1. Test Generator and Executor coordination', async () => {
      const testGeneratorAgent = {
        id: 'test-gen-001',
        type: 'qe-test-generator',
        task: 'Generate unit tests for UserService'
      };

      const testExecutorAgent = {
        id: 'test-exec-001',
        type: 'qe-test-executor',
        task: 'Execute generated tests'
      };

      // Store coordination plan in memory
      await execCommand(`npx claude-flow@alpha memory store "coordination-plan-${Date.now()}" '${JSON.stringify({
        agents: [testGeneratorAgent, testExecutorAgent],
        workflow: 'sequential',
        status: 'pending'
      })}' --namespace "aqe-test"`);

      // Simulate agent coordination
      const generatorResult = await simulateAgentExecution(testGeneratorAgent);
      expect(generatorResult.status).toBe('completed');
      expect(generatorResult.artifacts).toHaveProperty('testFiles');

      const executorResult = await simulateAgentExecution(testExecutorAgent, generatorResult.artifacts);
      expect(executorResult.status).toBe('completed');
      expect(executorResult.testResults).toHaveProperty('passed');
    });

    test('2. Coverage Analyzer and Quality Gate coordination', async () => {
      const coverageAgent = {
        id: 'coverage-001',
        type: 'qe-coverage-analyzer',
        task: 'Analyze test coverage gaps'
      };

      const qualityGateAgent = {
        id: 'quality-001',
        type: 'qe-quality-gate',
        task: 'Validate quality thresholds'
      };

      // Test coordination with shared memory
      const coordinationKey = `coverage-quality-${Date.now()}`;
      await execCommand(`npx claude-flow@alpha memory store "${coordinationKey}" '${JSON.stringify({
        coverage_threshold: 85,
        quality_gates: ['coverage', 'complexity', 'duplication'],
        coordination_status: 'active'
      })}' --namespace "aqe-test"`);

      const coverageResult = await simulateAgentExecution(coverageAgent);
      const qualityResult = await simulateAgentExecution(qualityGateAgent, {
        coverage_report: coverageResult.coverage
      });

      expect(qualityResult.gates_passed).toBeGreaterThan(2);
    });

    test('3. Performance and Security agent coordination', async () => {
      const perfAgent = {
        id: 'perf-001',
        type: 'qe-performance-tester',
        task: 'Run performance benchmarks'
      };

      const securityAgent = {
        id: 'security-001',
        type: 'qe-security-scanner',
        task: 'Security vulnerability scan'
      };

      // Parallel coordination test
      const results = await Promise.all([
        simulateAgentExecution(perfAgent),
        simulateAgentExecution(securityAgent)
      ]);

      expect(results[0].metrics).toHaveProperty('responseTime');
      expect(results[1].vulnerabilities).toBeDefined();
    });
  });

  describe('Task Handoff Mechanisms', () => {
    test('4. Sequential task handoff with state persistence', async () => {
      const pipeline = [
        { agent: 'qe-test-generator', task: 'generate', output: 'test-files' },
        { agent: 'qe-coverage-analyzer', task: 'analyze', input: 'test-files', output: 'coverage-report' },
        { agent: 'qe-quality-gate', task: 'validate', input: 'coverage-report', output: 'quality-verdict' }
      ];

      let previousOutput = null;
      for (const step of pipeline) {
        const agent = {
          id: `${step.agent}-${Date.now()}`,
          type: step.agent,
          task: step.task,
          input: previousOutput
        };

        const result = await simulateAgentExecution(agent);
        expect(result.status).toBe('completed');
        previousOutput = result[step.output];
      }

      expect(previousOutput).toHaveProperty('verdict');
    });

    test('5. Error handling in task handoff chain', async () => {
      const faultyAgent = {
        id: 'faulty-001',
        type: 'qe-test-generator',
        task: 'generate-with-error',
        shouldFail: true
      };

      const recoveryAgent = {
        id: 'recovery-001',
        type: 'qe-test-generator',
        task: 'recovery-generation'
      };

      try {
        await simulateAgentExecution(faultyAgent);
      } catch (error) {
        expect(error.message).toContain('Agent execution failed');

        // Test recovery mechanism
        const recoveryResult = await simulateAgentExecution(recoveryAgent);
        expect(recoveryResult.status).toBe('completed');
      }
    });
  });
});

// Helper functions
async function execCommand(command) {
  return new Promise((resolve, reject) => {
    const [cmd, ...args] = command.split(' ');
    const child = spawn(cmd, args, { stdio: 'pipe' });

    let stdout = '';
    let stderr = '';

    child.stdout.on('data', (data) => stdout += data);
    child.stderr.on('data', (data) => stderr += data);

    child.on('close', (code) => {
      if (code === 0) resolve(stdout);
      else reject(new Error(stderr));
    });
  });
}

async function simulateAgentExecution(agent, input = null) {
  // Simulate agent execution based on type
  const delay = Math.random() * 1000 + 500; // 500-1500ms
  await new Promise(resolve => setTimeout(resolve, delay));

  if (agent.shouldFail) {
    throw new Error('Agent execution failed');
  }

  const baseResult = {
    agentId: agent.id,
    status: 'completed',
    executionTime: delay,
    timestamp: new Date().toISOString()
  };

  switch (agent.type) {
    case 'qe-test-generator':
      return {
        ...baseResult,
        testFiles: ['user.test.js', 'auth.test.js'],
        artifacts: { testFiles: ['generated-test-1.js', 'generated-test-2.js'] }
      };

    case 'qe-test-executor':
      return {
        ...baseResult,
        testResults: { passed: 8, failed: 0, skipped: 1 },
        coverage: 87.5
      };

    case 'qe-coverage-analyzer':
      return {
        ...baseResult,
        coverage: { lines: 85, branches: 78, functions: 92, statements: 88 },
        gaps: ['error-handling', 'edge-cases']
      };

    case 'qe-quality-gate':
      return {
        ...baseResult,
        gates_passed: 3,
        verdict: 'PASS',
        quality_score: 8.5
      };

    case 'qe-performance-tester':
      return {
        ...baseResult,
        metrics: { responseTime: 120, throughput: 1500, memoryUsage: 45 }
      };

    case 'qe-security-scanner':
      return {
        ...baseResult,
        vulnerabilities: { high: 0, medium: 2, low: 5 },
        securityScore: 85
      };

    default:
      return baseResult;
  }
}