vibecodingmachine-core 2026.1.3-2209 → 2026.1.23-1010

package/src/health-tracking/__tests__/ide-health-tracker.test.js

@@ -0,0 +1,420 @@
+/**
+ * Unit tests for IDEHealthTracker
+ * @jest-environment node
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { IDEHealthTracker } = require('../ide-health-tracker');
+const { ValidationError } = require('../errors');
+
+describe('IDEHealthTracker', () => {
+  let tracker;
+  let testStorageFile;
+
+  beforeEach(() => {
+    // Create temporary storage file for testing
+    testStorageFile = path.join(os.tmpdir(), `test-health-${Date.now()}.json`);
+    tracker = new IDEHealthTracker({
+      storageFile: testStorageFile,
+      autoSave: false, // Disable auto-save for testing
+    });
+  });
+
+  afterEach(async () => {
+    // Clean up test files
+    if (await fs.pathExists(testStorageFile)) {
+      await fs.remove(testStorageFile);
+    }
+    const backupFile = `${testStorageFile}.bak`;
+    if (await fs.pathExists(backupFile)) {
+      await fs.remove(backupFile);
+    }
+  });
+
+  describe('recordSuccess()', () => {
+    it('should increment success count on recordSuccess', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(1);
+      expect(metrics.failureCount).toBe(0);
+      expect(metrics.consecutiveFailures).toBe(0);
+    });
+
+    it('should reset consecutive failures on success after failure', async () => {
+      await tracker.recordFailure('cursor', 'Test error');
+      await tracker.recordFailure('cursor', 'Test error');
+      const metricsAfterFailures = await tracker.getHealthMetrics('cursor');
+      expect(metricsAfterFailures.consecutiveFailures).toBe(2);
+
+      await tracker.recordSuccess('cursor', 120000);
+      const metricsAfterSuccess = await tracker.getHealthMetrics('cursor');
+      expect(metricsAfterSuccess.consecutiveFailures).toBe(0);
+      expect(metricsAfterSuccess.successCount).toBe(1);
+      expect(metricsAfterSuccess.failureCount).toBe(2);
+    });
+
+    it('should add responseTime to responseTimes array', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordSuccess('cursor', 115000);
+      await tracker.recordSuccess('cursor', 125000);
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(3);
+      // Note: We can't directly access responseTimes in metrics,
+      // but we can verify EWMA was calculated
+      expect(metrics.averageResponseTime).toBeGreaterThan(0);
+    });
+
+    it('should enforce max 50 response times', async () => {
+      // Add 60 response times
+      for (let i = 0; i < 60; i++) {
+        await tracker.recordSuccess('cursor', 120000 + i * 100);
+      }
+
+      // Verify it doesn't throw and counts are correct
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(60);
+      // Internal responseTimes array should be capped at 50
+      // This will be verified in internal state
+    });
+
+    it('should update lastSuccess timestamp', async () => {
+      const beforeTime = new Date().toISOString();
+      await tracker.recordSuccess('cursor', 120000);
+      const afterTime = new Date().toISOString();
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.lastSuccess).not.toBeNull();
+      expect(metrics.lastSuccess >= beforeTime).toBe(true);
+      expect(metrics.lastSuccess <= afterTime).toBe(true);
+    });
+
+    it('should throw ValidationError if ideId is empty', async () => {
+      await expect(tracker.recordSuccess('', 120000))
+        .rejects
+        .toThrow(ValidationError);
+    });
+
+    it('should throw ValidationError if responseTime is negative', async () => {
+      await expect(tracker.recordSuccess('cursor', -1000))
+        .rejects
+        .toThrow(ValidationError);
+    });
+
+    it('should accept metadata with continuationPromptsDetected', async () => {
+      await tracker.recordSuccess('cursor', 120000, {
+        continuationPromptsDetected: 2,
+        requirementId: 'req-042',
+      });
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(1);
+      // Interaction record should have continuationPromptsDetected
+      expect(metrics.recentInteractions).toHaveLength(1);
+      expect(metrics.recentInteractions[0].continuationPromptsDetected).toBe(2);
+    });
+
+    it('should recalculate EWMA on each success', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      const metrics1 = await tracker.getHealthMetrics('cursor');
+      const ewma1 = metrics1.averageResponseTime;
+
+      await tracker.recordSuccess('cursor', 150000);
+      const metrics2 = await tracker.getHealthMetrics('cursor');
+      const ewma2 = metrics2.averageResponseTime;
+
+      // EWMA should have changed
+      expect(ewma2).not.toBe(ewma1);
+      expect(ewma2).toBeGreaterThan(ewma1);
+    });
+
+    it('should emit health-updated event on success', (done) => {
+      tracker.on('health-updated', ({ ideId, outcome }) => {
+        expect(ideId).toBe('cursor');
+        expect(outcome).toBe('success');
+        done();
+      });
+
+      tracker.recordSuccess('cursor', 120000);
+    });
+  });
+
+  describe('recordFailure()', () => {
+    it('should increment failure count on recordFailure', async () => {
+      await tracker.recordFailure('cursor', 'Timeout exceeded');
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(0);
+      expect(metrics.failureCount).toBe(1);
+      expect(metrics.consecutiveFailures).toBe(1);
+    });
+
+    it('should increment consecutive failures on multiple failures', async () => {
+      await tracker.recordFailure('cursor', 'Error 1');
+      await tracker.recordFailure('cursor', 'Error 2');
+      await tracker.recordFailure('cursor', 'Error 3');
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.failureCount).toBe(3);
+      expect(metrics.consecutiveFailures).toBe(3);
+    });
+
+    it('should emit consecutive-failures event at threshold 5', (done) => {
+      tracker.on('consecutive-failures', ({ ideId, count, lastError }) => {
+        expect(ideId).toBe('cursor');
+        expect(count).toBe(5);
+        expect(lastError).toBe('Error 5');
+        done();
+      });
+
+      (async () => {
+        for (let i = 1; i <= 5; i++) {
+          await tracker.recordFailure('cursor', `Error ${i}`);
+        }
+      })();
+    });
+
+    it('should update lastFailure timestamp', async () => {
+      const beforeTime = new Date().toISOString();
+      await tracker.recordFailure('cursor', 'Test error');
+      const afterTime = new Date().toISOString();
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.lastFailure).not.toBeNull();
+      expect(metrics.lastFailure >= beforeTime).toBe(true);
+      expect(metrics.lastFailure <= afterTime).toBe(true);
+    });
+
+    it('should accept metadata with timeoutUsed', async () => {
+      await tracker.recordFailure('cursor', 'Timeout', {
+        timeoutUsed: 1800000,
+        requirementId: 'req-043',
+      });
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.failureCount).toBe(1);
+      expect(metrics.recentInteractions).toHaveLength(1);
+      expect(metrics.recentInteractions[0].errorMessage).toBe('Timeout');
+    });
+
+    it('should emit health-updated event on failure', (done) => {
+      tracker.on('health-updated', ({ ideId, outcome }) => {
+        expect(ideId).toBe('cursor');
+        expect(outcome).toBe('failure');
+        done();
+      });
+
+      tracker.recordFailure('cursor', 'Test error');
+    });
+  });
+
+  describe('recordQuota()', () => {
+    it('should NOT increment success or failure counters on quota', async () => {
+      await tracker.recordQuota('cursor', 'Monthly chat messages quota exceeded');
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(0);
+      expect(metrics.failureCount).toBe(0);
+      expect(metrics.consecutiveFailures).toBe(0);
+    });
+
+    it('should add interaction record with outcome=quota', async () => {
+      await tracker.recordQuota('cursor', 'Quota exceeded', {
+        requirementId: 'req-044',
+      });
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.recentInteractions).toHaveLength(1);
+      expect(metrics.recentInteractions[0].outcome).toBe('quota');
+      expect(metrics.recentInteractions[0].errorMessage).toBe('Quota exceeded');
+    });
+
+    it('should emit health-updated event with outcome=quota', (done) => {
+      tracker.on('health-updated', ({ ideId, outcome }) => {
+        expect(ideId).toBe('cursor');
+        expect(outcome).toBe('quota');
+        done();
+      });
+
+      tracker.recordQuota('cursor', 'Quota message');
+    });
+  });
+
+  describe('getHealthMetrics()', () => {
+    it('should return metrics for specific IDE', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordFailure('cursor', 'Error');
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successCount).toBe(1);
+      expect(metrics.failureCount).toBe(1);
+      expect(metrics.successRate).toBeCloseTo(0.5);
+      expect(metrics.totalInteractions).toBe(2);
+    });
+
+    it('should calculate success rate correctly', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordSuccess('cursor', 115000);
+      await tracker.recordSuccess('cursor', 125000);
+      await tracker.recordFailure('cursor', 'Error');
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.successRate).toBeCloseTo(0.75); // 3/4 = 0.75
+    });
+
+    it('should return recent 10 interactions', async () => {
+      // Add 15 interactions
+      for (let i = 0; i < 15; i++) {
+        if (i % 2 === 0) {
+          await tracker.recordSuccess('cursor', 120000);
+        } else {
+          await tracker.recordFailure('cursor', 'Error');
+        }
+      }
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      expect(metrics.recentInteractions).toHaveLength(10);
+    });
+
+    it('should return default metrics for unknown IDE', async () => {
+      const metrics = await tracker.getHealthMetrics('unknown-ide');
+      expect(metrics.successCount).toBe(0);
+      expect(metrics.failureCount).toBe(0);
+      expect(metrics.successRate).toBe(0);
+      expect(metrics.totalInteractions).toBe(0);
+    });
+  });
+
+  describe('getAllHealthMetrics()', () => {
+    it('should return metrics for all tracked IDEs', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordSuccess('windsurf', 180000);
+      await tracker.recordFailure('vscode', 'Error');
+
+      const allMetrics = await tracker.getAllHealthMetrics();
+      expect(allMetrics.size).toBe(3);
+      expect(allMetrics.has('cursor')).toBe(true);
+      expect(allMetrics.has('windsurf')).toBe(true);
+      expect(allMetrics.has('vscode')).toBe(true);
+    });
+
+    it('should return empty Map if no IDEs tracked', async () => {
+      const allMetrics = await tracker.getAllHealthMetrics();
+      expect(allMetrics.size).toBe(0);
+      expect(allMetrics instanceof Map).toBe(true);
+    });
+  });
+
+  describe('getRecommendedIDE()', () => {
+    it('should return IDE with highest success rate', async () => {
+      // Cursor: 80% success (4/5)
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordFailure('cursor', 'Error');
+
+      // Windsurf: 60% success (3/5)
+      await tracker.recordSuccess('windsurf', 180000);
+      await tracker.recordSuccess('windsurf', 180000);
+      await tracker.recordSuccess('windsurf', 180000);
+      await tracker.recordFailure('windsurf', 'Error');
+      await tracker.recordFailure('windsurf', 'Error');
+
+      const recommended = await tracker.getRecommendedIDE({ minInteractions: 5 });
+      expect(recommended).toBe('cursor');
+    });
+
+    it('should return null if no IDEs meet minInteractions threshold', async () => {
+      await tracker.recordSuccess('cursor', 120000);
+
+      const recommended = await tracker.getRecommendedIDE({ minInteractions: 10 });
+      expect(recommended).toBeNull();
+    });
+
+    it('should exclude IDEs below minInteractions threshold', async () => {
+      // Cursor: only 2 interactions
+      await tracker.recordSuccess('cursor', 120000);
+      await tracker.recordSuccess('cursor', 120000);
+
+      // Windsurf: 12 interactions with 75% success
+      for (let i = 0; i < 12; i++) {
+        if (i < 9) {
+          await tracker.recordSuccess('windsurf', 180000);
+        } else {
+          await tracker.recordFailure('windsurf', 'Error');
+        }
+      }
+
+      const recommended = await tracker.getRecommendedIDE({ minInteractions: 10 });
+      expect(recommended).toBe('windsurf');
+    });
+  });
+
+  describe('save() and load()', () => {
+    it('should persist health data across instances', async () => {
+      const tracker1 = new IDEHealthTracker({ storageFile: testStorageFile });
+      await tracker1.recordSuccess('cursor', 120000);
+      await tracker1.save();
+
+      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
+      await tracker2.load();
+      const metrics = await tracker2.getHealthMetrics('cursor');
+
+      expect(metrics.successCount).toBe(1);
+    });
+
+    it('should load default data if file does not exist', async () => {
+      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
+      await tracker2.load();
+      const metrics = await tracker2.getHealthMetrics('cursor');
+
+      expect(metrics.successCount).toBe(0);
+      expect(metrics.failureCount).toBe(0);
+    });
+
+    it('should throw FileSystemError on corrupted data without backup', async () => {
+      // Create corrupted file
+      await fs.writeFile(testStorageFile, 'invalid json{{{');
+
+      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
+      await expect(tracker2.load()).rejects.toThrow();
+    });
+  });
+
+  describe('autoSave with debouncing', () => {
+    it('should auto-save after debounce period when autoSave is enabled', async () => {
+      const autoSaveTracker = new IDEHealthTracker({
+        storageFile: testStorageFile,
+        autoSave: true,
+        debounceMs: 100,
+      });
+
+      await autoSaveTracker.recordSuccess('cursor', 120000);
+
+      // Wait for debounce using Promise
+      await new Promise(resolve => setTimeout(resolve, 200));
+
+      const fileExists = await fs.pathExists(testStorageFile);
+      expect(fileExists).toBe(true);
+    });
+  });
+
+  describe('interaction records', () => {
+    it('should enforce max 100 interactions per IDE', async () => {
+      // Add 120 interactions
+      for (let i = 0; i < 120; i++) {
+        await tracker.recordSuccess('cursor', 120000);
+      }
+
+      const metrics = await tracker.getHealthMetrics('cursor');
+      // Recent interactions should be capped at 10 (for display)
+      expect(metrics.recentInteractions).toHaveLength(10);
+      // Internal storage should be capped at 100
+      // This will be verified in implementation
+    });
+  });
+});