vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/refactoring/test-validator.js

@@ -0,0 +1,631 @@
+/**
+ * Test Validator
+ * 
+ * Validates refactoring operations by running tests and ensuring functionality is preserved.
+ * Provides comprehensive test validation and regression detection.
+ */
+
+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
+    };
+  }
+}
+
+/**
+ * Test validator class
+ */
+class TestValidator {
+  constructor(options = {}) {
+    this.options = {
+      runBaseline: true,
+      runValidation: true,
+      compareResults: true,
+      failOnRegression: true,
+      testTimeout: 60000,
+      maxRetries: 2,
+      parallelTests: true,
+      ...options
+    };
+    
+    this.testRunner = new TestRunner({
+      timeout: this.options.testTimeout,
+      retries: this.options.maxRetries
+    });
+    
+    this.testSuites = new Map();
+    this.validationResults = new Map();
+    this.globalBaseline = null;
+  }
+
+  /**
+   * Add test suite
+   */
+  addTestSuite(name, pattern, options = {}) {
+    const suite = new TestSuite(name, pattern, options);
+    this.testSuites.set(name, suite);
+    return suite;
+  }
+
+  /**
+   * Setup default test suites
+   */
+  setupDefaultTestSuites() {
+    // Unit tests
+    this.addTestSuite('unit', '**/*.test.js', {
+      timeout: 30000,
+      parallel: true
+    });
+    
+    // Integration tests
+    this.addTestSuite('integration', '**/*.integration.test.js', {
+      timeout: 60000,
+      parallel: false
+    });
+    
+    // E2E tests
+    this.addTestSuite('e2e', '**/*.e2e.test.js', {
+      timeout: 120000,
+      parallel: false
+    });
+    
+    // Refactoring-specific tests
+    this.addTestSuite('refactoring', '**/*.refactor.test.js', {
+      timeout: 45000,
+      parallel: true
+    });
+  }
+
+  /**
+   * 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;
+    }
+  }
+
+  /**
+   * Validate refactoring operation
+   */
+  async validateOperation(operationId, affectedFiles = []) {
+    const validation = new TestValidationResult(operationId);
+    const startTime = Date.now();
+    
+    try {
+      validation.setStatus(VALIDATION_STATUS.RUNNING);
+      
+      // Run validation tests
+      if (this.options.runValidation) {
+        console.log(`Running validation tests for operation: ${operationId}`);
+        
+        const validationResults = await this.runValidationTests(affectedFiles);
+        validation.setValidationResults(validationResults);
+      }
+      
+      // Compare with baseline
+      if (this.options.compareResults && this.globalBaseline) {
+        console.log('Comparing results with baseline...');
+        
+        const comparison = this.compareWithBaseline(validation.validationResults);
+        validation.setComparison(comparison);
+        
+        // Fail on regression if enabled
+        if (this.options.failOnRegression && comparison.hasRegressions) {
+          throw new Error(`Test regressions detected: ${comparison.regressions.length} failures`);
+        }
+      }
+      
+      validation.setStatus(VALIDATION_STATUS.PASSED);
+      
+    } catch (error) {
+      validation.addError(error);
+      validation.setStatus(VALIDATION_STATUS.FAILED);
+    }
+    
+    validation.setDuration((Date.now() - startTime) / 1000);
+    this.validationResults.set(operationId, validation);
+    
+    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
+   */
+  async validateOperations(operations) {
+    const results = [];
+    
+    for (const operation of operations) {
+      const result = await this.validateOperation(
+        operation.id,
+        operation.affectedFiles || []
+      );
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Check if tests are available
+   */
+  checkTestAvailability() {
+    return this.testRunner.checkTestAvailability();
+  }
+
+  /**
+   * Get test configuration
+   */
+  getTestConfiguration() {
+    return this.testRunner.getTestConfig();
+  }
+
+  /**
+   * Reset validation state
+   */
+  reset() {
+    this.validationResults.clear();
+    this.globalBaseline = 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;
+  }
+
+  /**
+   * Generate test report
+   */
+  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;
+  }
+}
+
+module.exports = {
+  TestValidator,
+  TestValidationResult,
+  TestSuite,
+  VALIDATION_STATUS
+};