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
import React from 'react';
import { getDefaultStore } from 'jotai';
import { DndProvider } from 'react-dnd';
import { BrowserRouter } from 'react-router-dom';
import { HTML5Backend } from 'react-dnd-html5-backend';
import { render, act, screen, fireEvent } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { atom, RecoilRoot, useRecoilValue, useSetRecoilState } from 'recoil';
import type { SetterOrUpdater } from 'recoil';
import type { SearchState } from '~/store/search';
/**
* Real recoil atom used to force ConversationsSection to re-render on demand,
* standing in for the conversation-list / title-generation cache churn that
* happens while a message is streaming. The mocked `useTitleGeneration`
* subscribes to it, so bumping it re-renders ConversationsSection (and only
* ConversationsSection) exactly like a streaming update would.
*/
const streamTickAtom = atom<number>({ key: 'conversations-section-stream-tick', default: 0 });
const TEST_TIMEOUT = 30_000;
const mockUseFavorites = jest.fn(() => ({
favorites: [] as unknown[],
reorderFavorites: jest.fn(),
isLoading: false,
}));
const mockUseGetConversationTags = jest.fn(() => ({ data: [] as unknown[] }));
const mockConversationsRender = jest.fn();
/** The projects the section reads to word an empty Chats list; none, loaded, by default. */
type ProjectsResult = {
data?: { pages: { projects: unknown[]; nextCursor: null }[]; pageParams: undefined[] };
isSuccess: boolean;
isError?: boolean;
};
const mockUseProjectsInfiniteQuery = jest.fn(
(): ProjectsResult => ({
data: { pages: [{ projects: [], nextCursor: null }], pageParams: [undefined] },
isSuccess: true,
}),
);
/** What the chats list asks the server for, captured per render. */
const mockListParams = jest.fn();
const mockSetChatsExpanded = jest.fn();
const mockMoveToTop = jest.fn();
const mockUseTitleGeneration = jest.fn(() => {
useRecoilValue(streamTickAtom);
});
/** One stable identity across renders, like react-query's cached data: the
* section's derived `conversations` memo (and so the PinnedSection props)
* keeps referential stability mid-stream, which is what the memoized-children
* guarantee below depends on. */
const mockConversationsResult = {
data: { pages: [{ conversations: [] as unknown[], nextCursor: null }] } as
| { pages: Array<{ conversations: unknown[]; nextCursor: string | null }> }
| undefined,
fetchNextPage: jest.fn(),
refetch: jest.fn(),
isFetchingNextPage: false,
isLoading: false,
isFetching: false,
isPreviousData: false,
isError: false,
};
/** Same identity rule as above: a fresh `pinnedData.conversations` array would
* rebuild `pinnedConversations` and re-render PinnedSection on every tick. */
const mockPinnedResult = { data: { conversations: [] as unknown[], nextCursor: null } };
jest.mock('~/store', () => {
const { atom: recoilAtom } = jest.requireActual('recoil');
return {
__esModule: true,
default: {
sidebarExpanded: recoilAtom({ key: 'mock-cs-sidebarExpanded', default: false }),
search: recoilAtom({
key: 'mock-cs-search',
default: { query: '', debouncedQuery: '', enabled: false, isTyping: false },
}),
},
};
});
jest.mock('~/hooks', () => ({
__esModule: true,
useLocalize: () => (key: string) => key,
useHasAccess: () => true,
useAuthContext: () => ({ isAuthenticated: true }),
useLocalStorage: () => [true, mockSetChatsExpanded],
useNavScrolling: () => ({ moveToTop: mockMoveToTop }),
useScrollFade: () => ({ attach: jest.fn(), hasMore: false }),
useFavorites: () => mockUseFavorites(),
useShowMarketplace: () => false,
useNewConvo: () => ({ newConversation: jest.fn() }),
useGetConversation: () => () => null,
}));
jest.mock('~/data-provider', () => ({
__esModule: true,
useConversationsInfiniteQuery: (params: Record<string, unknown>) => {
mockListParams(params);
return mockConversationsResult;
},
usePinnedConversationsQuery: () => mockPinnedResult,
/** The section reads the same projects ProjectsSection does, to tell an empty
* unassigned list from an empty account; these specs carry no projects. */
useProjectsInfiniteQuery: () => mockUseProjectsInfiniteQuery(),
useTitleGeneration: () => mockUseTitleGeneration(),
useGetEndpointsQuery: () => ({ data: {}, isLoading: false }),
useGetStartupConfig: () => ({ data: { modelSpecs: { list: [] } } }),
useGetConversationTags: () => mockUseGetConversationTags(),
}));
jest.mock('~/Providers', () => ({
__esModule: true,
useAssistantsMapContext: () => ({}),
useAgentsMapContext: () => ({}),
}));
jest.mock('~/hooks/Input/useSelectMention', () => ({
__esModule: true,
default: () => ({ onSelectEndpoint: jest.fn(), onSelectSpec: jest.fn() }),
}));
jest.mock('~/components/Conversations', () => {
const { memo } = jest.requireActual('react');
const ConversationsStub = memo(function ConversationsStub(props: {
accountHasProjects?: boolean;
conversations: Array<{ conversationId: string; title: string }>;
isSearchLoading: boolean;
isError: boolean;
onRetry: () => void;
}) {
const { conversations, isSearchLoading, isError, onRetry } = props;
mockConversationsRender(props);
const localize: (key: string) => string = jest.requireMock('~/hooks').useLocalize();
let body: React.ReactNode = conversations.map((convo) => (
<span key={convo.conversationId}>{convo.title}</span>
));
if (isError && conversations.length === 0) {
body = (
<button type="button" onClick={onRetry}>
{localize('com_ui_retry')}
</button>
);
}
if (isSearchLoading) {
body = <div data-testid="search-spinner" />;
}
return <div data-testid="conversations-stub">{body}</div>;
});
return { __esModule: true, Conversations: ConversationsStub };
});
jest.mock('~/components/Conversations/ProjectsSection', () => ({
__esModule: true,
default: () => <div data-testid="projects-stub" />,
}));
jest.mock('~/components/Conversations/PinnedSection', () => {
const { memo } = jest.requireActual('react');
/** Mirrors the real merged section closely enough for the streaming test:
* memoized like it, and its first act is the same `useFavorites` call
* through the ~/hooks mock, so that hook's call count tracks its renders. */
const PinnedSectionStub = memo(function PinnedSectionStub() {
mockUseFavorites();
return <div data-testid="pinned-stub" />;
});
PinnedSectionStub.displayName = 'PinnedSectionStub';
return { __esModule: true, default: PinnedSectionStub };
});
jest.mock('~/components/Nav/SearchBar', () => ({
__esModule: true,
default: () => <div data-testid="searchbar-stub" />,
}));
jest.mock('~/components/Nav/Favorites/FavoriteItem', () => ({
__esModule: true,
default: () => <div data-testid="favorite-item-stub" />,
}));
import { showProjectChatsAtom } from '~/components/Conversations/chatFilters';
import ConversationsSection from '../ConversationsSection';
import store from '~/store';
let setStreamTick: SetterOrUpdater<number>;
let setSearchState: SetterOrUpdater<SearchState>;
function TickController() {
setStreamTick = useSetRecoilState(streamTickAtom);
setSearchState = useSetRecoilState(store.search);
return null;
}
const createQueryClient = () => new QueryClient({ defaultOptions: { queries: { retry: false } } });
const renderCount = () =>
mockUseFavorites.mock.calls.length + mockUseTitleGeneration.mock.calls.length;
/**
* Yield a full event-loop turn inside act, so follow-up work that lands in the real
* scheduler as a macrotask is flushed before render counts are compared.
*/
const flushEventLoopTurn = () =>
act(async () => {
await new Promise((resolve) => setTimeout(resolve, 0));
});
/** Flush event-loop turns until two consecutive turns add no renders (bounded). */
const settleRenders = async () => {
let stableTurns = 0;
for (let turn = 0; turn < 20 && stableTurns < 2; turn++) {
const before = renderCount();
await flushEventLoopTurn();
stableTurns = renderCount() === before ? stableTurns + 1 : 0;
}
};
const renderSection = (searchQuery = '') =>
render(
<QueryClientProvider client={createQueryClient()}>
<RecoilRoot
initializeState={({ set }) => {
if (searchQuery) {
set(store.search, {
query: searchQuery,
debouncedQuery: searchQuery,
enabled: true,
isTyping: false,
isSearching: false,
});
}
}}
>
<BrowserRouter>
<DndProvider backend={HTML5Backend}>
<TickController />
<ConversationsSection />
</DndProvider>
</BrowserRouter>
</RecoilRoot>
</QueryClientProvider>,
);
describe('ConversationsSection section order', () => {
it('renders Pinned between Projects and Chats', async () => {
const { getByTestId } = renderSection();
await settleRenders();
const projects = getByTestId('projects-stub');
const pinned = getByTestId('pinned-stub');
const chats = getByTestId('conversations-stub');
expect(
projects.compareDocumentPosition(pinned) & Node.DOCUMENT_POSITION_FOLLOWING,
).toBeTruthy();
expect(pinned.compareDocumentPosition(chats) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
});
});
describe('ConversationsSection streaming re-renders', () => {
beforeEach(() => {
mockConversationsRender.mockClear();
mockUseFavorites.mockImplementation(() => ({
favorites: [],
reorderFavorites: jest.fn(),
isLoading: false,
}));
mockUseGetConversationTags.mockImplementation(() => ({ data: [] }));
mockUseTitleGeneration.mockImplementation(() => {
useRecoilValue(streamTickAtom);
});
});
it(
'does not re-render memoized children when the section re-renders mid-stream',
async () => {
renderSection();
await settleRenders();
expect(mockUseFavorites.mock.calls.length).toBeGreaterThan(0);
const favBaseline = mockUseFavorites.mock.calls.length;
const conversationsBaseline = mockConversationsRender.mock.calls.length;
const titleBaseline = mockUseTitleGeneration.mock.calls.length;
// Simulate a stream: repeatedly re-render ConversationsSection.
for (let i = 0; i < 5; i++) {
act(() => {
setStreamTick((prev) => prev + 1);
});
}
// Sanity check: the section genuinely re-rendered each tick.
expect(mockUseTitleGeneration.mock.calls.length).toBeGreaterThan(titleBaseline);
// The memoized children, fed referentially stable props, did not re-render.
expect(mockUseFavorites.mock.calls.length).toBe(favBaseline);
expect(mockConversationsRender.mock.calls.length).toBe(conversationsBaseline);
},
TEST_TIMEOUT,
);
});
describe('ConversationsSection project chats', () => {
beforeEach(() => {
mockListParams.mockClear();
});
afterEach(() => {
act(() => getDefaultStore().set(showProjectChatsAtom, false));
});
/** A project chat is shown only under its project, not twice, unless the user opts in. */
it('asks only for chats that belong to no project by default', async () => {
renderSection();
await settleRenders();
expect(mockListParams).toHaveBeenCalled();
expect(mockListParams.mock.calls.at(-1)?.[0]).toMatchObject({ projectId: 'unassigned' });
});
/** Turned on, a chat filed in a project is listed under Chats too, with its folder badge. */
it('lists project chats under Chats once they are shown', async () => {
act(() => getDefaultStore().set(showProjectChatsAtom, true));
renderSection();
await settleRenders();
expect(mockListParams.mock.calls.at(-1)?.[0]).toMatchObject({ projectId: undefined });
});
/** Searching is how a chat is found, and Projects is not rendered while a search
* is on: excluding project chats there would make them unreachable. */
it('searches across every chat, project or not', async () => {
let setSearch: SetterOrUpdater<SearchState>;
function SearchController() {
setSearch = useSetRecoilState(store.search);
return null;
}
render(
<QueryClientProvider client={createQueryClient()}>
<RecoilRoot>
<BrowserRouter>
<DndProvider backend={HTML5Backend}>
<SearchController />
<ConversationsSection />
</DndProvider>
</BrowserRouter>
</RecoilRoot>
</QueryClientProvider>,
);
await settleRenders();
act(() => {
setSearch({
query: 'draft',
debouncedQuery: 'draft',
enabled: true,
isTyping: false,
isSearching: true,
});
});
expect(mockListParams.mock.calls.at(-1)?.[0]).toMatchObject({
search: 'draft',
projectId: undefined,
});
});
});
describe('ConversationsSection empty Chats wording', () => {
const lastAccountHasProjects = () =>
(mockConversationsRender.mock.calls.at(-1)?.[0] as { accountHasProjects?: boolean })
.accountHasProjects;
/** The empty wording only distinguishes an empty account while Chats leaves project
* chats to their projects. */
beforeEach(() => {
mockConversationsRender.mockClear();
mockUseProjectsInfiniteQuery.mockReset();
act(() => getDefaultStore().set(showProjectChatsAtom, false));
});
afterEach(() => {
act(() => getDefaultStore().set(showProjectChatsAtom, false));
});
it('calls the account empty only once its projects have loaded and there are none', async () => {
mockUseProjectsInfiniteQuery.mockReturnValue({
data: { pages: [{ projects: [], nextCursor: null }], pageParams: [undefined] },
isSuccess: true,
});
renderSection();
await settleRenders();
expect(lastAccountHasProjects()).toBe(false);
});
it('does not call the account empty while its projects are still loading', async () => {
mockUseProjectsInfiniteQuery.mockReturnValue({ data: undefined, isSuccess: false });
renderSection();
await settleRenders();
expect(lastAccountHasProjects()).toBe(true);
});
it('lists every chat when the projects failed to load, so project chats keep a way back', async () => {
mockUseProjectsInfiniteQuery.mockReturnValue({
data: undefined,
isSuccess: false,
isError: true,
});
mockListParams.mockClear();
renderSection();
await settleRenders();
expect(mockListParams.mock.calls.at(-1)?.[0]).toEqual(
expect.objectContaining({ projectId: undefined }),
);
expect(lastAccountHasProjects()).toBe(false);
});
});
describe('ConversationsSection search refetch', () => {
it('does not display old matches as unfiltered chats while clearing the search', async () => {
const previousData = mockConversationsResult.data;
mockConversationsResult.data = {
pages: [
{
conversations: [{ conversationId: 'chat-1', title: 'Old search match' }],
nextCursor: null,
},
],
};
try {
renderSection('draft');
await settleRenders();
expect(screen.getByText('Old search match')).toBeInTheDocument();
act(() => {
setSearchState({
query: '',
debouncedQuery: 'draft',
enabled: true,
isTyping: true,
isSearching: false,
});
});
expect(screen.getByTestId('projects-stub')).toBeInTheDocument();
expect(screen.queryByText('Old search match')).not.toBeInTheDocument();
expect(screen.getByTestId('search-spinner')).toBeInTheDocument();
} finally {
mockConversationsResult.data = previousData;
}
});
it('shows progress while retrying a failed cached search with no results', async () => {
const previousData = mockConversationsResult.data;
mockConversationsResult.isError = true;
try {
renderSection('draft');
await settleRenders();
expect(screen.getByRole('button', { name: 'com_ui_retry' })).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'com_ui_retry' }));
expect(mockConversationsResult.refetch).toHaveBeenCalledTimes(1);
act(() => {
mockConversationsResult.isFetching = true;
setStreamTick((prev) => prev + 1);
});
expect(screen.getByTestId('search-spinner')).toBeInTheDocument();
expect(screen.queryByRole('button', { name: 'com_ui_retry' })).not.toBeInTheDocument();
act(() => {
mockConversationsResult.isFetching = false;
mockConversationsResult.isError = false;
mockConversationsResult.data = {
pages: [
{
conversations: [{ conversationId: 'chat-1', title: 'Found match' }],
nextCursor: null,
},
],
};
setStreamTick((prev) => prev + 1);
});
expect(screen.getByText('Found match')).toBeInTheDocument();
expect(screen.queryByTestId('search-spinner')).not.toBeInTheDocument();
} finally {
mockConversationsResult.data = previousData;
mockConversationsResult.isError = false;
mockConversationsResult.isFetching = false;
mockConversationsResult.refetch.mockClear();
}
});
it('shows loading for an uncached search', async () => {
const previousData = mockConversationsResult.data;
mockConversationsResult.data = undefined;
mockConversationsResult.isLoading = true;
try {
renderSection('draft');
await settleRenders();
expect(screen.getByTestId('search-spinner')).toBeInTheDocument();
} finally {
mockConversationsResult.data = previousData;
mockConversationsResult.isLoading = false;
}
});
it('does not show results from the previous search while the next one loads', async () => {
const previousData = mockConversationsResult.data;
mockConversationsResult.data = {
pages: [
{
conversations: [{ conversationId: 'chat-1', title: 'Previous match' }],
nextCursor: null,
},
],
};
mockConversationsResult.isPreviousData = true;
try {
renderSection('new term');
await settleRenders();
expect(screen.getByTestId('search-spinner')).toBeInTheDocument();
expect(screen.queryByText('Previous match')).not.toBeInTheDocument();
} finally {
mockConversationsResult.data = previousData;
mockConversationsResult.isPreviousData = false;
}
});
it('keeps cached results visible when a message triggers a background list refetch', async () => {
const previousData = mockConversationsResult.data;
mockConversationsResult.data = {
pages: [
{
conversations: [{ conversationId: 'chat-1', title: 'Matching chat' }],
nextCursor: null,
},
],
};
try {
renderSection('draft');
await settleRenders();
expect(screen.getByText('Matching chat')).toBeInTheDocument();
act(() => {
mockConversationsResult.isFetching = true;
setStreamTick((prev) => prev + 1);
});
expect(screen.getByText('Matching chat')).toBeInTheDocument();
expect(screen.queryByTestId('search-spinner')).not.toBeInTheDocument();
} finally {
mockConversationsResult.isFetching = false;
mockConversationsResult.data = previousData;
}
});
});
describe('ConversationsSection shared scroll surface', () => {
/** Searching swaps what the one surface holds — Projects and Pinned leave,
* the chats become results — and a position kept from the previous contents
* would open those results partway down. */
it('returns the surface to the top when a search replaces its contents', async () => {
let setSearch: SetterOrUpdater<SearchState>;
function SearchController() {
setSearch = useSetRecoilState(store.search);
return null;
}
const { container } = render(
<QueryClientProvider client={createQueryClient()}>
<RecoilRoot>
<BrowserRouter>
<DndProvider backend={HTML5Backend}>
<SearchController />
<ConversationsSection />
</DndProvider>
</BrowserRouter>
</RecoilRoot>
</QueryClientProvider>,
);
await settleRenders();
const surface = container.querySelector<HTMLElement>('.overflow-y-auto');
expect(surface).not.toBeNull();
surface!.scrollTop = 420;
act(() => {
setSearch({
query: 'draft',
debouncedQuery: 'draft',
enabled: true,
isTyping: false,
isSearching: true,
});
});
expect(surface!.scrollTop).toBe(0);
});
});