claw-dashboard 1.9.0 → 2.0.0

package/tests/retry.test.js

@@ -0,0 +1,308 @@
+/**
+ * Integration tests for retry logic with mock failures
+ */
+
+import retry from '../src/retry.js';
+
+// Simple mock helper that properly tracks call counts
+function createMockFn(successValue, errorSequence = []) {
+  let errorIndex = 0;
+  return async (...args) => {
+    if (errorIndex < errorSequence.length) {
+      const err = errorSequence[errorIndex++];
+      throw err;
+    }
+    return successValue;
+  };
+}
+
+describe('Retry Logic', () => {
+  describe('withRetry', () => {
+    test('should succeed on first attempt when function succeeds', async () => {
+      let callCount = 0;
+      const fn = async () => {
+        callCount++;
+        return 'success';
+      };
+      
+      const wrapped = retry.withRetry(fn);
+      const result = await wrapped();
+      
+      expect(result).toBe('success');
+      expect(callCount).toBe(1);
+    });
+
+    test('should retry on failure and eventually succeed', async () => {
+      const mockFn = createMockFn(
+        'success',
+        [new Error('Network timeout'), new Error('Connection refused')]
+      );
+      
+      const wrapped = retry.withRetry(mockFn);
+      const result = await wrapped();
+      
+      expect(result).toBe('success');
+    });
+
+    test('should fail after max retries exceeded', async () => {
+      const error = new Error('Network timeout');
+      const mockFn = async () => {
+        throw error;
+      };
+      
+      const wrapped = retry.withRetry(mockFn, { maxRetries: 2 });
+      
+      await expect(wrapped()).rejects.toThrow('Network timeout');
+    });
+
+    test('should not retry on non-retryable errors', async () => {
+      const error = new Error('Bad Request');
+      error.status = 400;
+      let callCount = 0;
+      const mockFn = async () => {
+        callCount++;
+        throw error;
+      };
+      
+      const wrapped = retry.withRetry(mockFn);
+      
+      await expect(wrapped()).rejects.toThrow('Bad Request');
+      expect(callCount).toBe(1);
+    });
+
+    test('should retry on retryable HTTP status codes', async () => {
+      const mockFn = createMockFn(
+        'success',
+        [{ message: 'Server Error', status: 500 }]
+      );
+      
+      const wrapped = retry.withRetry(mockFn);
+      const result = await wrapped();
+      
+      expect(result).toBe('success');
+    });
+
+    test('should retry on retryable error codes', async () => {
+      const mockFn = createMockFn(
+        'success',
+        [{ message: 'Connection refused', code: 'ECONNREFUSED' }]
+      );
+      
+      const wrapped = retry.withRetry(mockFn);
+      const result = await wrapped();
+      
+      expect(result).toBe('success');
+    });
+
+    test('should respect custom maxRetries option', async () => {
+      const error = new Error('Network timeout');
+      let attempts = 0;
+      const mockFn = async () => {
+        attempts++;
+        throw error;
+      };
+      
+      const wrapped = retry.withRetry(mockFn, { maxRetries: 5, initialDelay: 100 });
+      
+      await expect(wrapped()).rejects.toThrow();
+      expect(attempts).toBe(6);
+    }, 30000);
+
+    test('should pass arguments to wrapped function', async () => {
+      let receivedArgs = null;
+      const mockFn = async (...args) => {
+        receivedArgs = args;
+        return 'result';
+      };
+      
+      const wrapped = retry.withRetry(mockFn);
+      await wrapped('arg1', 'arg2');
+      
+      expect(receivedArgs).toEqual(['arg1', 'arg2']);
+    });
+
+    test('should use custom retryable statuses', async () => {
+      const mockFn = createMockFn(
+        'success',
+        [{ message: 'Bad Request', status: 400 }]
+      );
+      
+      const wrapped = retry.withRetry(mockFn, { 
+        retryableStatuses: [400, 500] 
+      });
+      
+      const result = await wrapped();
+      expect(result).toBe('success');
+    });
+  });
+
+  describe('calculateDelay', () => {
+    test('should calculate exponential backoff delay', () => {
+      const options = {
+        initialDelay: 1000,
+        maxDelay: 10000,
+        backoffMultiplier: 2
+      };
+      
+      const delay0 = retry.calculateDelay(0, options);
+      expect(delay0).toBeGreaterThanOrEqual(900);
+      expect(delay0).toBeLessThanOrEqual(1100);
+      
+      const delay1 = retry.calculateDelay(1, options);
+      expect(delay1).toBeGreaterThanOrEqual(1800);
+      expect(delay1).toBeLessThanOrEqual(2200);
+      
+      const delay2 = retry.calculateDelay(2, options);
+      expect(delay2).toBeGreaterThanOrEqual(3600);
+      expect(delay2).toBeLessThanOrEqual(4400);
+    });
+
+    test('should not exceed maxDelay', () => {
+      const options = {
+        initialDelay: 1000,
+        maxDelay: 5000,
+        backoffMultiplier: 2
+      };
+      
+      const delay = retry.calculateDelay(10, options);
+      expect(delay).toBeLessThanOrEqual(5500);
+    });
+  });
+
+  describe('isRetryableError', () => {
+    test('should return true for retryable error codes', () => {
+      const options = { retryableErrors: ['ECONNREFUSED', 'ETIMEDOUT'] };
+      
+      expect(retry.isRetryableError({ code: 'ECONNREFUSED' }, options)).toBe(true);
+      expect(retry.isRetryableError({ code: 'ETIMEDOUT' }, options)).toBe(true);
+    });
+
+    test('should return true for retryable HTTP statuses', () => {
+      const options = { retryableStatuses: [500, 503] };
+      
+      expect(retry.isRetryableError({ status: 500 }, options)).toBe(true);
+      expect(retry.isRetryableError({ status: 503 }, options)).toBe(true);
+    });
+
+    test('should return false for non-retryable errors', () => {
+      const options = { 
+        retryableErrors: ['ECONNREFUSED'],
+        retryableStatuses: [500]
+      };
+      
+      expect(retry.isRetryableError({ code: 'ENOMEM' }, options)).toBe(false);
+      expect(retry.isRetryableError({ status: 404 }, options)).toBe(false);
+      // Use truly non-retryable message
+      expect(retry.isRetryableError({ message: 'Invalid input provided' }, options)).toBe(false);
+    });
+  });
+
+  describe('retryUntil', () => {
+    test('should succeed when function eventually succeeds', async () => {
+      let attempts = 0;
+      const fn = async () => {
+        attempts++;
+        if (attempts < 3) {
+          throw new Error('Not ready yet');
+        }
+        return 'ready';
+      };
+      
+      const result = await retry.retryUntil(fn, 5000, 50);
+      
+      expect(result).toBe('ready');
+      expect(attempts).toBe(3);
+    });
+
+    test('should timeout when function never succeeds', async () => {
+      const fn = async () => {
+        throw new Error('Network error');
+      };
+      
+      await expect(
+        retry.retryUntil(fn, 100, 20)
+      ).rejects.toThrow('Retry timeout');
+    });
+  });
+
+  describe('createRetryableFetch', () => {
+    test('should retry on 5xx errors', async () => {
+      let attempts = 0;
+      const mockFetch = async () => {
+        attempts++;
+        if (attempts === 1) {
+          throw { message: 'Server Error', status: 500 };
+        }
+        return { status: 200, data: 'ok' };
+      };
+      
+      const wrappedFetch = retry.createRetryableFetch(mockFetch);
+      const response = await wrappedFetch('http://test.com');
+      
+      expect(response.status).toBe(200);
+      expect(attempts).toBe(2);
+    });
+
+    test('should not retry on 4xx errors', async () => {
+      let attempts = 0;
+      const mockFetch = async () => {
+        attempts++;
+        return { status: 404, statusText: 'Not Found' };
+      };
+      
+      const wrappedFetch = retry.createRetryableFetch(mockFetch);
+      const response = await wrappedFetch('http://test.com');
+      
+      expect(response.status).toBe(404);
+      expect(attempts).toBe(1);
+    });
+  });
+
+  describe('retryBatch', () => {
+    test('should execute all functions with retries', async () => {
+      let callCount1 = 0;
+      let callCount3 = 0;
+      const fn1 = async () => {
+        callCount1++;
+        if (callCount1 === 1) throw new Error('Network timeout');
+        return 'result1';
+      };
+      const fn2 = async () => 'result2';
+      const fn3 = async () => {
+        callCount3++;
+        if (callCount3 < 3) throw new Error('Network timeout');
+        return 'result3';
+      };
+      
+      const results = await retry.retryBatch([fn1, fn2, fn3], { maxRetries: 2 });
+      
+      expect(results[0].status).toBe('fulfilled');
+      expect(results[0].value).toBe('result1');
+      expect(results[1].status).toBe('fulfilled');
+      expect(results[1].value).toBe('result2');
+      expect(results[2].status).toBe('fulfilled');
+      expect(results[2].value).toBe('result3');
+    });
+
+    test('should handle batch with all failures', async () => {
+      const fn1 = async () => { throw new Error('Network timeout'); };
+      const fn2 = async () => { throw new Error('Connection refused'); };
+      
+      const results = await retry.retryBatch([fn1, fn2], { maxRetries: 1 });
+      
+      expect(results[0].status).toBe('rejected');
+      expect(results[1].status).toBe('rejected');
+    });
+  });
+
+  describe('DEFAULT_OPTIONS', () => {
+    test('should have sensible defaults', () => {
+      expect(retry.DEFAULT_OPTIONS.maxRetries).toBe(3);
+      expect(retry.DEFAULT_OPTIONS.initialDelay).toBe(1000);
+      expect(retry.DEFAULT_OPTIONS.maxDelay).toBe(10000);
+      expect(retry.DEFAULT_OPTIONS.backoffMultiplier).toBe(2);
+      expect(retry.DEFAULT_OPTIONS.retryableStatuses).toContain(500);
+      expect(retry.DEFAULT_OPTIONS.retryableErrors).toContain('ECONNREFUSED');
+    });
+  });
+});