vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/test-validator.js

@@ -6,146 +6,13 @@
  */
 
 const { TestRunner } = require('../utils/test-runner');
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Validation status
- */
-const VALIDATION_STATUS = {
-  PENDING: 'pending',
-  RUNNING: 'running',
-  PASSED: 'passed',
-  FAILED: 'failed',
-  SKIPPED: 'skipped',
-  ERROR: 'error'
-};
-
-/**
- * Test validation result class
- */
-class TestValidationResult {
-  constructor(operationId) {
-    this.operationId = operationId;
-    this.status = VALIDATION_STATUS.PENDING;
-    this.baselineResults = null;
-    this.validationResults = null;
-    this.comparison = null;
-    this.duration = 0;
-    this.errors = [];
-    this.warnings = [];
-    this.metadata = {
-      validatedAt: new Date().toISOString(),
-      testFramework: 'jest',
-      environment: process.env.NODE_ENV || 'test'
-    };
-  }
-
-  setStatus(status) {
-    this.status = status;
-  }
-
-  setBaselineResults(results) {
-    this.baselineResults = results;
-  }
-
-  setValidationResults(results) {
-    this.validationResults = results;
-  }
-
-  setComparison(comparison) {
-    this.comparison = comparison;
-  }
-
-  setDuration(duration) {
-    this.duration = duration;
-  }
-
-  addError(error) {
-    this.errors.push({
-      message: error.message,
-      timestamp: new Date().toISOString(),
-      stack: error.stack
-    });
-  }
-
-  addWarning(warning) {
-    this.warnings.push({
-      message: warning,
-      timestamp: new Date().toISOString()
-    });
-  }
-
-  isSuccessful() {
-    return this.status === VALIDATION_STATUS.PASSED && 
-           this.errors.length === 0 &&
-           (!this.comparison || !this.comparison.hasRegressions);
-  }
-
-  getSummary() {
-    return {
-      operationId: this.operationId,
-      status: this.status,
-      duration: this.duration,
-      baselineTests: this.baselineResults?.total || 0,
-      validationTests: this.validationResults?.total || 0,
-      hasRegressions: this.comparison?.hasRegressions || false,
-      errorCount: this.errors.length,
-      warningCount: this.warnings.length
-    };
-  }
-}
-
-/**
- * Test suite class
- */
-class TestSuite {
-  constructor(name, pattern, options = {}) {
-    this.name = name;
-    this.pattern = pattern;
-    this.options = {
-      timeout: 30000,
-      retries: 0,
-      parallel: true,
-      ...options
-    };
-    this.results = null;
-    this.lastRun = null;
-  }
-
-  async run() {
-    const testRunner = new TestRunner({
-      timeout: this.options.timeout,
-      retries: this.options.retries
-    });
-    
-    try {
-      this.results = await testRunner.runSpecificTests([this.pattern]);
-      this.lastRun = new Date().toISOString();
-      return this.results;
-    } catch (error) {
-      this.results = {
-        total: 0,
-        passed: 0,
-        failed: 0,
-        skipped: 0,
-        errors: [error],
-        duration: 0
-      };
-      this.lastRun = new Date().toISOString();
-      return this.results;
-    }
-  }
-
-  getSummary() {
-    return {
-      name: this.name,
-      pattern: this.pattern,
-      lastRun: this.lastRun,
-      results: this.results
-    };
-  }
-}
+const { VALIDATION_STATUS } = require('./validation/validation-status');
+const { TestValidationResult } = require('./validation/test-validation-result');
+const { TestSuite } = require('./validation/test-suite');
+const { BaselineRunner } = require('./validation/baseline-runner');
+const { ValidationRunner } = require('./validation/validation-runner');
+const { ResultComparator } = require('./validation/result-comparator');
+const { ReportGenerator } = require('./validation/report-generator');
 
 /**
  * Test validator class
@@ -170,7 +37,11 @@ class TestValidator {
     
     this.testSuites = new Map();
     this.validationResults = new Map();
-    this.globalBaseline = null;
+    
+    this.baselineRunner = new BaselineRunner(this.testSuites);
+    this.validationRunner = new ValidationRunner(this.testSuites);
+    this.resultComparator = new ResultComparator(null);
+    this.reportGenerator = new ReportGenerator();
   }
 
   /**
@@ -215,47 +86,9 @@ class TestValidator {
    * Run baseline tests
    */
   async runBaseline() {
-    console.log('Running baseline tests...');
-    
-    const startTime = Date.now();
-    const results = {
-      total: 0,
-      passed: 0,
-      failed: 0,
-      skipped: 0,
-      duration: 0,
-      suites: {}
-    };
-    
-    try {
-      // Run all test suites
-      for (const [name, suite] of this.testSuites) {
-        console.log(`Running ${name} tests...`);
-        const suiteResults = await suite.run();
-        
-        results.suites[name] = suiteResults;
-        results.total += suiteResults.total || 0;
-        results.passed += suiteResults.passed || 0;
-        results.failed += suiteResults.failed || 0;
-        results.skipped += suiteResults.skipped || 0;
-      }
-      
-      results.duration = (Date.now() - startTime) / 1000;
-      
-      this.globalBaseline = results;
-      
-      console.log(`Baseline completed: ${results.passed}/${results.total} passed`);
-      
-      if (results.failed > 0) {
-        console.warn(`${results.failed} baseline tests failed`);
-      }
-      
-      return results;
-      
-    } catch (error) {
-      console.error('Baseline test execution failed:', error.message);
-      throw error;
-    }
+    const results = await this.baselineRunner.runBaseline();
+    this.resultComparator.updateBaseline(results);
+    return results;
   }
 
   /**
@@ -272,15 +105,15 @@ class TestValidator {
       if (this.options.runValidation) {
         console.log(`Running validation tests for operation: ${operationId}`);
         
-        const validationResults = await this.runValidationTests(affectedFiles);
+        const validationResults = await this.validationRunner.runValidationTests(affectedFiles);
         validation.setValidationResults(validationResults);
       }
       
       // Compare with baseline
-      if (this.options.compareResults && this.globalBaseline) {
+      if (this.options.compareResults && this.baselineRunner.getBaseline()) {
         console.log('Comparing results with baseline...');
         
-        const comparison = this.compareWithBaseline(validation.validationResults);
+        const comparison = this.resultComparator.compareWithBaseline(validation.validationResults);
         validation.setComparison(comparison);
         
         // Fail on regression if enabled
@@ -302,159 +135,6 @@ class TestValidator {
     return validation;
   }
 
-  /**
-   * Run validation tests for affected files
-   */
-  async runValidationTests(affectedFiles) {
-    const results = {
-      total: 0,
-      passed: 0,
-      failed: 0,
-      skipped: 0,
-      duration: 0,
-      suites: {}
-    };
-    
-    const startTime = Date.now();
-    
-    try {
-      // Determine which test suites to run based on affected files
-      const relevantSuites = this.getRelevantTestSuites(affectedFiles);
-      
-      for (const suiteName of relevantSuites) {
-        const suite = this.testSuites.get(suiteName);
-        if (suite) {
-          console.log(`Running ${suiteName} validation tests...`);
-          
-          const suiteResults = await suite.run();
-          results.suites[suiteName] = suiteResults;
-          
-          results.total += suiteResults.total || 0;
-          results.passed += suiteResults.passed || 0;
-          results.failed += suiteResults.failed || 0;
-          results.skipped += suiteResults.skipped || 0;
-        }
-      }
-      
-      results.duration = (Date.now() - startTime) / 1000;
-      
-      console.log(`Validation completed: ${results.passed}/${results.total} passed`);
-      
-      return results;
-      
-    } catch (error) {
-      console.error('Validation test execution failed:', error.message);
-      throw error;
-    }
-  }
-
-  /**
-   * Get relevant test suites for affected files
-   */
-  getRelevantTestSuites(affectedFiles) {
-    const relevantSuites = new Set();
-    
-    for (const filePath of affectedFiles) {
-      // Check if file is a test file
-      if (filePath.includes('.test.') || filePath.includes('.spec.')) {
-        relevantSuites.add('unit');
-        continue;
-      }
-      
-      // Check file path to determine relevant suites
-      if (filePath.includes('/test/') || filePath.includes('/tests/')) {
-        relevantSuites.add('unit');
-      }
-      
-      if (filePath.includes('/integration/')) {
-        relevantSuites.add('integration');
-      }
-      
-      if (filePath.includes('/e2e/')) {
-        relevantSuites.add('e2e');
-      }
-      
-      // For refactoring operations, always run unit and refactoring tests
-      relevantSuites.add('unit');
-      relevantSuites.add('refactoring');
-    }
-    
-    return Array.from(relevantSuites);
-  }
-
-  /**
-   * Compare validation results with baseline
-   */
-  compareWithBaseline(validationResults) {
-    if (!this.globalBaseline || !validationResults) {
-      return {
-        hasRegressions: false,
-        regressions: [],
-        improvements: [],
-        unchanged: []
-      };
-    }
-    
-    const comparison = {
-      hasRegressions: false,
-      regressions: [],
-      improvements: [],
-      unchanged: []
-    };
-    
-    // Compare overall results
-    const baselineTotal = this.globalBaseline.total || 0;
-    const validationTotal = validationResults.total || 0;
-    
-    if (validationTotal < baselineTotal) {
-      comparison.regressions.push({
-        type: 'missing_tests',
-        message: `${baselineTotal - validationTotal} tests are missing`,
-        severity: 'high'
-      });
-      comparison.hasRegressions = true;
-    }
-    
-    const baselineFailed = this.globalBaseline.failed || 0;
-    const validationFailed = validationResults.failed || 0;
-    
-    if (validationFailed > baselineFailed) {
-      comparison.regressions.push({
-        type: 'new_failures',
-        message: `${validationFailed - baselineFailed} new test failures`,
-        severity: 'critical'
-      });
-      comparison.hasRegressions = true;
-    }
-    
-    if (validationFailed < baselineFailed) {
-      comparison.improvements.push({
-        type: 'fixed_failures',
-        message: `${baselineFailed - validationFailed} test failures fixed`,
-        severity: 'good'
-      });
-    }
-    
-    // Compare individual test suites
-    for (const [suiteName, baselineSuite] of Object.entries(this.globalBaseline.suites || {})) {
-      const validationSuite = validationResults.suites?.[suiteName];
-      
-      if (validationSuite) {
-        if (validationSuite.failed > (baselineSuite.failed || 0)) {
-          comparison.regressions.push({
-            type: 'suite_regression',
-            message: `${suiteName} suite: ${validationSuite.failed} failures (baseline: ${baselineSuite.failed || 0})`,
-            severity: 'high',
-            suite: suiteName
-          });
-          comparison.hasRegressions = true;
-        }
-      }
-    }
-    
-    return comparison;
-  }
-
   /**
    * Validate multiple operations
    */
