import { describe, expect, it, vi } from "vitest";

import { resolveRetryConfig, retryAsync } from "./retry-utils.js";

describe("resolveRetryConfig", () => {

const defaults = {

attempts: 4,

minDelayMs: 0,

maxDelayMs: 0,

jitter: 0,

};

it("does not round malformed attempt counts", () => {

expect(resolveRetryConfig(defaults, { attempts: 1.5 }).attempts).toBe(4);

expect(resolveRetryConfig(defaults, { attempts: Number.POSITIVE_INFINITY }).attempts).toBe(4);

expect(resolveRetryConfig(defaults, { attempts: Number.NaN }).attempts).toBe(4);

});

});

describe("retryAsync", () => {

it("falls back to the default attempt count for malformed numeric counts", async () => {

const run = vi.fn(async () => {

throw new Error("boom");

});

await expect(retryAsync(run, Number.NaN, 0)).rejects.toThrow("boom");

expect(run).toHaveBeenCalledTimes(3);

});

});

return Math.min(Math.max(next, floor), ceiling);

}

function resolveAttempts(value: unknown, fallback: number): number {

if (typeof value !== "number" || !Number.isSafeInteger(value)) {

return fallback;

}

return Math.max(1, value);

}

export function resolveRetryConfig(

defaults: Required<RetryConfig> = DEFAULT_RETRY_CONFIG,

overrides?: RetryConfig,

): Required<RetryConfig> {

const attempts = Math.max(1, Math.round(clampNumber(overrides?.attempts, defaults.attempts, 1)));

const attempts = resolveAttempts(overrides?.attempts, defaults.attempts);

const minDelayMs = Math.max(

0,

Math.round(clampNumber(overrides?.minDelayMs, defaults.minDelayMs, 0)),

initialDelayMs = 300,

): Promise<T> {

if (typeof attemptsOrOptions === "number") {

const attempts = Math.max(1, Math.round(attemptsOrOptions));

const attempts = resolveAttempts(attemptsOrOptions, DEFAULT_RETRY_CONFIG.attempts);

let lastErr: unknown;

for (let i = 0; i < attempts; i += 1) {

try {