test: add coverage for retries, redirects, client helpers, and header controls

Author: StopMakingThatBigFace

src/test/cookies-redirects.spec.ts

@@ -180,4 +180,30 @@ describe('cookies and redirects', () => {
       'redirect error mode should throw on first redirect response'
     );
   });
+
+  test('should reject when maxRedirects is exceeded', async () => {
+    await assert.rejects(
+      async () => {
+        await fetch(`${getBaseUrl()}/redirect/chain?count=2`, {
+          maxRedirects: 1,
+        });
+      },
+      (error: unknown) =>
+        error instanceof Error &&
+        'code' in (error as object) &&
+        (error as { code?: unknown }).code === 'ERR_TOO_MANY_REDIRECTS'
+    );
+  });
+
+  test('should reject redirect loops', async () => {
+    await assert.rejects(
+      async () => {
+        await fetch(`${getBaseUrl()}/redirect/loop-a`);
+      },
+      (error: unknown) =>
+        error instanceof Error &&
+        'code' in (error as object) &&
+        (error as { code?: unknown }).code === 'ERR_REDIRECT_LOOP'
+    );
+  });
 });

src/test/helpers/local-server.ts

@@ -69,12 +69,14 @@ export function setupLocalTestServer() {
 
     wsServer.on('connection', (socket: WsPeer, request: IncomingMessage) => {
       const cookie = readCookieHeader(request);
+      const url = new URL(request.url ?? '/', 'http://127.0.0.1');
 
       socket.send(
         JSON.stringify({
           kind: 'connected',
           cookie,
           protocol: socket.protocol,
+          url: url.pathname + url.search,
           rawHeaders: request.rawHeaders,
         })
       );
@@ -112,6 +114,29 @@ export function setupLocalTestServer() {
           return;
         }
 
+        if (url.pathname === '/retry/timeout') {
+          const key = url.searchParams.get('key') ?? 'default-timeout';
+          const failCount = Number(url.searchParams.get('failCount') ?? '0');
+          const delayMs = Number(url.searchParams.get('delayMs') ?? '100');
+          const count = (retryAttempts.get(key) ?? 0) + 1;
+
+          retryAttempts.set(key, count);
+
+          if (count <= failCount) {
+            setTimeout(() => {
+              if (!response.writableEnded) {
+                sendJson(response, 200, { attempt: count, timedOut: true });
+              }
+            }, delayMs);
+
+            return;
+          }
+
+          sendJson(response, 200, { attempt: count, timedOut: false });
+
+          return;
+        }
+
         if (url.pathname === '/timings/delay') {
           const delayMs = Number(url.searchParams.get('ms') ?? '50');
 
@@ -197,6 +222,14 @@ export function setupLocalTestServer() {
           return;
         }
 
+        if (url.pathname.startsWith('/status/')) {
+          const status = Number(url.pathname.slice('/status/'.length));
+
+          sendJson(response, status, { status });
+
+          return;
+        }
+
         if (url.pathname === '/redirect/start') {
           response.writeHead(302, {
             location: '/redirect/final',
@@ -216,6 +249,44 @@ export function setupLocalTestServer() {
           return;
         }
 
+        if (url.pathname === '/redirect/chain') {
+          const count = Number(url.searchParams.get('count') ?? '0');
+
+          if (count > 0) {
+            response.writeHead(302, {
+              location: `/redirect/chain?count=${count - 1}`,
+            });
+            response.end();
+
+            return;
+          }
+
+          response.writeHead(302, {
+            location: '/redirect/final',
+          });
+          response.end();
+
+          return;
+        }
+
+        if (url.pathname === '/redirect/loop-a') {
+          response.writeHead(302, {
+            location: '/redirect/loop-b',
+          });
+          response.end();
+
+          return;
+        }
+
+        if (url.pathname === '/redirect/loop-b') {
+          response.writeHead(302, {
+            location: '/redirect/loop-a',
+          });
+          response.end();
+
+          return;
+        }
+
         if (url.pathname === '/redirect/final') {
           sendJson(response, 200, {
             method: request.method,

src/test/hooks-retries.spec.ts

@@ -37,6 +37,32 @@ describe('hooks and retries', () => {
     );
   });
 
+  test('should allow beforeRequest to short-circuit with a synthetic response', async () => {
+    const response = await fetch(`${getBaseUrl()}/headers/raw`, {
+      hooks: {
+        beforeRequest: [
+          () =>
+            new WreqResponse(JSON.stringify({ shortCircuited: true }), {
+              status: 204,
+              headers: { 'content-type': 'application/json' },
+              url: 'https://local/short-circuit',
+            }),
+        ],
+      },
+    });
+
+    assert.strictEqual(response.status, 204);
+    assert.deepStrictEqual(await response.json(), { shortCircuited: true });
+    assert.strictEqual(response.url, 'https://local/short-circuit');
+    assert.deepStrictEqual(response.wreq.timings, {
+      startTime: response.wreq.timings?.startTime,
+      responseStart: response.wreq.timings?.startTime,
+      wait: 0,
+      endTime: response.wreq.timings?.startTime,
+      total: 0,
+    });
+  });
+
   test('should allow afterResponse to replace the response', async () => {
     const response = await fetch('https://httpbin.org/status/201', {
       browser: 'chrome_137',
@@ -115,6 +141,84 @@ describe('hooks and retries', () => {
     assert.strictEqual(body.retried, true, 'server should observe retries');
   });
 
+  test('should allow shouldRetry to veto a retryable response', async () => {
+    retryAttempts.set('retry-veto', 0);
+
+    const response = await fetch(`${getBaseUrl()}/retry?key=retry-veto&failCount=1`, {
+      retry: {
+        limit: 1,
+        statusCodes: [503],
+        shouldRetry: () => false,
+      },
+    });
+
+    assert.strictEqual(response.status, 503);
+    assert.deepStrictEqual(await response.json(), {
+      attempt: 1,
+      retried: false,
+    });
+  });
+
+  test('should stop retrying when the retry limit is exhausted', async () => {
+    retryAttempts.set('retry-limit', 0);
+
+    const response = await fetch(`${getBaseUrl()}/retry?key=retry-limit&failCount=2`, {
+      retry: {
+        limit: 1,
+        statusCodes: [503],
+        backoff: () => 0,
+      },
+    });
+
+    assert.strictEqual(response.status, 503);
+    assert.deepStrictEqual(await response.json(), {
+      attempt: 2,
+      retried: false,
+    });
+  });
+
+  test('should not retry methods outside the configured retry method list', async () => {
+    retryAttempts.set('retry-methods', 0);
+
+    const response = await fetch(`${getBaseUrl()}/retry?key=retry-methods&failCount=1`, {
+      method: 'POST',
+      body: 'payload',
+      retry: {
+        limit: 2,
+        methods: ['GET'],
+        statusCodes: [503],
+      },
+    });
+
+    assert.strictEqual(response.status, 503);
+    assert.deepStrictEqual(await response.json(), {
+      attempt: 1,
+      retried: false,
+    });
+  });
+
+  test('should retry timeout errors when their error code is configured', async () => {
+    retryAttempts.set('retry-timeout', 0);
+
+    const response = await fetch(
+      `${getBaseUrl()}/retry/timeout?key=retry-timeout&failCount=1&delayMs=100`,
+      {
+        timeout: 25,
+        retry: {
+          limit: 1,
+          errorCodes: ['ERR_TIMEOUT'],
+          backoff: () => 0,
+        },
+      }
+    );
+
+    assert.strictEqual(response.status, 200);
+    assert.deepStrictEqual(await response.json(), {
+      attempt: 2,
+      timedOut: false,
+    });
+  });
+
   test('should expose response timings and onStats callback data', async () => {
     let capturedStats:
       | {

src/test/http-client.spec.ts

@@ -170,6 +170,98 @@ describe('http client', () => {
     );
   });
 
+  test('should allow validateStatus to accept a custom non-2xx response', async () => {
+    const response = await fetch(`${getBaseUrl()}/status/418`, {
+      throwHttpErrors: true,
+      validateStatus: (status) => status === 418,
+    });
+
+    assert.strictEqual(response.status, 418);
+    assert.deepStrictEqual(await response.json(), { status: 418 });
+  });
+
+  test('should reject responses when validateStatus returns false', async () => {
+    await assert.rejects(
+      async () => {
+        await fetch(`${getBaseUrl()}/status/204`, {
+          throwHttpErrors: false,
+          validateStatus: () => false,
+        });
+      },
+      (error: unknown) => error instanceof Error && error.name === 'HTTPError'
+    );
+  });
+
+  test('should support client.post helper', async () => {
+    const client = createClient({
+      baseURL: getBaseUrl(),
+    });
+
+    const response = await client.post('/body/echo', JSON.stringify({ created: true }), {
+      headers: {
+        'content-type': 'application/json',
+      },
+    });
+    const body = await response.json<{ method: string; body: string }>();
+
+    assert.strictEqual(body.method, 'POST');
+    assert.strictEqual(body.body, JSON.stringify({ created: true }));
+  });
+
+  test('should merge defaults through client.extend', async () => {
+    let observedState: Record<string, unknown> | undefined;
+
+    const baseClient = createClient({
+      baseURL: getBaseUrl(),
+      headers: {
+        'x-base': 'one',
+      },
+      query: {
+        base: '1',
+      },
+      context: {
+        fromBase: true,
+      },
+      hooks: {
+        beforeRequest: [
+          ({ request, state }) => {
+            observedState = { ...state };
+            request.headers.set(
+              'x-state',
+              `${String(state.fromBase)}:${String(state.fromOverride)}`
+            );
+          },
+        ],
+      },
+    });
+
+    const client = baseClient.extend({
+      headers: {
+        'x-extended': 'two',
+      },
+      query: {
+        extended: '2',
+      },
+      context: {
+        fromOverride: true,
+      },
+    });
+
+    const response = await client.get('/headers/raw');
+    const body = await response.json<{ headers: Record<string, string> }>();
+    const requestUrl = new URL(response.url);
+
+    assert.strictEqual(body.headers['x-base'], 'one');
+    assert.strictEqual(body.headers['x-extended'], 'two');
+    assert.strictEqual(body.headers['x-state'], 'true:true');
+    assert.strictEqual(requestUrl.searchParams.get('base'), '1');
+    assert.strictEqual(requestUrl.searchParams.get('extended'), '2');
+    assert.deepStrictEqual(observedState, {
+      fromBase: true,
+      fromOverride: true,
+    });
+  });
+
   test('should preserve ordered header tuples and original header names', async () => {
     const response = await fetch(`${getBaseUrl()}/headers/raw`, {
       browser: 'chrome_137',