vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/test-runner.js

@@ -0,0 +1,579 @@
+/**
+ * Test Runner Integration
+ * 
+ * Integrates with existing test infrastructure to validate refactoring operations.
+ * Provides test execution, result analysis, and regression detection.
+ */
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Test result types
+ */
+const TEST_RESULT_TYPES = {
+  PASS: 'pass',
+  FAIL: 'fail',
+  SKIP: 'skip',
+  ERROR: 'error'
+};
+
+/**
+ * Test runner class
+ */
+class TestRunner {
+  constructor(options = {}) {
+    this.options = {
+      testCommand: 'npm test',
+      testDir: 'tests',
+      timeout: 300000, // 5 minutes
+      retries: 0,
+      verbose: false,
+      ...options
+    };
+    
+    this.baselineResults = null;
+    this.currentResults = null;
+    this.regressionDetected = false;
+  }
+
+  /**
+   * Run baseline tests before refactoring
+   */
+  async runBaseline() {
+    console.log('Running baseline tests...');
+    
+    try {
+      const results = await this.executeTests();
+      this.baselineResults = results;
+      
+      console.log(`Baseline completed: ${results.passed}/${results.total} passed`);
+      return results;
+    } catch (error) {
+      throw new Error(`Baseline test execution failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Run tests after refactoring
+   */
+  async runValidation() {
+    if (!this.baselineResults) {
+      throw new Error('Baseline results not available. Run baseline first.');
+    }
+
+    console.log('Running validation tests...');
+    
+    try {
+      const results = await this.executeTests();
+      this.currentResults = results;
+      
+      // Compare with baseline
+      const comparison = this.compareResults(this.baselineResults, results);
+      this.regressionDetected = comparison.hasRegressions;
+      
+      console.log(`Validation completed: ${results.passed}/${results.total} passed`);
+      
+      if (this.regressionDetected) {
+        console.log(`⚠️  Regressions detected: ${comparison.regressions.length}`);
+      }
+      
+      return {
+        results,
+        comparison,
+        hasRegressions: this.regressionDetected
+      };
+    } catch (error) {
+      throw new Error(`Validation test execution failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Execute tests and collect results
+   */
+  async executeTests() {
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let output = '';
+      let errorOutput = '';
+
+      try {
+        // Use npm test with JSON reporter if available
+        const testProcess = spawn('npm', ['test', '--', '--json', '--verbose'], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          cwd: process.cwd()
+        });
+
+        testProcess.stdout.on('data', (data) => {
+          output += data.toString();
+          if (this.options.verbose) {
+            process.stdout.write(data);
+          }
+        });
+
+        testProcess.stderr.on('data', (data) => {
+          errorOutput += data.toString();
+          if (this.options.verbose) {
+            process.stderr.write(data);
+          }
+        });
+
+        testProcess.on('close', (code) => {
+          const duration = Date.now() - startTime;
+          
+          try {
+            const results = this.parseTestOutput(output, errorOutput, code, duration);
+            resolve(results);
+          } catch (parseError) {
+            // Fallback to basic parsing
+            const fallbackResults = this.parseBasicOutput(output, errorOutput, code, duration);
+            resolve(fallbackResults);
+          }
+        });
+
+        testProcess.on('error', (error) => {
+          reject(new Error(`Test process failed: ${error.message}`));
+        });
+
+        // Set timeout
+        if (this.options.timeout) {
+          setTimeout(() => {
+            testProcess.kill('SIGKILL');
+            reject(new Error(`Test execution timed out after ${this.options.timeout}ms`));
+          }, this.options.timeout);
+        }
+
+      } catch (error) {
+        reject(new Error(`Failed to start test process: ${error.message}`));
+      }
+    });
+  }
+
+  /**
+   * Parse test output (Jest JSON format)
+   */
+  parseTestOutput(stdout, stderr, exitCode, duration) {
+    try {
+      // Try to parse JSON output
+      const jsonMatch = stdout.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const jsonData = JSON.parse(jsonMatch[0]);
+        return this.parseJestResults(jsonData, duration);
+      }
+    } catch (error) {
+      // JSON parsing failed, fall back to basic parsing
+    }
+
+    return this.parseBasicOutput(stdout, stderr, exitCode, duration);
+  }
+
+  /**
+   * Parse Jest results
+   */
+  parseJestResults(jsonData, duration) {
+    const results = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      errors: 0,
+      duration,
+      suites: [],
+      tests: [],
+      coverage: null
+    };
+
+    if (jsonData.numTotalTests) {
+      results.total = jsonData.numTotalTests;
+      results.passed = jsonData.numPassedTests || 0;
+      results.failed = jsonData.numFailedTests || 0;
+      results.skipped = jsonData.numPendingTests || 0;
+    }
+
+    if (jsonData.testResults) {
+      for (const testSuite of jsonData.testResults) {
+        const suite = {
+          name: testSuite.name,
+          file: testSuite.testFilePath,
+          passed: 0,
+          failed: 0,
+          skipped: 0,
+          duration: testSuite.perfStats?.end || 0,
+          tests: []
+        };
+
+        if (testSuite.assertionResults) {
+          for (const test of testSuite.assertionResults) {
+            const testResult = {
+              title: test.title,
+              fullName: test.fullName,
+              status: test.status,
+              duration: test.duration || 0,
+              failureMessages: test.failureMessages || []
+            };
+
+            suite.tests.push(testResult);
+            results.tests.push(testResult);
+
+            switch (test.status) {
+              case 'passed':
+                suite.passed++;
+                break;
+              case 'failed':
+                suite.failed++;
+                break;
+              case 'pending':
+                suite.skipped++;
+                break;
+            }
+          }
+        }
+
+        results.suites.push(suite);
+      }
+    }
+
+    if (jsonData.coverageMap) {
+      results.coverage = this.parseCoverageData(jsonData.coverageMap);
+    }
+
+    return results;
+  }
+
+  /**
+   * Parse basic test output
+   */
+  parseBasicOutput(stdout, stderr, exitCode, duration) {
+    const results = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      errors: 0,
+      duration,
+      suites: [],
+      tests: [],
+      coverage: null
+    };
+
+    // Parse Jest-style output
+    const testMatch = stdout.match(/(\d+)\s+tests?\s+(\d+)\s+failed/);
+    if (testMatch) {
+      results.total = parseInt(testMatch[1]);
+      results.failed = parseInt(testMatch[2]);
+      results.passed = results.total - results.failed;
+    }
+
+    // Parse pass/fail summary
+    const passMatch = stdout.match(/(\d+)\s+passing/);
+    if (passMatch) {
+      results.passed = parseInt(passMatch[1]);
+    }
+
+    const failMatch = stdout.match(/(\d+)\s+failing/);
+    if (failMatch) {
+      results.failed = parseInt(failMatch[1]);
+    }
+
+    const skipMatch = stdout.match(/(\d+)\s+skipping/);
+    if (skipMatch) {
+      results.skipped = parseInt(skipMatch[1]);
+    }
+
+    // Extract individual test results
+    const testLines = stdout.split('\n');
+    for (const line of testLines) {
+      const testMatch = line.match(/^(✓|✗|○)\s+(.+)$/);
+      if (testMatch) {
+        const status = testMatch[1] === '✓' ? 'passed' : 
+                      testMatch[1] === '✗' ? 'failed' : 'skipped';
+        const title = testMatch[2];
+        
+        results.tests.push({
+          title,
+          status,
+          duration: 0,
+          failureMessages: status === 'failed' ? [line] : []
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Parse coverage data
+   */
+  parseCoverageData(coverageMap) {
+    const coverage = {
+      lines: { total: 0, covered: 0, percentage: 0 },
+      functions: { total: 0, covered: 0, percentage: 0 },
+      branches: { total: 0, covered: 0, percentage: 0 },
+      statements: { total: 0, covered: 0, percentage: 0 }
+    };
+
+    for (const [filePath, fileCoverage] of Object.entries(coverageMap)) {
+      // Parse line coverage
+      if (fileCoverage.l) {
+        const lines = Object.values(fileCoverage.l);
+        coverage.lines.total += lines.length;
+        coverage.lines.covered += lines.filter(count => count > 0).length;
+      }
+
+      // Parse function coverage
+      if (fileCoverage.f) {
+        const functions = Object.values(fileCoverage.f);
+        coverage.functions.total += functions.length;
+        coverage.functions.covered += functions.filter(count => count > 0).length;
+      }
+
+      // Parse branch coverage
+      if (fileCoverage.b) {
+        for (const branches of Object.values(fileCoverage.b)) {
+          coverage.branches.total += branches.length;
+          coverage.branches.covered += branches.filter(count => count > 0).length;
+        }
+      }
+
+      // Parse statement coverage
+      if (fileCoverage.s) {
+        const statements = Object.values(fileCoverage.s);
+        coverage.statements.total += statements.length;
+        coverage.statements.covered += statements.filter(count => count > 0).length;
+      }
+    }
+
+    // Calculate percentages
+    for (const metric of Object.values(coverage)) {
+      metric.percentage = metric.total > 0 ? 
+        Math.round((metric.covered / metric.total) * 100) : 0;
+    }
+
+    return coverage;
+  }
+
+  /**
+   * Compare baseline and current results
+   */
+  compareResults(baseline, current) {
+    const comparison = {
+      hasRegressions: false,
+      regressions: [],
+      improvements: [],
+      unchanged: [],
+      summary: {
+        baseline: {
+          total: baseline.total,
+          passed: baseline.passed,
+          failed: baseline.failed,
+          duration: baseline.duration
+        },
+        current: {
+          total: current.total,
+          passed: current.passed,
+          failed: current.failed,
+          duration: current.duration
+        }
+      }
+    };
+
+    // Check for test count changes
+    if (current.total < baseline.total) {
+      comparison.regressions.push({
+        type: 'missing_tests',
+        message: `${baseline.total - current.total} tests are missing`,
+        severity: 'high'
+      });
+      comparison.hasRegressions = true;
+    }
+
+    if (current.total > baseline.total) {
+      comparison.improvements.push({
+        type: 'new_tests',
+        message: `${current.total - baseline.total} new tests added`,
+        severity: 'info'
+      });
+    }
+
+    // Check for test failures
+    if (current.failed > baseline.failed) {
+      comparison.regressions.push({
+        type: 'new_failures',
+        message: `${current.failed - baseline.failed} new test failures`,
+        severity: 'high'
+      });
+      comparison.hasRegressions = true;
+    }
+
+    if (current.failed < baseline.failed) {
+      comparison.improvements.push({
+        type: 'fixed_failures',
+        message: `${baseline.failed - current.failed} test failures fixed`,
+        severity: 'good'
+      });
+    }
+
+    // Check for performance regression
+    const performanceIncrease = current.duration - baseline.duration;
+    const performancePercent = (performanceIncrease / baseline.duration) * 100;
+
+    if (performanceIncrease > 5000 && performancePercent > 10) { // 5s and 10%
+      comparison.regressions.push({
+        type: 'performance',
+        message: `Test execution increased by ${Math.round(performancePercent)}% (${Math.round(performanceIncrease/1000)}s)`,
+        severity: 'medium'
+      });
+      comparison.hasRegressions = true;
+    }
+
+    // Compare individual test results
+    const baselineTests = new Map();
+    for (const test of baseline.tests) {
+      baselineTests.set(test.fullName, test);
+    }
+
+    for (const test of current.tests) {
+      const baselineTest = baselineTests.get(test.fullName);
+      
+      if (!baselineTest) {
+        comparison.improvements.push({
+          type: 'new_test',
+          message: `New test: ${test.title}`,
+          severity: 'info'
+        });
+      } else if (baselineTest.status === 'passed' && test.status === 'failed') {
+        comparison.regressions.push({
+          type: 'test_regression',
+          message: `Test now failing: ${test.title}`,
+          severity: 'high',
+          test: test
+        });
+        comparison.hasRegressions = true;
+      } else if (baselineTest.status === 'failed' && test.status === 'passed') {
+        comparison.improvements.push({
+          type: 'test_fixed',
+          message: `Test now passing: ${test.title}`,
+          severity: 'good'
+        });
+      }
+    }
+
+    return comparison;
+  }
+
+  /**
+   * Run specific test files
+   */
+  async runSpecificTests(testFiles) {
+    console.log(`Running ${testFiles.length} specific tests...`);
+    
+    const testArgs = ['test', '--', ...testFiles];
+    
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let output = '';
+      let errorOutput = '';
+
+      const testProcess = spawn('npm', testArgs, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: process.cwd()
+      });
+
+      testProcess.stdout.on('data', (data) => {
+        output += data.toString();
+        if (this.options.verbose) {
+          process.stdout.write(data);
+        }
+      });
+
+      testProcess.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+        if (this.options.verbose) {
+          process.stderr.write(data);
+        }
+      });
+
+      testProcess.on('close', (code) => {
+        const duration = Date.now() - startTime;
+        const results = this.parseBasicOutput(output, errorOutput, code, duration);
+        resolve(results);
+      });
+
+      testProcess.on('error', (error) => {
+        reject(new Error(`Test process failed: ${error.message}`));
+      });
+    });
+  }
+
+  /**
+   * Check if tests are available
+   */
+  checkTestAvailability() {
+    const testPaths = [
+      'package.json',
+      'tests',
+      '__tests__',
+      'test',
+      'spec'
+    ];
+
+    for (const testPath of testPaths) {
+      if (fs.existsSync(testPath)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Get test configuration
+   */
+  getTestConfig() {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+      return {
+        hasTestScript: !!packageJson.scripts?.test,
+        testScript: packageJson.scripts?.test,
+        jestConfig: packageJson.jest,
+        dependencies: {
+          jest: packageJson.dependencies?.jest || packageJson.devDependencies?.jest,
+          mocha: packageJson.dependencies?.mocha || packageJson.devDependencies?.mocha,
+          jasmine: packageJson.dependencies?.jasmine || packageJson.devDependencies?.jasmine
+        }
+      };
+    } catch (error) {
+      return { hasTestScript: false };
+    }
+  }
+
+  /**
+   * Generate test report
+   */
+  generateReport() {
+    if (!this.currentResults) {
+      throw new Error('No test results available. Run tests first.');
+    }
+
+    const report = {
+      timestamp: new Date().toISOString(),
+      baseline: this.baselineResults,
+      current: this.currentResults,
+      comparison: this.compareResults(this.baselineResults, this.currentResults),
+      config: this.getTestConfig(),
+      summary: {
+        hasRegressions: this.regressionDetected,
+        testCountChanged: this.baselineResults.total !== this.currentResults.total,
+        performanceChanged: Math.abs(this.currentResults.duration - this.baselineResults.duration) > 1000
+      }
+    };
+
+    return report;
+  }
+}
+
+module.exports = {
+  TestRunner,
+  TEST_RESULT_TYPES
+};