fix issues

apps/website/lib/api/base/ApiConnectionMonitor.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ApiConnectionMonitor } from './ApiConnectionMonitor';
+
+describe('ApiConnectionMonitor', () => {
+  let monitor: ApiConnectionMonitor;
+
+  beforeEach(() => {
+    // Reset singleton instance
+    (ApiConnectionMonitor as any).instance = undefined;
+    monitor = ApiConnectionMonitor.getInstance();
+  });
+
+  describe('getInstance', () => {
+    it('should return a singleton instance', () => {
+      const instance1 = ApiConnectionMonitor.getInstance();
+      const instance2 = ApiConnectionMonitor.getInstance();
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe('startMonitoring', () => {
+    it('should start monitoring without errors', () => {
+      expect(() => monitor.startMonitoring()).not.toThrow();
+    });
+
+    it('should be idempotent', () => {
+      monitor.startMonitoring();
+      expect(() => monitor.startMonitoring()).not.toThrow();
+    });
+  });
+
+  describe('recordSuccess', () => {
+    it('should record a successful request', () => {
+      const responseTime = 100;
+      monitor.recordSuccess(responseTime);
+      
+      const health = monitor.getHealth();
+      expect(health.totalRequests).toBe(1);
+      expect(health.successfulRequests).toBe(1);
+      expect(health.failedRequests).toBe(0);
+    });
+
+    it('should update average response time', () => {
+      monitor.recordSuccess(100);
+      monitor.recordSuccess(200);
+      
+      const health = monitor.getHealth();
+      expect(health.averageResponseTime).toBe(150);
+    });
+  });
+
+  describe('recordFailure', () => {
+    it('should record a failed request', () => {
+      const error = new Error('Test error');
+      monitor.recordFailure(error);
+      
+      const health = monitor.getHealth();
+      expect(health.totalRequests).toBe(1);
+      expect(health.successfulRequests).toBe(0);
+      expect(health.failedRequests).toBe(1);
+    });
+
+    it('should track consecutive failures', () => {
+      const error1 = new Error('Error 1');
+      const error2 = new Error('Error 2');
+      
+      monitor.recordFailure(error1);
+      monitor.recordFailure(error2);
+      
+      const health = monitor.getHealth();
+      expect(health.consecutiveFailures).toBe(2);
+    });
+  });
+
+  describe('getStatus', () => {
+    it('should return current status', () => {
+      const status = monitor.getStatus();
+      expect(typeof status).toBe('string');
+      expect(['connected', 'disconnected', 'degraded', 'checking']).toContain(status);
+    });
+  });
+
+  describe('getHealth', () => {
+    it('should return health metrics', () => {
+      const health = monitor.getHealth();
+      expect(health).toHaveProperty('status');
+      expect(health).toHaveProperty('lastCheck');
+      expect(health).toHaveProperty('lastSuccess');
+      expect(health).toHaveProperty('lastFailure');
+      expect(health).toHaveProperty('consecutiveFailures');
+      expect(health).toHaveProperty('totalRequests');
+      expect(health).toHaveProperty('successfulRequests');
+      expect(health).toHaveProperty('failedRequests');
+      expect(health).toHaveProperty('averageResponseTime');
+    });
+
+    it('should calculate success rate correctly', () => {
+      monitor.recordSuccess(100);
+      monitor.recordSuccess(100);
+      monitor.recordFailure(new Error('Test'));
+      
+      const health = monitor.getHealth();
+      const successRate = health.successfulRequests / health.totalRequests;
+      expect(successRate).toBeCloseTo(2/3, 10);
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return true when healthy', () => {
+      // Record some successful requests
+      for (let i = 0; i < 5; i++) {
+        monitor.recordSuccess(100);
+      }
+      
+      expect(monitor.isAvailable()).toBe(true);
+    });
+
+    it('should return false when many failures occur', () => {
+      // Record many failures
+      for (let i = 0; i < 10; i++) {
+        monitor.recordFailure(new Error('Test'));
+      }
+
+      expect(monitor.isAvailable()).toBe(false);
+    });
+  });
+
+  describe('getReliability', () => {
+    it('should return reliability score', () => {
+      monitor.recordSuccess(100);
+      monitor.recordSuccess(100);
+      monitor.recordSuccess(100);
+      monitor.recordFailure(new Error('Test'));
+      
+      const reliability = monitor.getReliability();
+      expect(reliability).toBeGreaterThanOrEqual(0);
+      expect(reliability).toBeLessThanOrEqual(100);
+    });
+
+    it('should return 1 for perfect reliability', () => {
+      for (let i = 0; i < 10; i++) {
+        monitor.recordSuccess(100);
+      }
+
+      expect(monitor.getReliability()).toBe(100);
+    });
+
+    it('should return 0 for complete failure', () => {
+      for (let i = 0; i < 10; i++) {
+        monitor.recordFailure(new Error('Test'));
+      }
+      
+      expect(monitor.getReliability()).toBe(0);
+    });
+  });
+
+  describe('performHealthCheck', () => {
+    it('should return health check result', async () => {
+      const result = await monitor.performHealthCheck();
+      expect(result).toHaveProperty('timestamp');
+      expect(result).toHaveProperty('healthy');
+      expect(result).toHaveProperty('responseTime');
+    });
+  });
+});