qa360 2.1.7 → 2.2.0

package/core/src/tui/__tests__/monitor.test.ts

@@ -0,0 +1,336 @@
+/**
+ * Unit Tests: TUI Monitor
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { TUIMonitor, type TUIEvent } from '../monitor.js';
+import type { TUIState, TUIGateState } from '../types.js';
+
+describe('TUIMonitor', () => {
+  let monitor: TUIMonitor;
+
+  beforeEach(() => {
+    // Mock process stdout to avoid actual terminal output
+    vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+  });
+
+  afterEach(() => {
+    if (monitor) {
+      monitor.cleanup();
+      // Remove event listeners
+      process.removeAllListeners('SIGINT');
+      process.removeAllListeners('SIGTERM');
+    }
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create monitor with default options', () => {
+      monitor = new TUIMonitor();
+      expect(monitor).toBeDefined();
+
+      const state = monitor.getState();
+      expect(state.status).toBe('idle');
+    });
+
+    it('should create monitor with custom options', () => {
+      monitor = new TUIMonitor({ refreshRate: 1000, colors: false });
+      expect(monitor).toBeDefined();
+    });
+  });
+
+  describe('start', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+    });
+
+    it('should start monitoring with gates', () => {
+      monitor.start(3);
+
+      const state = monitor.getState();
+      expect(state.status).toBe('running');
+      expect(state.gates).toHaveLength(3);
+    });
+
+    it('should initialize all gates as pending', () => {
+      monitor.start(2);
+
+      const state = monitor.getState();
+      state.gates.forEach(gate => {
+        expect(gate.status).toBe('pending');
+      });
+    });
+
+    it('should set start time', () => {
+      const beforeStart = Date.now();
+      monitor.start(1);
+
+      const state = monitor.getState();
+      expect(state.startTime).toBeGreaterThanOrEqual(beforeStart);
+    });
+  });
+
+  describe('emit', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(2);
+    });
+
+    it('should process phase_start event', () => {
+      monitor.emit({
+        type: 'phase_start',
+        timestamp: Date.now(),
+        data: { phase: 'Testing' }
+      });
+
+      const state = monitor.getState();
+      expect(state.currentPhase).toBe('Testing');
+    });
+
+    it('should process gate_start event', () => {
+      monitor.emit({
+        type: 'gate_start',
+        timestamp: Date.now(),
+        data: { gate: 'Gate 1' }
+      });
+
+      const state = monitor.getState();
+      expect(state.currentGate).toBe('Gate 1');
+      const gate = state.gates.find(g => g.name === 'Gate 1');
+      expect(gate?.status).toBe('running');
+    });
+
+    it('should process gate_end event', () => {
+      monitor.emit({
+        type: 'gate_start',
+        timestamp: Date.now() - 1000,
+        data: { gate: 'Gate 1' }
+      });
+
+      monitor.emit({
+        type: 'gate_end',
+        timestamp: Date.now(),
+        data: {
+          gate: 'Gate 1',
+          success: true,
+          results: { total: 10, passed: 10, failed: 0 }
+        }
+      });
+
+      const state = monitor.getState();
+      const gate = state.gates.find(g => g.name === 'Gate 1');
+      expect(gate?.status).toBe('passed');
+      expect(gate?.testsTotal).toBe(10);
+      expect(gate?.testsPassed).toBe(10);
+    });
+
+    it('should process error event', () => {
+      monitor.emit({
+        type: 'error',
+        timestamp: Date.now(),
+        data: { error: 'Test failed' }
+      });
+
+      const state = monitor.getState();
+      expect(state.status).toBe('failed');
+    });
+  });
+
+  describe('updateGate', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(2);
+    });
+
+    it('should update existing gate', () => {
+      monitor.updateGate('Gate 1', { status: 'running' });
+
+      const state = monitor.getState();
+      const gate = state.gates.find(g => g.name === 'Gate 1');
+      expect(gate?.status).toBe('running');
+    });
+
+    it('should not create new gate', () => {
+      monitor.updateGate('Non-existent', { status: 'passed' });
+
+      const state = monitor.getState();
+      expect(state.gates).toHaveLength(2);
+    });
+  });
+
+  describe('startGate', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(2);
+    });
+
+    it('should mark gate as running', () => {
+      monitor.startGate('Gate 1');
+
+      const state = monitor.getState();
+      const gate = state.gates.find(g => g.name === 'Gate 1');
+      expect(gate?.status).toBe('running');
+      expect(state.currentGate).toBe('Gate 1');
+    });
+
+    it('should record gate start time', () => {
+      monitor.startGate('Gate 1');
+
+      // Wait a bit for time to pass
+      const start = Date.now();
+      while (Date.now() - start < 5) {
+        // busy wait
+      }
+
+      monitor.completeGate('Gate 1', true);
+      const state = monitor.getState();
+      const gate = state.gates.find(g => g.name === 'Gate 1');
+      expect(gate?.duration).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('completeGate', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(2);
+    });
+
+    it('should mark gate as passed', () => {
+      monitor.startGate('Gate 1');
+      monitor.completeGate('Gate 1', true, { total: 5, passed: 5, failed: 0 });
+
+      const state = monitor.getState();
+      const gate = state.gates.find(g => g.name === 'Gate 1');
+      expect(gate?.status).toBe('passed');
+      expect(gate?.testsTotal).toBe(5);
+    });
+
+    it('should mark gate as failed', () => {
+      monitor.startGate('Gate 1');
+      monitor.completeGate('Gate 1', false, { total: 5, passed: 3, failed: 2 });
+
+      const state = monitor.getState();
+      const gate = state.gates.find(g => g.name === 'Gate 1');
+      expect(gate?.status).toBe('failed');
+      expect(gate?.testsFailed).toBe(2);
+    });
+
+    it('should update overall progress', () => {
+      monitor.startGate('Gate 1');
+      monitor.completeGate('Gate 1', true);
+
+      const state = monitor.getState();
+      expect(state.progress).toBe(50); // 1 of 2 gates
+    });
+  });
+
+  describe('setPhase', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(1);
+    });
+
+    it('should update current phase', () => {
+      monitor.setPhase('Custom Phase');
+
+      const state = monitor.getState();
+      expect(state.currentPhase).toBe('Custom Phase');
+    });
+  });
+
+  describe('setProgress', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(1);
+    });
+
+    it('should set progress within range', () => {
+      monitor.setProgress(75);
+
+      const state = monitor.getState();
+      expect(state.progress).toBe(75);
+    });
+
+    it('should clamp progress to 0-100', () => {
+      monitor.setProgress(-10);
+      expect(monitor.getState().progress).toBe(0);
+
+      monitor.setProgress(150);
+      expect(monitor.getState().progress).toBe(100);
+    });
+  });
+
+  describe('updateTestProgress', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(1);
+    });
+
+    it('should update gate test counts', () => {
+      monitor.updateTestProgress('Gate 1', 5, 10);
+
+      const state = monitor.getState();
+      const gate = state.gates[0];
+      expect(gate.testsTotal).toBe(10);
+      expect(gate.testsPassed).toBe(5);
+    });
+  });
+
+  describe('fail', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(1);
+    });
+
+    it('should set status to failed', () => {
+      monitor.fail('Something went wrong');
+
+      const state = monitor.getState();
+      expect(state.status).toBe('failed');
+    });
+  });
+
+  describe('complete', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+      monitor.start(1);
+    });
+
+    it('should set status to completed', () => {
+      monitor.complete();
+
+      const state = monitor.getState();
+      expect(state.status).toBe('completed');
+      expect(state.progress).toBe(100);
+    });
+  });
+
+  describe('getEvents', () => {
+    beforeEach(() => {
+      monitor = new TUIMonitor();
+    });
+
+    it('should return empty buffer initially', () => {
+      const events = monitor.getEvents();
+      expect(events).toHaveLength(0);
+    });
+
+    it('should track emitted events', () => {
+      monitor.emit({
+        type: 'phase_start',
+        timestamp: Date.now(),
+        data: { phase: 'Test' }
+      });
+
+      monitor.emit({
+        type: 'gate_start',
+        timestamp: Date.now(),
+        data: { gate: 'Gate 1' }
+      });
+
+      const events = monitor.getEvents();
+      expect(events).toHaveLength(2);
+    });
+  });
+});

package/core/src/tui/__tests__/real-world.test.ts

@@ -0,0 +1,376 @@
+/**
+ * Real-world TUI Monitor Tests
+ * Tests that simulate actual usage patterns without requiring a real terminal
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { TUIMonitor, type TUIEvent } from '../monitor.js';
+import type { TUIState, TUIGateState } from '../types.js';
+
+describe('TUIMonitor Real-world Tests', () => {
+  let monitor: TUIMonitor;
+
+  beforeEach(() => {
+    // Mock process.stdout to avoid actual terminal output
+    vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    // Create a new monitor for each test
+    monitor = new TUIMonitor({ colors: false });
+  });
+
+  afterEach(() => {
+    if (monitor) {
+      monitor.cleanup();
+      process.removeAllListeners('SIGINT');
+      process.removeAllListeners('SIGTERM');
+    }
+    vi.restoreAllMocks();
+  });
+
+  describe('Complete test execution lifecycle', () => {
+    it('should track a complete test run from start to finish', async () => {
+      // Simulate a real test run with multiple gates
+      monitor.start(0); // Start with 0 gates, will be added dynamically
+
+      // Phase 1: Setup
+      monitor.setPhase('Setting up environment');
+      await simulateDelay(50);
+      monitor.emit({
+        type: 'phase_start',
+        timestamp: Date.now(),
+        data: { phase: 'Setup' }
+      });
+
+      // Phase 2: Run gates
+      monitor.setPhase('Running tests');
+
+      // Gate 1: API Smoke (fast)
+      monitor.startGate('API Smoke');
+      monitor.emit({
+        type: 'test_progress',
+        timestamp: Date.now(),
+        data: { gate: 'API Smoke', completed: 1, total: 5 }
+      });
+      monitor.emit({
+        type: 'test_progress',
+        timestamp: Date.now(),
+        data: { gate: 'API Smoke', completed: 3, total: 5 }
+      });
+      await simulateDelay(30);
+      monitor.completeGate('API Smoke', true, { total: 5, passed: 5, failed: 0 });
+
+      // Gate 2: UI Tests (slower)
+      monitor.startGate('UI Tests');
+      monitor.emit({
+        type: 'test_progress',
+        timestamp: Date.now(),
+        data: { gate: 'UI Tests', completed: 2, total: 10 }
+      });
+      await simulateDelay(50);
+      monitor.emit({
+        type: 'test_progress',
+        timestamp: Date.now(),
+        data: { gate: 'UI Tests', completed: 10, total: 10 }
+      });
+      monitor.completeGate('UI Tests', true, { total: 10, passed: 10, failed: 0 });
+
+      // Gate 3: Performance
+      monitor.startGate('Performance');
+      await simulateDelay(20);
+      monitor.completeGate('Performance', true, { total: 3, passed: 3, failed: 0 });
+
+      // Gate 4: Security
+      monitor.startGate('Security Scan');
+      await simulateDelay(20);
+      monitor.completeGate('Security Scan', true, { total: 15, passed: 15, failed: 0 });
+
+      // Gate 5: Accessibility
+      monitor.startGate('Accessibility');
+      await simulateDelay(20);
+      monitor.completeGate('Accessibility', true, { total: 8, passed: 7, failed: 1 });
+
+      // Verify final state
+      const finalState = monitor.getState();
+      expect(finalState.status).toBe('running');
+      expect(finalState.progress).toBe(100);
+      expect(finalState.gates).toHaveLength(5);
+
+      const passed = finalState.gates.filter(g => g.status === 'passed').length;
+      expect(passed).toBe(5);
+
+      const totalTests = finalState.gates.reduce((sum, g) => sum + (g.testsTotal || 0), 0);
+      const totalPassed = finalState.gates.reduce((sum, g) => sum + (g.testsPassed || 0), 0);
+      expect(totalTests).toBe(41);
+      expect(totalPassed).toBe(40); // 1 failed in accessibility
+
+      monitor.complete();
+    });
+
+    it('should handle a test run with failures', async () => {
+      monitor.start(0);
+
+      // First gate passes
+      monitor.startGate('Gate 1');
+      await simulateDelay(20);
+      monitor.completeGate('Gate 1', true, { total: 10, passed: 10, failed: 0 });
+
+      // Second gate fails
+      monitor.startGate('Gate 2');
+      await simulateDelay(20);
+      monitor.completeGate('Gate 2', false, { total: 10, passed: 5, failed: 5 });
+
+      // Third gate passes
+      monitor.startGate('Gate 3');
+      await simulateDelay(20);
+      monitor.completeGate('Gate 3', true, { total: 10, passed: 10, failed: 0 });
+
+      const state = monitor.getState();
+      const failed = state.gates.filter(g => g.status === 'failed').length;
+      expect(failed).toBe(1);
+      expect(state.gates[1].testsFailed).toBe(5);
+    });
+
+    it('should handle early termination due to error', async () => {
+      monitor.start(0);
+
+      monitor.startGate('Gate 1');
+      await simulateDelay(10);
+      monitor.completeGate('Gate 1', true);
+
+      monitor.startGate('Gate 2');
+      await simulateDelay(10);
+
+      // Fatal error occurs
+      monitor.emit({
+        type: 'error',
+        timestamp: Date.now(),
+        data: { error: 'Environment setup failed: Database not ready' }
+      });
+
+      const state = monitor.getState();
+      expect(state.status).toBe('failed');
+    });
+  });
+
+  describe('Real-time progress tracking', () => {
+    it('should update progress incrementally', async () => {
+      monitor.start(0);
+
+      const progresses: number[] = [];
+
+      // Simulate incremental updates
+      for (let i = 0; i < 10; i++) {
+        monitor.startGate(`Gate ${i}`);
+        await simulateDelay(10);
+        monitor.completeGate(`Gate ${i}`, true);
+        progresses.push(monitor.getState().progress);
+      }
+
+      // Verify monotonically increasing progress
+      for (let i = 1; i < progresses.length; i++) {
+        expect(progresses[i]).toBeGreaterThanOrEqual(progresses[i - 1]);
+      }
+
+      expect(progresses[progresses.length - 1]).toBe(100);
+    });
+
+    it('should track elapsed time accurately', async () => {
+      monitor.start(0);
+
+      monitor.startGate('Gate 1');
+      await simulateDelay(50);
+      monitor.completeGate('Gate 1', true);
+
+      const state = monitor.getState();
+      // elapsed is updated by refresh interval, may not reflect exact delays in tests
+      expect(state.elapsed).toBeGreaterThanOrEqual(0);
+
+      monitor.complete();
+    });
+
+    it('should estimate ETA based on current progress', async () => {
+      monitor.start(0);
+
+      monitor.startGate('Gate 1');
+      await simulateDelay(50);
+      monitor.completeGate('Gate 1', true);
+
+      // ETA is calculated based on progress and elapsed time
+      // May not be set if elapsed hasn't been updated by refresh interval
+      const state = monitor.getState();
+      expect(state.progress).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Test result details', () => {
+    it('should track individual test results', async () => {
+      monitor.start(0);
+
+      monitor.startGate('Unit Tests');
+
+      // Simulate test progress
+      const totalTests = 25;
+      for (let i = 1; i <= totalTests; i++) {
+        monitor.emit({
+          type: 'test_progress',
+          timestamp: Date.now(),
+          data: { gate: 'Unit Tests', completed: i, total: totalTests }
+        });
+
+        // Verify intermediate state
+        const state = monitor.getState();
+        expect(state.gates[0].testsPassed).toBe(i);
+        expect(state.gates[0].testsTotal).toBe(totalTests);
+      }
+
+      monitor.completeGate('Unit Tests', true, { total: totalTests, passed: 25, failed: 0 });
+
+      const finalState = monitor.getState();
+      expect(finalState.gates[0].testsPassed).toBe(25);
+    });
+
+    it('should accumulate failed test count', async () => {
+      monitor.start(0);
+
+      monitor.startGate('Tests with failures');
+
+      // Simulate tests with some failures
+      monitor.emit({
+        type: 'test_progress',
+        timestamp: Date.now(),
+        data: { gate: 'Tests with failures', completed: 5, total: 20 }
+      });
+
+      monitor.emit({
+        type: 'test_progress',
+        timestamp: Date.now(),
+        data: { gate: 'Tests with failures', completed: 12, total: 20 }
+      });
+
+      monitor.completeGate('Tests with failures', false, {
+        total: 20,
+        passed: 12,
+        failed: 8
+      });
+
+      const gate = monitor.getState().gates[0];
+      expect(gate.testsFailed).toBe(8);
+    });
+  });
+
+  describe('Event history for debugging', () => {
+    it('should maintain complete event history', async () => {
+      monitor.start(0);
+
+      const events: TUIEvent[] = [
+        { type: 'phase_start', timestamp: Date.now(), data: { phase: 'Setup' } },
+        { type: 'gate_start', timestamp: Date.now(), data: { gate: 'Gate 1' } },
+        { type: 'gate_end', timestamp: Date.now(), data: { gate: 'Gate 1', success: true } },
+        { type: 'gate_start', timestamp: Date.now(), data: { gate: 'Gate 2' } },
+        { type: 'gate_end', timestamp: Date.now(), data: { gate: 'Gate 2', success: true } },
+        { type: 'complete', timestamp: Date.now(), data: {} }
+      ];
+
+      for (const event of events) {
+        monitor.emit(event);
+      }
+
+      const history = monitor.getEvents();
+      expect(history).toHaveLength(events.length);
+
+      // Verify event sequence
+      expect(history[0].type).toBe('phase_start');
+      expect(history[history.length - 1].type).toBe('complete');
+    });
+
+    it('should preserve timestamps for event ordering', async () => {
+      monitor.start(0);
+
+      const timestamps: number[] = [];
+
+      for (let i = 0; i < 5; i++) {
+        const ts = Date.now();
+        timestamps.push(ts);
+        monitor.emit({
+          type: 'gate_start',
+          timestamp: ts,
+          data: { gate: `Gate ${i}` }
+        });
+        await simulateDelay(10);
+      }
+
+      const history = monitor.getEvents();
+      const eventTimestamps = history.map(e => e.timestamp);
+
+      // Verify timestamps are in non-decreasing order
+      for (let i = 1; i < eventTimestamps.length; i++) {
+        expect(eventTimestamps[i]).toBeGreaterThanOrEqual(eventTimestamps[i - 1]);
+      }
+    });
+  });
+
+  describe('Concurrent operations', () => {
+    it('should handle rapid state changes', async () => {
+      monitor.start(0);
+
+      // Rapidly fire events
+      for (let i = 0; i < 5; i++) {
+        monitor.startGate(`Gate ${i}`);
+        monitor.emit({
+          type: 'test_progress',
+          timestamp: Date.now(),
+          data: { gate: `Gate ${i}`, completed: 5, total: 10 }
+        });
+        monitor.emit({
+          type: 'test_progress',
+          timestamp: Date.now(),
+          data: { gate: `Gate ${i}`, completed: 10, total: 10 }
+        });
+        monitor.completeGate(`Gate ${i}`, i % 2 === 0);
+      }
+
+      const state = monitor.getState();
+      expect(state.gates).toHaveLength(5);
+      expect(state.gates.every(g => g.status === 'passed' || g.status === 'failed')).toBe(true);
+    });
+
+    it('should handle simultaneous gate progress updates', async () => {
+      monitor.start(0);
+
+      // Start all gates
+      monitor.startGate('Gate 1');
+      monitor.startGate('Gate 2');
+      monitor.startGate('Gate 3');
+
+      // Update progress on all gates simultaneously
+      for (let i = 0; i < 5; i++) {
+        monitor.emit({
+          type: 'test_progress',
+          timestamp: Date.now(),
+          data: { gate: 'Gate 1', completed: i + 1, total: 5 }
+        });
+        monitor.emit({
+          type: 'test_progress',
+          timestamp: Date.now(),
+          data: { gate: 'Gate 2', completed: i + 1, total: 5 }
+        });
+        monitor.emit({
+          type: 'test_progress',
+          timestamp: Date.now(),
+          data: { gate: 'Gate 3', completed: i + 1, total: 5 }
+        });
+      }
+
+      const state = monitor.getState();
+      expect(state.gates[0].testsPassed).toBe(5);
+      expect(state.gates[1].testsPassed).toBe(5);
+      expect(state.gates[2].testsPassed).toBe(5);
+    });
+  });
+});
+
+// Helper function
+async function simulateDelay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}