Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
/**
* @jest-environment @happy-dom/jest-environment
*/
import React from 'react';
import { RecoilRoot } from 'recoil';
import { getDefaultStore } from 'jotai';
import { MemoryRouter } from 'react-router-dom';
import { render, act } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import {
FileSources,
readTwoFactorSetupToken,
clearTwoFactorSetupToken,
persistTwoFactorSetupToken,
} from 'librechat-data-provider';
import type { TAuthConfig } from '~/common';
import {
SESSION_KEY,
getCachedTTSAudio,
setCachedTTSAudio,
retainFileDeletion,
getTTSCacheGeneration,
clearRetainedFileDeletions,
takeRetainedFileDeletions,
} from '~/utils';
import {
chatFilterStatusAtom,
chatFilterTagsAtom,
chatSortAtom,
resetChatFilterSessionAtom,
} from '~/components/Conversations/chatFilters';
import { AuthContextProvider, useAuthContext } from '../AuthContext';
const mockNavigate = jest.fn();
jest.mock('react-router-dom', () => ({
...jest.requireActual('react-router-dom'),
useNavigate: () => mockNavigate,
}));
const mockApiBaseUrl = jest.fn(() => '');
jest.mock('librechat-data-provider', () => ({
...jest.requireActual('librechat-data-provider'),
setTokenHeader: jest.fn(),
apiBaseUrl: () => mockApiBaseUrl(),
}));
let mockCapturedLoginOptions: {
onSuccess: (...args: unknown[]) => void;
onError: (...args: unknown[]) => void;
};
let mockCapturedLogoutOptions: {
onSuccess: (...args: unknown[]) => void;
onError: (...args: unknown[]) => void;
};
const mockEndPullRequestSession = jest.fn();
const mockClearTitleGenerationState = jest.fn();
const mockRefreshMutate = jest.fn();
const mockLoginMutate = jest.fn();
const mockLogoutMutate = jest.fn();
let capturedAuthContext: ReturnType<typeof useAuthContext> | undefined;
jest.mock('~/data-provider', () => ({
useLoginUserMutation: jest.fn(
(options: {
onSuccess: (...args: unknown[]) => void;
onError: (...args: unknown[]) => void;
}) => {
mockCapturedLoginOptions = options;
return { mutate: mockLoginMutate };
},
),
useLogoutUserMutation: jest.fn(
(options: {
onSuccess: (...args: unknown[]) => void;
onError: (...args: unknown[]) => void;
}) => {
mockCapturedLogoutOptions = options;
return { mutate: mockLogoutMutate };
},
),
useRefreshTokenMutation: jest.fn(() => ({ mutate: mockRefreshMutate })),
useGetUserQuery: jest.fn(() => ({
data: undefined,
isError: false,
error: null,
})),
useGetRole: jest.fn(() => ({ data: null })),
endPullRequestSession: jest.fn(() => mockEndPullRequestSession()),
clearTitleGenerationState: jest.fn(() => mockClearTitleGenerationState()),
setPullRequestSessionOwner: jest.fn(),
useListRoles: jest.fn(() => ({ data: undefined })),
}));
const authConfig: TAuthConfig = { loginRedirect: '/login', test: true };
function TestConsumer() {
const ctx = useAuthContext();
capturedAuthContext = ctx;
return (
<div
data-testid="consumer"
data-authenticated={ctx.isAuthenticated}
data-auth-ready={ctx.isAuthReady}
data-error={ctx.error ?? ''}
data-roles={JSON.stringify(ctx.roles ?? {})}
/>
);
}
function renderProvider() {
const queryClient = new QueryClient({
defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
});
const tree = () => (
<QueryClientProvider client={queryClient}>
<RecoilRoot>
<MemoryRouter>
<AuthContextProvider authConfig={authConfig}>
<TestConsumer />
</AuthContextProvider>
</MemoryRouter>
</RecoilRoot>
</QueryClientProvider>
);
const result = render(tree());
return { ...result, rerenderProvider: () => result.rerender(tree()) };
}
/** Renders without test:true so silentRefresh actually runs */
function renderProviderLive() {
const queryClient = new QueryClient({
defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
});
return render(
<QueryClientProvider client={queryClient}>
<RecoilRoot>
<MemoryRouter>
<AuthContextProvider authConfig={{ loginRedirect: '/login' }}>
<TestConsumer />
</AuthContextProvider>
</MemoryRouter>
</RecoilRoot>
</QueryClientProvider>,
);
}
function renderOptionalProvider() {
const queryClient = new QueryClient({
defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
});
return render(
<QueryClientProvider client={queryClient}>
<RecoilRoot>
<MemoryRouter>
<AuthContextProvider authConfig={{ loginRedirect: '/login', optional: true }}>
<TestConsumer />
</AuthContextProvider>
</MemoryRouter>
</RecoilRoot>
</QueryClientProvider>,
);
}
describe('AuthContextProvider: test mode', () => {
beforeEach(() => {
jest.clearAllMocks();
});
it('is ready without starting silent refresh', () => {
const { getByTestId } = renderProvider();
expect(getByTestId('consumer')).toHaveAttribute('data-auth-ready', 'true');
expect(mockRefreshMutate).not.toHaveBeenCalled();
});
it('preserves auth context when mutation result objects change without an auth change', () => {
const { rerenderProvider } = renderProvider();
const previousContext = capturedAuthContext;
rerenderProvider();
expect(capturedAuthContext?.login).toBe(previousContext?.login);
expect(capturedAuthContext?.logout).toBe(previousContext?.logout);
expect(capturedAuthContext).toBe(previousContext);
});
});
describe('AuthContextProvider two-factor login handoff', () => {
beforeEach(() => {
jest.clearAllMocks();
sessionStorage.clear();
capturedAuthContext = undefined;
window.history.replaceState({}, '', '/login');
});
afterEach(() => {
sessionStorage.clear();
window.history.replaceState({}, '', '/');
});
it('routes unenrolled users to required setup', () => {
renderProvider();
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
twoFASetupRequired: true,
tempToken: 'setup-token',
});
});
expect(mockNavigate).toHaveBeenCalledWith('/login/2fa/setup', { replace: true });
/** The credential is handed over out of band, never through the address bar. */
expect(readTwoFactorSetupToken()).toBe('setup-token');
});
it('retains a non-default destination through setup reload and consumes it after completion', () => {
window.history.replaceState(
{},
'',
'/login?redirect_to=%2Fc%2Fredirect-lifecycle-proof%3Fmodel%3Dtest',
);
const firstRender = renderProvider();
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
twoFASetupRequired: true,
tempToken: 'setup-token',
});
});
expect(sessionStorage.getItem(SESSION_KEY)).toBe('/c/redirect-lifecycle-proof?model=test');
firstRender.unmount();
window.history.replaceState({}, '', '/login/2fa/setup');
renderProvider();
act(() => {
capturedAuthContext?.completeAuthentication('auth-token', { id: 'user-1' } as never);
});
expect(mockNavigate).toHaveBeenLastCalledWith('/c/redirect-lifecycle-proof?model=test', {
replace: true,
});
expect(sessionStorage.getItem(SESSION_KEY)).toBeNull();
act(() => {
capturedAuthContext?.completeAuthentication('auth-token', { id: 'user-1' } as never);
});
expect(mockNavigate).toHaveBeenLastCalledWith('/c/new', { replace: true });
});
it('keeps enrolled users on the existing verification route', () => {
renderProvider();
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
tempToken: 'challenge-token',
});
});
expect(mockNavigate).toHaveBeenCalledWith('/login/2fa?tempToken=challenge-token', {
replace: true,
});
});
/**
* An abandoned setup token outlives the screen that staged it, so a later sign-in in the same tab
* must not leave the previous user's enrollment credential available to finish.
*/
it('drops an abandoned setup token when the next sign-in succeeds', () => {
renderProvider();
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
twoFASetupRequired: true,
tempToken: 'abandoned-token',
});
});
expect(readTwoFactorSetupToken()).toBe('abandoned-token');
act(() => {
mockCapturedLoginOptions.onSuccess({
token: 'other-user-token',
user: { id: 'user-2' },
});
});
expect(readTwoFactorSetupToken()).toBe('');
});
it('drops an abandoned setup token when the next sign-in is challenged', () => {
renderProvider();
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
twoFASetupRequired: true,
tempToken: 'abandoned-token',
});
});
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
tempToken: 'challenge-token',
});
});
expect(readTwoFactorSetupToken()).toBe('');
});
it('drops an abandoned setup token when the next sign-in fails', () => {
renderProvider();
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
twoFASetupRequired: true,
tempToken: 'abandoned-token',
});
});
act(() => {
mockCapturedLoginOptions.onError({ response: { status: 401 } });
});
expect(readTwoFactorSetupToken()).toBe('');
});
it('still hands the fresh credential to a setup that follows another sign-in', () => {
renderProvider();
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
twoFASetupRequired: true,
tempToken: 'first-token',
});
});
act(() => {
mockCapturedLoginOptions.onSuccess({
twoFAPending: true,
twoFASetupRequired: true,
tempToken: 'second-token',
});
});
expect(readTwoFactorSetupToken()).toBe('second-token');
});
});
describe('AuthContextProvider: login onError redirect handling', () => {
beforeEach(() => {
jest.clearAllMocks();
window.history.replaceState({}, '', '/login');
});
afterEach(() => {
window.history.replaceState({}, '', '/');
});
it('preserves a valid redirect_to param across login failure', () => {
window.history.replaceState({}, '', '/login?redirect_to=%2Fc%2Fabc123');
renderProvider();
act(() => {
mockCapturedLoginOptions.onError({ message: 'Invalid credentials' });
});
expect(mockNavigate).toHaveBeenCalledWith('/login?redirect_to=%2Fc%2Fabc123', {
replace: true,
});
});
it('drops redirect_to when it contains an absolute URL (open-redirect prevention)', () => {
window.history.replaceState({}, '', '/login?redirect_to=https%3A%2F%2Fevil.com');
renderProvider();
act(() => {
mockCapturedLoginOptions.onError({ message: 'Invalid credentials' });
});
expect(mockNavigate).toHaveBeenCalledWith('/login', { replace: true });
});
it('drops redirect_to when it points to /login (recursive redirect prevention)', () => {
window.history.replaceState({}, '', '/login?redirect_to=%2Flogin');
renderProvider();
act(() => {
mockCapturedLoginOptions.onError({ message: 'Invalid credentials' });
});
expect(mockNavigate).toHaveBeenCalledWith('/login', { replace: true });
});
it('navigates to plain /login when no redirect_to param exists', () => {
renderProvider();
act(() => {
mockCapturedLoginOptions.onError({ message: 'Server error' });
});
expect(mockNavigate).toHaveBeenCalledWith('/login', { replace: true });
});
it.each(['auth_cross_origin', 'TWO_FACTOR_FEDERATED_LOGIN_BLOCKED'])(
'surfaces the recognized %s rejection code instead of the HTTP status message',
(code) => {
jest.useFakeTimers();
const { getByTestId } = renderProvider();
act(() => {
mockCapturedLoginOptions.onError({
message: 'Request failed with status code 403',
response: { data: { code } },
});
jest.advanceTimersByTime(400);
});
expect(getByTestId('consumer')).toHaveAttribute('data-error', code);
jest.useRealTimers();
},
);
it('keeps the HTTP status message for other rejections that carry a code', () => {
jest.useFakeTimers();
const { getByTestId } = renderProvider();
act(() => {
mockCapturedLoginOptions.onError({
message: 'Request failed with status code 429',
response: { data: { message: 'Too many login attempts', code: 'something_else' } },
});
jest.advanceTimersByTime(400);
});
expect(getByTestId('consumer')).toHaveAttribute(
'data-error',
'Request failed with status code 429',
);
jest.useRealTimers();
});
it('preserves redirect_to with query params and hash', () => {
const target = '/c/abc123?model=gpt-4#section';
window.history.replaceState({}, '', `/login?redirect_to=${encodeURIComponent(target)}`);
renderProvider();
act(() => {
mockCapturedLoginOptions.onError({ message: 'Invalid credentials' });
});
const navigatedUrl = mockNavigate.mock.calls[0][0] as string;
const params = new URLSearchParams(navigatedUrl.split('?')[1]);
expect(decodeURIComponent(params.get('redirect_to')!)).toBe(target);
});
});
describe('AuthContextProvider — logout onSuccess/onError handling', () => {
const mockSetTokenHeader = jest.requireMock('librechat-data-provider').setTokenHeader;
beforeEach(() => {
jest.clearAllMocks();
window.history.replaceState({}, '', '/c/some-chat');
});
afterEach(() => {
window.history.replaceState({}, '', '/');
});
it('calls window.location.replace and setTokenHeader(undefined) when redirect is present', () => {
const replaceSpy = jest.spyOn(window.location, 'replace').mockImplementation(() => {});
renderProvider();
act(() => {
mockCapturedLogoutOptions.onSuccess({
message: 'Logout successful',
redirect: 'https://idp.example.com/logout?id_token_hint=abc',
});
});
expect(replaceSpy).toHaveBeenCalledWith('https://idp.example.com/logout?id_token_hint=abc');
expect(mockSetTokenHeader).toHaveBeenCalledWith(undefined);
});
it('resets account-scoped chat filters at the logout session boundary', () => {
const jotaiStore = getDefaultStore();
jotaiStore.set(chatFilterStatusAtom, 'archived');
jotaiStore.set(chatFilterTagsAtom, ['legacy-bookmark']);
jotaiStore.set(chatSortAtom, { field: 'title', direction: 'asc' });
renderProvider();
act(() => {
mockCapturedLogoutOptions.onSuccess({ message: 'Logout successful' });
});
expect(jotaiStore.get(chatFilterStatusAtom)).toBe('active');
expect(jotaiStore.get(chatFilterTagsAtom)).toEqual([]);
expect(jotaiStore.get(chatSortAtom)).toEqual({ field: 'title', direction: 'asc' });
jotaiStore.set(resetChatFilterSessionAtom);
});
it('ends the sidebar pull request queue at the logout session boundary', () => {
mockEndPullRequestSession.mockClear();
renderProvider();
act(() => {
mockCapturedLogoutOptions.onSuccess({ message: 'Logout successful' });
});
expect(mockEndPullRequestSession).toHaveBeenCalled();
});
it('clears module-level title generation state at the logout session boundary', () => {
mockClearTitleGenerationState.mockClear();
renderProvider();
act(() => {
mockCapturedLogoutOptions.onSuccess({ message: 'Logout successful' });
});
expect(mockClearTitleGenerationState).toHaveBeenCalled();
});
it('does not end the sidebar pull request queue while a session is being established', () => {
mockEndPullRequestSession.mockClear();
renderProvider();
act(() => {
capturedAuthContext?.completeAuthentication('auth-token', { id: 'user-1' } as never);
});
expect(mockEndPullRequestSession).not.toHaveBeenCalled();
});
it('does not call window.location.replace when redirect is absent', async () => {
const replaceSpy = jest.spyOn(window.location, 'replace').mockImplementation(() => {});
renderProvider();
act(() => {
mockCapturedLogoutOptions.onSuccess({ message: 'Logout successful' });
});
expect(replaceSpy).not.toHaveBeenCalled();
});
it('does not trigger silentRefresh after OIDC redirect', () => {
const replaceSpy = jest.spyOn(window.location, 'replace').mockImplementation(() => {});
renderProviderLive();
mockRefreshMutate.mockClear();
act(() => {
mockCapturedLogoutOptions.onSuccess({
message: 'Logout successful',
redirect: 'https://idp.example.com/logout?id_token_hint=abc',
});
});
expect(replaceSpy).toHaveBeenCalled();
expect(mockRefreshMutate).not.toHaveBeenCalled();
});
});
describe('AuthContextProvider — silentRefresh post-login redirect', () => {
beforeEach(() => {
jest.clearAllMocks();
sessionStorage.clear();
});
afterEach(() => {
sessionStorage.clear();
window.history.replaceState({}, '', '/');
});
it('navigates to stored sessionStorage redirect after successful token refresh', () => {
jest.useFakeTimers();
sessionStorage.setItem(SESSION_KEY, '/c/new?endpoint=bedrock&model=claude-sonnet-4-6');
renderProviderLive();
expect(mockRefreshMutate).toHaveBeenCalledTimes(1);
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'USER' }, token: 'new-token' });
});
act(() => {
jest.advanceTimersByTime(100);
});
expect(mockNavigate).toHaveBeenCalledWith('/c/new?endpoint=bedrock&model=claude-sonnet-4-6', {
replace: true,
});
expect(sessionStorage.getItem(SESSION_KEY)).toBeNull();
jest.useRealTimers();
});
/**
* A federated sign-in lands here rather than through the login mutation, so the previous user's
* abandoned enrollment credential has to be dropped on this path too.
*/
it('drops an abandoned setup token when a refresh sign-in is accepted', () => {
jest.useFakeTimers();
persistTwoFactorSetupToken('abandoned-token');
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'USER' }, token: 'new-token' });
});
act(() => {
jest.advanceTimersByTime(100);
});
expect(readTwoFactorSetupToken()).toBe('');
jest.useRealTimers();
});
it('routes an unenrolled refresh session to setup and preserves the requested destination', () => {
window.history.replaceState({}, '', '/c/requested?model=test#latest');
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ twoFASetupRequired: true, tempToken: 'setup token' });
});
expect(sessionStorage.getItem(SESSION_KEY)).toBe('/c/requested?model=test#latest');
expect(mockNavigate).toHaveBeenCalledWith('/login/2fa/setup', { replace: true });
/** Carried verbatim rather than URL-encoded, because it never enters a URL. */
expect(readTwoFactorSetupToken()).toBe('setup token');
});
it('navigates to current URL when no stored redirect exists', () => {
jest.useFakeTimers();
window.history.replaceState({}, '', '/c/new');
renderProviderLive();
expect(mockRefreshMutate).toHaveBeenCalledTimes(1);
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'USER' }, token: 'new-token' });
});
act(() => {
jest.advanceTimersByTime(100);
});
expect(mockNavigate).toHaveBeenCalledWith('/c/new', { replace: true });
jest.useRealTimers();
});
it('keeps the enforcement destination when refresh lands on the setup route', () => {
window.history.replaceState({}, '', '/login/2fa/setup?redirect_to=%2Fc%2Frequested');
persistTwoFactorSetupToken('setup-token');
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ twoFASetupRequired: true, tempToken: 'refreshed token' });
});
/** Replacing the route again would drop the query holding the only copy of the destination. */
expect(mockNavigate).not.toHaveBeenCalled();
expect(window.location.search).toBe('?redirect_to=%2Fc%2Frequested');
/** The setup route is not a safe redirect, so it must never be banked as one either. */
expect(sessionStorage.getItem(SESSION_KEY)).toBeNull();
expect(readTwoFactorSetupToken()).toBe('refreshed token');
});
it('keeps a required setup route mounted when refresh fails after reload', () => {
window.history.replaceState({}, '', '/login/2fa/setup');
persistTwoFactorSetupToken('setup-token');
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onError: (error: Error) => void },
];
act(() => refreshOptions.onError(new Error('No refresh session')));
expect(mockNavigate).not.toHaveBeenCalled();
expect(window.location.pathname).toBe('/login/2fa/setup');
});
it('keeps a required setup route mounted when refresh returns no token after reload', () => {
window.history.replaceState({}, '', '/login/2fa/setup');
persistTwoFactorSetupToken('setup-token');
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => refreshOptions.onSuccess({}));
expect(mockNavigate).not.toHaveBeenCalled();
expect(window.location.pathname).toBe('/login/2fa/setup');
});
it('does not re-trigger silentRefresh after successful redirect', () => {
jest.useFakeTimers();
sessionStorage.setItem(SESSION_KEY, '/c/abc?endpoint=bedrock');
renderProviderLive();
expect(mockRefreshMutate).toHaveBeenCalledTimes(1);
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
mockRefreshMutate.mockClear();
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'USER' }, token: 'new-token' });
});
act(() => {
jest.advanceTimersByTime(100);
});
expect(mockNavigate).toHaveBeenCalledTimes(1);
expect(mockNavigate).toHaveBeenCalledWith('/c/abc?endpoint=bedrock', { replace: true });
expect(mockRefreshMutate).not.toHaveBeenCalled();
jest.useRealTimers();
});
it('falls back to current URL for unsafe stored redirect', () => {
jest.useFakeTimers();
window.history.replaceState({}, '', '/c/new');
sessionStorage.setItem(SESSION_KEY, 'https://evil.com/steal');
renderProviderLive();
expect(mockRefreshMutate).toHaveBeenCalledTimes(1);
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'USER' }, token: 'new-token' });
});
act(() => {
jest.advanceTimersByTime(100);
});
expect(mockNavigate).toHaveBeenCalledWith('/c/new', { replace: true });
expect(mockNavigate).not.toHaveBeenCalledWith('https://evil.com/steal', expect.anything());
expect(sessionStorage.getItem(SESSION_KEY)).toBeNull();
jest.useRealTimers();
});
});
describe('AuthContextProvider — optional authentication', () => {
beforeEach(() => {
jest.clearAllMocks();
window.history.replaceState({}, '', '/share/share-1');
});
afterEach(() => {
window.history.replaceState({}, '', '/');
});
it('keeps a public route visible when no refresh token exists', () => {
renderOptionalProvider();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess(undefined);
});
expect(mockNavigate).not.toHaveBeenCalled();
expect(document.querySelector('[data-testid="consumer"]')).toHaveAttribute(
'data-auth-ready',
'true',
);
});
it('keeps a public route visible when session refresh fails', () => {
renderOptionalProvider();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onError: (error: unknown) => void },
];
act(() => {
refreshOptions.onError(new Error('No session'));
});
expect(mockNavigate).not.toHaveBeenCalled();
expect(document.querySelector('[data-testid="consumer"]')).toHaveAttribute(
'data-auth-ready',
'true',
);
});
});
describe('AuthContextProvider — prerendered page', () => {
const setPrerendering = (value: boolean) =>
Object.defineProperty(document, 'prerendering', { configurable: true, value });
beforeEach(() => {
jest.clearAllMocks();
setPrerendering(true);
});
afterEach(() => {
delete (document as Document & { prerendering?: boolean }).prerendering;
});
it('defers the silent refresh until the prerendered page is shown', () => {
renderProviderLive();
expect(mockRefreshMutate).not.toHaveBeenCalled();
setPrerendering(false);
act(() => {
document.dispatchEvent(new Event('prerenderingchange'));
});
expect(mockRefreshMutate).toHaveBeenCalledTimes(1);
});
});
describe('AuthContextProvider — silentRefresh subdirectory deployment', () => {
beforeEach(() => {
jest.clearAllMocks();
sessionStorage.clear();
mockApiBaseUrl.mockReturnValue('/chat');
});
afterEach(() => {
mockApiBaseUrl.mockReturnValue('');
sessionStorage.clear();
window.history.replaceState({}, '', '/');
});
it('strips base path from window.location.pathname before navigating (prevents /chat/chat doubling)', () => {
jest.useFakeTimers();
window.history.replaceState({}, '', '/chat/c/abc123?model=gpt-4');
renderProviderLive();
expect(mockRefreshMutate).toHaveBeenCalledTimes(1);
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'USER' }, token: 'new-token' });
});
act(() => {
jest.advanceTimersByTime(100);
});
expect(mockNavigate).toHaveBeenCalledWith('/c/abc123?model=gpt-4', { replace: true });
expect(mockNavigate).not.toHaveBeenCalledWith(
expect.stringContaining('/chat/c/'),
expect.anything(),
);
jest.useRealTimers();
});
it('falls back to root when window.location.pathname equals the base path', () => {
jest.useFakeTimers();
window.history.replaceState({}, '', '/chat');
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'USER' }, token: 'new-token' });
});
act(() => {
jest.advanceTimersByTime(100);
});
expect(mockNavigate).toHaveBeenCalledWith('/', { replace: true });
jest.useRealTimers();
});
});
describe('AuthContextProvider — logout error handling', () => {
beforeEach(() => {
jest.clearAllMocks();
window.history.replaceState({}, '', '/c/some-chat');
});
afterEach(() => {
window.history.replaceState({}, '', '/');
});
it('clears auth state on logout error without external redirect', () => {
jest.useFakeTimers();
const replaceSpy = jest.spyOn(window.location, 'replace').mockImplementation(() => {});
const { getByTestId } = renderProvider();
act(() => {
mockCapturedLogoutOptions.onError(new Error('Logout failed'));
});
act(() => {
jest.advanceTimersByTime(100);
});
expect(replaceSpy).not.toHaveBeenCalled();
expect(getByTestId('consumer').getAttribute('data-authenticated')).toBe('false');
jest.useRealTimers();
});
});
describe('AuthContextProvider — custom role detection and fetching', () => {
const mockUseGetRole = jest.requireMock('~/data-provider').useGetRole;
const staffPermissions = {
name: 'STAFF',
permissions: { PROMPTS: { USE: true, CREATE: false } },
};
beforeEach(() => {
jest.clearAllMocks();
sessionStorage.clear();
});
afterEach(() => {
sessionStorage.clear();
window.history.replaceState({}, '', '/');
});
it('calls useGetRole with the custom role name and enabled: true for custom role users', () => {
jest.useFakeTimers();
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'STAFF' }, token: 'tok' });
});
act(() => {
jest.advanceTimersByTime(100);
});
const staffCalls = mockUseGetRole.mock.calls.filter(([name]: [string]) => name === 'STAFF');
expect(staffCalls.length).toBeGreaterThan(0);
const lastStaffCall = staffCalls[staffCalls.length - 1];
expect(lastStaffCall[1]).toEqual(expect.objectContaining({ enabled: true }));
jest.useRealTimers();
});
it('calls useGetRole with enabled: false for USER role users', () => {
jest.useFakeTimers();
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'USER' }, token: 'tok' });
});
act(() => {
jest.advanceTimersByTime(100);
});
const sentinelCalls = mockUseGetRole.mock.calls.filter(([name]: [string]) => name === '_');
expect(sentinelCalls.length).toBeGreaterThan(0);
for (const call of sentinelCalls) {
expect(call[1]).toEqual(expect.objectContaining({ enabled: false }));
}
jest.useRealTimers();
});
it('calls useGetRole with enabled: false for ADMIN role users', () => {
jest.useFakeTimers();
renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'ADMIN' }, token: 'tok' });
});
act(() => {
jest.advanceTimersByTime(100);
});
const sentinelCalls = mockUseGetRole.mock.calls.filter(([name]: [string]) => name === '_');
expect(sentinelCalls.length).toBeGreaterThan(0);
for (const call of sentinelCalls) {
expect(call[1]).toEqual(expect.objectContaining({ enabled: false }));
}
jest.useRealTimers();
});
it('includes custom role data in the roles context map when loaded', () => {
jest.useFakeTimers();
mockUseGetRole.mockImplementation((name: string, opts?: { enabled?: boolean }) => {
if (name === 'STAFF' && opts?.enabled) {
return { data: staffPermissions };
}
return { data: null };
});
const { getByTestId } = renderProviderLive();
const [, refreshOptions] = mockRefreshMutate.mock.calls[0] as [
unknown,
{ onSuccess: (data: unknown) => void },
];
act(() => {
refreshOptions.onSuccess({ user: { id: '1', role: 'STAFF' }, token: 'tok' });
});
act(() => {
jest.advanceTimersByTime(100);
});
const rolesAttr = getByTestId('consumer').getAttribute('data-roles') ?? '{}';
const roles = JSON.parse(rolesAttr);
expect(roles).toHaveProperty('STAFF');
expect(roles.STAFF).toEqual(staffPermissions);
mockUseGetRole.mockReturnValue({ data: null });
jest.useRealTimers();
});
});
describe('AuthContextProvider: enrollment hand-off that keeps the document', () => {
const mockUseGetUserQuery = jest.requireMock('~/data-provider').useGetUserQuery;
const dispatchHandoff = (inDocument: boolean) =>
act(() => {
window.dispatchEvent(
new CustomEvent('authRedirectStarted', {
detail: { href: '/login/2fa/setup', inDocument },
}),
);
});
const lastUserQueryConfig = () => {
const calls = mockUseGetUserQuery.mock.calls;
return calls[calls.length - 1][0];
};
beforeEach(() => {
jest.clearAllMocks();
sessionStorage.clear();
clearTwoFactorSetupToken();
capturedAuthContext = undefined;
window.history.replaceState({}, '', '/c/some-chat');
});
afterEach(() => {
clearRetainedFileDeletions();
sessionStorage.clear();
clearTwoFactorSetupToken();
window.history.replaceState({}, '', '/');
});
it('finishes enrollment with a ready session that can retain its own failed deletions', () => {
clearRetainedFileDeletions();
const { getByTestId } = renderProviderLive();
expect(getByTestId('consumer')).toHaveAttribute('data-auth-ready', 'false');
act(() => {
capturedAuthContext?.completeAuthentication('auth-token', { id: 'user-1' } as never);
});
const deletion = {
file_id: 'enrolled-user-file',
embedded: false,
filepath: '/uploads/user-1/file.txt',
source: FileSources.local,
};
retainFileDeletion(deletion);
expect(getByTestId('consumer')).toHaveAttribute('data-auth-ready', 'true');
expect(takeRetainedFileDeletions()).toEqual([deletion]);
dispatchHandoff(true);
expect(takeRetainedFileDeletions()).toEqual([]);
retainFileDeletion(deletion);
expect(takeRetainedFileDeletions()).toEqual([]);
});
/**
* Where session storage is blocked the hand-off routes in place instead of replacing the
* document, so this provider stays mounted and the session it redirects away from would live on.
* An enabled user query leaves for the login page as soon as it fails, which would pull the user
* off the enrollment the server is demanding.
*/
it('releases the replaced session so its user query cannot navigate away', () => {
const jotaiStore = getDefaultStore();
jotaiStore.set(chatFilterStatusAtom, 'archived');
jotaiStore.set(chatFilterTagsAtom, ['previous-session']);
const { getByTestId } = renderProvider();
act(() => {
capturedAuthContext?.completeAuthentication('auth-token', { id: 'user-1' } as never);
});
expect(getByTestId('consumer').getAttribute('data-authenticated')).toBe('true');
expect(lastUserQueryConfig()).toEqual(expect.objectContaining({ enabled: true }));
dispatchHandoff(true);
expect(getByTestId('consumer').getAttribute('data-authenticated')).toBe('false');
expect(lastUserQueryConfig()).toEqual(expect.objectContaining({ enabled: false }));
expect(jotaiStore.get(chatFilterStatusAtom)).toBe('active');
expect(jotaiStore.get(chatFilterTagsAtom)).toEqual([]);
});
/** A replaced document discards the session on its own, so nothing is released early here. */
it('leaves the session alone when the hand-off replaces the document', () => {
const { getByTestId } = renderProvider();
act(() => {
capturedAuthContext?.completeAuthentication('auth-token', { id: 'user-1' } as never);
});
dispatchHandoff(false);
expect(getByTestId('consumer').getAttribute('data-authenticated')).toBe('true');
expect(lastUserQueryConfig()).toEqual(expect.objectContaining({ enabled: true }));
});
/** With storage blocked the in-memory mirror is the only copy the setup screen can read. */
it('keeps the setup credential the surviving document is holding', () => {
renderProvider();
act(() => {
capturedAuthContext?.completeAuthentication('auth-token', { id: 'user-1' } as never);
});
persistTwoFactorSetupToken('setup-token');
dispatchHandoff(true);
expect(readTwoFactorSetupToken()).toBe('setup-token');
});
});
describe('AuthContextProvider: read-aloud cache at every session end', () => {
const mockUseGetUserQuery = jest.requireMock('~/data-provider').useGetUserQuery;
const cacheAudio = () =>
setCachedTTSAudio('departing', new Blob(['audio']), getTTSCacheGeneration());
const refreshOptions = () =>
mockRefreshMutate.mock.calls[0][1] as {
onSuccess: (data: unknown) => void;
onError: (error: unknown) => void;
};
beforeEach(() => {
jest.clearAllMocks();
jest.spyOn(window.location, 'replace').mockImplementation(() => {});
cacheAudio();
});
afterEach(() => {
jest.useRealTimers();
window.history.replaceState({}, '', '/');
});
it('empties on logout', () => {
renderProvider();
act(() => mockCapturedLogoutOptions.onSuccess({ message: 'Logout successful' }));
expect(getCachedTTSAudio('departing')).toBeUndefined();
});
it('empties on an IdP logout redirect', () => {
renderProvider();
act(() =>
mockCapturedLogoutOptions.onSuccess({
message: 'Logout successful',
redirect: 'https://idp.example.com/logout',
}),
);
expect(getCachedTTSAudio('departing')).toBeUndefined();
});
it('empties when the logout request fails', () => {
renderProvider();
act(() => mockCapturedLogoutOptions.onError(new Error('network')));
expect(getCachedTTSAudio('departing')).toBeUndefined();
});
it('empties when the refresh token is rejected', () => {
renderProviderLive();
act(() => refreshOptions().onError(new Error('401')));
expect(getCachedTTSAudio('departing')).toBeUndefined();
});
it('empties when a refresh returns no session', () => {
renderProviderLive();
act(() => refreshOptions().onSuccess({}));
expect(getCachedTTSAudio('departing')).toBeUndefined();
});
it('empties when the user query fails', () => {
mockUseGetUserQuery.mockReturnValue({
data: undefined,
isError: true,
error: new Error('401'),
});
renderProvider();
expect(getCachedTTSAudio('departing')).toBeUndefined();
mockUseGetUserQuery.mockReturnValue({ data: undefined, isError: false, error: null });
});
it('empties when a different account signs in without a logout', () => {
jest.useFakeTimers();
renderProviderLive();
act(() => {
refreshOptions().onSuccess({ user: { id: 'first', role: 'USER' }, token: 'first-token' });
jest.advanceTimersByTime(100);
});
cacheAudio();
act(() => {
capturedAuthContext?.completeAuthentication('second-token', { id: 'second' } as never);
});
expect(getCachedTTSAudio('departing')).toBeUndefined();
});
it('keeps the cache when the same account signs in again', () => {
renderProvider();
act(() => {
capturedAuthContext?.completeAuthentication('token', { id: 'same' } as never);
});
cacheAudio();
act(() => {
capturedAuthContext?.completeAuthentication('token-2', { id: 'same' } as never);
});
expect(getCachedTTSAudio('departing')).toBeDefined();
});
});
describe('AuthContextProvider: browser setup destination', () => {
const destination = '/code/setup/browser-attempt';
const authenticated = { token: 'auth-token', user: { id: 'setup-user', role: 'USER' } };
beforeEach(() => {
jest.clearAllMocks();
jest.useFakeTimers();
sessionStorage.clear();
clearTwoFactorSetupToken();
capturedAuthContext = undefined;
window.history.replaceState({}, '', `/login?redirect_to=${encodeURIComponent(destination)}`);
});
afterEach(() => {
jest.useRealTimers();
sessionStorage.clear();
clearTwoFactorSetupToken();
mockApiBaseUrl.mockReturnValue('');
window.history.replaceState({}, '', '/');
});
it('returns password sign-in to the setup without approving it', () => {
renderProvider();
act(() => mockCapturedLoginOptions.onSuccess(authenticated));
act(() => jest.advanceTimersByTime(100));
expect(mockNavigate).toHaveBeenLastCalledWith(destination, { replace: true });
expect(sessionStorage.getItem(SESSION_KEY)).toBeNull();
});
it('retains the destination through the normal 2FA challenge', () => {
renderProvider();
act(() => mockCapturedLoginOptions.onSuccess({ twoFAPending: true, tempToken: 'challenge' }));
expect(sessionStorage.getItem(SESSION_KEY)).toBe(destination);
window.history.replaceState({}, '', '/login/2fa?tempToken=challenge');
act(() =>
capturedAuthContext?.completeAuthentication(authenticated.token, authenticated.user as never),
);
expect(mockNavigate).toHaveBeenLastCalledWith(destination, { replace: true });
expect(sessionStorage.getItem(SESSION_KEY)).toBeNull();
});
it('retains the destination through mandatory 2FA enrollment and reload', () => {
const first = renderProvider();
act(() =>
mockCapturedLoginOptions.onSuccess({ twoFASetupRequired: true, tempToken: 'enrollment' }),
);
expect(sessionStorage.getItem(SESSION_KEY)).toBe(destination);
first.unmount();
window.history.replaceState({}, '', '/login/2fa/setup');
renderProvider();
act(() =>
capturedAuthContext?.completeAuthentication(authenticated.token, authenticated.user as never),
);
expect(mockNavigate).toHaveBeenLastCalledWith(destination, { replace: true });
});
it.each(['OAuth', 'OIDC'])('returns %s silent refresh to the stored setup destination', () => {
sessionStorage.setItem(SESSION_KEY, destination);
window.history.replaceState({}, '', '/');
renderProviderLive();
const options = mockRefreshMutate.mock.calls[0][1] as { onSuccess: (data: unknown) => void };
act(() => options.onSuccess(authenticated));
act(() => jest.advanceTimersByTime(100));
expect(mockNavigate).toHaveBeenLastCalledWith(destination, { replace: true });
expect(sessionStorage.getItem(SESSION_KEY)).toBeNull();
});
it('keeps the exact setup destination when refreshing under a basename', () => {
mockApiBaseUrl.mockReturnValue('/librechat');
window.history.replaceState({}, '', `/librechat${destination}`);
renderProviderLive();
const options = mockRefreshMutate.mock.calls[0][1] as { onSuccess: (data: unknown) => void };
act(() => options.onSuccess(authenticated));
act(() => jest.advanceTimersByTime(100));
expect(mockNavigate).toHaveBeenLastCalledWith(destination, { replace: true });
});
it('preserves the setup destination through refresh-enforced enrollment under a basename', () => {
mockApiBaseUrl.mockReturnValue('/librechat');
window.history.replaceState({}, '', `/librechat${destination}`);
renderProviderLive();
const options = mockRefreshMutate.mock.calls[0][1] as { onSuccess: (data: unknown) => void };
act(() => options.onSuccess({ twoFASetupRequired: true, tempToken: 'enrollment' }));
expect(sessionStorage.getItem(SESSION_KEY)).toBe(destination);
expect(mockNavigate).toHaveBeenLastCalledWith('/login/2fa/setup', { replace: true });
});
});