LibreChat/packages/data-provider/specs/request-interceptor.spec.ts
Danny Avila 5ca49b5f4e
🪢 fix: Resolve the Races Behind Four Intermittent Session and Scenario E2E Tests (#18061)
* 🔑 fix: Replay a Request Rejected for a Superseded Bearer Instead of Refreshing Again

A burst of requests leaves with one bearer. The first 401 starts a refresh and the
rest share it only while it is in flight: a 401 delivered after the refresh settled
found no recovery running and started a second one, although the session had already
recovered and the response described a bearer that was no longer in use.

Compare the bearer the rejected request carried with the current one. When it has
been replaced and no recovery is running, replay the request with the current
bearer. A replay that is rejected again carries the current bearer, so it takes the
ordinary refresh path. The fetch transport follows the same rule.

This is what failed "recovers from an expired bearer during app bootstrap without
redirect looping": 9 of the 21 bootstrap 401s were delivered after the first
recovery finished, so the test counted a third refresh and a second recovery cycle.

* 🔊 test: Play Decodable Audio and Hold the Reply's Button in the Read-Aloud Replay Scenario

The fixture answered the speech request with four bytes the MP3 parser rejects, so
every playback failed. A failed playback cancels its request, and the audio is
cached only once the response has been read to the end, so the replay was served
from memory only when the response finished before the decoder gave up. When the
decoder won, the replay issued the second request the scenario forbids.

The test also located the button by its name. While a message is read aloud its
button is named "Stop", so the locator resolved to the user message's read-aloud
button: the wait for playback to end passed at once, and the second click could
land on a different message.

Serve a third of a second of silent MPEG frames so playback succeeds and ends on
its own, and locate the reply's button by its test id so the wait and the replay
address the same control.

* 📅 test: Wait for the Schedule Save to Land Before Reloading

The edit scenario clicked Save and reloaded the page in the next step. A reload
discards requests still in flight, so when it won the race the PATCH was cancelled
before the server answered and the edited schedule never appeared. Await the PATCH
response, and require it to succeed, before reloading.

* 🔗 fix: Grant a Legacy Shared Link's Permissions Once When Its First Views Race

The share page requests a link's config and its messages together, and each request
migrates a legacy link on the way in. Both find no grant and both write one. The
grant is an upsert matched on the principal and resource, which no unique index
covers, so the two writes inserted two rows: a second public entry, a second owner
entry, or both.

`grantPermission` now accepts the `_id` to give the entry if the grant creates it.
The migration derives that id from the link and the principal, so the second insert
collides on `_id` and is replayed as an update of the first entry. It holds across
processes because the database enforces it. Grants that pass no id are unchanged.

"manages a shared-link snapshot and preserves legacy public links through runtime
migration" asserts one public entry and saw two.

* 🔑 fix: Refresh When a Replayed Fetch Is Rejected With the Current Bearer

The fetch transport replayed a request whose bearer had been superseded and
returned whatever came back. A second 401 there means the current bearer is not
accepted either, which is the case the refresh exists for, and the axios path
already handles it that way. Replay first, then fall through to the ordinary
recovery when the replay is rejected too.

* 🔗 refactor: Derive a Unique Grant's Entry Id in the Data Layer

`AccessControlService.grantPermission` took the entry's `_id` as a Mongoose
`ObjectId`, which put a storage type in an exported `packages/api` signature. The
service now takes `uniqueEntry: true`, and `grantPermission` in data-schemas
derives the id from the principal and resource it already matches on. A caller can
no longer pass an id that names a different grant.
2026-11-11 16:22:39 -05:00

929 lines
28 KiB
TypeScript

/**
* @jest-environment @happy-dom/jest-environment
*/
import axios from 'axios';
import type { InternalAxiosRequestConfig } from 'axios';
import { setTokenHeader } from '../src/headers-helpers';
/**
* The response interceptor in request.ts registers at import time when
* `typeof window !== 'undefined'` (happy-dom provides window).
*
* We use axios's built-in request adapter mock to avoid real HTTP calls,
* and verify the interceptor's behavior by observing whether a 401 triggers
* a refresh POST or is immediately rejected.
*
* happy-dom is used instead of jsdom because it allows overriding
* window.location via Object.defineProperty, which jsdom 26+ blocks.
*/
const mockAdapter = jest.fn();
let originalAdapter: typeof axios.defaults.adapter;
let savedLocation: Location;
let dataRequest: typeof import('../src/request').default;
type RetryableAdapterConfig = InternalAxiosRequestConfig & { _retry?: boolean };
function createAdapterResponse(config: InternalAxiosRequestConfig, data: unknown = {}) {
return Promise.resolve({
data,
status: 200,
headers: {},
config,
});
}
function create401Error(config: InternalAxiosRequestConfig) {
return Promise.reject({
response: { status: 401 },
config,
});
}
function getCallsForUrl(urlPart: string) {
return mockAdapter.mock.calls.filter(([config]) => config.url?.includes(urlPart) === true);
}
function createDeferred<T>() {
let resolve!: (value: T) => void;
let reject!: (reason?: unknown) => void;
const promise = new Promise<T>((res, rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
}
async function waitForAdapterCall(urlPart: string) {
for (let i = 0; i < 10; i++) {
if (getCallsForUrl(urlPart).length > 0) {
return;
}
await new Promise((resolve) => setTimeout(resolve, 0));
}
throw new Error(`Adapter was not called for ${urlPart}`);
}
function createJwt(expiresAtMs: number) {
const payload = Buffer.from(JSON.stringify({ exp: Math.floor(expiresAtMs / 1000) })).toString(
'base64url',
);
return `header.${payload}.signature`;
}
beforeAll(async () => {
originalAdapter = axios.defaults.adapter;
axios.defaults.adapter = mockAdapter;
dataRequest = (await import('../src/request')).default;
});
beforeEach(() => {
mockAdapter.mockReset();
savedLocation = window.location;
});
afterAll(() => {
axios.defaults.adapter = originalAdapter;
});
afterEach(() => {
delete axios.defaults.headers.common['Authorization'];
window.localStorage.clear();
delete (window as Window & { __librechatAuthRecovery?: unknown }).__librechatAuthRecovery;
Object.defineProperty(window, 'location', {
value: savedLocation,
writable: true,
configurable: true,
});
});
function setWindowLocation(overrides: Partial<Location>) {
Object.defineProperty(window, 'location', {
value: { ...window.location, ...overrides },
writable: true,
configurable: true,
});
}
function setTrackedWindowLocation(overrides: Partial<Location>) {
let href = overrides.href ?? window.location.href;
const hrefWrites: string[] = [];
Object.defineProperty(window, 'location', {
value: {
...window.location,
...overrides,
get href() {
return href;
},
set href(value: string) {
hrefWrites.push(value);
href = value;
},
},
writable: true,
configurable: true,
});
return hrefWrites;
}
describe('axios 401 interceptor — Authorization header guard', () => {
it('skips refresh and rejects when Authorization header is cleared', async () => {
expect.assertions(1);
setTokenHeader(undefined);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/messages', headers: {} },
});
try {
await axios.get('/api/messages');
} catch {
// expected rejection
}
expect(mockAdapter).toHaveBeenCalledTimes(1);
});
it('attempts refresh on shared link page even without Authorization header', async () => {
expect.assertions(2);
setTokenHeader(undefined);
setWindowLocation({
href: 'http://localhost/share/abc123',
pathname: '/share/abc123',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/share/abc123', method: 'get', headers: {} },
});
mockAdapter.mockResolvedValueOnce({
data: { token: 'new-token' },
status: 200,
headers: {},
config: {},
});
mockAdapter.mockResolvedValueOnce({
data: { sharedLink: {} },
status: 200,
headers: {},
config: {},
});
try {
await axios.get('/api/share/abc123');
} catch {
// may reject depending on exact flow
}
expect(mockAdapter.mock.calls.length).toBe(3);
const refreshCall = mockAdapter.mock.calls[1];
expect(refreshCall[0].url).toContain('api/auth/refresh');
});
it('attempts refresh for the share fork POST even without Authorization header', async () => {
expect.assertions(2);
setTokenHeader(undefined);
setWindowLocation({
href: 'http://localhost/share/abc123',
pathname: '/share/abc123',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/share/abc123/fork', method: 'post', headers: {} },
});
mockAdapter.mockResolvedValueOnce({
data: { token: 'new-token' },
status: 200,
headers: {},
config: {},
});
mockAdapter.mockResolvedValueOnce({
data: { conversation: {}, messages: [] },
status: 201,
headers: {},
config: {},
});
try {
await axios.post('/api/share/abc123/fork');
} catch {
// may reject depending on exact flow
}
expect(mockAdapter.mock.calls.length).toBe(3);
expect(mockAdapter.mock.calls[1][0].url).toContain('api/auth/refresh');
});
it('does not refresh or redirect for unrelated 401s on public shared link pages', async () => {
expect.assertions(2);
setTokenHeader(undefined);
setWindowLocation({
href: 'http://localhost/share/abc123',
pathname: '/share/abc123',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/mcp/servers', headers: {} },
});
try {
await axios.get('/api/mcp/servers');
} catch {
// expected rejection
}
expect(mockAdapter).toHaveBeenCalledTimes(1);
expect(window.location.href).toBe('http://localhost/share/abc123');
});
it('does not treat nested share routes as public shared link pages', async () => {
expect.assertions(1);
setTokenHeader(undefined);
setWindowLocation({
href: 'http://localhost/foo/share/abc123',
pathname: '/foo/share/abc123',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/share/abc123', method: 'get', headers: {} },
});
try {
await axios.get('/api/share/abc123');
} catch {
// expected rejection
}
expect(mockAdapter).toHaveBeenCalledTimes(1);
});
it('does not treat nested API share paths as shared message requests', async () => {
expect.assertions(1);
setTokenHeader(undefined);
setWindowLocation({
href: 'http://localhost/share/abc123',
pathname: '/share/abc123',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/foo/api/share/abc123', method: 'get', headers: {} },
});
try {
await axios.get('/foo/api/share/abc123');
} catch {
// expected rejection
}
expect(mockAdapter).toHaveBeenCalledTimes(1);
});
it('does not bypass guard when share/ appears only in query params', async () => {
expect.assertions(1);
setTokenHeader(undefined);
setWindowLocation({
href: 'http://localhost/c/chat?ref=share/token',
pathname: '/c/chat',
search: '?ref=share/token',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/messages', headers: {} },
});
try {
await axios.get('/api/messages');
} catch {
// expected rejection
}
expect(mockAdapter).toHaveBeenCalledTimes(1);
});
it('redirects to login with redirect_to when unauthenticated on share page and refresh fails', async () => {
expect.assertions(1);
setTokenHeader(undefined);
setWindowLocation({
href: 'http://localhost/share/abc123',
pathname: '/share/abc123',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/share/abc123', method: 'get', headers: {} },
});
mockAdapter.mockResolvedValueOnce({
data: { token: '' },
status: 200,
headers: {},
config: {},
});
try {
await axios.get('/api/share/abc123');
} catch {
// expected rejection
}
expect(window.location.href).toBe('/login?redirect_to=%2Fshare%2Fabc123');
});
it('redirects to login when the share fork refresh itself fails (stale session)', async () => {
expect.assertions(1);
setTokenHeader(undefined);
setWindowLocation({
href: 'http://localhost/share/abc123',
pathname: '/share/abc123',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/share/abc123/fork', method: 'post', headers: {} },
});
mockAdapter.mockRejectedValueOnce({
response: { status: 403 },
config: { url: '/api/auth/refresh', method: 'post', headers: {} },
});
try {
await axios.post('/api/share/abc123/fork');
} catch {
// expected rejection
}
expect(window.location.href).toBe('/login?redirect_to=%2Fshare%2Fabc123');
});
it('redirects to login with redirect_to when authenticated and refresh returns no token on share page', async () => {
expect.assertions(1);
setTokenHeader('some-token');
setWindowLocation({
href: 'http://localhost/share/abc123',
pathname: '/share/abc123',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/share/abc123', method: 'get', headers: {} },
});
mockAdapter.mockResolvedValueOnce({
data: { token: '' },
status: 200,
headers: {},
config: {},
});
try {
await axios.get('/api/share/abc123');
} catch {
// expected rejection
}
expect(window.location.href).toBe('/login?redirect_to=%2Fshare%2Fabc123');
});
it('redirects to login with redirect_to when refresh returns no token on regular page', async () => {
expect.assertions(1);
setTokenHeader('some-token');
setWindowLocation({
href: 'http://localhost/c/some-conversation',
pathname: '/c/some-conversation',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/messages', headers: {} },
});
mockAdapter.mockResolvedValueOnce({
data: { token: '' },
status: 200,
headers: {},
config: {},
});
try {
await axios.get('/api/messages');
} catch {
// expected rejection
}
expect(window.location.href).toBe('/login?redirect_to=%2Fc%2Fsome-conversation');
});
it('redirects to plain /login without redirect_to when already on a login path', async () => {
expect.assertions(1);
setTokenHeader('some-token');
setWindowLocation({
href: 'http://localhost/login/2fa',
pathname: '/login/2fa',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/messages', headers: {} },
});
mockAdapter.mockResolvedValueOnce({
data: { token: '' },
status: 200,
headers: {},
config: {},
});
try {
await axios.get('/api/messages');
} catch {
// expected rejection
}
expect(window.location.href).toBe('/login');
});
it('attempts refresh when Authorization header is present', async () => {
expect.assertions(2);
setTokenHeader('valid-token');
mockAdapter.mockRejectedValueOnce({
response: { status: 401 },
config: { url: '/api/messages', headers: {}, _retry: false },
});
mockAdapter.mockResolvedValueOnce({
data: { token: 'new-token' },
status: 200,
headers: {},
config: {},
});
mockAdapter.mockResolvedValueOnce({
data: { messages: [] },
status: 200,
headers: {},
config: {},
});
try {
await axios.get('/api/messages');
} catch {
// may reject depending on exact flow
}
expect(mockAdapter.mock.calls.length).toBe(3);
const refreshCall = mockAdapter.mock.calls[1];
expect(refreshCall[0].url).toContain('api/auth/refresh');
});
it('coalesces concurrent 401 responses into one refresh and retries with the new token', async () => {
expect.assertions(3);
setTokenHeader('expired-token');
mockAdapter.mockImplementation((config: RetryableAdapterConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return createAdapterResponse(config, { token: 'new-token' });
}
if (config._retry === true) {
return createAdapterResponse(config, { ok: true });
}
return create401Error(config);
});
const responses = await Promise.all([
axios.get('/api/messages'),
axios.get('/api/convos'),
axios.get('/api/files'),
]);
expect(responses.map((response) => response.data)).toEqual([
{ ok: true },
{ ok: true },
{ ok: true },
]);
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(
mockAdapter.mock.calls
.filter(([config]) => (config as RetryableAdapterConfig)._retry === true)
.every(([config]) => config.headers?.Authorization === 'Bearer new-token'),
).toBe(true);
});
it('holds new requests behind an in-flight auth recovery', async () => {
expect.assertions(4);
setTokenHeader('expired-token');
const refresh = createDeferred<string>();
mockAdapter.mockImplementation((config: RetryableAdapterConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return refresh.promise.then((token) => createAdapterResponse(config, { token }));
}
if (config.url === '/api/messages' && config._retry !== true) {
return create401Error(config);
}
return createAdapterResponse(config, { ok: true });
});
const firstRequest = axios.get('/api/messages');
await waitForAdapterCall('/api/auth/refresh');
const secondRequest = axios.get('/api/projects');
await Promise.resolve();
expect(getCallsForUrl('/api/projects')).toHaveLength(0);
refresh.resolve('new-token');
const responses = await Promise.all([firstRequest, secondRequest]);
expect(responses.map((response) => response.data)).toEqual([{ ok: true }, { ok: true }]);
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(getCallsForUrl('/api/projects')[0][0].headers?.Authorization).toBe('Bearer new-token');
});
it('redirects once when a burst of 401s cannot refresh a token', async () => {
expect.assertions(3);
setTokenHeader('expired-token');
const hrefWrites = setTrackedWindowLocation({
href: 'http://localhost/c/race',
pathname: '/c/race',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return createAdapterResponse(config, { token: '' });
}
return create401Error(config);
});
await Promise.allSettled([
axios.get('/api/messages'),
axios.get('/api/convos'),
axios.get('/api/files'),
]);
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(hrefWrites).toHaveLength(1);
expect(hrefWrites[0]).toBe('/login?redirect_to=%2Fc%2Frace');
});
it('settles concurrent idle-tab requests and preserves the deep link when the session is gone', async () => {
setTokenHeader('expired-token');
const hrefWrites = setTrackedWindowLocation({
href: 'http://localhost/c/resume?view=chat',
pathname: '/c/resume',
search: '?view=chat',
hash: '',
});
const events: string[] = [];
const listener = (event: Event) => events.push((event as CustomEvent).detail.state);
window.addEventListener('authRecovery', listener);
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return Promise.reject({
response: { status: 401, data: { code: 'OPENID_SESSION_MISSING' } },
config,
});
}
return create401Error(config);
});
try {
const results = await Promise.allSettled([
axios.get('/api/messages'),
axios.get('/api/convos'),
axios.get('/api/files'),
]);
expect(results.every((result) => result.status === 'rejected')).toBe(true);
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(hrefWrites).toEqual(['/login?redirect_to=%2Fc%2Fresume%3Fview%3Dchat']);
expect(events).toEqual(['started', 'finished']);
} finally {
window.removeEventListener('authRecovery', listener);
}
});
it('keeps redirect deduping when the storage timestamp is corrupted', async () => {
expect.assertions(2);
setTokenHeader('expired-token');
const hrefWrites = setTrackedWindowLocation({
href: 'http://localhost/c/race',
pathname: '/c/race',
search: '',
hash: '',
} as Partial<Location>);
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return createAdapterResponse(config, { token: '' });
}
return create401Error(config);
});
await axios.get('/api/messages').catch(() => undefined);
window.localStorage.setItem('librechat.auth.redirect.startedAt', 'not-a-number');
await axios.get('/api/convos').catch(() => undefined);
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(hrefWrites).toEqual(['/login?redirect_to=%2Fc%2Frace']);
});
it('refreshes a near-expiry bearer token before sending a request', async () => {
expect.assertions(4);
setTokenHeader(createJwt(Date.now() + 60_000));
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return createAdapterResponse(config, { token: 'fresh-token' });
}
return createAdapterResponse(config, { ok: true });
});
const response = await axios.get('/api/messages');
expect(response.data).toEqual({ ok: true });
expect(mockAdapter.mock.calls[0][0].url).toContain('/api/auth/refresh');
expect(mockAdapter.mock.calls[1][0].url).toBe('/api/messages');
expect(mockAdapter.mock.calls[1][0].headers?.Authorization).toBe('Bearer fresh-token');
});
it('uses shared proactive refresh for authenticated fetch requests', async () => {
expect.assertions(4);
setTokenHeader(createJwt(Date.now() + 60_000));
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return createAdapterResponse(config, { token: 'fresh-token' });
}
return createAdapterResponse(config, { ok: true });
});
const fetchSpy = jest.spyOn(globalThis, 'fetch').mockResolvedValue(
new Response(null, {
status: 200,
headers: { 'Content-Type': 'text/event-stream' },
}),
);
await dataRequest.authenticatedFetch('/api/files', {
method: 'POST',
body: new FormData(),
headers: { Accept: 'text/event-stream' },
});
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(fetchSpy).toHaveBeenCalledTimes(1);
const uploadHeaders = new Headers(fetchSpy.mock.calls[0][1]?.headers);
expect(uploadHeaders.get('Authorization')).toBe('Bearer fresh-token');
expect(uploadHeaders.get('Accept')).toBe('text/event-stream');
});
it('refreshes and retries an authenticated fetch request after a 401', async () => {
expect.assertions(4);
setTokenHeader('expired-token');
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return createAdapterResponse(config, { token: 'fresh-token' });
}
return createAdapterResponse(config, { ok: true });
});
const fetchSpy = jest
.spyOn(globalThis, 'fetch')
.mockResolvedValueOnce(new Response(null, { status: 401 }))
.mockResolvedValueOnce(
new Response(null, {
status: 200,
headers: { 'Content-Type': 'text/event-stream' },
}),
);
await dataRequest.authenticatedFetch('/api/files', {
method: 'POST',
body: new FormData(),
});
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(fetchSpy).toHaveBeenCalledTimes(2);
const firstHeaders = new Headers(fetchSpy.mock.calls[0][1]?.headers);
const retriedHeaders = new Headers(fetchSpy.mock.calls[1][1]?.headers);
expect(firstHeaders.get('Authorization')).toBe('Bearer expired-token');
expect(retriedHeaders.get('Authorization')).toBe('Bearer fresh-token');
});
/**
* A burst of requests leaves with one bearer, and some of their 401s are delivered only after
* the refresh the first 401 started has settled. Those describe a bearer that is already gone.
*/
it('replays a 401 that carried a superseded bearer without a second refresh', async () => {
expect.assertions(5);
setTokenHeader('expired-token');
const lateRejection = createDeferred<void>();
const sentBearers: Record<string, string[]> = {};
const recoveryStates: string[] = [];
const recordRecovery = (event: Event) => {
recoveryStates.push((event as CustomEvent<{ state: string }>).detail.state);
};
window.addEventListener('authRecovery', recordRecovery);
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
const url = config.url ?? '';
if (url.includes('/api/auth/refresh')) {
return createAdapterResponse(config, { token: 'new-token' });
}
const authorization = String(config.headers?.Authorization);
(sentBearers[url] ??= []).push(authorization);
if (authorization !== 'Bearer expired-token') {
return createAdapterResponse(config, { ok: true });
}
if (url === '/api/convos') {
return lateRejection.promise.then(() => create401Error(config));
}
return create401Error(config);
});
try {
const lateRequest = axios.get('/api/convos');
const recovered = await axios.get('/api/messages');
lateRejection.resolve();
const replayed = await lateRequest;
expect([recovered.data, replayed.data]).toEqual([{ ok: true }, { ok: true }]);
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(sentBearers['/api/messages']).toEqual(['Bearer expired-token', 'Bearer new-token']);
expect(sentBearers['/api/convos']).toEqual(['Bearer expired-token', 'Bearer new-token']);
expect(recoveryStates).toEqual(['started', 'finished']);
} finally {
window.removeEventListener('authRecovery', recordRecovery);
}
});
it('still refreshes when the replayed request is rejected with the current bearer', async () => {
expect.assertions(3);
setTokenHeader('expired-token');
const lateRejection = createDeferred<void>();
let refreshes = 0;
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
const url = config.url ?? '';
if (url.includes('/api/auth/refresh')) {
refreshes += 1;
return createAdapterResponse(config, { token: `token-${refreshes}` });
}
const authorization = String(config.headers?.Authorization);
if (url === '/api/convos' && authorization === 'Bearer expired-token') {
return lateRejection.promise.then(() => create401Error(config));
}
if (authorization === 'Bearer token-2') {
return createAdapterResponse(config, { ok: true });
}
if (url === '/api/messages' && authorization === 'Bearer token-1') {
return createAdapterResponse(config, { ok: true });
}
return create401Error(config);
});
const lateRequest = axios.get('/api/convos');
await axios.get('/api/messages');
lateRejection.resolve();
const replayed = await lateRequest;
expect(replayed.data).toEqual({ ok: true });
expect(refreshes).toBe(2);
expect(getCallsForUrl('/api/convos')).toHaveLength(3);
});
it('replays an authenticated fetch whose bearer was superseded without a second refresh', async () => {
expect.assertions(4);
setTokenHeader('expired-token');
const lateRejection = createDeferred<Response>();
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return createAdapterResponse(config, { token: 'new-token' });
}
if (String(config.headers?.Authorization) === 'Bearer expired-token') {
return create401Error(config);
}
return createAdapterResponse(config, { ok: true });
});
const fetchSpy = jest
.spyOn(globalThis, 'fetch')
.mockReturnValueOnce(lateRejection.promise)
.mockResolvedValueOnce(new Response(null, { status: 200 }));
const upload = dataRequest.authenticatedFetch('/api/files', { method: 'POST' });
await axios.get('/api/messages');
lateRejection.resolve(new Response(null, { status: 401 }));
const response = await upload;
expect(response.status).toBe(200);
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(fetchSpy).toHaveBeenCalledTimes(2);
expect(new Headers(fetchSpy.mock.calls[1][1]?.headers).get('Authorization')).toBe(
'Bearer new-token',
);
});
it('still refreshes when the replayed fetch is rejected with the current bearer', async () => {
expect.assertions(4);
setTokenHeader('expired-token');
const lateRejection = createDeferred<Response>();
let refreshes = 0;
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
refreshes += 1;
return createAdapterResponse(config, { token: `token-${refreshes}` });
}
if (String(config.headers?.Authorization) === 'Bearer expired-token') {
return create401Error(config);
}
return createAdapterResponse(config, { ok: true });
});
const fetchSpy = jest
.spyOn(globalThis, 'fetch')
.mockReturnValueOnce(lateRejection.promise)
.mockResolvedValueOnce(new Response(null, { status: 401 }))
.mockResolvedValueOnce(new Response(null, { status: 200 }));
const upload = dataRequest.authenticatedFetch('/api/files', { method: 'POST' });
await axios.get('/api/messages');
lateRejection.resolve(new Response(null, { status: 401 }));
const response = await upload;
expect(response.status).toBe(200);
expect(refreshes).toBe(2);
expect(new Headers(fetchSpy.mock.calls[1][1]?.headers).get('Authorization')).toBe(
'Bearer token-1',
);
expect(new Headers(fetchSpy.mock.calls[2][1]?.headers).get('Authorization')).toBe(
'Bearer token-2',
);
});
it('does not wait on the in-flight recovery when the refresh request itself fails', async () => {
expect.assertions(3);
setTokenHeader(createJwt(Date.now() + 60_000));
mockAdapter.mockImplementation((config: InternalAxiosRequestConfig) => {
if (config.url?.includes('/api/auth/refresh') === true) {
return create401Error(config);
}
return createAdapterResponse(config, { ok: true });
});
const response = await axios.get('/api/messages');
expect(response.data).toEqual({ ok: true });
expect(getCallsForUrl('/api/auth/refresh')).toHaveLength(1);
expect(getCallsForUrl('/api/messages')).toHaveLength(1);
});
});