vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/utils/test-runner.js

@@ -5,571 +5,47 @@
  * 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'
-};
+const { TestRunnerCore, TEST_RESULT_TYPES } = require('./test-runner-core');
+const { runBaseline } = require('./test-runner-baseline');
+const { runValidation, runSpecific } = require('./test-runner-validation');
+const { generateReport } = require('./test-runner-report');
 
 /**
  * Test runner class
  */
-class TestRunner {
+class TestRunner extends TestRunnerCore {
   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;
+    super(options);
   }
 
   /**
    * 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}`);
-    }
+    return runBaseline(this);
   }
 
   /**
    * 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;
+    return runValidation(this);
   }
 
   /**
    * 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}`));
-      });
+    return runSpecific(testFiles, {
+      verbose: this.options.verbose
     });
   }
 
-  /**
-   * 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;
+    return generateReport(this);
   }
 }