@zapier/zapier-sdk 0.13.7 → 0.13.9

package/dist/utils/batch-utils.test.js

@@ -0,0 +1,476 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { batch } from "./batch-utils";
+// Mock the timers/promises module
+vi.mock("timers/promises", () => ({
+    setTimeout: vi.fn(() => Promise.resolve()),
+}));
+// Mock retry-utils to control backoff behavior in tests
+vi.mock("./retry-utils", () => ({
+    calculateWaitTime: vi.fn(() => 0), // No delay in tests
+    MAX_CONSECUTIVE_ERRORS: 3,
+}));
+describe("batch", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("basic functionality", () => {
+        it("should execute all tasks and return settled results", async () => {
+            const tasks = [
+                () => Promise.resolve("result1"),
+                () => Promise.resolve("result2"),
+                () => Promise.resolve("result3"),
+            ];
+            const results = await batch(tasks);
+            expect(results).toEqual([
+                { status: "fulfilled", value: "result1" },
+                { status: "fulfilled", value: "result2" },
+                { status: "fulfilled", value: "result3" },
+            ]);
+        });
+        it("should handle empty task array", async () => {
+            const results = await batch([]);
+            expect(results).toEqual([]);
+        });
+        it("should handle single task", async () => {
+            const tasks = [() => Promise.resolve("single")];
+            const results = await batch(tasks);
+            expect(results).toEqual([{ status: "fulfilled", value: "single" }]);
+        });
+        it("should maintain result order matching input order", async () => {
+            // Create tasks that resolve in reverse order but should maintain input order
+            const tasks = [
+                () => new Promise((resolve) => setTimeout(() => resolve("first"), 30)),
+                () => new Promise((resolve) => setTimeout(() => resolve("second"), 20)),
+                () => new Promise((resolve) => setTimeout(() => resolve("third"), 10)),
+            ];
+            const results = await batch(tasks);
+            expect(results[0]).toEqual({ status: "fulfilled", value: "first" });
+            expect(results[1]).toEqual({ status: "fulfilled", value: "second" });
+            expect(results[2]).toEqual({ status: "fulfilled", value: "third" });
+        });
+    });
+    describe("concurrency limiting", () => {
+        it("should limit concurrent execution", async () => {
+            let concurrentCount = 0;
+            let maxConcurrent = 0;
+            const createTask = () => () => {
+                concurrentCount++;
+                maxConcurrent = Math.max(maxConcurrent, concurrentCount);
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        concurrentCount--;
+                        resolve("done");
+                    }, 10);
+                });
+            };
+            const tasks = Array.from({ length: 20 }, createTask);
+            await batch(tasks, { concurrency: 5 });
+            // Max concurrent should not exceed limit
+            expect(maxConcurrent).toBeLessThanOrEqual(5);
+        });
+        it("should respect custom concurrency limit", async () => {
+            let concurrentCount = 0;
+            let maxConcurrent = 0;
+            const createTask = () => () => {
+                concurrentCount++;
+                maxConcurrent = Math.max(maxConcurrent, concurrentCount);
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        concurrentCount--;
+                        resolve("done");
+                    }, 10);
+                });
+            };
+            const tasks = Array.from({ length: 20 }, createTask);
+            await batch(tasks, { concurrency: 3 });
+            expect(maxConcurrent).toBeLessThanOrEqual(3);
+        });
+        it("should handle concurrency limit greater than task count", async () => {
+            const tasks = [() => Promise.resolve(1), () => Promise.resolve(2)];
+            const results = await batch(tasks, { concurrency: 10 });
+            expect(results).toHaveLength(2);
+        });
+    });
+    describe("error handling", () => {
+        it("should handle failing tasks without stopping batch", async () => {
+            const tasks = [
+                () => Promise.resolve("success1"),
+                () => Promise.reject(new Error("failed")),
+                () => Promise.resolve("success2"),
+            ];
+            const results = await batch(tasks, { retry: false });
+            expect(results[0]).toEqual({ status: "fulfilled", value: "success1" });
+            expect(results[1]).toEqual({
+                status: "rejected",
+                reason: expect.any(Error),
+            });
+            expect(results[2]).toEqual({ status: "fulfilled", value: "success2" });
+        });
+        it("should retry failed tasks when retry is enabled", async () => {
+            let attemptCount = 0;
+            const failTwiceThenSucceed = () => {
+                attemptCount++;
+                if (attemptCount <= 2) {
+                    return Promise.reject(new Error("temporary failure"));
+                }
+                return Promise.resolve("success");
+            };
+            const tasks = [failTwiceThenSucceed];
+            const results = await batch(tasks, { retry: true });
+            expect(results[0]).toEqual({ status: "fulfilled", value: "success" });
+            expect(attemptCount).toBe(3); // Initial + 2 retries
+        });
+        it("should give up after MAX_CONSECUTIVE_ERRORS retries", async () => {
+            let attemptCount = 0;
+            const alwaysFail = () => {
+                attemptCount++;
+                return Promise.reject(new Error("always fails"));
+            };
+            const tasks = [alwaysFail];
+            const results = await batch(tasks, { retry: true });
+            expect(results[0]).toEqual({
+                status: "rejected",
+                reason: expect.any(Error),
+            });
+            expect(attemptCount).toBe(3); // MAX_CONSECUTIVE_ERRORS
+        });
+        it("should not retry when retry is disabled", async () => {
+            let attemptCount = 0;
+            const failTask = () => {
+                attemptCount++;
+                return Promise.reject(new Error("failed"));
+            };
+            const tasks = [failTask];
+            const results = await batch(tasks, { retry: false });
+            expect(results[0]).toEqual({
+                status: "rejected",
+                reason: expect.any(Error),
+            });
+            expect(attemptCount).toBe(1); // No retries
+        });
+    });
+    describe("options validation", () => {
+        it("should throw error for invalid concurrency", async () => {
+            const tasks = [() => Promise.resolve("test")];
+            await expect(batch(tasks, { concurrency: 0 })).rejects.toThrow("Concurrency must be greater than 0");
+            await expect(batch(tasks, { concurrency: -1 })).rejects.toThrow("Concurrency must be greater than 0");
+        });
+        it("should use default options when not provided", async () => {
+            const tasks = [() => Promise.resolve("test")];
+            const results = await batch(tasks);
+            expect(results).toEqual([{ status: "fulfilled", value: "test" }]);
+        });
+    });
+    describe("mixed success and failure scenarios", () => {
+        it("should handle alternating success and failure", async () => {
+            const tasks = [
+                () => Promise.resolve("success1"),
+                () => Promise.reject(new Error("error1")),
+                () => Promise.resolve("success2"),
+                () => Promise.reject(new Error("error2")),
+                () => Promise.resolve("success3"),
+            ];
+            const results = await batch(tasks, { retry: false });
+            expect(results[0].status).toBe("fulfilled");
+            expect(results[1].status).toBe("rejected");
+            expect(results[2].status).toBe("fulfilled");
+            expect(results[3].status).toBe("rejected");
+            expect(results[4].status).toBe("fulfilled");
+        });
+        it("should handle some tasks succeeding after retry", async () => {
+            let task1Attempts = 0;
+            let task2Attempts = 0;
+            const task1 = () => {
+                task1Attempts++;
+                if (task1Attempts === 1) {
+                    return Promise.reject(new Error("task1 first attempt"));
+                }
+                return Promise.resolve("task1 success");
+            };
+            const task2 = () => {
+                task2Attempts++;
+                return Promise.resolve("task2 success");
+            };
+            const tasks = [task1, task2];
+            const results = await batch(tasks, { retry: true });
+            expect(results[0]).toEqual({
+                status: "fulfilled",
+                value: "task1 success",
+            });
+            expect(results[1]).toEqual({
+                status: "fulfilled",
+                value: "task2 success",
+            });
+            expect(task1Attempts).toBe(2); // Initial + 1 retry
+            expect(task2Attempts).toBe(1); // No retry needed
+        });
+    });
+    describe("performance characteristics", () => {
+        it("should complete faster with higher concurrency", async () => {
+            const delay = 50; // ms
+            const taskCount = 10;
+            const tasks = Array.from({ length: taskCount }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), delay)));
+            // Low concurrency (sequential-ish)
+            const start1 = Date.now();
+            await batch([...tasks], { concurrency: 1 });
+            const duration1 = Date.now() - start1;
+            // High concurrency (parallel)
+            const start2 = Date.now();
+            await batch([...tasks], { concurrency: 10 });
+            const duration2 = Date.now() - start2;
+            // High concurrency should be significantly faster
+            // Allow some margin for timing variability
+            expect(duration2).toBeLessThan(duration1 * 0.8);
+        });
+    });
+    describe("result ordering guarantees", () => {
+        it("should maintain exact order with out-of-order completion and mixed results", async () => {
+            // This is the ultimate ordering test - combining:
+            // 1. Tasks that complete in reverse order (via delays)
+            // 2. Mixed success/failure
+            // 3. High concurrency (multiple workers racing)
+            const executionLog = [];
+            const tasks = [
+                // Task 0: Slow success
+                () => new Promise((resolve) => {
+                    setTimeout(() => {
+                        executionLog.push("task0-complete");
+                        resolve("result0");
+                    }, 100);
+                }),
+                // Task 1: Fast failure
+                () => new Promise((_, reject) => {
+                    setTimeout(() => {
+                        executionLog.push("task1-complete");
+                        reject(new Error("error1"));
+                    }, 10);
+                }),
+                // Task 2: Medium success
+                () => new Promise((resolve) => {
+                    setTimeout(() => {
+                        executionLog.push("task2-complete");
+                        resolve("result2");
+                    }, 50);
+                }),
+                // Task 3: Instant failure
+                () => new Promise((_, reject) => {
+                    executionLog.push("task3-complete");
+                    reject(new Error("error3"));
+                }),
+                // Task 4: Medium-slow success
+                () => new Promise((resolve) => {
+                    setTimeout(() => {
+                        executionLog.push("task4-complete");
+                        resolve("result4");
+                    }, 75);
+                }),
+            ];
+            const results = await batch(tasks, { concurrency: 5, retry: false });
+            // Verify all tasks completed
+            expect(executionLog).toHaveLength(5);
+            expect(executionLog).toContain("task0-complete");
+            expect(executionLog).toContain("task1-complete");
+            expect(executionLog).toContain("task2-complete");
+            expect(executionLog).toContain("task3-complete");
+            expect(executionLog).toContain("task4-complete");
+            // BUT results MUST maintain input order despite out-of-order completion
+            expect(results).toHaveLength(5);
+            // Task 0: position 0, slow success
+            expect(results[0]).toEqual({
+                status: "fulfilled",
+                value: "result0",
+            });
+            // Task 1: position 1, fast failure
+            expect(results[1]).toEqual({
+                status: "rejected",
+                reason: expect.objectContaining({
+                    message: "error1",
+                }),
+            });
+            // Task 2: position 2, medium success
+            expect(results[2]).toEqual({
+                status: "fulfilled",
+                value: "result2",
+            });
+            // Task 3: position 3, instant failure
+            expect(results[3]).toEqual({
+                status: "rejected",
+                reason: expect.objectContaining({
+                    message: "error3",
+                }),
+            });
+            // Task 4: position 4, medium-slow success
+            expect(results[4]).toEqual({
+                status: "fulfilled",
+                value: "result4",
+            });
+        });
+        it("should match Promise.allSettled ordering behavior exactly", async () => {
+            // This test ensures our batch function has identical ordering to Promise.allSettled
+            const tasks = [
+                () => new Promise((resolve) => setTimeout(() => resolve("a"), 30)),
+                () => new Promise((_, reject) => setTimeout(() => reject(new Error("b")), 10)),
+                () => new Promise((resolve) => setTimeout(() => resolve("c"), 20)),
+            ];
+            // Run both in parallel
+            const [batchResults, settledResults] = await Promise.all([
+                batch(tasks.map((t) => t), { concurrency: 3, retry: false }),
+                Promise.allSettled(tasks.map((t) => t())),
+            ]);
+            // Results should have same structure
+            expect(batchResults).toHaveLength(settledResults.length);
+            // Compare each result
+            for (let i = 0; i < batchResults.length; i++) {
+                const batchResult = batchResults[i];
+                const settledResult = settledResults[i];
+                expect(batchResult.status).toBe(settledResult.status);
+                if (batchResult.status === "fulfilled" &&
+                    settledResult.status === "fulfilled") {
+                    expect(batchResult.value).toBe(settledResult.value);
+                }
+                if (batchResult.status === "rejected" &&
+                    settledResult.status === "rejected") {
+                    expect(batchResult.reason).toBeInstanceOf(Error);
+                    expect(settledResult.reason).toBeInstanceOf(Error);
+                }
+            }
+        });
+    });
+    describe("timeout handling", () => {
+        beforeEach(async () => {
+            // Unmock setTimeout for timeout tests to allow real timing
+            vi.unmock("timers/promises");
+            // Re-import batch to get the non-mocked version
+            vi.resetModules();
+        });
+        afterEach(() => {
+            // Restore mocks after timeout tests
+            vi.doMock("timers/promises", () => ({
+                setTimeout: vi.fn(() => Promise.resolve()),
+            }));
+        });
+        it("should throw error when overall batch timeout is exceeded", async () => {
+            const { batch } = await import("./batch-utils");
+            const tasks = Array.from({ length: 10 }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), 100)));
+            await expect(batch(tasks, { concurrency: 2, timeoutMs: 50 })).rejects.toThrow("Batch operation timed out");
+        });
+        it("should timeout individual tasks when taskTimeoutMs is set", async () => {
+            const { batch } = await import("./batch-utils");
+            const tasks = [
+                () => Promise.resolve("instant"), // Instant task - should not timeout
+                () => new Promise((resolve) => setTimeout(() => resolve("slow"), 500)), // Slow task - should timeout
+                () => Promise.resolve("instant2"), // Another instant task - should not timeout
+            ];
+            const results = await batch(tasks, {
+                taskTimeoutMs: 100, // 100ms timeout
+                retry: false,
+                batchDelay: 0, // Disable batch delay for timing reliability
+            });
+            expect(results[0].status).toBe("fulfilled");
+            expect(results[1].status).toBe("rejected");
+            if (results[1].status === "rejected") {
+                expect(results[1].reason).toBeInstanceOf(Error);
+                expect(results[1].reason.message).toContain("timed out");
+            }
+            expect(results[2].status).toBe("fulfilled");
+        });
+        it("should not retry tasks that timeout", async () => {
+            const { batch } = await import("./batch-utils");
+            let attemptCount = 0;
+            const slowTask = () => {
+                attemptCount++;
+                return new Promise((resolve) => setTimeout(() => resolve("done"), 200));
+            };
+            const results = await batch([slowTask], {
+                taskTimeoutMs: 50,
+                retry: true,
+            });
+            expect(results[0].status).toBe("rejected");
+            expect(attemptCount).toBe(1); // Should not retry timeout errors
+        });
+        it("should validate timeout parameters", async () => {
+            const { batch } = await import("./batch-utils");
+            const tasks = [() => Promise.resolve("test")];
+            await expect(batch(tasks, { timeoutMs: 0 })).rejects.toThrow("Timeout must be greater than 0");
+            await expect(batch(tasks, { timeoutMs: -100 })).rejects.toThrow("Timeout must be greater than 0");
+            await expect(batch(tasks, { taskTimeoutMs: 0 })).rejects.toThrow("Task timeout must be greater than 0");
+            await expect(batch(tasks, { taskTimeoutMs: -100 })).rejects.toThrow("Task timeout must be greater than 0");
+        });
+        it("should complete tasks that finish before overall timeout", async () => {
+            const { batch } = await import("./batch-utils");
+            const tasks = [
+                () => new Promise((resolve) => setTimeout(() => resolve("task1"), 10)),
+                () => new Promise((resolve) => setTimeout(() => resolve("task2"), 20)),
+                () => new Promise((resolve) => setTimeout(() => resolve("task3"), 30)),
+            ];
+            const results = await batch(tasks, {
+                timeoutMs: 100,
+                concurrency: 3,
+            });
+            expect(results).toHaveLength(3);
+            expect(results[0].status).toBe("fulfilled");
+            expect(results[1].status).toBe("fulfilled");
+            expect(results[2].status).toBe("fulfilled");
+        });
+        it("should report tasks remaining when batch timeout occurs", async () => {
+            const { batch } = await import("./batch-utils");
+            const tasks = Array.from({ length: 20 }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), 100)));
+            try {
+                await batch(tasks, { concurrency: 2, timeoutMs: 50 });
+                expect.fail("Should have thrown timeout error");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(Error);
+                expect(error.message).toContain("task(s) not completed");
+            }
+        });
+        it("should allow taskTimeoutMs without overall timeout affecting quick tasks", async () => {
+            const { batch } = await import("./batch-utils");
+            const tasks = [
+                () => Promise.resolve("instant1"),
+                () => Promise.resolve("instant2"),
+                () => Promise.resolve("instant3"),
+            ];
+            const results = await batch(tasks, {
+                taskTimeoutMs: 1000,
+                timeoutMs: 5000,
+            });
+            expect(results).toHaveLength(3);
+            expect(results.every((r) => r.status === "fulfilled")).toBe(true);
+        });
+        it("should handle mix of timed out and successful tasks", async () => {
+            const { batch } = await import("./batch-utils");
+            const tasks = [
+                () => Promise.resolve("fast1"), // Instant - should not timeout
+                () => new Promise((resolve) => setTimeout(() => resolve("slow1"), 500)), // Slow - should timeout
+                () => Promise.resolve("fast2"), // Instant - should not timeout
+                () => new Promise((resolve) => setTimeout(() => resolve("slow2"), 500)), // Slow - should timeout
+            ];
+            const results = await batch(tasks, {
+                taskTimeoutMs: 100,
+                retry: false,
+                concurrency: 4,
+                batchDelay: 0, // Disable batch delay for timing reliability
+            });
+            expect(results[0].status).toBe("fulfilled");
+            expect(results[1].status).toBe("rejected");
+            expect(results[2].status).toBe("fulfilled");
+            expect(results[3].status).toBe("rejected");
+        });
+        it("should use default timeout when not specified", async () => {
+            const { batch } = await import("./batch-utils");
+            const tasks = [
+                () => Promise.resolve("test1"),
+                () => Promise.resolve("test2"),
+            ];
+            // Should not throw with default 3-minute timeout
+            const results = await batch(tasks);
+            expect(results).toHaveLength(2);
+            expect(results[0].status).toBe("fulfilled");
+            expect(results[1].status).toBe("fulfilled");
+        });
+    });
+});

