Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

19.2 KB
Raw Blame
/**
 * @vitest-environment jsdom
 */

import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { getNativeNetworkAbortSignal } from '../mobile/native-network-status';

import {
  confirmSessionExpired,
  ensureFreshSession,
  fetchToken,
  fetchWithToken,
  unsetTokenPromise,
} from './fetchWithToken';

const nativeNetwork = vi.hoisted(() => ({ controller: new AbortController() }));
vi.mock('../mobile/native-network-status', () => ({
  getNativeNetworkAbortSignal: vi.fn(() => nativeNetwork.controller.signal),
}));

const RESOURCE_URL = 'https://localhost/resource';

// One of the auth service's definitive "session cannot be refreshed" bodies.
const REFRESH_REJECTED_BODY = 'no refresh token to refresh';

function jsonResponse(status: number, body: unknown = {}): Response {
  return {
    ok: status >= 200 && status < 300,
    status,
    json: () => Promise.resolve(body),
    text: () => Promise.resolve(JSON.stringify(body)),
    headers: new Headers({ 'Content-Type': 'application/json' }),
  } as Response;
}

function textResponse(status: number, body: string): Response {
  return {
    ok: status >= 200 && status < 300,
    status,
    json: () => Promise.reject(new SyntaxError('not json')),
    text: () => Promise.resolve(body),
    headers: new Headers({ 'Content-Type': 'text/plain' }),
  } as Response;
}

function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>((r) => {
    resolve = r;
  });
  return { promise, resolve };
}

const tick = () => new Promise((r) => setTimeout(r, 0));

const isRefresh = (input: RequestInfo | URL) =>
  String(input).includes('/jwt/refresh');

