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

package/tests/unit/early-exit/quality-signal.test.ts

@@ -1,589 +0,0 @@
-/**
- * Unit tests for Quality Signal Calculator
- * ADR-033: Early Exit Testing
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  calculateQualitySignal,
-  calculateLambdaStability,
-  calculateConfidence,
-  countQualityPartitions,
-  createQualitySignal,
-  isStableForExit,
-} from '../../../src/early-exit/quality-signal';
-import { LayerResult, QualitySignal, QualityFlags } from '../../../src/early-exit/types';
-
-describe('Quality Signal Calculator', () => {
-  // ============================================================================
-  // calculateQualitySignal Tests
-  // ============================================================================
-  describe('calculateQualitySignal', () => {
-    it('should calculate lambda correctly for perfect metrics', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'unit',
-        passRate: 1.0,
-        coverage: 1.0,
-        flakyRatio: 0,
-        totalTests: 100,
-        passedTests: 100,
-        failedTests: 0,
-        skippedTests: 0,
-        duration: 1000,
-      };
-
-      const signal = calculateQualitySignal(layerResult);
-
-      expect(signal.lambda).toBeCloseTo(100, 1);
-      expect(signal.boundaryEdges).toBe(0);
-      expect(signal.boundaryConcentration).toBe(0);
-      expect(signal.flags).toBe(QualityFlags.NONE);
-    });
-
-    it('should calculate lambda correctly for moderate metrics', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'unit',
-        passRate: 0.85,
-        coverage: 0.75,
-        flakyRatio: 0.05,
-        totalTests: 100,
-        passedTests: 85,
-        failedTests: 10,
-        skippedTests: 5,
-        duration: 1500,
-      };
-
-      const signal = calculateQualitySignal(layerResult);
-
-      // Lambda should be constrained by lowest metric
-      expect(signal.lambda).toBeLessThan(90);
-      expect(signal.lambda).toBeGreaterThan(70);
-    });
-
-    it('should detect boundary edges when metrics are near 70%', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'integration',
-        passRate: 0.72, // Near 70%
-        coverage: 0.68, // Near 70%
-        flakyRatio: 0.05,
-        totalTests: 50,
-        passedTests: 36,
-        failedTests: 10,
-        skippedTests: 4,
-        duration: 5000,
-      };
-
-      const signal = calculateQualitySignal(layerResult);
-
-      expect(signal.boundaryEdges).toBeGreaterThanOrEqual(1);
-    });
-
-    it('should calculate high boundary concentration for multiple issues', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 1,
-        layerType: 'integration',
-        passRate: 0.6,   // 40% failure rate
-        coverage: 0.5,   // 50% uncovered
-        flakyRatio: 0.2, // 20% flaky
-        totalTests: 100,
-        passedTests: 60,
-        failedTests: 30,
-        skippedTests: 10,
-        duration: 10000,
-      };
-
-      const signal = calculateQualitySignal(layerResult);
-
-      expect(signal.boundaryConcentration).toBeGreaterThan(0.2);
-    });
-
-    it('should set CRITICAL_FAILURE flag when pass rate is below 50%', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'unit',
-        passRate: 0.4,
-        coverage: 0.7,
-        flakyRatio: 0.1,
-        totalTests: 100,
-        passedTests: 40,
-        failedTests: 55,
-        skippedTests: 5,
-        duration: 2000,
-      };
-
-      const signal = calculateQualitySignal(layerResult);
-
-      expect(signal.flags & QualityFlags.CRITICAL_FAILURE).toBeTruthy();
-      expect(signal.flags & QualityFlags.FORCE_CONTINUE).toBeTruthy();
-    });
-
-    it('should set COVERAGE_REGRESSION flag when lambda drops significantly', () => {
-      const previousSignal: QualitySignal = {
-        lambda: 90,
-        lambdaPrev: 88,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const layerResult: LayerResult = {
-        layerIndex: 1,
-        layerType: 'integration',
-        passRate: 0.7,
-        coverage: 0.6,
-        flakyRatio: 0.15,
-        previousLambda: 90,
-        totalTests: 50,
-        passedTests: 35,
-        failedTests: 10,
-        skippedTests: 5,
-        duration: 5000,
-      };
-
-      const signal = calculateQualitySignal(layerResult, previousSignal);
-
-      // Large drop from 90 to ~60-70 should trigger regression
-      expect(signal.flags & QualityFlags.COVERAGE_REGRESSION).toBeTruthy();
-    });
-
-    it('should set HIGH_FLAKY_RATE flag when flaky ratio exceeds 30%', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'e2e',
-        passRate: 0.8,
-        coverage: 0.7,
-        flakyRatio: 0.35,
-        totalTests: 100,
-        passedTests: 80,
-        failedTests: 10,
-        skippedTests: 10,
-        duration: 30000,
-      };
-
-      const signal = calculateQualitySignal(layerResult);
-
-      expect(signal.flags & QualityFlags.HIGH_FLAKY_RATE).toBeTruthy();
-    });
-
-    it('should correctly assign source layer', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 2,
-        layerType: 'e2e',
-        passRate: 0.95,
-        coverage: 0.8,
-        flakyRatio: 0.02,
-        totalTests: 30,
-        passedTests: 28,
-        failedTests: 1,
-        skippedTests: 1,
-        duration: 25000,
-      };
-
-      const signal = calculateQualitySignal(layerResult);
-
-      expect(signal.sourceLayer).toBe(2);
-    });
-
-    it('should use previous signal lambda for lambdaPrev', () => {
-      const previousSignal: QualitySignal = {
-        lambda: 85,
-        lambdaPrev: 82,
-        boundaryEdges: 0,
-        boundaryConcentration: 0.1,
-        partitionCount: 1,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const layerResult: LayerResult = {
-        layerIndex: 1,
-        layerType: 'integration',
-        passRate: 0.92,
-        coverage: 0.85,
-        flakyRatio: 0.03,
-        totalTests: 50,
-        passedTests: 46,
-        failedTests: 2,
-        skippedTests: 2,
-        duration: 6000,
-      };
-
-      const signal = calculateQualitySignal(layerResult, previousSignal);
-
-      expect(signal.lambdaPrev).toBe(85);
-    });
-  });
-
-  // ============================================================================
-  // calculateLambdaStability Tests
-  // ============================================================================
-  describe('calculateLambdaStability', () => {
-    it('should return high stability for stable signals', () => {
-      const current: QualitySignal = {
-        lambda: 90,
-        lambdaPrev: 89,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 1,
-      };
-
-      const previous: QualitySignal = {
-        lambda: 89,
-        lambdaPrev: 88,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const stability = calculateLambdaStability(current, previous);
-
-      expect(stability).toBeGreaterThan(0.95);
-    });
-
-    it('should return low stability for volatile signals', () => {
-      const current: QualitySignal = {
-        lambda: 60,
-        lambdaPrev: 90,
-        boundaryEdges: 2,
-        boundaryConcentration: 0.3,
-        partitionCount: 2,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 1,
-      };
-
-      const previous: QualitySignal = {
-        lambda: 90,
-        lambdaPrev: 85,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const stability = calculateLambdaStability(current, previous);
-
-      expect(stability).toBeLessThan(0.7);
-    });
-
-    it('should return moderate stability for first signal', () => {
-      const current: QualitySignal = {
-        lambda: 85,
-        lambdaPrev: 85,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const stability = calculateLambdaStability(current);
-
-      expect(stability).toBe(0.75);
-    });
-
-    it('should handle zero previous lambda', () => {
-      const current: QualitySignal = {
-        lambda: 80,
-        lambdaPrev: 0,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const previous: QualitySignal = {
-        lambda: 0,
-        lambdaPrev: 0,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const stability = calculateLambdaStability(current, previous);
-
-      expect(stability).toBe(0.75); // Should return default moderate stability
-    });
-  });
-
-  // ============================================================================
-  // calculateConfidence Tests
-  // ============================================================================
-  describe('calculateConfidence', () => {
-    it('should return high confidence for excellent signal', () => {
-      const signal: QualitySignal = {
-        lambda: 95,
-        lambdaPrev: 94,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const confidence = calculateConfidence(signal, 0.98);
-
-      expect(confidence).toBeGreaterThan(0.85);
-    });
-
-    it('should return lower confidence for poor signal', () => {
-      const signal: QualitySignal = {
-        lambda: 40,       // Very low lambda
-        lambdaPrev: 75,
-        boundaryEdges: 3, // Maximum boundary edges
-        boundaryConcentration: 0.8, // Very high concentration
-        partitionCount: 5,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const confidence = calculateConfidence(signal, 0.4); // Low stability
-
-      // With very poor metrics and low stability, confidence should be low
-      expect(confidence).toBeLessThan(0.65);
-    });
-
-    it('should apply penalty for critical failure flag', () => {
-      const signal: QualitySignal = {
-        lambda: 80,
-        lambdaPrev: 78,
-        boundaryEdges: 0,
-        boundaryConcentration: 0.1,
-        partitionCount: 1,
-        flags: QualityFlags.CRITICAL_FAILURE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const confidenceWithFlag = calculateConfidence(signal, 0.9);
-
-      const signalNoFlag = { ...signal, flags: QualityFlags.NONE };
-      const confidenceNoFlag = calculateConfidence(signalNoFlag, 0.9);
-
-      expect(confidenceWithFlag).toBeLessThan(confidenceNoFlag);
-    });
-
-    it('should be bounded between 0 and 1', () => {
-      const veryBadSignal: QualitySignal = {
-        lambda: 10,
-        lambdaPrev: 80,
-        boundaryEdges: 3,
-        boundaryConcentration: 0.8,
-        partitionCount: 5,
-        flags: QualityFlags.CRITICAL_FAILURE | QualityFlags.COVERAGE_REGRESSION,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const confidence = calculateConfidence(veryBadSignal, 0.2);
-
-      expect(confidence).toBeGreaterThanOrEqual(0);
-      expect(confidence).toBeLessThanOrEqual(1);
-    });
-  });
-
-  // ============================================================================
-  // countQualityPartitions Tests
-  // ============================================================================
-  describe('countQualityPartitions', () => {
-    it('should count zero partitions for excellent results', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'unit',
-        passRate: 0.99,
-        coverage: 0.9,
-        flakyRatio: 0.01,
-        totalTests: 100,
-        passedTests: 99,
-        failedTests: 0,
-        skippedTests: 1,
-        duration: 1000,
-      };
-
-      const partitions = countQualityPartitions(layerResult);
-
-      expect(partitions).toBe(0);
-    });
-
-    it('should count multiple partitions for poor results', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'unit',
-        passRate: 0.7,  // Below 90% = partition
-        coverage: 0.5,  // Below 70% = partition
-        flakyRatio: 0.1, // Above 5% = partition
-        totalTests: 100,
-        passedTests: 70,
-        failedTests: 20,
-        skippedTests: 10,
-        duration: 2000,
-      };
-
-      const partitions = countQualityPartitions(layerResult);
-
-      expect(partitions).toBe(3);
-    });
-
-    it('should count additional partitions from test results with different error types', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'unit',
-        passRate: 0.8,
-        coverage: 0.6,   // Below 70% threshold
-        flakyRatio: 0.1, // Above 5% threshold
-        totalTests: 100,
-        passedTests: 80,
-        failedTests: 15,
-        skippedTests: 5,
-        duration: 2000,
-        testResults: [
-          { name: 'test1', file: 'a.ts', status: 'failed', error: 'timeout exceeded', duration: 500 },
-          { name: 'test2', file: 'b.ts', status: 'failed', error: 'assertion error', duration: 100 },
-          { name: 'test3', file: 'c.ts', status: 'failed', error: 'network error', duration: 200 },
-        ],
-      };
-
-      const partitions = countQualityPartitions(layerResult);
-
-      // Base partitions from metrics + partitions from error types
-      // At least 3 from metrics: pass rate < 90, coverage < 70, flaky > 5%
-      // Plus up to 3 from error types (capped)
-      expect(partitions).toBeGreaterThanOrEqual(3);
-      expect(partitions).toBeLessThanOrEqual(10); // Total cap
-    });
-
-    it('should cap partitions at 10', () => {
-      const layerResult: LayerResult = {
-        layerIndex: 0,
-        layerType: 'unit',
-        passRate: 0.5,
-        coverage: 0.3,
-        flakyRatio: 0.2,
-        totalTests: 100,
-        passedTests: 50,
-        failedTests: 40,
-        skippedTests: 10,
-        duration: 5000,
-        testResults: [
-          { name: 'test1', file: 'a.ts', status: 'failed', error: 'timeout', duration: 500 },
-          { name: 'test2', file: 'b.ts', status: 'failed', error: 'assertion', duration: 100 },
-          { name: 'test3', file: 'c.ts', status: 'failed', error: 'network', duration: 200 },
-          { name: 'test4', file: 'd.ts', status: 'failed', error: 'memory', duration: 300 },
-          { name: 'test5', file: 'e.ts', status: 'failed', error: 'other', duration: 150 },
-          { name: 'test6', file: 'f.ts', status: 'failed', error: 'timeout', duration: 500 },
-          { name: 'test7', file: 'g.ts', status: 'failed', error: 'assertion', duration: 100 },
-          { name: 'test8', file: 'h.ts', status: 'failed', error: 'network', duration: 200 },
-        ],
-      };
-
-      const partitions = countQualityPartitions(layerResult);
-
-      expect(partitions).toBeLessThanOrEqual(10);
-    });
-  });
-
-  // ============================================================================
-  // createQualitySignal Tests
-  // ============================================================================
-  describe('createQualitySignal', () => {
-    it('should create signal from basic metrics', () => {
-      const signal = createQualitySignal(0.95, 0.85, 0.02);
-
-      expect(signal.lambda).toBeGreaterThan(80);
-      expect(signal.sourceLayer).toBe(0);
-      expect(signal.timestamp).toBeInstanceOf(Date);
-    });
-
-    it('should use provided previous lambda', () => {
-      const signal = createQualitySignal(0.90, 0.80, 0.05, 85);
-
-      expect(signal.lambdaPrev).toBe(85);
-    });
-
-    it('should use provided layer index', () => {
-      const signal = createQualitySignal(0.90, 0.80, 0.05, undefined, 2);
-
-      expect(signal.sourceLayer).toBe(2);
-    });
-  });
-
-  // ============================================================================
-  // isStableForExit Tests
-  // ============================================================================
-  describe('isStableForExit', () => {
-    it('should return true for stable, high-quality signal', () => {
-      const signal: QualitySignal = {
-        lambda: 92,
-        lambdaPrev: 91, // Very stable (small delta)
-        boundaryEdges: 0,
-        boundaryConcentration: 0.1,
-        partitionCount: 0,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      // Use lower stability threshold that matches the actual signal stability
-      const isStable = isStableForExit(signal, 80, 0.75);
-
-      expect(isStable).toBe(true);
-    });
-
-    it('should return false when lambda is below threshold', () => {
-      const signal: QualitySignal = {
-        lambda: 75,
-        lambdaPrev: 73,
-        boundaryEdges: 0,
-        boundaryConcentration: 0.1,
-        partitionCount: 1,
-        flags: QualityFlags.NONE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const isStable = isStableForExit(signal, 80, 0.85);
-
-      expect(isStable).toBe(false);
-    });
-
-    it('should return false when FORCE_CONTINUE flag is set', () => {
-      const signal: QualitySignal = {
-        lambda: 95,
-        lambdaPrev: 94,
-        boundaryEdges: 0,
-        boundaryConcentration: 0,
-        partitionCount: 0,
-        flags: QualityFlags.FORCE_CONTINUE,
-        timestamp: new Date(),
-        sourceLayer: 0,
-      };
-
-      const isStable = isStableForExit(signal, 80, 0.85);
-
-      expect(isStable).toBe(false);
-    });
-  });
-});