@@ -476,38 +156,7 @@ class TestValidator {
    * Get validation summary
    */
   getValidationSummary() {
-    const summary = {
-      totalValidations: this.validationResults.size,
-      successful: 0,
-      failed: 0,
-      withRegressions: 0,
-      averageDuration: 0,
-      errors: [],
-      warnings: []
-    };
-    
-    let totalDuration = 0;
-    
-    for (const validation of this.validationResults.values()) {
-      if (validation.isSuccessful()) {
-        summary.successful++;
-      } else {
-        summary.failed++;
-      }
-      
-      if (validation.comparison?.hasRegressions) {
-        summary.withRegressions++;
-      }
-      
-      totalDuration += validation.duration;
-      summary.errors.push(...validation.errors);
-      summary.warnings.push(...validation.warnings);
-    }
-    
-    summary.averageDuration = summary.totalValidations > 0 ? 
-      totalDuration / summary.totalValidations : 0;
-    
-    return summary;
+    return this.reportGenerator.calculateSummary(this.validationResults);
   }
 
   /**
@@ -529,32 +178,20 @@ class TestValidator {
    */
   reset() {
     this.validationResults.clear();
-    this.globalBaseline = null;
+    this.baselineRunner.reset();
+    this.resultComparator.updateBaseline(null);
   }
 
   /**
    * Export validation results
    */
   exportResults(format = 'json') {
-    const exportData = {
-      metadata: {
-        exportedAt: new Date().toISOString(),
-        validatorVersion: '1.0.0',
-        options: this.options
-      },
-      baseline: this.globalBaseline,
-      validations: Array.from(this.validationResults.entries()).map(([id, validation]) => ({
-        operationId: id,
-        ...validation.getSummary()
-      })),
-      summary: this.getValidationSummary()
-    };
-    
-    if (format === 'json') {
-      return JSON.stringify(exportData, null, 2);
-    }
-    
-    return exportData;
+    return this.reportGenerator.exportResults(
+      this.validationResults,
+      this.baselineRunner.getBaseline(),
+      this.options,
+      format
+    );
   }
 
   /**
@@ -562,64 +199,11 @@ class TestValidator {
    */
   generateReport() {
     const summary = this.getValidationSummary();
-    
-    return {
-      title: 'Test Validation Report',
-      generatedAt: new Date().toISOString(),
-      summary,
-      baseline: this.globalBaseline,
-      validations: Array.from(this.validationResults.values()),
-      recommendations: this.generateRecommendations(summary)
-    };
-  }
-
-  /**
-   * Generate recommendations based on validation results
-   */
-  generateRecommendations(summary) {
-    const recommendations = [];
-    
-    if (summary.failed > 0) {
-      recommendations.push({
-        type: 'fix_failures',
-        priority: 'high',
-        title: `Fix ${summary.failed} Failed Validations`,
-        description: 'Some refactoring operations failed validation. Review errors and fix issues.',
-        action: 'Review validation errors and fix failing tests'
-      });
-    }
-    
-    if (summary.withRegressions > 0) {
-      recommendations.push({
-        type: 'address_regressions',
-        priority: 'critical',
-        title: `Address ${summary.withRegressions} Test Regressions`,
-        description: 'Test regressions were detected. Refactoring may have broken existing functionality.',
-        action: 'Review regression details and fix broken functionality'
-      });
-    }
-    
-    if (summary.averageDuration > 30) {
-      recommendations.push({
-        type: 'optimize_performance',
-        priority: 'medium',
-        title: 'Optimize Test Performance',
-        description: 'Test validation is taking longer than expected. Consider optimizing test suite.',
-        action: 'Review test performance and optimize slow tests'
-      });
-    }
-    
-    if (summary.errors.length > 0) {
-      recommendations.push({
-        type: 'fix_errors',
-        priority: 'high',
-        title: 'Fix Validation Errors',
-        description: 'Validation errors occurred during test execution.',
-        action: 'Review error messages and fix validation issues'
-      });
-    }
-    
-    return recommendations;
+    return this.reportGenerator.generateReport(
+      this.validationResults,
+      this.baselineRunner.getBaseline(),
+      summary
+    );
   }
 }
 

