import {jest, describe, it, expect, beforeEach, afterEach} from '@jest/globals';

import type {IncomingMessage} from 'http';

jest.unstable_mockModule('@actions/core', () => ({

info: jest.fn()

}));

const core = await import('@actions/core');

const httpm = await import('@actions/http-client');

const {RetryingHttpClient, isRetryableNetworkError, parseRetryAfter} =

await import('../src/retrying-http-client.js');

function response(

statusCode: number,

retryAfter?: string

): httpm.HttpClientResponse {

return {

message: {

statusCode,

headers: retryAfter ? {'retry-after': retryAfter} : {}

} as IncomingMessage,

readBody: jest.fn(async () => '')

} as unknown as httpm.HttpClientResponse;

}

describe('RetryingHttpClient', () => {

let request: ReturnType<typeof jest.spyOn>;

let sleep: jest.Mock<(delayMs: number) => Promise<void>>;

beforeEach(() => {

request = jest.spyOn(httpm.HttpClient.prototype, 'request');

sleep = jest.fn(async () => undefined);

});

afterEach(() => {

jest.restoreAllMocks();

jest.clearAllMocks();

});

it('uses exponential backoff with jitter for retryable responses', async () => {

request

.mockResolvedValueOnce(response(503))

.mockResolvedValueOnce(response(502))

.mockResolvedValueOnce(response(200));

const client = new RetryingHttpClient('test', {

sleep,

random: () => 0,

baseDelayMs: 1000,

maxDelayMs: 10000

});

await expect(client.get('https://example.com')).resolves.toBeDefined();

expect(request).toHaveBeenCalledTimes(3);

expect(sleep).toHaveBeenNthCalledWith(1, 500);

expect(sleep).toHaveBeenNthCalledWith(2, 1000);

expect(core.info).toHaveBeenNthCalledWith(

1,

'Request attempt 1 of 4 failed (HTTP 503); retrying in 500 ms'

);

expect(core.info).toHaveBeenNthCalledWith(

2,

'Request attempt 2 of 4 failed (HTTP 502); retrying in 1000 ms'

);

});

it('honors Retry-After delta-seconds over the client delay', async () => {

request

.mockResolvedValueOnce(response(429, '3'))

.mockResolvedValueOnce(response(200));

const client = new RetryingHttpClient('test', {

sleep,

random: () => 0

});

await client.get('https://example.com');

expect(sleep).toHaveBeenCalledWith(3000);

});

it('honors Retry-After HTTP dates over the client delay', async () => {

const now = Date.parse('2026-07-29T00:00:00Z');

request

.mockResolvedValueOnce(response(503, new Date(now + 5000).toUTCString()))

.mockResolvedValueOnce(response(200));

const client = new RetryingHttpClient('test', {

sleep,

random: () => 0,

now: () => now

});

await client.get('https://example.com');

expect(sleep).toHaveBeenCalledWith(5000);

});

it('caps Retry-After at the configured maximum delay', async () => {

request

.mockResolvedValueOnce(response(429, '60'))

.mockResolvedValueOnce(response(200));

const client = new RetryingHttpClient('test', {

sleep,

random: () => 0,

maxDelayMs: 10000

});

await client.get('https://example.com');

expect(sleep).toHaveBeenCalledWith(10000);

});

it.each([429, 502, 503, 504, 522])(

'retries HTTP %s responses',

async statusCode => {

request

.mockResolvedValueOnce(response(statusCode))

.mockResolvedValueOnce(response(200));

const client = new RetryingHttpClient('test', {

sleep,

random: () => 0

});

await client.get('https://example.com');

expect(request).toHaveBeenCalledTimes(2);

}

);

it.each(['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'ECONNREFUSED'])(

'retries network errors with code %s',

async code => {

request

.mockRejectedValueOnce(Object.assign(new Error(code), {code}))

.mockResolvedValueOnce(response(200));

const client = new RetryingHttpClient('test', {

sleep,

random: () => 0

});

await client.get('https://example.com');

expect(request).toHaveBeenCalledTimes(2);

}

);

it('retries retryable aggregate network errors', async () => {

const aggregateError = Object.assign(new Error('connection failed'), {

errors: [Object.assign(new Error('timed out'), {code: 'ETIMEDOUT'})]

});

request

.mockRejectedValueOnce(aggregateError)

.mockResolvedValueOnce(response(200));

const client = new RetryingHttpClient('test', {

sleep,

random: () => 0

});

await client.get('https://example.com');

expect(request).toHaveBeenCalledTimes(2);

expect(sleep).toHaveBeenCalledWith(500);

});

it('does not retry non-retryable responses or network errors', async () => {

request.mockResolvedValueOnce(response(500));

const client = new RetryingHttpClient('test', {sleep});

await expect(client.get('https://example.com')).resolves.toBeDefined();

expect(request).toHaveBeenCalledTimes(1);

expect(sleep).not.toHaveBeenCalled();

request.mockRejectedValueOnce(

Object.assign(new Error('certificate failed'), {code: 'CERT_HAS_EXPIRED'})

);

await expect(client.get('https://example.com')).rejects.toThrow(

'certificate failed'

);

expect(request).toHaveBeenCalledTimes(2);

expect(sleep).not.toHaveBeenCalled();

});

it('stops after the configured total attempt count', async () => {

request

.mockResolvedValueOnce(response(503))

.mockResolvedValueOnce(response(503));

const client = new RetryingHttpClient('test', {

maxAttempts: 2,

sleep,

random: () => 0

});

const finalResponse = await client.get('https://example.com');

expect(finalResponse.message.statusCode).toBe(503);

expect(request).toHaveBeenCalledTimes(2);

expect(sleep).toHaveBeenCalledTimes(1);

});

it('propagates the final network error after exhausting attempts', async () => {

const finalError = Object.assign(new Error('still unavailable'), {

code: 'ECONNREFUSED'

});

request

.mockRejectedValueOnce(

Object.assign(new Error('unavailable'), {code: 'ECONNREFUSED'})

)

.mockRejectedValueOnce(finalError);

const client = new RetryingHttpClient('test', {

maxAttempts: 2,

sleep,

random: () => 0

});

await expect(client.get('https://example.com')).rejects.toBe(finalError);

expect(request).toHaveBeenCalledTimes(2);

expect(sleep).toHaveBeenCalledTimes(1);

});

it('does not retry write requests', async () => {

request.mockResolvedValueOnce(response(503));

const client = new RetryingHttpClient('test', {sleep});

await client.post('https://example.com', '{}');

expect(request).toHaveBeenCalledTimes(1);

expect(sleep).not.toHaveBeenCalled();

});

});

describe('retry classification', () => {

it('parses valid Retry-After values and ignores invalid or past values', () => {

const now = Date.parse('2026-07-29T00:00:00Z');

expect(parseRetryAfter('7', now)).toBe(7000);

expect(parseRetryAfter(new Date(now + 3000).toUTCString(), now)).toBe(3000);

expect(parseRetryAfter(new Date(now - 3000).toUTCString(), now)).toBe(

undefined

);

expect(parseRetryAfter('not-a-date', now)).toBe(undefined);

});

it('recognizes direct and nested retryable network error codes', () => {

expect(isRetryableNetworkError({code: 'ECONNRESET'})).toBe(true);

expect(

isRetryableNetworkError({errors: [{code: 'ENOTFOUND'}, {code: 'OTHER'}]})

).toBe(true);

expect(isRetryableNetworkError({code: 'CERT_HAS_EXPIRED'})).toBe(false);

expect(isRetryableNetworkError(new Error('unknown'))).toBe(false);

});

});