Add success-after-retry and Retry-After end-to-end tests

Close the coverage gap from the axios-retry migration review:
- a retryable GET that fails once then succeeds resolves (proves a retry
  actually recovers, not just exhausts);
- a 429 with `retry-after: 2` schedules a 2000ms delay, proving the
  Retry-After header flows through calculateRetryDelay via the
  axios-retry retryDelay callback.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: zeevmoney

src/tests/unit/retry-interceptor.spec.ts

@@ -34,6 +34,35 @@ function installRejectingAdapter(instance: AxiosInstance, status = 503): { count
   return { count: () => calls };
 }
 
+// Installs an adapter that rejects with a synthetic 503 for the first
+// `failTimes` calls, then resolves with a success response, so we can prove a
+// retry actually recovers.
+function installRejectThenResolveAdapter(
+  instance: AxiosInstance,
+  failTimes: number,
+): { count: () => number } {
+  let calls = 0;
+  instance.defaults.adapter = (config: InternalAxiosRequestConfig) => {
+    calls += 1;
+    if (calls <= failTimes) {
+      const error = new Error('synthetic failure') as AxiosError;
+      error.isAxiosError = true;
+      error.config = config;
+      error.toJSON = () => ({});
+      error.response = { status: 503, statusText: 'Error', headers: {}, config, data: {} };
+      return Promise.reject(error);
+    }
+    return Promise.resolve({
+      status: 200,
+      statusText: 'OK',
+      headers: {},
+      config,
+      data: { ok: true },
+    });
+  };
+  return { count: () => calls };
+}
+
 async function newPermit(overrides: Record<string, unknown>): Promise<PermitInternals> {
   const { Permit } = await import('../../index');
   return new Permit({ token: 'test', ...overrides }) as unknown as PermitInternals;
@@ -128,3 +157,66 @@ test.serial('maps axios-retry retryCount to our 0-based attempt number', async (
     global.setTimeout = realSetTimeout;
   }
 });
+
+test('a retry recovers: GET succeeds after one failed attempt', async (t) => {
+  const permit = await newPermit({
+    retry: { maxRetries: 2, retryDelay: 1, maxDelay: 5, backoffMultiplier: 1 },
+  });
+  const rest = installRejectThenResolveAdapter(permit.config.axiosInstance, 1);
+
+  const response = await permit.config.axiosInstance.request({ method: 'GET', url: '/x' });
+
+  // Initial failure + one retry that succeeds.
+  t.is(rest.count(), 2);
+  t.is(response.status, 200);
+  t.deepEqual(response.data, { ok: true });
+});
+
+test.serial('Retry-After header drives the retry delay end-to-end', async (t) => {
+  // 429 with `retry-after: 2` (seconds) must produce a 2000ms scheduled delay,
+  // which exceeds the 10ms backoff and is under maxDelay, proving Retry-After
+  // flows through calculateRetryDelay via our retryDelay callback. The
+  // Retry-After branch returns the exact value with no jitter, so we only need
+  // to capture the setTimeout delay (nothing is actually awaited).
+  const realSetTimeout = global.setTimeout;
+  const scheduledDelays: number[] = [];
+  global.setTimeout = ((fn: () => void, delay?: number): ReturnType<typeof setTimeout> => {
+    scheduledDelays.push(delay ?? 0);
+    return realSetTimeout(fn, 0);
+  }) as typeof setTimeout;
+  try {
+    const permit = await newPermit({
+      retry: { maxRetries: 1, retryDelay: 10, maxDelay: 30000, backoffMultiplier: 1 },
+    });
+
+    let calls = 0;
+    permit.config.axiosInstance.defaults.adapter = (
+      config: InternalAxiosRequestConfig,
+    ): Promise<never> => {
+      calls += 1;
+      const error = new Error('rate limited') as AxiosError;
+      error.isAxiosError = true;
+      error.config = config;
+      error.toJSON = () => ({});
+      error.response = {
+        status: 429,
+        statusText: 'Too Many Requests',
+        headers: { 'retry-after': '2' },
+        config,
+        data: {},
+      };
+      return Promise.reject(error);
+    };
+
+    await t.throwsAsync(() => permit.config.axiosInstance.request({ method: 'GET', url: '/x' }));
+
+    // 429 is retryable and GET is allowed, so it retried once.
+    t.is(calls, 2);
+    t.true(
+      scheduledDelays.includes(2000),
+      `expected a 2000ms delay, got ${scheduledDelays.join(',')}`,
+    );
+  } finally {
+    global.setTimeout = realSetTimeout;
+  }
+});