DeepSource MCP Server

/** * @vitest-environment node */ import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'; import { executeWithRetry, withRetry, RetryContext } from '../../../utils/retry/retry-executor.js'; import { CircuitBreakerManager } from '../../../utils/retry/circuit-breaker.js'; import { RetryBudgetManager } from '../../../utils/retry/retry-budget.js'; import { ErrorCategory } from '../../../utils/errors/categories.js'; import { createClassifiedError } from '../../../utils/errors/factory.js'; describe('Retry Executor', () => { let circuitBreakerManager: CircuitBreakerManager; let retryBudgetManager: RetryBudgetManager; beforeEach(() => { circuitBreakerManager = CircuitBreakerManager.getInstance(); retryBudgetManager = RetryBudgetManager.getInstance(); circuitBreakerManager.clear(); retryBudgetManager.clear(); vi.useFakeTimers(); }); afterEach(() => { vi.useRealTimers(); }); describe('executeWithRetry', () => { it('should succeed on first attempt', async () => { vi.useRealTimers(); // Use real timers for synchronous success const fn = vi.fn().mockResolvedValue('success'); const result = await executeWithRetry(fn); expect(result.success).toBe(true); expect(result.data).toBe('success'); expect(result.attempts).toBe(1); expect(fn).toHaveBeenCalledTimes(1); vi.useFakeTimers(); // Reset to fake timers }); it('should retry on retriable errors', async () => { const retriableError = createClassifiedError( 'Rate limit exceeded', ErrorCategory.RATE_LIMIT, new Error('429') ); const fn = vi .fn() .mockRejectedValueOnce(retriableError) .mockRejectedValueOnce(retriableError) .mockResolvedValueOnce('success'); const promise = executeWithRetry(fn, { endpoint: 'test', }); // Advance through retries await vi.advanceTimersByTimeAsync(1500); // First retry await vi.advanceTimersByTimeAsync(3000); // Second retry const result = await promise; expect(result.success).toBe(true); expect(result.data).toBe('success'); expect(result.attempts).toBe(3); expect(fn).toHaveBeenCalledTimes(3); }); it('should not retry non-retriable errors', async () => { const nonRetriableError = createClassifiedError( 'Not found', ErrorCategory.NOT_FOUND, new Error('404') ); const fn = vi.fn().mockRejectedValue(nonRetriableError); const result = await executeWithRetry(fn); expect(result.success).toBe(false); expect(result.error).toBe(nonRetriableError); expect(result.attempts).toBe(1); expect(fn).toHaveBeenCalledTimes(1); }); it('should respect circuit breaker', async () => { const endpoint = 'test-circuit'; const breaker = circuitBreakerManager.getBreaker(endpoint); // Open the circuit for (let i = 0; i < 5; i++) { breaker.recordFailure(); } const fn = vi.fn().mockResolvedValue('success'); const result = await executeWithRetry(fn, { endpoint }); expect(result.success).toBe(false); expect(result.circuitBreakerBlocked).toBe(true); expect(result.attempts).toBe(0); expect(fn).not.toHaveBeenCalled(); }); it('should respect retry budget', async () => { const endpoint = 'test-budget'; const budget = retryBudgetManager.getBudget(endpoint); // Exhaust the budget for (let i = 0; i < 10; i++) { budget.consumeRetry(); } const retriableError = createClassifiedError( 'Server error', ErrorCategory.SERVER, new Error('500') ); const fn = vi.fn().mockRejectedValue(retriableError); const result = await executeWithRetry(fn, { endpoint }); expect(result.success).toBe(false); expect(result.budgetExhausted).toBe(true); expect(result.attempts).toBe(1); // First attempt is made expect(fn).toHaveBeenCalledTimes(1); }); it('should call onRetryAttempt callback', async () => { const retriableError = createClassifiedError( 'Network error', ErrorCategory.NETWORK, new Error('ECONNREFUSED') ); const fn = vi.fn().mockRejectedValueOnce(retriableError).mockResolvedValueOnce('success'); const contexts: RetryContext[] = []; const onRetryAttempt = vi.fn((context: RetryContext) => { contexts.push(context); }); const promise = executeWithRetry(fn, { endpoint: 'test', onRetryAttempt, }); await vi.advanceTimersByTimeAsync(2000); const result = await promise; expect(result.success).toBe(true); expect(onRetryAttempt).toHaveBeenCalledTimes(1); expect(contexts[0]).toMatchObject({ endpoint: 'test', attemptNumber: 1, isLastAttempt: false, }); }); it('should respect maximum total duration', async () => { vi.useRealTimers(); // Use real timers for this test const retriableError = createClassifiedError( 'Timeout', ErrorCategory.TIMEOUT, new Error('ETIMEDOUT') ); const fn = vi.fn().mockRejectedValue(retriableError); const result = await executeWithRetry(fn, { endpoint: 'test', maxTotalDuration: 50, // Very short duration }); expect(result.success).toBe(false); expect(fn).toHaveBeenCalledTimes(1); // Should stop after first attempt due to max duration vi.useFakeTimers(); // Reset to fake timers }); it('should use custom Retry-After header', async () => { const retriableError = createClassifiedError( 'Rate limit', ErrorCategory.RATE_LIMIT, new Error('429') ); const fn = vi.fn().mockRejectedValueOnce(retriableError).mockResolvedValueOnce('success'); const promise = executeWithRetry(fn, { endpoint: 'test', extractRetryAfter: () => '2', // 2 seconds }); // Should wait 2 seconds as specified by Retry-After await vi.advanceTimersByTimeAsync(1500); expect(fn).toHaveBeenCalledTimes(1); // Still waiting await vi.advanceTimersByTimeAsync(1000); const result = await promise; expect(result.success).toBe(true); expect(fn).toHaveBeenCalledTimes(2); }); it('should exhaust all retry attempts', async () => { const retriableError = createClassifiedError( 'Server error', ErrorCategory.SERVER, new Error('503') ); const fn = vi.fn().mockRejectedValue(retriableError); const promise = executeWithRetry(fn, { endpoint: 'test', }); // Advance through all retries await vi.advanceTimersByTimeAsync(1500); // First retry await vi.advanceTimersByTimeAsync(3000); // Second retry await vi.advanceTimersByTimeAsync(6000); // Third retry const result = await promise; expect(result.success).toBe(false); expect(result.error).toBe(retriableError); expect(result.attempts).toBe(4); // Initial + 3 retries expect(fn).toHaveBeenCalledTimes(4); }); it('should handle circuit breaker opening during retries', async () => { vi.useRealTimers(); // Use real timers const endpoint = 'test-circuit-open'; const breaker = circuitBreakerManager.getBreaker(endpoint, { failureThreshold: 2, failureWindow: 10000, recoveryTimeout: 5000, }); const retriableError = createClassifiedError( 'Server error', ErrorCategory.SERVER, new Error('500') ); const fn = vi.fn().mockRejectedValue(retriableError); const result = await executeWithRetry(fn, { endpoint }); expect(result.success).toBe(false); expect(result.attempts).toBe(3); // Initial + 2 retries before circuit opens expect(breaker.getState()).toBe('open'); vi.useFakeTimers(); // Reset to fake timers }); }); describe('withRetry', () => { it('should create a retry-enabled wrapper', async () => { let attemptCount = 0; const fn = vi.fn(async () => { attemptCount++; if (attemptCount < 3) { throw createClassifiedError('Temporary error', ErrorCategory.NETWORK, new Error()); } return 'success'; }); const wrappedFn = withRetry(fn); const promise = wrappedFn(); await vi.advanceTimersByTimeAsync(5000); const result = await promise; expect(result).toBe('success'); expect(fn).toHaveBeenCalledTimes(3); }); it('should throw error when all retries fail', async () => { const error = createClassifiedError( 'Persistent error', ErrorCategory.SERVER, new Error('500') ); const fn = vi.fn().mockRejectedValue(error); const wrappedFn = withRetry(fn); const promise = wrappedFn().catch((e) => e); // Catch to prevent unhandled rejection await vi.advanceTimersByTimeAsync(20000); // Advance through all retries const result = await promise; expect(result).toBe(error); expect(fn).toHaveBeenCalledTimes(4); // Initial + 3 retries }); it('should use provided options', async () => { vi.useRealTimers(); // Use real timers const fn = vi .fn() .mockRejectedValue(createClassifiedError('Error', ErrorCategory.NETWORK, new Error())); const wrappedFn = withRetry(fn, { endpoint: 'custom', maxTotalDuration: 50, // Very short duration }); await expect(wrappedFn()).rejects.toThrow(); // Should stop early due to max duration expect(fn).toHaveBeenCalledTimes(1); vi.useFakeTimers(); // Reset to fake timers }); }); describe('Error classification', () => { it('should correctly identify retriable errors', async () => { vi.useRealTimers(); // Use real timers const testCases = [ { error: new Error('Network error'), shouldRetry: true }, { error: new Error('ECONNREFUSED'), shouldRetry: true }, { error: new Error('Rate limit exceeded'), shouldRetry: true }, { error: new Error('500 Internal Server Error'), shouldRetry: true }, { error: new Error('502 Bad Gateway'), shouldRetry: true }, { error: new Error('503 Service Unavailable'), shouldRetry: true }, { error: new Error('Timeout occurred'), shouldRetry: true }, { error: new Error('404 Not Found'), shouldRetry: false }, { error: new Error('Invalid input'), shouldRetry: false }, { error: new Error('Authentication failed'), shouldRetry: false }, ]; for (const testCase of testCases) { circuitBreakerManager.clear(); // Clear state between tests retryBudgetManager.clear(); const fn = vi.fn().mockRejectedValue(testCase.error); // Use a custom policy with minimal retry attempts for speed const quickPolicy = { maxAttempts: 1, baseDelay: 10, maxDelay: 100, jitterFactor: 0, retriableErrors: [ ErrorCategory.RATE_LIMIT, ErrorCategory.NETWORK, ErrorCategory.TIMEOUT, ErrorCategory.SERVER, ], respectRetryAfter: false, name: 'test-quick', }; const result = await executeWithRetry(fn, { endpoint: `test-${Math.random()}`, // Use unique endpoint for each test policy: quickPolicy, }); if (testCase.shouldRetry) { expect(result.attempts).toBeGreaterThan(1); } else { expect(result.attempts).toBe(1); } } vi.useFakeTimers(); // Reset to fake timers }); it('should handle classified errors', async () => { const classifiedRetriable = createClassifiedError( 'Server error', ErrorCategory.SERVER, new Error() ); const classifiedNonRetriable = createClassifiedError( 'Auth error', ErrorCategory.AUTH, new Error() ); const fnRetriable = vi .fn() .mockRejectedValueOnce(classifiedRetriable) .mockResolvedValueOnce('success'); const fnNonRetriable = vi.fn().mockRejectedValue(classifiedNonRetriable); const promise1 = executeWithRetry(fnRetriable); await vi.advanceTimersByTimeAsync(2000); const result1 = await promise1; const result2 = await executeWithRetry(fnNonRetriable); expect(result1.attempts).toBe(2); expect(result2.attempts).toBe(1); }); }); describe('Integration with all components', () => { it('should coordinate circuit breaker, budget, and backoff', async () => { const endpoint = 'integration-test'; const breaker = circuitBreakerManager.getBreaker(endpoint, { failureThreshold: 5, recoveryTimeout: 1000, }); const budget = retryBudgetManager.getBudget(endpoint); const retriableError = createClassifiedError( 'Intermittent error', ErrorCategory.NETWORK, new Error() ); let attemptCount = 0; const fn = vi.fn(async () => { attemptCount++; if (attemptCount < 4) { throw retriableError; } return 'success'; }); const promise = executeWithRetry(fn, { endpoint, onRetryAttempt: (context) => { // Verify context is properly populated expect(context.endpoint).toBe(endpoint); expect(context.attemptNumber).toBeGreaterThan(0); expect(context.elapsedMs).toBeGreaterThan(0); }, }); // Advance through retries with exponential backoff await vi.advanceTimersByTimeAsync(1500); // ~1s + jitter await vi.advanceTimersByTimeAsync(2500); // ~2s + jitter await vi.advanceTimersByTimeAsync(5000); // ~4s + jitter const result = await promise; expect(result.success).toBe(true); expect(result.attempts).toBe(4); // Check budget was consumed const budgetStats = budget.getStats(); expect(budgetStats.consumed).toBe(3); // 3 retries // Check circuit breaker recorded attempts const breakerStats = breaker.getStats(); expect(breakerStats.failureCount).toBe(3); expect(breakerStats.successCount).toBe(1); expect(breakerStats.state).toBe('closed'); }); }); });