package/dist/utils/retry-utils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Retry and Backoff Utilities
+ *
+ * Shared utilities for implementing resilient retry logic with exponential backoff
+ * and jitter. Used by both polling and batch operations.
+ */
+/**
+ * Maximum number of consecutive errors before giving up
+ * Prevents infinite retry loops when the API is consistently failing
+ */
+export declare const MAX_CONSECUTIVE_ERRORS = 3;
+/**
+ * Base delay for error backoff in milliseconds
+ * Each error adds this amount (with scaling) to the wait time
+ */
+export declare const BASE_ERROR_BACKOFF_MS = 1000;
+/**
+ * Jitter factor (0.0 to 1.0) for randomizing wait times
+ * Prevents thundering herd problem when many clients retry simultaneously
+ * A factor of 0.5 means we add 0-50% random variance to the base interval
+ */
+export declare const JITTER_FACTOR = 0.5;
+/**
+ * Calculate wait time with jitter and error backoff
+ *
+ * This implements two key reliability patterns:
+ * 1. Jitter - Adds randomness to prevent synchronized retries across clients
+ * 2. Error backoff - Increases wait time when errors occur, giving the API time to recover
+ *
+ * @param baseInterval - The base wait time in milliseconds
+ * @param errorCount - Number of consecutive errors (0 if no errors)
+ * @returns Wait time in milliseconds with jitter and error backoff applied
+ *
+ * @example
+ * // No errors: returns 1000-1500ms (1000 + 0-500ms jitter)
+ * calculateWaitTime(1000, 0);
+ *
+ * // 2 errors: returns 1000-1500ms base + up to 1000ms error backoff = 1000-2500ms
+ * calculateWaitTime(1000, 2);
+ *
+ * // 6 errors: returns 1000-1500ms base + 2000ms capped backoff = 3000-3500ms
+ * calculateWaitTime(1000, 6);
+ */
+export declare function calculateWaitTime(baseInterval: number, errorCount: number): number;
+//# sourceMappingURL=retry-utils.d.ts.map