describe('fetchWithToken refresh latch', () => {
  const originalFetch = global.fetch;
  const mockFetch = vi.fn<typeof fetch>();

  beforeEach(() => {
    unsetTokenPromise();
    nativeNetwork.controller = new AbortController();
    vi.mocked(getNativeNetworkAbortSignal).mockImplementation(
      () => nativeNetwork.controller.signal
    );
    global.fetch = mockFetch as typeof fetch;
  });

  afterEach(() => {
    global.fetch = originalFetch;
    mockFetch.mockReset();
    vi.useRealTimers();
    vi.restoreAllMocks();
  });

  const refreshCalls = () =>
    mockFetch.mock.calls.filter(([input]) => isRefresh(input)).length;

  test('reuses a recent successful refresh only for proactive socket setup', async () => {
    vi.useFakeTimers();
    vi.setSystemTime(100_000);
    mockFetch.mockResolvedValue(jsonResponse(200));
    await fetchToken();
    await ensureFreshSession();
    await ensureFreshSession();
    expect(refreshCalls()).toBe(1);
    await fetchToken();
    expect(refreshCalls()).toBe(2);
    vi.setSystemTime(130_000);
    await ensureFreshSession();
    expect(refreshCalls()).toBe(3);
    unsetTokenPromise();
    await ensureFreshSession();
    expect(refreshCalls()).toBe(4);
  });

  test('does not reuse a refresh after the clock moves backwards', async () => {
    vi.useFakeTimers();
    vi.setSystemTime(100_000);
    mockFetch.mockResolvedValue(jsonResponse(200));
    await ensureFreshSession();
    vi.setSystemTime(90_000);
    await ensureFreshSession();
    expect(refreshCalls()).toBe(2);
  });

  test('a 401 forces refresh even after successful socket setup', async () => {
    mockFetch.mockImplementation(async (input) =>
      isRefresh(input) ? jsonResponse(200) : jsonResponse(401)
    );
    await ensureFreshSession();
    await fetchWithToken(RESOURCE_URL);
    expect(refreshCalls()).toBe(2);
  });

  test('a reset prevents an old successful refresh from being reused', async () => {
    const response = deferred<Response>();
    mockFetch
      .mockReturnValueOnce(response.promise)
      .mockResolvedValue(jsonResponse(200));
    const oldRefresh = fetchToken();
    unsetTokenPromise();
    response.resolve(jsonResponse(200));
    await oldRefresh;
    await ensureFreshSession();
    expect(refreshCalls()).toBe(2);
  });

  test('refreshes on runtimes without AbortSignal.any', async () => {
    vi.spyOn(AbortSignal, 'any').mockImplementation(() => {
      throw new TypeError('AbortSignal.any is unavailable');
    });
    mockFetch.mockResolvedValue(jsonResponse(200));

    expect((await fetchToken()).isOk()).toBe(true);
  });

  test('clears failed refresh setup and its timer so the next caller can retry', async () => {
    vi.useFakeTimers();
    vi.mocked(getNativeNetworkAbortSignal).mockImplementationOnce(() => {
      throw new Error('Reachability setup failed');
    });
    mockFetch.mockResolvedValue(jsonResponse(200));

    await expect(fetchToken()).rejects.toThrow('Reachability setup failed');
    expect(vi.getTimerCount()).toBe(0);
    expect((await fetchToken()).isOk()).toBe(true);
    expect(refreshCalls()).toBe(1);
  });

  test('a stalled refresh times out and permits retry without expiring the session', async () => {
    vi.useFakeTimers();
    const response = deferred<Response>();
    const started = Promise.withResolvers<void>();
    let refreshSignal: AbortSignal | null | undefined;
    mockFetch.mockImplementation((_input, init) => {
      refreshSignal = init?.signal;
      started.resolve();
      // Model a native bridge that does not settle when aborted.
      return response.promise;
    });

    const first = fetchToken();
    await started.promise;
    await vi.advanceTimersByTimeAsync(12_000);

    expect(refreshSignal?.aborted).toBe(true);
    const result = await first;
    expect(result.isErr()).toBe(true);
    if (result.isErr()) {
      expect(result.error).toEqual([
        { code: 'NETWORK_ERROR', message: 'Authentication refresh timed out' },
      ]);
    }

    mockFetch.mockResolvedValue(jsonResponse(200));
    await expect(confirmSessionExpired()).resolves.toBe(false);
    expect(refreshCalls()).toBe(2);

    // The retired refresh must not latch its late rejection over a new session.
    response.resolve(textResponse(400, REFRESH_REJECTED_BODY));
    await vi.advanceTimersByTimeAsync(0);
    expect((await fetchToken()).isOk()).toBe(true);
    expect(refreshCalls()).toBe(3);
  });

  test('bounds proactive socket setup that shares a stalled refresh', async () => {
    vi.useFakeTimers();
    mockFetch.mockImplementation(() => new Promise<Response>(() => {}));

    const request = fetchToken();
    await vi.advanceTimersByTimeAsync(0);
    const socket = ensureFreshSession();
    await vi.advanceTimersByTimeAsync(12_000);

    const timedOut = [
      { code: 'NETWORK_ERROR', message: 'Authentication refresh timed out' },
    ];
    expect((await request)._unsafeUnwrapErr()).toEqual(timedOut);
    expect((await socket)._unsafeUnwrapErr()).toEqual(timedOut);
    expect(refreshCalls()).toBe(1);

    mockFetch.mockResolvedValue(jsonResponse(200));
    expect((await ensureFreshSession()).isOk()).toBe(true);
    expect(refreshCalls()).toBe(2);
  });

  test('a refresh timing out after a reset leaves the newer refresh shared', async () => {
    vi.useFakeTimers();
    const responses: ((response: Response) => void)[] = [];
    mockFetch.mockImplementation(
      () => new Promise<Response>((resolve) => responses.push(resolve))
    );

    const old = fetchToken();
    await vi.advanceTimersByTimeAsync(6_000);
    unsetTokenPromise();
    const current = fetchToken();
    await vi.advanceTimersByTimeAsync(6_000);
    expect((await old).isErr()).toBe(true);

    const joined = ensureFreshSession();
    expect(refreshCalls()).toBe(2);
    responses[1]?.(jsonResponse(200));
    expect((await current).isOk()).toBe(true);
    expect((await joined).isOk()).toBe(true);
    expect(refreshCalls()).toBe(2);
  });

  test('cancels one caller while preserving the shared refresh for another', async () => {
    const response = deferred<Response>();
    const started = Promise.withResolvers<void>();
    let refreshSignal: AbortSignal | null | undefined;
    mockFetch.mockImplementation((input, init) => {
      if (isRefresh(input)) {
        refreshSignal = init?.signal;
        started.resolve();
        return response.promise;
      }
      return Promise.resolve(jsonResponse(401));
    });
    const controller = new AbortController();
    const request = fetchWithToken(RESOURCE_URL, { signal: controller.signal });
    await started.promise;
    const other = fetchToken();
    controller.abort();

    const result = await request;
    expect(result.isErr()).toBe(true);
    if (result.isErr()) expect(result.error[0]?.code).toBe('NETWORK_ERROR');
    expect(refreshSignal?.aborted).toBe(false);
    expect(mockFetch).toHaveBeenCalledTimes(2);

    response.resolve(jsonResponse(200));
    expect((await other).isOk()).toBe(true);
    expect(refreshCalls()).toBe(1);
  });

  test('does not start refresh for an already cancelled caller', async () => {
    const controller = new AbortController();
    controller.abort();

    expect((await fetchToken(controller.signal)).isErr()).toBe(true);
    expect(mockFetch).not.toHaveBeenCalled();
  });

  test('releases a stalled refresh when native connectivity drops and retries online', async () => {
    const started = Promise.withResolvers<void>();
    const response = deferred<Response>();
    mockFetch.mockImplementation(() => {
      started.resolve();
      return response.promise;
    });
    const first = fetchToken();
    await started.promise;

    expect(getNativeNetworkAbortSignal()).toBe(nativeNetwork.controller.signal);
    nativeNetwork.controller.abort();
    expect(mockFetch.mock.calls[0]?.[1]?.signal?.aborted).toBe(true);
    const result = await first;
    expect(result.isErr()).toBe(true);
    if (result.isErr()) expect(result.error[0]?.code).toBe('NETWORK_ERROR');

    nativeNetwork.controller = new AbortController();
    mockFetch.mockResolvedValue(jsonResponse(200));
    expect((await fetchToken()).isOk()).toBe(true);
    expect(refreshCalls()).toBe(2);
    response.resolve(jsonResponse(200));
  });

  test('fires at most one doomed refresh across sequential 401s', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(
        isRefresh(input)
          ? textResponse(400, REFRESH_REJECTED_BODY)
          : jsonResponse(401)
      )
    );

    for (let i = 0; i < 3; i++) {
      const result = await fetchWithToken<{ data: string }>(RESOURCE_URL);
      expect(result.isErr()).toBe(true);
      if (result.isErr()) {
        expect(result.error.some((e) => e.code === 'UNAUTHORIZED')).toBe(true);
      }
    }

    expect(refreshCalls()).toBe(1);
  });

  test('a 401 from the refresh endpoint latches', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(isRefresh(input) ? jsonResponse(401) : jsonResponse(401))
    );

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    await fetchWithToken<{ data: string }>(RESOURCE_URL);

    expect(refreshCalls()).toBe(1);
  });

  test('authenticated expired-token request still refreshes and retries', async () => {
    let refreshed = false;
    mockFetch.mockImplementation((input) => {
      if (isRefresh(input)) {
        refreshed = true;
        return Promise.resolve(jsonResponse(200));
      }
      return Promise.resolve(
        refreshed ? jsonResponse(200, { data: 'ok' }) : jsonResponse(401)
      );
    });

    const result = await fetchWithToken<{ data: string }>(RESOURCE_URL);

    expect(result.isOk()).toBe(true);
    if (result.isOk()) expect(result.value).toEqual({ data: 'ok' });
    expect(refreshCalls()).toBe(1);
  });

  test('a successful refresh does not latch subsequent 401s', async () => {
    let refreshCount = 0;
    mockFetch.mockImplementation((input) => {
      if (isRefresh(input)) {
        refreshCount++;
        return Promise.resolve(jsonResponse(200));
      }
      // Each resource call 401s, forcing a fresh refresh every time.
      return Promise.resolve(jsonResponse(401));
    });

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    await fetchWithToken<{ data: string }>(RESOURCE_URL);

    expect(refreshCount).toBe(2);
  });

  test('a transient refresh failure (500) does not latch', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(isRefresh(input) ? jsonResponse(500) : jsonResponse(401))
    );

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    await fetchWithToken<{ data: string }>(RESOURCE_URL);

    expect(refreshCalls()).toBe(2);
  });

  test('a proxy 400 without a known rejection body does not latch', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(
        isRefresh(input)
          ? textResponse(400, '<html>Bad Request</html>')
          : jsonResponse(401)
      )
    );

    const result = await fetchWithToken<{ data: string }>(RESOURCE_URL);
    await fetchWithToken<{ data: string }>(RESOURCE_URL);

    expect(refreshCalls()).toBe(2);
    // The transient failure surfaces as-is instead of masquerading as a dead
    // session.
    expect(result.isErr()).toBe(true);
    if (result.isErr()) {
      expect(result.error.some((e) => e.code === 'HTTP_ERROR')).toBe(true);
      expect(result.error.some((e) => e.code === 'UNAUTHORIZED')).toBe(false);
    }
  });

  test('a gateway error (502) surfaces as HTTP_ERROR and does not latch', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(isRefresh(input) ? jsonResponse(502) : jsonResponse(401))
    );

    const result = await fetchWithToken<{ data: string }>(RESOURCE_URL);
    await fetchWithToken<{ data: string }>(RESOURCE_URL);

    expect(refreshCalls()).toBe(2);
    expect(result.isErr()).toBe(true);
    if (result.isErr()) {
      expect(result.error.some((e) => e.code === 'UNAUTHORIZED')).toBe(false);
    }
  });

  test('a latched failure expires after the TTL', async () => {
    vi.useFakeTimers({ toFake: ['Date'] });
    mockFetch.mockImplementation((input) =>
      Promise.resolve(
        isRefresh(input)
          ? textResponse(400, REFRESH_REJECTED_BODY)
          : jsonResponse(401)
      )
    );

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(1);

    vi.setSystemTime(Date.now() + 61_000);

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(2);
  });

  test('regaining visibility clears the latch', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(
        isRefresh(input)
          ? textResponse(400, REFRESH_REJECTED_BODY)
          : jsonResponse(401)
      )
    );

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(1);

    // jsdom's visibilityState is 'visible', so this models a foregrounding.
    document.dispatchEvent(new Event('visibilitychange'));

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(2);
  });

  test('regaining visibility expires a refresh older than its deadline', async () => {
    vi.useFakeTimers();
    vi.setSystemTime(100_000);
    const response = deferred<Response>();
    mockFetch.mockReturnValueOnce(response.promise);
    const stalled = fetchToken();
    await vi.advanceTimersByTimeAsync(0);

    // A recent refresh survives foregrounding.
    vi.setSystemTime(105_000);
    document.dispatchEvent(new Event('visibilitychange'));
    const joined = fetchToken();
    await vi.advanceTimersByTimeAsync(0);
    expect(refreshCalls()).toBe(1);

    // Suspension paused the deadline timer while the wall clock moved on.
    vi.setSystemTime(200_000);
    document.dispatchEvent(new Event('visibilitychange'));
    const timedOut = [
      { code: 'NETWORK_ERROR', message: 'Authentication refresh timed out' },
    ];
    expect((await stalled)._unsafeUnwrapErr()).toEqual(timedOut);
    expect((await joined)._unsafeUnwrapErr()).toEqual(timedOut);

    mockFetch.mockResolvedValue(jsonResponse(200));
    expect((await fetchToken()).isOk()).toBe(true);
    expect(refreshCalls()).toBe(2);
    response.resolve(jsonResponse(200));
  });

  test('regaining connectivity clears the latch', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(
        isRefresh(input)
          ? textResponse(400, REFRESH_REJECTED_BODY)
          : jsonResponse(401)
      )
    );

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(1);

    window.dispatchEvent(new Event('online'));

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(2);
  });

  test('unsetTokenPromise clears the latch so refresh is attempted again', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(
        isRefresh(input)
          ? textResponse(400, REFRESH_REJECTED_BODY)
          : jsonResponse(401)
      )
    );

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(1);

    unsetTokenPromise();

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(2);
  });

  test('a reset while a refresh is pending neither latches nor clears newer state', async () => {
    const pending = [deferred<Response>(), deferred<Response>()];
    let idx = 0;
    mockFetch.mockImplementation((input) => {
      if (isRefresh(input)) {
        const d = pending[idx++];
        return d ? d.promise : Promise.resolve(jsonResponse(200));
      }
      return Promise.resolve(jsonResponse(401));
    });

    // R1 starts and stays in-flight.
    const p1 = fetchToken();
    // A login-style reset happens while R1 is pending.
    unsetTokenPromise();
    // R2 starts under the new generation and also stays in-flight.
    const p2 = fetchToken();
    await tick();
    expect(refreshCalls()).toBe(2);

    // R1 fails definitively under the stale generation.
    pending[0].resolve(textResponse(400, REFRESH_REJECTED_BODY));
    expect((await p1).isErr()).toBe(true);

    // R1's finally must not have cleared R2's tokenPromise: a call now dedupes
    // onto R2 instead of starting a third refresh.
    const p2b = fetchToken();
    await tick();
    expect(refreshCalls()).toBe(2);

    pending[1].resolve(jsonResponse(200));
    expect((await p2).isOk()).toBe(true);
    expect((await p2b).isOk()).toBe(true);

    // R1's stale failure must not have latched: a fresh 401 still refreshes.
    expect((await fetchToken()).isOk()).toBe(true);
    expect(refreshCalls()).toBe(3);
  });

  test('confirmSessionExpired bypasses the latch and confirms a definitive rejection', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(
        isRefresh(input)
          ? textResponse(400, REFRESH_REJECTED_BODY)
          : jsonResponse(401)
      )
    );

    await fetchWithToken<{ data: string }>(RESOURCE_URL);
    expect(refreshCalls()).toBe(1);

    // Despite the latch, confirmation must consult the server again.
    await expect(confirmSessionExpired()).resolves.toBe(true);
    expect(refreshCalls()).toBe(2);
  });

  test('confirmSessionExpired reports a transient failure as not expired', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(isRefresh(input) ? jsonResponse(503) : jsonResponse(401))
    );

    await expect(confirmSessionExpired()).resolves.toBe(false);
  });

  test('confirmSessionExpired reports an alive session as not expired', async () => {
    mockFetch.mockImplementation((input) =>
      Promise.resolve(isRefresh(input) ? jsonResponse(200) : jsonResponse(401))
    );

    await expect(confirmSessionExpired()).resolves.toBe(false);
  });
});