Skip to content

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

42.5 KB
Raw Blame
/**
 * @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 });
  });
});