vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/verification/AgentCommunicationTester.js

@@ -0,0 +1,474 @@
+/**
+ * Agent Communication Tester
+ * 
+ * Tests agent communication through file operations and command execution.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const TestRequirementManager = require('./TestRequirementManager');
+const { VerificationType } = require('../VerificationType');
+
+/**
+ * Agent communication tester class
+ */
+class AgentCommunicationTester {
+  /**
+   * Create communication tester instance
+   * @param {Object} options - Tester options
+   */
+  constructor(options = {}) {
+    this.testManager = options.testManager || new TestRequirementManager(options);
+    this.logger = options.logger || null;
+    this.timeout = options.timeout || 30000;
+    this.maxConcurrentTests = options.maxConcurrentTests || 3;
+    this.continueOnFailure = options.continueOnFailure !== false;
+  }
+
+  /**
+   * Test agent communication
+   * @param {Object} agent - Agent configuration
+   * @param {Object} options - Test options
+   * @returns {Promise<Object>} - Test result
+   */
+  async testCommunication(agent, options = {}) {
+    const testId = `comm-test-${agent.id}-${Date.now()}`;
+    const startTime = Date.now();
+    
+    try {
+      if (this.logger) {
+        await this.logger.info('Starting agent communication test', {
+          testId,
+          agentId: agent.id,
+          agentName: agent.name
+        });
+      }
+
+      const testConfigs = this.createTestConfigs(agent, options);
+      const results = [];
+      let allPassed = true;
+
+      // Run tests
+      for (const testConfig of testConfigs) {
+        try {
+          const result = await this.runSingleTest(agent, testConfig);
+          results.push(result);
+          
+          if (!result.success && !this.continueOnFailure) {
+            break;
+          }
+        } catch (error) {
+          const errorResult = {
+            testId: testConfig.id,
+            success: false,
+            error: error.message,
+            duration: 0
+          };
+          results.push(errorResult);
+          allPassed = false;
+          
+          if (!this.continueOnFailure) {
+            break;
+          }
+        }
+      }
+
+      // Calculate overall result
+      const passedTests = results.filter(r => r.success).length;
+      const totalTests = results.length;
+      allPassed = passedTests === totalTests && totalTests > 0;
+
+      const duration = Date.now() - startTime;
+      
+      const testResult = {
+        success: allPassed,
+        testId,
+        agentId: agent.id,
+        agentName: agent.name,
+        duration,
+        results,
+        summary: {
+          totalTests,
+          passedTests,
+          failedTests: totalTests - passedTests,
+          allPassed
+        }
+      };
+
+      if (this.logger) {
+        await this.logger.info('Agent communication test completed', {
+          testId,
+          agentId: agent.id,
+          success: testResult.success,
+          summary: testResult.summary,
+          duration
+        });
+      }
+
+      return testResult;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      const errorResult = {
+        success: false,
+        testId,
+        agentId: agent.id,
+        agentName: agent.name,
+        duration,
+        error: error.message,
+        results: [],
+        summary: {
+          totalTests: 0,
+          passedTests: 0,
+          failedTests: 0,
+          allPassed: false
+        }
+      };
+
+      if (this.logger) {
+        await this.logger.error('Agent communication test failed', {
+          testId,
+          agentId: agent.id,
+          error: error.message,
+          duration
+        });
+      }
+
+      return errorResult;
+    }
+  }
+
+  /**
+   * Run single communication test
+   * @param {Object} agent - Agent configuration
+   * @param {Object} testConfig - Test configuration
+   * @returns {Promise<Object>} - Test result
+   */
+  async runSingleTest(agent, testConfig) {
+    const startTime = Date.now();
+    
+    try {
+      switch (testConfig.type) {
+        case VerificationType.FILE_OPERATION:
+          return await this.runFileOperationTest(agent, testConfig);
+          
+        case VerificationType.COMMAND_EXECUTION:
+          return await this.runCommandExecutionTest(agent, testConfig);
+          
+        default:
+          throw new Error(`Unsupported test type: ${testConfig.type}`);
+      }
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      return {
+        testId: testConfig.id,
+        success: false,
+        error: error.message,
+        duration,
+        type: testConfig.type
+      };
+    }
+  }
+
+  /**
+   * Run file operation test
+   * @param {Object} agent - Agent configuration
+   * @param {Object} testConfig - Test configuration
+   * @returns {Promise<Object>} - Test result
+   */
+  async runFileOperationTest(agent, testConfig) {
+    const startTime = Date.now();
+    
+    try {
+      // Complete requirement cycle
+      const cycleResult = await this.testManager.completeRequirementCycle(
+        agent.id,
+        testConfig
+      );
+      
+      const duration = Date.now() - startTime;
+      
+      return {
+        testId: testConfig.id,
+        success: cycleResult.success,
+        duration,
+        type: VerificationType.FILE_OPERATION,
+        description: testConfig.description,
+        steps: cycleResult.steps,
+        summary: cycleResult.summary
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      return {
+        testId: testConfig.id,
+        success: false,
+        error: error.message,
+        duration,
+        type: VerificationType.FILE_OPERATION,
+        description: testConfig.description
+      };
+    }
+  }
+
+  /**
+   * Run command execution test
+   * @param {Object} agent - Agent configuration
+   * @param {Object} testConfig - Test configuration
+   * @returns {Promise<Object>} - Test result
+   */
+  async runCommandExecutionTest(agent, testConfig) {
+    const startTime = Date.now();
+    
+    try {
+      const { spawn } = require('child_process');
+      
+      const result = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error(`Command timeout: ${testConfig.command}`));
+        }, testConfig.timeout || this.timeout);
+        
+        const child = spawn(testConfig.command, {
+          shell: true,
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+        
+        let stdout = '';
+        let stderr = '';
+        
+        child.stdout.on('data', (data) => {
+          stdout += data.toString();
+        });
+        
+        child.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+        
+        child.on('close', (code) => {
+          clearTimeout(timeout);
+          
+          resolve({
+            exitCode: code,
+            stdout: stdout.trim(),
+            stderr: stderr.trim()
+          });
+        });
+        
+        child.on('error', (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        });
+      });
+      
+      const duration = Date.now() - startTime;
+      const success = result.exitCode === 0;
+      
+      // Check if expected result is in output
+      const expectedResultFound = testConfig.expectedResult && 
+        result.stdout.includes(testConfig.expectedResult);
+      
+      const testSuccess = success && (!testConfig.expectedResult || expectedResultFound);
+      
+      return {
+        testId: testConfig.id,
+        success: testSuccess,
+        duration,
+        type: VerificationType.COMMAND_EXECUTION,
+        description: testConfig.description,
+        command: testConfig.command,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        expectedResult: testConfig.expectedResult,
+        expectedResultFound
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      return {
+        testId: testConfig.id,
+        success: false,
+        error: error.message,
+        duration,
+        type: VerificationType.COMMAND_EXECUTION,
+        description: testConfig.description,
+        command: testConfig.command
+      };
+    }
+  }
+
+  /**
+   * Create test configurations for agent
+   * @param {Object} agent - Agent configuration
+   * @param {Object} options - Test options
+   * @returns {Array} - Test configurations
+   */
+  createTestConfigs(agent, options = {}) {
+    const configs = [];
+    const { testTypes = null } = options;
+    
+    // File operation test
+    if (!testTypes || testTypes.includes(VerificationType.FILE_OPERATION)) {
+      configs.push({
+        id: `${agent.id}-file-op-test`,
+        type: VerificationType.FILE_OPERATION,
+        description: 'File write/read/delete communication test',
+        content: `communication-test-${agent.id}-${Date.now()}`,
+        timeout: 15000
+      });
+    }
+    
+    // Command execution tests
+    if (!testTypes || testTypes.includes(VerificationType.COMMAND_EXECUTION)) {
+      // Test agent-specific commands
+      if (agent.verificationCommands && agent.verificationCommands.length > 0) {
+        agent.verificationCommands.forEach((command, index) => {
+          configs.push({
+            id: `${agent.id}-cmd-test-${index}`,
+            type: VerificationType.COMMAND_EXECUTION,
+            description: `Agent command test: ${command}`,
+            command: command,
+            expectedResult: null, // Just check exit code
+            timeout: 30000
+          });
+        });
+      }
+      
+      // Generic command tests
+      configs.push({
+        id: `${agent.id}-echo-test`,
+        type: VerificationType.COMMAND_EXECUTION,
+        description: 'Echo command test',
+        command: `echo "communication-test-${agent.id}"`,
+        expectedResult: `communication-test-${agent.id}`,
+        timeout: 10000
+      });
+    }
+    
+    return configs;
+  }
+
+  /**
+   * Test multiple agents communication
+   * @param {Array} agents - Agent configurations
+   * @param {Object} options - Test options
+   * @returns {Promise<Object>} - Batch test result
+   */
+  async testMultipleAgents(agents, options = {}) {
+    const batchId = `batch-comm-test-${Date.now()}`;
+    const startTime = Date.now();
+    
+    try {
+      const results = [];
+      
+      if (options.parallel && this.maxConcurrentTests > 1) {
+        // Parallel execution
+        const promises = agents.map(agent => 
+          this.testCommunication(agent, options)
+        );
+        
+        const batchResults = await Promise.allSettled(promises);
+        
+        batchResults.forEach((result, index) => {
+          if (result.status === 'fulfilled') {
+            results.push(result.value);
+          } else {
+            results.push({
+              success: false,
+              agentId: agents[index].id,
+              error: result.reason?.message || 'Unknown error',
+              duration: 0
+            });
+          }
+        });
+      } else {
+        // Sequential execution
+        for (const agent of agents) {
+          const result = await this.testCommunication(agent, options);
+          results.push(result);
+        }
+      }
+      
+      const duration = Date.now() - startTime;
+      
+      // Calculate summary
+      const totalAgents = agents.length;
+      const successfulAgents = results.filter(r => r.success).length;
+      const failedAgents = totalAgents - successfulAgents;
+      
+      const batchResult = {
+        success: failedAgents === 0,
+        batchId,
+        duration,
+        results,
+        summary: {
+          totalAgents,
+          successfulAgents,
+          failedAgents,
+          successRate: totalAgents > 0 ? (successfulAgents / totalAgents) * 100 : 0
+        }
+      };
+      
+      if (this.logger) {
+        await this.logger.info('Batch agent communication test completed', {
+          batchId,
+          summary: batchResult.summary,
+          duration
+        });
+      }
+      
+      return batchResult;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      const errorResult = {
+        success: false,
+        batchId,
+        duration,
+        error: error.message,
+        results: [],
+        summary: {
+          totalAgents: agents.length,
+          successfulAgents: 0,
+          failedAgents: agents.length,
+          successRate: 0
+        }
+      };
+      
+      if (this.logger) {
+        await this.logger.error('Batch agent communication test failed', {
+          batchId,
+          error: error.message,
+          duration
+        });
+      }
+      
+      return errorResult;
+    }
+  }
+
+  /**
+   * Get tester information
+   * @returns {Object} - Tester info
+   */
+  getInfo() {
+    return {
+      name: 'Agent Communication Tester',
+      version: '1.0.0',
+      timeout: this.timeout,
+      maxConcurrentTests: this.maxConcurrentTests,
+      continueOnFailure: this.continueOnFailure,
+      features: [
+        'file operation testing',
+        'command execution testing',
+        'parallel testing',
+        'batch testing',
+        'error handling',
+        'timeout protection',
+        'detailed logging'
+      ]
+    };
+  }
+}
+
+module.exports = AgentCommunicationTester;