@hazeljs/resilience 0.2.0-beta.41

package/dist/__tests__/decorators.test.js

@@ -0,0 +1,288 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const decorators_1 = require("../decorators");
+const index_1 = require("../index");
+const circuit_breaker_registry_1 = require("../circuit-breaker/circuit-breaker-registry");
+const types_1 = require("../types");
+describe('CircuitBreaker decorator', () => {
+    beforeEach(() => {
+        circuit_breaker_registry_1.CircuitBreakerRegistry.clear();
+    });
+    it('should wrap method with circuit breaker', async () => {
+        class TestService {
+            async success() {
+                return 'ok';
+            }
+        }
+        __decorate([
+            (0, decorators_1.CircuitBreaker)({ failureThreshold: 5, resetTimeout: 100 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "success", null);
+        const svc = new TestService();
+        const result = await svc.success();
+        expect(result).toBe('ok');
+    });
+    it('should use fallback when configured and primary fails', async () => {
+        class TestService {
+            async primary() {
+                throw new Error('primary failed');
+            }
+            fallbackMethod() {
+                return 'fallback';
+            }
+        }
+        __decorate([
+            (0, decorators_1.CircuitBreaker)({ failureThreshold: 2, resetTimeout: 100, fallback: 'fallbackMethod' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "primary", null);
+        const svc = new TestService();
+        const result = await svc.primary();
+        expect(result).toBe('fallback');
+    });
+    it('should use @Fallback decorator when primary fails', async () => {
+        class TestService {
+            async primary() {
+                throw new Error('primary failed');
+            }
+            async primaryFallback() {
+                return 'fallback';
+            }
+        }
+        __decorate([
+            (0, decorators_1.CircuitBreaker)({ failureThreshold: 2, resetTimeout: 100 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "primary", null);
+        __decorate([
+            (0, decorators_1.Fallback)('primary'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "primaryFallback", null);
+        const svc = new TestService();
+        const result = await svc.primary();
+        expect(result).toBe('fallback');
+    });
+    it('should throw when no fallback and primary fails', async () => {
+        class TestService {
+            async primary() {
+                throw new Error('primary failed');
+            }
+        }
+        __decorate([
+            (0, decorators_1.CircuitBreaker)({ failureThreshold: 2, resetTimeout: 100 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "primary", null);
+        const svc = new TestService();
+        await expect(svc.primary()).rejects.toThrow('primary failed');
+    });
+});
+describe('Retry decorator', () => {
+    it('should retry on failure and eventually succeed', async () => {
+        let attempts = 0;
+        class TestService {
+            async flaky() {
+                attempts++;
+                if (attempts < 3)
+                    throw new Error('fail');
+                return 'ok';
+            }
+        }
+        __decorate([
+            (0, decorators_1.Retry)({ maxAttempts: 5, backoff: 'fixed', baseDelay: 10 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "flaky", null);
+        const svc = new TestService();
+        const result = await svc.flaky();
+        expect(result).toBe('ok');
+        expect(attempts).toBe(3);
+    });
+    it('should throw after max attempts exhausted', async () => {
+        class TestService {
+            async alwaysFail() {
+                throw new Error('always fail');
+            }
+        }
+        __decorate([
+            (0, decorators_1.Retry)({ maxAttempts: 2, backoff: 'fixed', baseDelay: 10 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "alwaysFail", null);
+        const svc = new TestService();
+        await expect(svc.alwaysFail()).rejects.toThrow('Retry exhausted');
+    });
+});
+describe('Timeout decorator', () => {
+    it('should resolve when within timeout', async () => {
+        class TestService {
+            async fast() {
+                return 'ok';
+            }
+        }
+        __decorate([
+            (0, decorators_1.Timeout)(500),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "fast", null);
+        const svc = new TestService();
+        const result = await svc.fast();
+        expect(result).toBe('ok');
+    });
+    it('should reject when exceeding timeout', async () => {
+        class TestService {
+            async slow() {
+                await new Promise((r) => setTimeout(r, 200));
+                return 'slow';
+            }
+        }
+        __decorate([
+            (0, decorators_1.Timeout)(50),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "slow", null);
+        const svc = new TestService();
+        await expect(svc.slow()).rejects.toThrow();
+    });
+    it('should accept config object', async () => {
+        class TestService {
+            async fast() {
+                return 'ok';
+            }
+        }
+        __decorate([
+            (0, decorators_1.Timeout)({ duration: 500 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "fast", null);
+        const svc = new TestService();
+        const result = await svc.fast();
+        expect(result).toBe('ok');
+    });
+});
+describe('Bulkhead decorator', () => {
+    it('should limit concurrent executions', async () => {
+        class TestService {
+            async limited() {
+                await new Promise((r) => setTimeout(r, 50));
+                return 'done';
+            }
+        }
+        __decorate([
+            (0, decorators_1.Bulkhead)({ maxConcurrent: 1, maxQueue: 0 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "limited", null);
+        const svc = new TestService();
+        const [a, b] = await Promise.all([
+            svc.limited(),
+            svc.limited().catch((e) => e.message),
+        ]);
+        expect(a).toBe('done');
+        expect(b).toContain('Bulkhead');
+    });
+});
+describe('RateLimit decorator', () => {
+    it('should allow requests within limit', async () => {
+        class TestService {
+            async limited() {
+                return 'ok';
+            }
+        }
+        __decorate([
+            (0, decorators_1.RateLimit)({ strategy: 'sliding-window', max: 5, window: 60000 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "limited", null);
+        const svc = new TestService();
+        const result = await svc.limited();
+        expect(result).toBe('ok');
+    });
+    it('should throw RateLimitError when limit exceeded', async () => {
+        class TestService {
+            async limited() {
+                return 'ok';
+            }
+        }
+        __decorate([
+            (0, decorators_1.RateLimit)({ strategy: 'sliding-window', max: 1, window: 60000 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "limited", null);
+        const svc = new TestService();
+        await svc.limited();
+        await expect(svc.limited()).rejects.toThrow(types_1.RateLimitError);
+    });
+});
+describe('Fallback decorator', () => {
+    beforeEach(() => {
+        circuit_breaker_registry_1.CircuitBreakerRegistry.clear();
+    });
+    it('should store fallback metadata', async () => {
+        class TestService {
+            async primary() {
+                return 'ok';
+            }
+            async primaryFallback() {
+                return 'fallback';
+            }
+        }
+        __decorate([
+            (0, decorators_1.CircuitBreaker)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "primary", null);
+        __decorate([
+            (0, decorators_1.Fallback)('primary'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestService.prototype, "primaryFallback", null);
+        const svc = new TestService();
+        const result = await svc.primary();
+        expect(result).toBe('ok');
+    });
+});
+describe('Re-exported decorators', () => {
+    it('WithCircuitBreaker should equal CircuitBreaker', () => {
+        expect(index_1.WithCircuitBreaker).toBe(decorators_1.CircuitBreaker);
+    });
+    it('WithRetry should equal Retry', () => {
+        expect(index_1.WithRetry).toBe(decorators_1.Retry);
+    });
+    it('WithTimeout should equal Timeout', () => {
+        expect(index_1.WithTimeout).toBe(decorators_1.Timeout);
+    });
+    it('WithBulkhead should equal Bulkhead', () => {
+        expect(index_1.WithBulkhead).toBe(decorators_1.Bulkhead);
+    });
+    it('WithRateLimit should equal RateLimit', () => {
+        expect(index_1.WithRateLimit).toBe(decorators_1.RateLimit);
+    });
+});

package/dist/__tests__/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/__tests__/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/index.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/index.test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Index exports test - verifies all public API is exported correctly
+ */
+const index_1 = require("../index");
+describe('resilience index exports', () => {
+    it('should export circuit breaker components', () => {
+        expect(index_1.CircuitBreaker).toBeDefined();
+        expect(index_1.CircuitBreakerRegistry).toBeDefined();
+        expect(index_1.CountBasedSlidingWindow).toBeDefined();
+        expect(index_1.TimeBasedSlidingWindow).toBeDefined();
+        expect(index_1.createSlidingWindow).toBeDefined();
+    });
+    it('should export retry policy', () => {
+        expect(index_1.RetryPolicy).toBeDefined();
+    });
+    it('should export timeout', () => {
+        expect(index_1.Timeout).toBeDefined();
+        expect(index_1.withTimeout).toBeDefined();
+    });
+    it('should export bulkhead', () => {
+        expect(index_1.Bulkhead).toBeDefined();
+    });
+    it('should export rate limiter', () => {
+        expect(index_1.RateLimiter).toBeDefined();
+        expect(index_1.TokenBucketLimiter).toBeDefined();
+        expect(index_1.SlidingWindowLimiter).toBeDefined();
+    });
+    it('should export metrics', () => {
+        expect(index_1.MetricsCollector).toBeDefined();
+        expect(index_1.MetricsRegistry).toBeDefined();
+    });
+    it('should export decorators', () => {
+        expect(index_1.WithCircuitBreaker).toBeDefined();
+        expect(index_1.WithRetry).toBeDefined();
+        expect(index_1.WithTimeout).toBeDefined();
+        expect(index_1.WithBulkhead).toBeDefined();
+        expect(index_1.Fallback).toBeDefined();
+        expect(index_1.WithRateLimit).toBeDefined();
+    });
+    it('should export types and errors', () => {
+        expect(index_1.CircuitState).toBeDefined();
+        expect(index_1.CircuitBreakerError).toBeDefined();
+        expect(index_1.RetryExhaustedError).toBeDefined();
+        expect(index_1.TimeoutError).toBeDefined();
+        expect(index_1.BulkheadError).toBeDefined();
+        expect(index_1.RateLimitError).toBeDefined();
+    });
+});

package/dist/__tests__/metrics.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metrics.test.d.ts.map

package/dist/__tests__/metrics.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/metrics.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/metrics.test.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metrics_collector_1 = require("../metrics/metrics-collector");
+describe('MetricsCollector', () => {
+    let collector;
+    beforeEach(() => {
+        collector = new metrics_collector_1.MetricsCollector(60000);
+    });
+    it('should start with empty metrics', () => {
+        const snapshot = collector.getSnapshot();
+        expect(snapshot.totalCalls).toBe(0);
+        expect(snapshot.failureRate).toBe(0);
+    });
+    it('should record successes', () => {
+        collector.recordSuccess(100);
+        collector.recordSuccess(200);
+        const snapshot = collector.getSnapshot();
+        expect(snapshot.totalCalls).toBe(2);
+        expect(snapshot.successCalls).toBe(2);
+        expect(snapshot.failureCalls).toBe(0);
+        expect(snapshot.failureRate).toBe(0);
+        expect(snapshot.averageResponseTime).toBe(150);
+    });
+    it('should record failures', () => {
+        collector.recordSuccess(100);
+        collector.recordFailure(200, 'error');
+        const snapshot = collector.getSnapshot();
+        expect(snapshot.totalCalls).toBe(2);
+        expect(snapshot.successCalls).toBe(1);
+        expect(snapshot.failureCalls).toBe(1);
+        expect(snapshot.failureRate).toBe(50);
+    });
+    it('should calculate percentiles', () => {
+        // Record various durations
+        for (let i = 1; i <= 100; i++) {
+            collector.recordSuccess(i);
+        }
+        const snapshot = collector.getSnapshot();
+        expect(snapshot.p50ResponseTime).toBeGreaterThanOrEqual(49);
+        expect(snapshot.p50ResponseTime).toBeLessThanOrEqual(51);
+        expect(snapshot.p99ResponseTime).toBeGreaterThanOrEqual(98);
+        expect(snapshot.minResponseTime).toBe(1);
+        expect(snapshot.maxResponseTime).toBe(100);
+    });
+    it('should evict entries outside the window', async () => {
+        const shortWindow = new metrics_collector_1.MetricsCollector(100); // 100ms window
+        shortWindow.recordSuccess(50);
+        expect(shortWindow.getCallCount()).toBe(1);
+        // Wait for entries to expire
+        await new Promise((resolve) => setTimeout(resolve, 150));
+        expect(shortWindow.getCallCount()).toBe(0);
+    });
+    it('should reset metrics', () => {
+        collector.recordSuccess(100);
+        collector.recordFailure(200);
+        collector.reset();
+        expect(collector.getCallCount()).toBe(0);
+        expect(collector.getFailureRate()).toBe(0);
+    });
+});
+describe('MetricsRegistry', () => {
+    beforeEach(() => {
+        metrics_collector_1.MetricsRegistry.clear();
+    });
+    it('should create and cache collectors', () => {
+        const c1 = metrics_collector_1.MetricsRegistry.getOrCreate('test');
+        const c2 = metrics_collector_1.MetricsRegistry.getOrCreate('test');
+        expect(c1).toBe(c2);
+    });
+    it('should return different collectors for different names', () => {
+        const c1 = metrics_collector_1.MetricsRegistry.getOrCreate('a');
+        const c2 = metrics_collector_1.MetricsRegistry.getOrCreate('b');
+        expect(c1).not.toBe(c2);
+    });
+    it('should get all snapshots', () => {
+        metrics_collector_1.MetricsRegistry.getOrCreate('a').recordSuccess(100);
+        metrics_collector_1.MetricsRegistry.getOrCreate('b').recordFailure(200);
+        const snapshots = metrics_collector_1.MetricsRegistry.getAllSnapshots();
+        expect(Object.keys(snapshots)).toHaveLength(2);
+        expect(snapshots['a'].totalCalls).toBe(1);
+        expect(snapshots['b'].totalCalls).toBe(1);
+    });
+});

package/dist/__tests__/rate-limiter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rate-limiter.test.d.ts.map

package/dist/__tests__/rate-limiter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/rate-limiter.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/rate-limiter.test.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rate_limiter_1 = require("../rate-limiter/rate-limiter");
+const types_1 = require("../types");
+describe('TokenBucketLimiter', () => {
+    it('should allow requests within capacity', () => {
+        const limiter = new rate_limiter_1.TokenBucketLimiter(5, 10);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+    });
+    it('should reject when tokens exhausted', () => {
+        const limiter = new rate_limiter_1.TokenBucketLimiter(2, 10);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(false);
+    });
+    it('should refill tokens over time', async () => {
+        const limiter = new rate_limiter_1.TokenBucketLimiter(1, 100); // 100 tokens/sec
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(false);
+        await new Promise((r) => setTimeout(r, 15)); // ~1.5 tokens
+        expect(limiter.tryAcquire()).toBe(true);
+    });
+    it('getRetryAfterMs should return 0 when token available', () => {
+        const limiter = new rate_limiter_1.TokenBucketLimiter(5, 10);
+        expect(limiter.getRetryAfterMs()).toBe(0);
+    });
+    it('getRetryAfterMs should return positive when exhausted', () => {
+        const limiter = new rate_limiter_1.TokenBucketLimiter(1, 100);
+        limiter.tryAcquire();
+        const retryAfter = limiter.getRetryAfterMs();
+        expect(retryAfter).toBeGreaterThan(0);
+    });
+});
+describe('SlidingWindowLimiter', () => {
+    it('should allow requests within max', () => {
+        const limiter = new rate_limiter_1.SlidingWindowLimiter(5, 60000);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+    });
+    it('should reject when limit exceeded', () => {
+        const limiter = new rate_limiter_1.SlidingWindowLimiter(2, 60000);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(false);
+    });
+    it('getRetryAfterMs should return 0 when under limit', () => {
+        const limiter = new rate_limiter_1.SlidingWindowLimiter(5, 60000);
+        limiter.tryAcquire();
+        expect(limiter.getRetryAfterMs()).toBe(0);
+    });
+    it('getRetryAfterMs should return positive when at limit', () => {
+        const limiter = new rate_limiter_1.SlidingWindowLimiter(1, 60000);
+        limiter.tryAcquire();
+        expect(limiter.getRetryAfterMs()).toBeGreaterThan(0);
+    });
+});
+describe('RateLimiter', () => {
+    describe('token-bucket strategy', () => {
+        it('should execute fn when within limit', async () => {
+            const limiter = new rate_limiter_1.RateLimiter({
+                strategy: 'token-bucket',
+                max: 5,
+                window: 60000,
+            });
+            const result = await limiter.execute(() => Promise.resolve('ok'));
+            expect(result).toBe('ok');
+        });
+        it('should throw RateLimitError when limit exceeded', async () => {
+            const limiter = new rate_limiter_1.RateLimiter({
+                strategy: 'token-bucket',
+                max: 1,
+                window: 60000,
+            });
+            await limiter.execute(() => Promise.resolve('first'));
+            await expect(limiter.execute(() => Promise.resolve('second'))).rejects.toThrow(types_1.RateLimitError);
+        });
+        it('should include retryAfterMs in RateLimitError', async () => {
+            const limiter = new rate_limiter_1.RateLimiter({
+                strategy: 'token-bucket',
+                max: 1,
+                window: 60000,
+            });
+            await limiter.execute(() => Promise.resolve());
+            try {
+                await limiter.execute(() => Promise.resolve());
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(types_1.RateLimitError);
+                expect(e.retryAfterMs).toBeGreaterThan(0);
+            }
+        });
+    });
+    describe('sliding-window strategy', () => {
+        it('should execute fn when within limit', async () => {
+            const limiter = new rate_limiter_1.RateLimiter({
+                strategy: 'sliding-window',
+                max: 5,
+                window: 60000,
+            });
+            const result = await limiter.execute(() => Promise.resolve('ok'));
+            expect(result).toBe('ok');
+        });
+        it('should throw RateLimitError when limit exceeded', async () => {
+            const limiter = new rate_limiter_1.RateLimiter({
+                strategy: 'sliding-window',
+                max: 1,
+                window: 60000,
+            });
+            await limiter.execute(() => Promise.resolve('first'));
+            await expect(limiter.execute(() => Promise.resolve('second'))).rejects.toThrow(types_1.RateLimitError);
+        });
+    });
+    it('tryAcquire should consume token and return boolean', () => {
+        const limiter = new rate_limiter_1.RateLimiter({
+            strategy: 'sliding-window',
+            max: 1,
+            window: 60000,
+        });
+        expect(limiter.tryAcquire()).toBe(true);
+        expect(limiter.tryAcquire()).toBe(false);
+    });
+    it('getRetryAfterMs should return 0 when under limit', () => {
+        const limiter = new rate_limiter_1.RateLimiter({
+            strategy: 'sliding-window',
+            max: 5,
+            window: 60000,
+        });
+        expect(limiter.getRetryAfterMs()).toBe(0);
+    });
+    it('getStrategy should return configured strategy', () => {
+        const tb = new rate_limiter_1.RateLimiter({ strategy: 'token-bucket', max: 10, window: 1000 });
+        expect(tb.getStrategy()).toBe('token-bucket');
+        const sw = new rate_limiter_1.RateLimiter({ strategy: 'sliding-window', max: 10, window: 1000 });
+        expect(sw.getStrategy()).toBe('sliding-window');
+    });
+});

package/dist/__tests__/retry-policy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=retry-policy.test.d.ts.map

package/dist/__tests__/retry-policy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-policy.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/retry-policy.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/retry-policy.test.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const retry_policy_1 = require("../retry/retry-policy");
+const types_1 = require("../types");
+describe('RetryPolicy', () => {
+    it('should succeed on first try', async () => {
+        const policy = new retry_policy_1.RetryPolicy({ maxAttempts: 3 });
+        const result = await policy.execute(() => Promise.resolve('ok'));
+        expect(result).toBe('ok');
+    });
+    it('should retry on failure and eventually succeed', async () => {
+        let attempts = 0;
+        const policy = new retry_policy_1.RetryPolicy({
+            maxAttempts: 3,
+            baseDelay: 10,
+            jitter: false,
+            backoff: 'fixed',
+        });
+        const result = await policy.execute(async () => {
+            attempts++;
+            if (attempts < 3)
+                throw new Error('transient');
+            return 'recovered';
+        });
+        expect(result).toBe('recovered');
+        expect(attempts).toBe(3);
+    });
+    it('should throw RetryExhaustedError after max attempts', async () => {
+        const policy = new retry_policy_1.RetryPolicy({
+            maxAttempts: 2,
+            baseDelay: 10,
+            jitter: false,
+            backoff: 'fixed',
+        });
+        await expect(policy.execute(() => Promise.reject(new Error('always-fail')))).rejects.toThrow(types_1.RetryExhaustedError);
+    });
+    it('should not retry non-retryable errors', async () => {
+        let attempts = 0;
+        const policy = new retry_policy_1.RetryPolicy({
+            maxAttempts: 5,
+            baseDelay: 10,
+            retryPredicate: (error) => error instanceof Error && error.message !== 'fatal',
+        });
+        await expect(policy.execute(async () => {
+            attempts++;
+            throw new Error('fatal');
+        })).rejects.toThrow('fatal');
+        expect(attempts).toBe(1); // No retries for non-retryable
+    });
+    it('should call onRetry callback', async () => {
+        const retries = [];
+        const policy = new retry_policy_1.RetryPolicy({
+            maxAttempts: 3,
+            baseDelay: 10,
+            jitter: false,
+            backoff: 'fixed',
+            onRetry: (_error, attempt) => retries.push(attempt),
+        });
+        await policy.execute(() => Promise.reject(new Error('fail'))).catch(() => { });
+        expect(retries).toEqual([1, 2, 3]);
+    });
+    it('should use exponential backoff', async () => {
+        const timestamps = [];
+        const policy = new retry_policy_1.RetryPolicy({
+            maxAttempts: 3,
+            baseDelay: 50,
+            jitter: false,
+            backoff: 'exponential',
+        });
+        await policy
+            .execute(async () => {
+            timestamps.push(Date.now());
+            throw new Error('fail');
+        })
+            .catch(() => { });
+        // Should have 4 timestamps (initial + 3 retries)
+        expect(timestamps.length).toBe(4);
+        // Delays should roughly double: ~50ms, ~100ms, ~200ms
+        const delay1 = timestamps[1] - timestamps[0];
+        const delay2 = timestamps[2] - timestamps[1];
+        expect(delay1).toBeGreaterThanOrEqual(30); // ~50ms with some tolerance
+        expect(delay2).toBeGreaterThanOrEqual(60); // ~100ms with some tolerance
+    });
+});