@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/time-crystal/phase-executor.ts

@@ -1,521 +0,0 @@
-/**
- * Agentic QE v3 - Phase Executor
- * ADR-032: Time Crystal Scheduling
- *
- * Executes test phases with quality-gated progression.
- * Integrates with the test-execution domain for actual test running.
- *
- * IMPORTANT: For REAL test execution, provide a TestRunner implementation:
- * - VitestTestRunner: Executes tests via Vitest subprocess
- * - JestTestRunner: Executes tests via Jest subprocess
- *
- * See test-runner.ts for real implementations.
- * The simulateRun() method is MOCK MODE ONLY for development/testing.
- */
-
-import { TestPhase, PhaseResult, PhaseThresholds } from './types';
-
-/**
- * Test runner interface - abstracts actual test execution
- */
-export interface TestRunner {
-  /**
-   * Run tests for specified types
-   *
-   * @param testTypes - Types of tests to run
-   * @param options - Execution options
-   * @returns Test execution results
-   */
-  run(
-    testTypes: string[],
-    options: TestRunnerOptions
-  ): Promise<TestRunnerResult>;
-}
-
-/**
- * Test runner options
- */
-export interface TestRunnerOptions {
-  /** Maximum parallelism */
-  parallelism: number;
-
-  /** Timeout in milliseconds */
-  timeout: number;
-
-  /** Whether to collect coverage */
-  collectCoverage: boolean;
-
-  /** Whether to retry failed tests */
-  retryFailed: boolean;
-
-  /** Maximum retries for failed tests */
-  maxRetries: number;
-
-  /** Filter pattern for test files */
-  filter?: string;
-}
-
-/**
- * Test runner result
- */
-export interface TestRunnerResult {
-  /** Total tests discovered */
-  total: number;
-
-  /** Tests that passed */
-  passed: number;
-
-  /** Tests that failed */
-  failed: number;
-
-  /** Tests that were skipped */
-  skipped: number;
-
-  /** Tests flagged as flaky */
-  flaky: number;
-
-  /** Code coverage percentage (0-1) */
-  coverage: number;
-
-  /** Execution duration in milliseconds */
-  duration: number;
-
-  /** Detailed test results (optional) */
-  details?: TestDetail[];
-}
-
-/**
- * Individual test detail
- */
-export interface TestDetail {
-  /** Test name */
-  name: string;
-
-  /** Test file */
-  file: string;
-
-  /** Test status */
-  status: 'passed' | 'failed' | 'skipped' | 'flaky';
-
-  /** Duration in milliseconds */
-  duration: number;
-
-  /** Error message if failed */
-  error?: string;
-
-  /** Number of retries */
-  retries?: number;
-}
-
-/**
- * Phase Executor
- *
- * Executes a test phase and evaluates quality gates.
- *
- * USAGE:
- * - For REAL tests: Provide a TestRunner (VitestTestRunner or JestTestRunner)
- * - For MOCK mode: Omit the runner (uses simulateRun with fake data - dev only)
- *
- * Example with real execution:
- * ```typescript
- * import { VitestTestRunner } from './test-runner';
- *
- * const runner = new VitestTestRunner({ cwd: '/path/to/project' });
- * const executor = new PhaseExecutor(phase, runner);
- * const result = await executor.run(); // REAL test results
- * ```
- */
-export class PhaseExecutor {
-  private readonly phase: TestPhase;
-  private readonly runner?: TestRunner;
-  private readonly timeout: number;
-  private readonly mockMode: boolean;
-
-  /**
-   * Create a phase executor
-   *
-   * @param phase - The test phase to execute
-   * @param runner - Test runner for REAL execution. If omitted, uses MOCK MODE.
-   * @param timeout - Execution timeout (defaults to phase.expectedDuration * 2)
-   */
-  constructor(phase: TestPhase, runner?: TestRunner, timeout?: number) {
-    this.phase = phase;
-    this.runner = runner;
-    this.timeout = timeout ?? phase.expectedDuration * 2;
-    this.mockMode = !runner;
-
-    if (this.mockMode) {
-      console.warn(
-        `[PhaseExecutor] MOCK MODE: No TestRunner provided for phase "${phase.name}". ` +
-          `Results will be simulated with fake data. ` +
-          `For production, use VitestTestRunner or JestTestRunner from test-runner.ts`
-      );
-    }
-  }
-
-  /**
-   * Check if executor is in mock mode (no real test execution)
-   */
-  isMockMode(): boolean {
-    return this.mockMode;
-  }
-
-  /**
-   * Execute the phase
-   *
-   * @returns Phase execution result with quality gate evaluation
-   */
-  async run(): Promise<PhaseResult> {
-    const startTime = Date.now();
-
-    let runnerResult: TestRunnerResult;
-
-    if (this.runner) {
-      // Use real test runner
-      runnerResult = await this.runner.run(
-        this.phase.testTypes,
-        {
-          parallelism: this.phase.agentConfig.parallelism,
-          timeout: this.timeout,
-          collectCoverage: true,
-          retryFailed: true,
-          maxRetries: 2,
-        }
-      );
-    } else {
-      // Simulate test execution
-      runnerResult = await this.simulateRun();
-    }
-
-    const duration = Date.now() - startTime;
-
-    // Calculate metrics
-    const passRate = runnerResult.total > 0
-      ? runnerResult.passed / runnerResult.total
-      : 0;
-
-    const flakyRatio = runnerResult.total > 0
-      ? runnerResult.flaky / runnerResult.total
-      : 0;
-
-    // Evaluate quality gates
-    const qualityMet = this.evaluateQualityGates({
-      passRate,
-      flakyRatio,
-      coverage: runnerResult.coverage,
-    });
-
-    return {
-      phaseId: this.phase.id,
-      phaseName: this.phase.name,
-      passRate,
-      flakyRatio,
-      coverage: runnerResult.coverage,
-      duration,
-      testsRun: runnerResult.total,
-      testsPassed: runnerResult.passed,
-      testsFailed: runnerResult.failed,
-      testsSkipped: runnerResult.skipped,
-      qualityMet,
-    };
-  }
-
-  /**
-   * MOCK MODE: Simulate test execution with deterministic fake data.
-   *
-   * WARNING: This method returns FAKE data for development/testing only.
-   * For REAL test execution, provide a TestRunner (VitestTestRunner or JestTestRunner).
-   *
-   * The fake data is deterministic based on phase configuration to allow
-   * predictable testing of the scheduler logic without requiring actual tests.
-   */
-  private async simulateRun(): Promise<TestRunnerResult> {
-    // Simulate some execution time (shortened for fast iteration)
-    const simulatedDuration = Math.min(this.phase.expectedDuration / 10, 1000);
-    await new Promise(resolve => setTimeout(resolve, simulatedDuration));
-
-    // MOCK DATA: Deterministic values based on phase configuration
-    // No Math.random() - values are predictable for testing
-    const baseTests = this.getBaseTestCount();
-
-    // Deterministic "variance" based on phase ID to simulate different scenarios
-    const deterministicOffset = (this.phase.id % 3) * 5; // 0, 5, or 10
-    const total = baseTests + deterministicOffset;
-
-    // Deterministic pass rate based on phase type
-    const basePassRate = this.getBasePassRate();
-    const passed = Math.floor(total * basePassRate);
-    const failed = Math.floor((total - passed) * 0.8); // 80% of non-passed are failures
-    const skipped = total - passed - failed;
-
-    // Deterministic flaky count: 1 per 50 tests
-    const flaky = Math.floor(total / 50);
-
-    // Deterministic coverage based on phase type
-    const baseCoverage = this.getBaseCoverage();
-
-    return {
-      total,
-      passed,
-      failed,
-      skipped,
-      flaky,
-      coverage: baseCoverage, // No random variance - deterministic
-      duration: simulatedDuration,
-    };
-  }
-
-  /**
-   * Get base test count based on phase type
-   */
-  private getBaseTestCount(): number {
-    const typeCounts: Record<string, number> = {
-      unit: 100,
-      integration: 50,
-      e2e: 20,
-      performance: 10,
-      security: 15,
-      visual: 25,
-      accessibility: 30,
-      contract: 40,
-    };
-
-    return this.phase.testTypes.reduce(
-      (sum, type) => sum + (typeCounts[type] || 30),
-      0
-    );
-  }
-
-  /**
-   * Get base pass rate based on phase type
-   */
-  private getBasePassRate(): number {
-    // Unit tests have highest pass rate, E2E lowest
-    if (this.phase.testTypes.includes('unit')) {
-      return 0.98;
-    }
-    if (this.phase.testTypes.includes('integration')) {
-      return 0.95;
-    }
-    if (this.phase.testTypes.includes('e2e')) {
-      return 0.90;
-    }
-    return 0.93;
-  }
-
-  /**
-   * Get base coverage based on phase type
-   */
-  private getBaseCoverage(): number {
-    if (this.phase.testTypes.includes('unit')) {
-      return 0.85;
-    }
-    if (this.phase.testTypes.includes('integration')) {
-      return 0.75;
-    }
-    if (this.phase.testTypes.includes('e2e')) {
-      return 0.65;
-    }
-    return 0.60;
-  }
-
-  /**
-   * Evaluate quality gates
-   *
-   * @param metrics - Current metrics to evaluate
-   * @returns True if all quality gates pass
-   */
-  private evaluateQualityGates(metrics: {
-    passRate: number;
-    flakyRatio: number;
-    coverage: number;
-  }): boolean {
-    const thresholds = this.phase.qualityThresholds;
-
-    // Check pass rate
-    if (metrics.passRate < thresholds.minPassRate) {
-      return false;
-    }
-
-    // Check flaky ratio
-    if (metrics.flakyRatio > thresholds.maxFlakyRatio) {
-      return false;
-    }
-
-    // Check coverage
-    if (metrics.coverage < thresholds.minCoverage) {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Get the phase being executed
-   */
-  getPhase(): TestPhase {
-    return this.phase;
-  }
-}
-
-/**
- * Quality Gate Evaluator
- *
- * Standalone utility for evaluating quality gates
- */
-export class QualityGateEvaluator {
-  private readonly thresholds: PhaseThresholds;
-
-  constructor(thresholds: PhaseThresholds) {
-    this.thresholds = thresholds;
-  }
-
-  /**
-   * Evaluate a phase result against thresholds
-   */
-  evaluate(result: PhaseResult): QualityGateResult {
-    const gates: GateEvaluation[] = [];
-
-    // Pass rate gate
-    gates.push({
-      name: 'Pass Rate',
-      threshold: this.thresholds.minPassRate,
-      actual: result.passRate,
-      passed: result.passRate >= this.thresholds.minPassRate,
-      comparison: 'gte',
-    });
-
-    // Flaky ratio gate
-    gates.push({
-      name: 'Flaky Ratio',
-      threshold: this.thresholds.maxFlakyRatio,
-      actual: result.flakyRatio,
-      passed: result.flakyRatio <= this.thresholds.maxFlakyRatio,
-      comparison: 'lte',
-    });
-
-    // Coverage gate
-    gates.push({
-      name: 'Coverage',
-      threshold: this.thresholds.minCoverage,
-      actual: result.coverage,
-      passed: result.coverage >= this.thresholds.minCoverage,
-      comparison: 'gte',
-    });
-
-    const allPassed = gates.every(g => g.passed);
-    const failedGates = gates.filter(g => !g.passed);
-
-    return {
-      passed: allPassed,
-      gates,
-      failedGates,
-      summary: allPassed
-        ? 'All quality gates passed'
-        : `${failedGates.length} quality gate(s) failed: ${failedGates.map(g => g.name).join(', ')}`,
-    };
-  }
-
-  /**
-   * Create a default evaluator for a phase
-   */
-  static forPhase(phase: TestPhase): QualityGateEvaluator {
-    return new QualityGateEvaluator(phase.qualityThresholds);
-  }
-}
-
-/**
- * Quality gate evaluation result
- */
-export interface QualityGateResult {
-  /** Whether all gates passed */
-  passed: boolean;
-
-  /** Individual gate evaluations */
-  gates: GateEvaluation[];
-
-  /** Gates that failed */
-  failedGates: GateEvaluation[];
-
-  /** Human-readable summary */
-  summary: string;
-}
-
-/**
- * Individual gate evaluation
- */
-export interface GateEvaluation {
-  /** Gate name */
-  name: string;
-
-  /** Threshold value */
-  threshold: number;
-
-  /** Actual value */
-  actual: number;
-
-  /** Whether gate passed */
-  passed: boolean;
-
-  /** Comparison type */
-  comparison: 'gte' | 'lte' | 'eq';
-}
-
-/**
- * Create a mock test runner for testing
- */
-export function createMockTestRunner(
-  resultOverrides?: Partial<TestRunnerResult>
-): TestRunner {
-  return {
-    async run(
-      testTypes: string[],
-      _options: TestRunnerOptions
-    ): Promise<TestRunnerResult> {
-      // Base results on test types
-      const baseTotal = testTypes.length * 25;
-      const defaultResult: TestRunnerResult = {
-        total: baseTotal,
-        passed: Math.floor(baseTotal * 0.95),
-        failed: Math.floor(baseTotal * 0.03),
-        skipped: Math.floor(baseTotal * 0.02),
-        flaky: 1,
-        coverage: 0.85,
-        duration: 1000,
-      };
-
-      return {
-        ...defaultResult,
-        ...resultOverrides,
-      };
-    },
-  };
-}
-
-/**
- * Create a failing test runner for testing error paths
- */
-export function createFailingTestRunner(
-  passRate: number = 0.5,
-  coverage: number = 0.3
-): TestRunner {
-  return {
-    async run(
-      testTypes: string[],
-      _options: TestRunnerOptions
-    ): Promise<TestRunnerResult> {
-      const total = testTypes.length * 25;
-      const passed = Math.floor(total * passRate);
-
-      return {
-        total,
-        passed,
-        failed: total - passed,
-        skipped: 0,
-        flaky: 5,
-        coverage,
-        duration: 1000,
-      };
-    },
-  };
-}