package/dist/utils/retry-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-utils.d.ts","sourceRoot":"","sources":["../../src/utils/retry-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;GAGG;AACH,eAAO,MAAM,qBAAqB,OAAQ,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,MAAM,CAYR"}

package/dist/utils/retry-utils.js

@@ -0,0 +1,51 @@
+/**
+ * Retry and Backoff Utilities
+ *
+ * Shared utilities for implementing resilient retry logic with exponential backoff
+ * and jitter. Used by both polling and batch operations.
+ */
+/**
+ * Maximum number of consecutive errors before giving up
+ * Prevents infinite retry loops when the API is consistently failing
+ */
+export const MAX_CONSECUTIVE_ERRORS = 3;
+/**
+ * Base delay for error backoff in milliseconds
+ * Each error adds this amount (with scaling) to the wait time
+ */
+export const BASE_ERROR_BACKOFF_MS = 1000;
+/**
+ * Jitter factor (0.0 to 1.0) for randomizing wait times
+ * Prevents thundering herd problem when many clients retry simultaneously
+ * A factor of 0.5 means we add 0-50% random variance to the base interval
+ */
+export const JITTER_FACTOR = 0.5;
+/**
+ * Calculate wait time with jitter and error backoff
+ *
+ * This implements two key reliability patterns:
+ * 1. Jitter - Adds randomness to prevent synchronized retries across clients
+ * 2. Error backoff - Increases wait time when errors occur, giving the API time to recover
+ *
+ * @param baseInterval - The base wait time in milliseconds
+ * @param errorCount - Number of consecutive errors (0 if no errors)
+ * @returns Wait time in milliseconds with jitter and error backoff applied
+ *
+ * @example
+ * // No errors: returns 1000-1500ms (1000 + 0-500ms jitter)
+ * calculateWaitTime(1000, 0);
+ *
+ * // 2 errors: returns 1000-1500ms base + up to 1000ms error backoff = 1000-2500ms
+ * calculateWaitTime(1000, 2);
+ *
+ * // 6 errors: returns 1000-1500ms base + 2000ms capped backoff = 3000-3500ms
+ * calculateWaitTime(1000, 6);
+ */
+export function calculateWaitTime(baseInterval, errorCount) {
+    // Jitter to avoid thundering herd (multiple clients retrying at exact same time)
+    const jitter = Math.random() * JITTER_FACTOR * baseInterval;
+    // Exponential backoff scaled by error count, but capped at 2x base interval
+    // This prevents wait times from growing unboundedly
+    const errorBackoff = Math.min(BASE_ERROR_BACKOFF_MS * (errorCount / 2), baseInterval * 2);
+    return Math.floor(baseInterval + jitter + errorBackoff);
+}