package/src/refactoring/validation/baseline-runner.js

@@ -0,0 +1,71 @@
+/**
+ * Baseline Runner
+ * 
+ * Handles running baseline tests before refactoring operations.
+ */
+
+class BaselineRunner {
+  constructor(testSuites) {
+    this.testSuites = testSuites;
+    this.globalBaseline = null;
+  }
+
+  /**
+   * Run baseline tests
+   */
+  async runBaseline() {
+    console.log('Running baseline tests...');
+    
+    const startTime = Date.now();
+    const results = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      duration: 0,
+      suites: {}
+    };
+    
+    try {
+      // Run all test suites
+      for (const [name, suite] of this.testSuites) {
+        console.log(`Running ${name} tests...`);
+        const suiteResults = await suite.run();
+        
+        results.suites[name] = suiteResults;
+        results.total += suiteResults.total || 0;
+        results.passed += suiteResults.passed || 0;
+        results.failed += suiteResults.failed || 0;
+        results.skipped += suiteResults.skipped || 0;
+      }
+      
+      results.duration = (Date.now() - startTime) / 1000;
+      
+      this.globalBaseline = results;
+      
+      console.log(`Baseline completed: ${results.passed}/${results.total} passed`);
+      
+      if (results.failed > 0) {
+        console.warn(`${results.failed} baseline tests failed`);
+      }
+      
+      return results;
+      
+    } catch (error) {
+      console.error('Baseline test execution failed:', error.message);
+      throw error;
+    }
+  }
+
+  getBaseline() {
+    return this.globalBaseline;
+  }
+
+  reset() {
+    this.globalBaseline = null;
+  }
+}
+
+module.exports = {
+  BaselineRunner
+};