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

package/tests/time-crystal/scheduler.test.ts

@@ -1,626 +0,0 @@
-/**
- * Agentic QE v3 - Time Crystal Scheduler Tests
- * ADR-032: Time Crystal Scheduling
- *
- * Tests for the CPG controller and self-sustaining scheduling.
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import {
-  TimeCrystalScheduler,
-  createDefaultScheduler,
-} from '../../src/time-crystal/scheduler';
-import {
-  TestPhase,
-  CPGConfig,
-  DEFAULT_CPG_CONFIG,
-  FAST_CPG_CONFIG,
-  PhaseResult,
-  TimeCrystalEvent,
-} from '../../src/time-crystal/types';
-import { DEFAULT_TEST_PHASES } from '../../src/time-crystal/default-phases';
-
-describe('TimeCrystalScheduler', () => {
-  const testPhases: TestPhase[] = [
-    {
-      id: 0,
-      name: 'Unit',
-      testTypes: ['unit'],
-      expectedDuration: 1000,
-      qualityThresholds: { minPassRate: 0.95, maxFlakyRatio: 0.05, minCoverage: 0.80 },
-      agentConfig: { agents: ['test-executor'], parallelism: 4 },
-    },
-    {
-      id: 1,
-      name: 'Integration',
-      testTypes: ['integration'],
-      expectedDuration: 2000,
-      qualityThresholds: { minPassRate: 0.90, maxFlakyRatio: 0.10, minCoverage: 0.70 },
-      agentConfig: { agents: ['test-executor'], parallelism: 2 },
-    },
-    {
-      id: 2,
-      name: 'E2E',
-      testTypes: ['e2e'],
-      expectedDuration: 3000,
-      qualityThresholds: { minPassRate: 0.85, maxFlakyRatio: 0.15, minCoverage: 0.60 },
-      agentConfig: { agents: ['test-executor'], parallelism: 1 },
-    },
-  ];
-
-  const fastConfig: CPGConfig = {
-    numPhases: 3,
-    frequency: 10, // Very fast for testing
-    coupling: 0.3,
-    stabilityThreshold: 0.1,
-    dt: 1,
-    transitionThreshold: 0.5,
-  };
-
-  describe('constructor', () => {
-    it('should create scheduler with phases and config', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      expect(scheduler.getPhases()).toHaveLength(3);
-      expect(scheduler.getCurrentPhaseIndex()).toBe(0);
-      expect(scheduler.getConfig().numPhases).toBe(3);
-    });
-
-    it('should use default config if not provided', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases);
-
-      expect(scheduler.getConfig().coupling).toBe(DEFAULT_CPG_CONFIG.coupling);
-    });
-
-    it('should throw on empty phases array', () => {
-      expect(() => new TimeCrystalScheduler([])).toThrow('At least one test phase is required');
-    });
-
-    it('should override numPhases in config with actual phase count', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, { ...fastConfig, numPhases: 10 });
-
-      expect(scheduler.getConfig().numPhases).toBe(3);
-    });
-  });
-
-  describe('tick', () => {
-    it('should advance time on tick', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      const initialTime = scheduler.getTime();
-
-      // Need to set running state for tick to work
-      scheduler.runTicks(1);
-
-      expect(scheduler.getTime()).toBe(initialTime + fastConfig.dt);
-    });
-
-    it('should return null when no transition occurs', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, {
-        ...fastConfig,
-        transitionThreshold: 0.99, // High threshold prevents transitions
-      });
-
-      const transition = scheduler.runTicks(1)[0];
-
-      expect(transition).toBeUndefined();
-    });
-
-    it('should detect phase transitions', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      // Run many ticks to get transitions
-      const transitions = scheduler.runTicks(200);
-
-      expect(transitions.length).toBeGreaterThan(0);
-    });
-
-    it('should return correct transition data', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      const transitions = scheduler.runTicks(500);
-      const transition = transitions[0];
-
-      if (transition) {
-        expect(transition.from).toBeDefined();
-        expect(transition.to).toBeDefined();
-        expect(transition.fromPhase).toBeDefined();
-        expect(transition.toPhase).toBeDefined();
-        expect(transition.timestamp).toBeGreaterThan(0);
-        expect(transition.from).not.toBe(transition.to);
-      }
-    });
-
-    it('should cycle through all phases', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      // Run enough ticks for multiple cycles
-      scheduler.runTicks(1000);
-
-      const state = scheduler.getState();
-
-      // Should have visited all phases
-      const uniquePhases = new Set(state.phaseHistory);
-      expect(uniquePhases.size).toBe(3);
-    });
-  });
-
-  describe('runTicks', () => {
-    it('should run specified number of ticks', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      scheduler.runTicks(100);
-
-      expect(scheduler.getTime()).toBe(100 * fastConfig.dt);
-    });
-
-    it('should collect all transitions', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      const transitions = scheduler.runTicks(500);
-
-      // Should have multiple transitions in 500 ticks with fast config
-      expect(transitions.length).toBeGreaterThan(2);
-    });
-
-    it('should maintain running state', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      expect(scheduler.isRunning()).toBe(false);
-      scheduler.runTicks(10);
-      expect(scheduler.isRunning()).toBe(false); // Should restore original state
-    });
-  });
-
-  describe('start/stop', () => {
-    it('should set running state', async () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      expect(scheduler.isRunning()).toBe(false);
-
-      // Start in background and immediately stop
-      const startPromise = scheduler.start();
-      expect(scheduler.isRunning()).toBe(true);
-
-      scheduler.stop();
-      await startPromise;
-
-      expect(scheduler.isRunning()).toBe(false);
-    });
-
-    it('should not restart if already running', async () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      const promise1 = scheduler.start();
-      const promise2 = scheduler.start(); // Should return immediately
-
-      scheduler.stop();
-      await Promise.all([promise1, promise2]);
-
-      expect(scheduler.isRunning()).toBe(false);
-    });
-  });
-
-  describe('pause/resume', () => {
-    it('should pause and resume', async () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      const startPromise = scheduler.start();
-
-      scheduler.pause();
-      expect(scheduler.isPaused()).toBe(true);
-
-      const pausedTime = scheduler.getTime();
-      await new Promise(resolve => setTimeout(resolve, 50));
-
-      // Time should not advance while paused
-      expect(scheduler.getTime()).toBe(pausedTime);
-
-      scheduler.resume();
-      expect(scheduler.isPaused()).toBe(false);
-
-      scheduler.stop();
-      await startPromise;
-    });
-  });
-
-  describe('getCurrentPhase', () => {
-    it('should return current phase', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      const phase = scheduler.getCurrentPhase();
-
-      expect(phase).toBe(testPhases[0]);
-      expect(phase.name).toBe('Unit');
-    });
-  });
-
-  describe('getState', () => {
-    it('should return complete scheduler state', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      scheduler.runTicks(100);
-
-      const state = scheduler.getState();
-
-      expect(state.running).toBe(false);
-      expect(state.time).toBe(100 * fastConfig.dt);
-      expect(state.currentPhase).toBeDefined();
-      expect(state.phaseHistory).toBeDefined();
-      expect(state.oscillatorStates).toHaveLength(3);
-      expect(typeof state.isStable).toBe('boolean');
-    });
-
-    it('should include oscillator states', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      scheduler.runTicks(50);
-
-      const state = scheduler.getState();
-      const oscState = state.oscillatorStates[0];
-
-      expect(oscState.id).toBe(0);
-      expect(typeof oscState.phase).toBe('number');
-      expect(typeof oscState.omega).toBe('number');
-      expect(typeof oscState.amplitude).toBe('number');
-      expect(typeof oscState.activity).toBe('number');
-    });
-  });
-
-  describe('isStable', () => {
-    it('should return false with insufficient history', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      expect(scheduler.isStable()).toBe(false);
-    });
-
-    it('should detect stable periodic behavior', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      // Run enough ticks for multiple complete cycles
-      scheduler.runTicks(2000);
-
-      // After many cycles, should stabilize
-      const state = scheduler.getState();
-
-      // Check if we have enough history for stability check
-      if (state.phaseHistory.length >= 6) {
-        // May or may not be stable depending on oscillator dynamics
-        expect(typeof state.isStable).toBe('boolean');
-      }
-    });
-  });
-
-  describe('getHealth', () => {
-    it('should return health metrics', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      scheduler.runTicks(100);
-
-      const health = scheduler.getHealth();
-
-      expect(['healthy', 'degraded', 'unstable', 'broken']).toContain(health.status);
-      expect(typeof health.synchronized).toBe('boolean');
-      expect(health.orderParameter).toBeGreaterThanOrEqual(0);
-      expect(health.orderParameter).toBeLessThanOrEqual(1);
-      expect(health.coherence).toBeGreaterThanOrEqual(0);
-      expect(health.coherence).toBeLessThanOrEqual(1);
-      expect(health.completedCycles).toBeGreaterThanOrEqual(0);
-      expect(Array.isArray(health.issues)).toBe(true);
-    });
-
-    it('should detect synchronization', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      scheduler.runTicks(500);
-
-      const health = scheduler.getHealth();
-
-      // Order parameter should be reasonable
-      expect(health.orderParameter).toBeDefined();
-    });
-  });
-
-  describe('getOrderParameter', () => {
-    it('should return order parameter', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      scheduler.runTicks(100);
-
-      const r = scheduler.getOrderParameter();
-
-      expect(r).toBeGreaterThanOrEqual(0);
-      expect(r).toBeLessThanOrEqual(1);
-    });
-  });
-
-  describe('setCouplingStrength', () => {
-    it('should update coupling strength', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      scheduler.setCouplingStrength(0.8);
-
-      // Run and verify dynamics are affected
-      scheduler.runTicks(100);
-      // Should still work with new coupling
-      expect(scheduler.getTime()).toBeGreaterThan(0);
-    });
-  });
-
-  describe('forcePhaseTransition', () => {
-    it('should force transition to specified phase', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      scheduler.forcePhaseTransition(2);
-
-      expect(scheduler.getCurrentPhaseIndex()).toBe(2);
-      expect(scheduler.getCurrentPhase().name).toBe('E2E');
-    });
-
-    it('should throw on invalid phase index', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      expect(() => scheduler.forcePhaseTransition(-1)).toThrow('Invalid phase');
-      expect(() => scheduler.forcePhaseTransition(5)).toThrow('Invalid phase');
-    });
-
-    it('should update phase history', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      scheduler.forcePhaseTransition(1);
-
-      const state = scheduler.getState();
-      expect(state.phaseHistory).toContain(1);
-    });
-  });
-
-  describe('event handling', () => {
-    it('should emit events on tick', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      const events: TimeCrystalEvent[] = [];
-
-      scheduler.on((event) => events.push(event));
-      scheduler.runTicks(10);
-
-      expect(events.length).toBeGreaterThan(0);
-      expect(events.some(e => e.type === 'crystal:tick')).toBe(true);
-    });
-
-    it('should emit transition events', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      const events: TimeCrystalEvent[] = [];
-
-      scheduler.on((event) => events.push(event));
-      scheduler.runTicks(500);
-
-      expect(events.some(e => e.type === 'phase:transition')).toBe(true);
-    });
-
-    it('should allow removing event handlers', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-      const events: TimeCrystalEvent[] = [];
-      const handler = (event: TimeCrystalEvent) => events.push(event);
-
-      scheduler.on(handler);
-      scheduler.runTicks(10);
-      const countWithHandler = events.length;
-
-      scheduler.off(handler);
-      scheduler.runTicks(10);
-
-      // No new events after removing handler
-      expect(events.length).toBe(countWithHandler);
-    });
-  });
-
-  describe('phase execution', () => {
-    it('should execute phase with callback', async () => {
-      const executedPhases: string[] = [];
-
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig, {
-        onPhaseExecute: async (phase) => {
-          executedPhases.push(phase.name);
-          return {
-            phaseId: phase.id,
-            phaseName: phase.name,
-            passRate: 0.98,
-            flakyRatio: 0.01,
-            coverage: 0.85,
-            duration: 100,
-            testsRun: 50,
-            testsPassed: 49,
-            testsFailed: 1,
-            testsSkipped: 0,
-            qualityMet: true,
-          };
-        },
-      });
-
-      const result = await scheduler.executePhase(testPhases[0]);
-
-      expect(executedPhases).toContain('Unit');
-      expect(result.qualityMet).toBe(true);
-    });
-
-    it('should handle quality failure', async () => {
-      let failureDetected = false;
-
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig, {
-        onPhaseExecute: async (phase) => ({
-          phaseId: phase.id,
-          phaseName: phase.name,
-          passRate: 0.5, // Below threshold
-          flakyRatio: 0.2,
-          coverage: 0.3,
-          duration: 100,
-          testsRun: 50,
-          testsPassed: 25,
-          testsFailed: 25,
-          testsSkipped: 0,
-          qualityMet: false,
-        }),
-        onQualityFailure: async () => {
-          failureDetected = true;
-        },
-      });
-
-      await scheduler.executePhase(testPhases[0]);
-
-      expect(failureDetected).toBe(true);
-    });
-  });
-
-  describe('getPhaseResults', () => {
-    it('should track phase results', async () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      await scheduler.executePhase(testPhases[0]);
-      await scheduler.executePhase(testPhases[0]);
-
-      const results = scheduler.getPhaseResults(0);
-
-      expect(results.length).toBe(2);
-    });
-
-    it('should return empty array for unexecuted phase', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      const results = scheduler.getPhaseResults(2);
-
-      expect(results).toHaveLength(0);
-    });
-  });
-
-  describe('repairCrystal', () => {
-    it('should reset oscillators', async () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      // Run to desynchronize
-      scheduler.runTicks(500);
-      const beforeRepair = scheduler.getOrderParameter();
-
-      await scheduler.repairCrystal();
-
-      // After repair, oscillators should be re-synchronized
-      const afterRepair = scheduler.getOrderParameter();
-
-      // Order parameter may change after repair
-      expect(typeof afterRepair).toBe('number');
-    });
-  });
-
-  describe('getCycleCount', () => {
-    it('should count completed cycles', () => {
-      const scheduler = new TimeCrystalScheduler(testPhases, fastConfig);
-
-      expect(scheduler.getCycleCount()).toBe(0);
-
-      // Run enough to complete cycles
-      scheduler.runTicks(2000);
-
-      // May or may not have completed cycles depending on dynamics
-      expect(scheduler.getCycleCount()).toBeGreaterThanOrEqual(0);
-    });
-  });
-});
-
-describe('createDefaultScheduler', () => {
-  it('should create scheduler with default phases', () => {
-    const scheduler = createDefaultScheduler();
-
-    expect(scheduler.getPhases()).toHaveLength(4);
-    expect(scheduler.getPhases()[0].name).toBe('Unit');
-    expect(scheduler.getPhases()[1].name).toBe('Integration');
-    expect(scheduler.getPhases()[2].name).toBe('E2E');
-    expect(scheduler.getPhases()[3].name).toBe('Performance');
-  });
-
-  it('should accept custom config', () => {
-    const scheduler = createDefaultScheduler(FAST_CPG_CONFIG);
-
-    expect(scheduler.getConfig().frequency).toBe(FAST_CPG_CONFIG.frequency);
-  });
-
-  it('should accept custom options', () => {
-    let transitionCount = 0;
-
-    const scheduler = createDefaultScheduler(FAST_CPG_CONFIG, {
-      onPhaseTransition: async () => {
-        transitionCount++;
-      },
-    });
-
-    scheduler.runTicks(100);
-
-    // Callback should be set
-    expect(scheduler.getPhases()).toBeDefined();
-  });
-});
-
-describe('Integration: Full scheduling cycle', () => {
-  it('should complete multiple test cycles', () => {
-    const scheduler = new TimeCrystalScheduler(
-      [
-        {
-          id: 0,
-          name: 'Fast',
-          testTypes: ['unit'],
-          expectedDuration: 100,
-          qualityThresholds: { minPassRate: 0.9, maxFlakyRatio: 0.1, minCoverage: 0.7 },
-          agentConfig: { agents: ['executor'], parallelism: 4 },
-        },
-        {
-          id: 1,
-          name: 'Slow',
-          testTypes: ['e2e'],
-          expectedDuration: 200,
-          qualityThresholds: { minPassRate: 0.8, maxFlakyRatio: 0.2, minCoverage: 0.5 },
-          agentConfig: { agents: ['executor'], parallelism: 1 },
-        },
-      ],
-      {
-        numPhases: 2,
-        frequency: 50, // Higher frequency for more transitions
-        coupling: 0.4,
-        stabilityThreshold: 0.1,
-        dt: 1,
-        transitionThreshold: 0.4, // Lower threshold for easier transitions
-      }
-    );
-
-    // Run for extended period
-    const transitions = scheduler.runTicks(5000);
-
-    // Should have multiple transitions (at least 3)
-    expect(transitions.length).toBeGreaterThanOrEqual(3);
-
-    // Should visit both phases
-    const visitedPhases = new Set(transitions.map(t => t.to));
-    expect(visitedPhases.size).toBe(2);
-
-    // Health should be reasonable
-    const health = scheduler.getHealth();
-    expect(health.orderParameter).toBeGreaterThan(0);
-  });
-
-  it('should maintain phase order in crystal pattern', () => {
-    // Use 2 phases for simpler dynamics (alternating pattern)
-    const twoPhases = DEFAULT_TEST_PHASES.slice(0, 2);
-    const scheduler = new TimeCrystalScheduler(twoPhases, {
-      numPhases: 2,
-      frequency: 50, // High frequency for fast oscillation
-      coupling: 0.5, // Strong coupling
-      stabilityThreshold: 0.1,
-      dt: 1,
-      transitionThreshold: 0.3, // Low threshold for easy transitions
-    });
-
-    const transitions = scheduler.runTicks(5000);
-
-    // With 2 phases, all transitions should alternate (0->1, 1->0)
-    // which means every transition is "sequential" in a ring
-    if (transitions.length >= 2) {
-      // Verify we have transitions between both phases
-      const transitionTypes = new Set(transitions.map(t => `${t.from}->${t.to}`));
-      expect(transitionTypes.size).toBeGreaterThanOrEqual(1);
-
-      // Verify health is reasonable
-      const health = scheduler.getHealth();
-      expect(health.orderParameter).toBeGreaterThan(0);
-    }
-  });
-});