package/dist/utils/retry-utils.test.d.ts

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

package/dist/utils/retry-utils.test.d.ts.map

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

package/dist/utils/retry-utils.test.js

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { calculateWaitTime, MAX_CONSECUTIVE_ERRORS, BASE_ERROR_BACKOFF_MS, JITTER_FACTOR, } from "./retry-utils";
+describe("retry-utils", () => {
+    describe("calculateWaitTime", () => {
+        beforeEach(() => {
+            // Seed random for consistent testing
+            vi.spyOn(Math, "random");
+        });
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+        it("should return base interval with jitter when no errors", () => {
+            vi.spyOn(Math, "random").mockReturnValue(0.5); // Middle of jitter range
+            const baseInterval = 1000;
+            const waitTime = calculateWaitTime(baseInterval, 0);
+            // With 0.5 random and JITTER_FACTOR 0.5:
+            // jitter = 0.5 * 0.5 * 1000 = 250ms
+            // errorBackoff = 0 (no errors)
+            // total = 1000 + 250 + 0 = 1250ms
+            expect(waitTime).toBe(1250);
+        });
+        it("should add error backoff for consecutive errors", () => {
+            vi.spyOn(Math, "random").mockReturnValue(0); // No jitter for simpler math
+            const baseInterval = 1000;
+            const errorCount = 2;
+            const waitTime = calculateWaitTime(baseInterval, errorCount);
+            // jitter = 0 (random is 0)
+            // errorBackoff = BASE_ERROR_BACKOFF_MS * (errorCount / 2) = 1000 * (2/2) = 1000ms
+            // total = 1000 + 0 + 1000 = 2000ms
+            expect(waitTime).toBe(2000);
+        });
+        it("should cap error backoff at 2x base interval", () => {
+            vi.spyOn(Math, "random").mockReturnValue(0); // No jitter
+            const baseInterval = 1000;
+            const errorCount = 10; // Large error count
+            const waitTime = calculateWaitTime(baseInterval, errorCount);
+            // errorBackoff would be 1000 * (10/2) = 5000ms
+            // but it's capped at 2x base = 2000ms
+            // total = 1000 + 0 + 2000 = 3000ms
+            expect(waitTime).toBe(3000);
+        });
+        it("should add random jitter to prevent thundering herd", () => {
+            const baseInterval = 1000;
+            const results = new Set();
+            // Run multiple times with real random to ensure jitter varies
+            vi.spyOn(Math, "random").mockRestore(); // Use real random
+            for (let i = 0; i < 10; i++) {
+                const waitTime = calculateWaitTime(baseInterval, 0);
+                results.add(waitTime);
+            }
+            // Should have multiple different values due to jitter
+            expect(results.size).toBeGreaterThan(1);
+            // All values should be in expected range
+            // baseInterval (1000) + jitter (0 to JITTER_FACTOR * baseInterval)
+            // = 1000 to 1500ms
+            for (const result of results) {
+                expect(result).toBeGreaterThanOrEqual(1000);
+                expect(result).toBeLessThanOrEqual(1500);
+            }
+        });
+        it("should combine jitter and error backoff", () => {
+            vi.spyOn(Math, "random").mockReturnValue(0.5);
+            const baseInterval = 1000;
+            const errorCount = 2;
+            const waitTime = calculateWaitTime(baseInterval, errorCount);
+            // jitter = 0.5 * 0.5 * 1000 = 250ms
+            // errorBackoff = 1000 * (2/2) = 1000ms
+            // total = 1000 + 250 + 1000 = 2250ms
+            expect(waitTime).toBe(2250);
+        });
+        it("should return integer wait time", () => {
+            vi.spyOn(Math, "random").mockReturnValue(0.333);
+            const baseInterval = 1000;
+            const waitTime = calculateWaitTime(baseInterval, 1);
+            // Result should be floored integer
+            expect(Number.isInteger(waitTime)).toBe(true);
+        });
+    });
+    describe("constants", () => {
+        it("should export MAX_CONSECUTIVE_ERRORS", () => {
+            expect(MAX_CONSECUTIVE_ERRORS).toBe(3);
+        });
+        it("should export BASE_ERROR_BACKOFF_MS", () => {
+            expect(BASE_ERROR_BACKOFF_MS).toBe(1000);
+        });
+        it("should export JITTER_FACTOR", () => {
+            expect(JITTER_FACTOR).toBe(0.5);
+        });
+    });
+});