import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { HealthMonitor } from '../src/services/health.js';
import { ProviderManager } from '../src/providers/manager.js';
import { ProviderHealth } from '../src/config/types.js';
// Mock dependencies
jest.mock('../src/utils/logger');
jest.mock('../src/providers/manager.js');
describe('HealthMonitor', () => {
let healthMonitor: HealthMonitor;
let mockProviderManager: jest.Mocked<ProviderManager>;
beforeEach(() => {
// Create a mock ProviderManager
mockProviderManager = {
checkHealth: jest.fn(),
} as unknown as jest.Mocked<ProviderManager>;
healthMonitor = new HealthMonitor(mockProviderManager);
});
describe('performHealthChecks', () => {
it('should call providerManager.checkHealth and return results', async () => {
const healthResults: ProviderHealth[] = [
{
provider: 'openai',
healthy: true,
latency: 150,
lastCheck: new Date(),
},
{
provider: 'groq',
healthy: true,
latency: 80,
lastCheck: new Date(),
},
];
mockProviderManager.checkHealth.mockResolvedValue(healthResults);
const results = await healthMonitor.performHealthChecks();
expect(mockProviderManager.checkHealth).toHaveBeenCalledTimes(1);
expect(results).toEqual(healthResults);
expect(results).toHaveLength(2);
});
it('should handle unhealthy providers with errors', async () => {
const healthResults: ProviderHealth[] = [
{
provider: 'openai',
healthy: true,
latency: 150,
lastCheck: new Date(),
},
{
provider: 'groq',
healthy: false,
lastCheck: new Date(),
error: 'Connection refused',
},
];
mockProviderManager.checkHealth.mockResolvedValue(healthResults);
const results = await healthMonitor.performHealthChecks();
expect(results).toHaveLength(2);
expect(results[0].healthy).toBe(true);
expect(results[1].healthy).toBe(false);
expect(results[1].error).toBe('Connection refused');
});
it('should handle all unhealthy providers', async () => {
const healthResults: ProviderHealth[] = [
{
provider: 'openai',
healthy: false,
lastCheck: new Date(),
error: 'API key invalid',
},
{
provider: 'groq',
healthy: false,
lastCheck: new Date(),
error: 'Timeout',
},
];
mockProviderManager.checkHealth.mockResolvedValue(healthResults);
const results = await healthMonitor.performHealthChecks();
expect(results.every((r) => !r.healthy)).toBe(true);
});
it('should handle empty provider list', async () => {
mockProviderManager.checkHealth.mockResolvedValue([]);
const results = await healthMonitor.performHealthChecks();
expect(results).toEqual([]);
});
it('should handle providers without latency info', async () => {
const healthResults: ProviderHealth[] = [
{
provider: 'openai',
healthy: false,
lastCheck: new Date(),
error: 'Failed before timing',
},
];
mockProviderManager.checkHealth.mockResolvedValue(healthResults);
const results = await healthMonitor.performHealthChecks();
expect(results[0].latency).toBeUndefined();
});
it('should propagate errors from checkHealth', async () => {
mockProviderManager.checkHealth.mockRejectedValue(new Error('Network error'));
await expect(healthMonitor.performHealthChecks()).rejects.toThrow('Network error');
});
});
});
