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 { getDefaultStore } from 'jotai';
import { filesFamily } from '@librechat/chat/react';
import { renderHook, act } from '@testing-library/react';
import type { MouseEvent } from 'react';
import type { ExtendedFile } from '~/common';
import type { FilesDraft } from '~/utils';
const mockNewConversation = jest.fn();
const mockClearMessagesCache = jest.fn();
const mockInvalidateQueries = jest.fn();
const mockClearAllDrafts = jest.fn();
const mockClearFilesDraft = jest.fn();
const mockDeleteFiles = jest.fn();
const mockScheduleRetainedRetry = jest.fn();
/** A live composer entry: what the ownership check reads off the file map. */
type LiveFile = {
file_id: string;
attached?: boolean;
progress?: number;
filepath?: string;
source?: string;
embedded?: boolean;
};
/** Values the module-level mocks read, so each test can stage its own scenario. */
const mockState = {
saveDrafts: false,
isSubmitting: false,
tabId: 'this-tab',
filesDraft: { fileIds: [], pendingPastes: {} } as FilesDraft,
pendingFilesDraft: { fileIds: [], pendingPastes: {} } as FilesDraft,
/** Pane 0's live composer files, held in the real Jotai atom the hook reads. */
get files(): Map<string, LiveFile> {
return getDefaultStore().get(filesFamily(0));
},
set files(files: Map<string, LiveFile>) {
act(() => getDefaultStore().set(filesFamily(0), files as Map<string, ExtendedFile>));
},
retainedDeletions: [] as { file_id: string; filepath: string; source: string }[],
markedPasteIds: [] as string[],
submittedPasteIds: [] as string[],
liveAttachmentIds: [] as string[],
/** What other live tabs publish and have drafted; the real collectors read these from shared
* storage, and a discard must treat them as protection while ignoring its own. */
foreignLiveAttachmentIds: [] as string[],
foreignDraftedIds: [] as string[],
retainedPassInFlight: false,
fileConfig: { deletionRetryLimit: 5 } as { deletionRetryLimit: number } | undefined,
persistedPendingDiscardIds: [] as string[],
retainedListener: null as (() => void) | null,
pendingDiscardListener: null as (() => void) | null,
fileList: undefined as
| {
file_id: string;
filepath: string;
source: string;
embedded?: boolean;
temp_file_id?: string;
}[]
| undefined,
};
jest.mock('@tanstack/react-query', () => ({
useQueryClient: () => ({ invalidateQueries: mockInvalidateQueries }),
}));
jest.mock('recoil', () => ({
useRecoilValue: (key: unknown) => {
if (typeof key === 'string' && key.startsWith('conversationIdByIndex')) {
return 'convo-1';
}
if (typeof key === 'string' && key.startsWith('isSubmitting')) {
return mockState.isSubmitting;
}
return undefined;
},
}));
jest.mock('~/Providers/ChatSettingsContext', () => ({
useChatSettings: () => ({ saveDrafts: mockState.saveDrafts }),
}));
jest.mock('~/hooks/useNewConvo', () => ({
__esModule: true,
default: () => ({ newConversation: mockNewConversation }),
}));
jest.mock('~/utils', () => ({
clearMessagesCache: (...args: unknown[]) => mockClearMessagesCache(...args),
clearAllDrafts: (...args: unknown[]) => mockClearAllDrafts(...args),
clearFilesDraft: (...args: unknown[]) => mockClearFilesDraft(...args),
getNewConversationDraftId: (index = 0) => (index === 0 ? 'new' : `new:${index}`),
getPendingDraftId: (index = 0) => (index === 0 ? 'pending' : `pending:${index}`),
getComposerDraftId: (index = 0, conversationId?: string | null) => {
if (conversationId != null && conversationId !== '') {
return conversationId;
}
return index === 0 ? 'new' : `new:${index}`;
},
getFilesDraft: (id: string) =>
id === 'pending' || (typeof id === 'string' && id.startsWith('pending:'))
? mockState.pendingFilesDraft
: mockState.filesDraft,
isFilesDraftOwnedByThisTab: (draft: { tabId?: string }) =>
draft.tabId == null || draft.tabId === mockState.tabId,
loadPendingDiscardIds: () => [...mockState.persistedPendingDiscardIds],
storePendingDiscardIds: (_index: number, ids: string[]) => {
mockState.persistedPendingDiscardIds = [...ids];
},
subscribePendingDiscardIds: (listener: () => void) => {
mockState.pendingDiscardListener = listener;
return () => {
mockState.pendingDiscardListener = null;
};
},
subscribeRetainedFileDeletions: (listener: () => void) => {
mockState.retainedListener = listener;
return () => {
mockState.retainedListener = null;
mockState.pendingDiscardListener = null;
};
},
takeRetainedFileDeletions: () => mockState.retainedDeletions,
claimFileDeletionRetries: (records: typeof mockState.retainedDeletions) => {
const unique = Array.from(new Map(records.map((record) => [record.file_id, record])).values());
mockState.retainedDeletions = unique;
return unique;
},
settleFileDeletionRetries: (
_records: typeof mockState.retainedDeletions,
failed: Set<string>,
) => {
mockState.retainedDeletions = mockState.retainedDeletions.filter((record) =>
failed.has(record.file_id),
);
},
clearRetainedFileDeletion: (fileId: string) => {
mockState.retainedDeletions = mockState.retainedDeletions.filter(
(record) => record.file_id !== fileId,
);
},
failedFileIdsFrom: (result: { failedFileIds?: string[] } | void) =>
result != null && Array.isArray(result.failedFileIds) ? result.failedFileIds : [],
scheduleRetainedFileDeletionRetry: (pendingDiscard?: boolean) =>
mockScheduleRetainedRetry(pendingDiscard),
isPastedTextFileMarked: (fileId: string) => mockState.markedPasteIds.includes(fileId),
isPasteSubmitted: (fileId: string) => mockState.submittedPasteIds.includes(fileId),
collectLiveAttachmentIds: ({ excludeOwnPane }: { excludeOwnPane?: number | 'tab' } = {}) =>
new Set<string>(
excludeOwnPane === undefined
? [...mockState.liveAttachmentIds, ...mockState.foreignLiveAttachmentIds]
: mockState.foreignLiveAttachmentIds,
),
/** The union every deletion path consults: other tabs' drafts and other tabs' live presence,
* with the caller's own discarded draft keys left out. */
collectForeignAttachmentClaims: (excludeDraftIds: string[] = []) => {
const ids = new Set<string>(mockState.foreignDraftedIds);
const excluded = new Set(excludeDraftIds);
const own: [string, FilesDraft][] = [
['new', mockState.filesDraft],
['pending', mockState.pendingFilesDraft],
];
for (const [draftId, draft] of own) {
if (excluded.has(draftId)) {
continue;
}
for (const fileId of draft.fileIds) {
ids.add(fileId);
}
for (const pasteId of draft.pastedTextIds ?? []) {
ids.add(pasteId);
}
for (const pendingId of Object.keys(draft.pendingPastes)) {
ids.add(pendingId);
}
}
for (const id of mockState.foreignLiveAttachmentIds) {
ids.add(id);
}
return ids;
},
removeTabAttachmentPresence: (ids: string[]) => {
const idSet = new Set(ids);
mockState.liveAttachmentIds = mockState.liveAttachmentIds.filter((id) => !idSet.has(id));
},
beginRetainedDeletionPass: () => {
if (mockState.retainedPassInFlight) {
return false;
}
mockState.retainedPassInFlight = true;
return true;
},
endRetainedDeletionPass: () => {
mockState.retainedPassInFlight = false;
},
/** Stands in for the localStorage sweep: the ids every draft is holding, minus the keys the
* caller is discarding. Other tabs' drafts are never excludable, which is the point. */
collectDraftedAttachmentIds: (excludeIds: string[] = []) => {
const ids = new Set<string>(mockState.foreignDraftedIds);
const excluded = new Set(excludeIds);
const own: [string, FilesDraft][] = [
['new', mockState.filesDraft],
['pending', mockState.pendingFilesDraft],
];
for (const [draftId, draft] of own) {
if (excluded.has(draftId)) {
continue;
}
for (const fileId of draft.fileIds) {
ids.add(fileId);
}
for (const pasteId of draft.pastedTextIds ?? []) {
ids.add(pasteId);
}
for (const pendingId of Object.keys(draft.pendingPastes)) {
ids.add(pendingId);
}
}
return ids;
},
}));
jest.mock('~/data-provider', () => ({
useGetFiles: () => ({ data: mockState.fileList }),
useDeleteFilesMutation: () => ({ mutateAsync: mockDeleteFiles }),
useGetFileConfig: () => ({ data: mockState.fileConfig, isSuccess: mockState.fileConfig != null }),
}));
jest.mock('~/store', () => ({
__esModule: true,
default: {
conversationIdByIndex: (index: number) => `conversationIdByIndex-${index}`,
},
}));
jest.mock('librechat-data-provider', () => ({
QueryKeys: { messages: 'messages' },
}));
import useNewChat from '../useNewChat';
const clickEvent = (overrides: Partial<MouseEvent<HTMLElement>> = {}) =>
({
button: 0,
ctrlKey: false,
metaKey: false,
shiftKey: false,
preventDefault: jest.fn(),
...overrides,
}) as unknown as MouseEvent<HTMLElement>;
describe('useNewChat', () => {
beforeEach(() => {
jest.clearAllMocks();
mockDeleteFiles.mockResolvedValue(undefined);
mockState.saveDrafts = false;
mockState.isSubmitting = false;
mockState.tabId = 'this-tab';
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.pendingFilesDraft = { fileIds: [], pendingPastes: {} };
mockState.files = new Map();
mockState.fileList = undefined;
mockState.retainedDeletions = [];
mockState.persistedPendingDiscardIds = [];
mockState.retainedListener = null;
mockState.pendingDiscardListener = null;
mockState.markedPasteIds = [];
mockState.submittedPasteIds = [];
mockState.liveAttachmentIds = [];
mockState.foreignLiveAttachmentIds = [];
mockState.foreignDraftedIds = [];
mockState.retainedPassInFlight = false;
mockState.fileConfig = { deletionRetryLimit: 5 };
mockScheduleRetainedRetry.mockClear();
});
it('clears the outgoing conversation before resetting', () => {
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockClearMessagesCache).toHaveBeenCalledWith(expect.anything(), 'convo-1');
expect(mockInvalidateQueries).toHaveBeenCalledWith(['messages']);
expect(mockNewConversation).toHaveBeenCalledTimes(1);
});
it('drops the unsaved-chat attachments before the reset restores from them', () => {
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
expect(mockClearFilesDraft.mock.invocationCallOrder[0]).toBeLessThan(
mockNewConversation.mock.invocationCallOrder[0],
);
});
/** The reset is also how a user gets back to an unsaved chat they typed in and left, and the
* restore that puts an unwanted paste back is the same one that puts the message back. */
it('keeps what was typed in the unsaved chat', () => {
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockClearAllDrafts).not.toHaveBeenCalledWith('new');
});
it('drops only its own pane unsaved-chat attachments', () => {
const { result } = renderHook(() => useNewChat({ index: 1 }));
act(() => result.current.startNewChat());
expect(mockClearFilesDraft).toHaveBeenCalledWith('new:1');
expect(mockClearFilesDraft).not.toHaveBeenCalledWith('new');
});
it('deletes the draft uploads a draft-saving user is discarding with the draft', () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['stored-file'],
pendingPastes: { 'in-flight-paste': { text: 'x', selectionStart: 0 } },
};
mockState.files = new Map([
['stored-file', { file_id: 'stored-file', progress: 1 }],
['in-flight-paste', { file_id: 'in-flight-paste', progress: 0.4 }],
]);
mockState.fileList = [
{ file_id: 'stored-file', filepath: '/uploads/stored.txt', source: 'local' },
{ file_id: 'in-flight-paste', filepath: '/uploads/pending.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{
file_id: 'stored-file',
embedded: false,
filepath: '/uploads/stored.txt',
source: 'local',
},
{
file_id: 'in-flight-paste',
embedded: false,
filepath: '/uploads/pending.txt',
source: 'local',
},
],
});
expect(mockDeleteFiles.mock.invocationCallOrder[0]).toBeLessThan(
mockClearFilesDraft.mock.invocationCallOrder[0],
);
});
it('leaves deletion to the reset path when draft saving is off', () => {
/** The same draft the draft-saving case above deletes, so only the preference differs. */
mockState.saveDrafts = false;
mockState.filesDraft = {
fileIds: ['stored-file'],
pendingPastes: { 'in-flight-paste': { text: 'x', selectionStart: 0 } },
};
mockState.files = new Map([
['stored-file', { file_id: 'stored-file', progress: 1 }],
['in-flight-paste', { file_id: 'in-flight-paste', progress: 0.4 }],
]);
mockState.fileList = [
{ file_id: 'stored-file', filepath: '/uploads/stored.txt', source: 'local' },
{ file_id: 'in-flight-paste', filepath: '/uploads/pending.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
});
it('discards a live generated paste the draft could not record', () => {
/** Persisting the draft can fail outright (private mode, quota) while the upload and its
* chip still succeed, leaving the draft empty and the upload with nothing to clean it up. */
mockState.saveDrafts = true;
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.markedPasteIds = ['unrecorded-paste'];
mockState.files = new Map([
[
'unrecorded-paste',
{
file_id: 'unrecorded-paste',
progress: 1,
filepath: '/uploads/unrecorded.txt',
source: 'local',
},
],
]);
mockState.fileList = [];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [expect.objectContaining({ file_id: 'unrecorded-paste' })],
});
});
it('spares a paste a message already took, even after the run ends', () => {
/** Submitting empties the file map but leaves the draft's provenance behind, and Stop and
* error paths clear the submitting flag without clearing the draft. */
mockState.saveDrafts = true;
mockState.submittedPasteIds = ['sent-paste'];
mockState.filesDraft = { fileIds: [], pendingPastes: {}, pastedTextIds: ['sent-paste'] };
mockState.files = new Map();
mockState.fileList = [
{ file_id: 'sent-paste', filepath: '/uploads/sent.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
});
it('discards a completed paste marked under its temporary upload id', () => {
/** The registry holds the client id; the finished entry carries the server one and keeps the
* original as temp_file_id. */
mockState.saveDrafts = true;
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.markedPasteIds = ['client-upload-id'];
mockState.files = new Map([
[
'client-upload-id',
{
file_id: 'server-file-id',
temp_file_id: 'client-upload-id',
progress: 1,
filepath: '/uploads/paste.txt',
source: 'local',
},
],
]);
mockState.fileList = [];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [expect.objectContaining({ file_id: 'server-file-id' })],
});
});
it('defers an in-flight paste upload even with draft saving off', () => {
/** It has no filepath yet, so nothing can build a payload for it now; the id has to outlive
* the reset or the record it becomes is orphaned. */
mockState.saveDrafts = false;
mockState.markedPasteIds = ['in-flight-paste'];
mockState.files = new Map([['in-flight-paste', { file_id: 'in-flight-paste', progress: 0.3 }]]);
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockState.persistedPendingDiscardIds).toContain('in-flight-paste');
});
it('spares a marked paste that came back re-attached from the library', () => {
mockState.saveDrafts = true;
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.markedPasteIds = ['sent-paste'];
mockState.files = new Map([
[
'sent-paste',
{
file_id: 'sent-paste',
progress: 1,
attached: true,
filepath: '/uploads/sent.txt',
source: 'local',
},
],
]);
mockState.fileList = [];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
});
it('deletes embedded owned uploads with the discarded draft', () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['known', 'embedded', 'missing'],
pendingPastes: {},
};
mockState.files = new Map([
['known', { file_id: 'known', progress: 1 }],
['embedded', { file_id: 'embedded', progress: 1 }],
]);
mockState.fileList = [
{ file_id: 'known', filepath: '/uploads/known.txt', source: 'local' },
{ file_id: 'embedded', filepath: '/uploads/embedded.txt', source: 'local', embedded: true },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{ file_id: 'known', embedded: false, filepath: '/uploads/known.txt', source: 'local' },
{
file_id: 'embedded',
embedded: true,
filepath: '/uploads/embedded.txt',
source: 'local',
},
],
});
});
it('spares a draft another browser tab still owns', () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['other-tab-file'],
pendingPastes: {},
tabId: 'other-tab',
};
mockState.fileList = [
{ file_id: 'other-tab-file', filepath: '/uploads/other.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(mockClearFilesDraft).not.toHaveBeenCalledWith('new');
expect(mockClearAllDrafts).toHaveBeenCalledWith('pending');
});
it('deletes a draft carrying this tab stamp', () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['own-file'],
pendingPastes: {},
tabId: 'this-tab',
};
mockState.files = new Map([['own-file', { file_id: 'own-file', progress: 1 }]]);
mockState.fileList = [{ file_id: 'own-file', filepath: '/uploads/own.txt', source: 'local' }];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{ file_id: 'own-file', embedded: false, filepath: '/uploads/own.txt', source: 'local' },
],
});
});
it('spares a discarded paste another live tab is holding', () => {
/** The retry effect consults other tabs before deleting; this direct path has to as well, or
* New Chat here deletes the server file out from under the other tab's chip. */
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['shared-file'],
pendingPastes: {},
tabId: 'this-tab',
};
mockState.files = new Map([['shared-file', { file_id: 'shared-file', progress: 1 }]]);
mockState.fileList = [
{ file_id: 'shared-file', filepath: '/uploads/shared.txt', source: 'local' },
];
mockState.foreignLiveAttachmentIds = ['shared-file'];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
});
it('spares a discarded paste another tab has drafted elsewhere', () => {
/** That tab reattached the file to a conversation this pane has never opened, so only its
* persisted draft records it. This tab's own discarded keys are excluded from that lookup,
* or every discard would protect itself and nothing would ever be cleaned up. */
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['shared-file'],
pendingPastes: {},
tabId: 'this-tab',
};
mockState.files = new Map([['shared-file', { file_id: 'shared-file', progress: 1 }]]);
mockState.fileList = [
{ file_id: 'shared-file', filepath: '/uploads/shared.txt', source: 'local' },
];
mockState.foreignDraftedIds = ['shared-file'];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
});
it('spares library files the draft recorded through a re-attach', () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['library-file', 'own-file'],
pendingPastes: {},
};
/** `attached: true` is how a re-attached stored file enters the composer: it has other
* references, so discarding this draft must not delete it. */
mockState.files = new Map([
['library-file', { file_id: 'library-file', attached: true, progress: 1 }],
['own-file', { file_id: 'own-file', progress: 1 }],
]);
mockState.fileList = [
{ file_id: 'library-file', filepath: '/uploads/library.txt', source: 'local' },
{ file_id: 'own-file', filepath: '/uploads/own.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{ file_id: 'own-file', embedded: false, filepath: '/uploads/own.txt', source: 'local' },
],
});
});
it('deletes a draft-owned paste before the composer map is rebuilt after a reload', () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['late-paste'],
pendingPastes: {},
pastedTextIds: ['late-paste'],
};
/** The reload just happened: the files query has not restored any chips into the map yet. */
mockState.fileList = [
{ file_id: 'late-paste', filepath: '/uploads/late.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{ file_id: 'late-paste', embedded: false, filepath: '/uploads/late.txt', source: 'local' },
],
});
});
it('defers a draft-owned paste whose record has not arrived after a reload', async () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['late-paste'],
pendingPastes: {},
pastedTextIds: ['late-paste'],
};
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.fileList = [
{ file_id: 'late-paste', filepath: '/uploads/late.txt', source: 'local' },
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{ file_id: 'late-paste', embedded: false, filepath: '/uploads/late.txt', source: 'local' },
],
});
});
it('drains a deletion another flow retained after a failed request', async () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['stored-file'],
pendingPastes: {},
};
mockState.files = new Map([['stored-file', { file_id: 'stored-file', progress: 1 }]]);
mockState.retainedDeletions = [
{ file_id: 'retained-file', filepath: '/uploads/retained.txt', source: 'local' },
];
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
/** The retained payload rides along the retry effect's next files-cache tick. */
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.files = new Map();
mockState.fileList = [
{ file_id: 'stored-file', filepath: '/uploads/stored.txt', source: 'local' },
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{
file_id: 'stored-file',
embedded: false,
filepath: '/uploads/stored.txt',
source: 'local',
},
{ file_id: 'retained-file', filepath: '/uploads/retained.txt', source: 'local' },
],
});
expect(mockState.retainedDeletions).toHaveLength(0);
});
it('waits for the configured budget before claiming restored cleanup work', async () => {
mockState.fileConfig = undefined;
mockState.fileList = [];
mockState.retainedDeletions = [
{ file_id: 'retained-file', filepath: '/uploads/file.txt', source: 'local' },
];
const { rerender } = renderHook(() => useNewChat());
await act(async () => undefined);
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(mockState.retainedDeletions).toHaveLength(1);
mockState.fileConfig = { deletionRetryLimit: 10 };
await act(async () => rerender());
expect(mockDeleteFiles).toHaveBeenCalledTimes(1);
});
it('asks for a deferred wakeup when another mounted pane owns the cleanup pass', () => {
mockState.retainedPassInFlight = true;
mockState.persistedPendingDiscardIds = ['late-paste'];
mockState.fileList = [
{ file_id: 'late-paste', filepath: '/uploads/late.txt', source: 'local' },
];
renderHook(() => useNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(mockScheduleRetainedRetry).toHaveBeenCalledWith(true);
});
it('keeps retained deletions when the retried request fails again', async () => {
mockDeleteFiles.mockRejectedValueOnce(new Error('offline'));
mockState.retainedDeletions = [
{ file_id: 'retained-file', filepath: '/uploads/retained.txt', source: 'local' },
];
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
mockState.fileList = [];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledTimes(1);
expect(mockState.retainedDeletions).toHaveLength(1);
/** A second failure moves nothing this effect watches, so the payload only gets another
* attempt if one is scheduled. */
expect(mockScheduleRetainedRetry).toHaveBeenCalled();
});
it('retries a deferred deletion whose request failed', async () => {
mockDeleteFiles.mockRejectedValueOnce(new Error('offline'));
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['in-flight'],
pendingPastes: {},
};
mockState.files = new Map([['in-flight', { file_id: 'in-flight', progress: 0.4 }]]);
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.files = new Map();
mockState.fileList = [
{ file_id: 'in-flight', filepath: '/uploads/in-flight.txt', source: 'local' },
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledTimes(1);
/** The failed delete kept the id; the next cache update retries it. */
mockState.fileList = [
{ file_id: 'in-flight', filepath: '/uploads/in-flight.txt', source: 'local' },
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledTimes(2);
});
it('retains an immediate deletion whose request failed for a retry', async () => {
mockDeleteFiles.mockRejectedValueOnce(new Error('offline'));
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['stored-file'],
pendingPastes: {},
};
mockState.files = new Map([['stored-file', { file_id: 'stored-file', progress: 1 }]]);
mockState.fileList = [
{ file_id: 'stored-file', filepath: '/uploads/stored.txt', source: 'local' },
];
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledTimes(1);
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.files = new Map();
mockState.fileList = [
{ file_id: 'stored-file', filepath: '/uploads/stored.txt', source: 'local' },
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledTimes(2);
expect(mockDeleteFiles).toHaveBeenLastCalledWith({
files: [
{
file_id: 'stored-file',
embedded: false,
filepath: '/uploads/stored.txt',
source: 'local',
},
],
});
});
it('spares draft ids the composer no longer shows, whose ownership is unknowable', () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['absent-file'],
pendingPastes: {},
};
mockState.fileList = [
{ file_id: 'absent-file', filepath: '/uploads/absent.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
});
it('deletes an in-flight upload once its record arrives in the files cache', async () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['in-flight'],
pendingPastes: {},
};
mockState.files = new Map([['in-flight', { file_id: 'in-flight', progress: 0.4 }]]);
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
/** What the reset itself does: the draft key is dropped and the composer map cleared. */
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.files = new Map();
mockState.fileList = [
{ file_id: 'in-flight', filepath: '/uploads/in-flight.txt', source: 'local' },
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{
file_id: 'in-flight',
embedded: false,
filepath: '/uploads/in-flight.txt',
source: 'local',
},
],
});
});
it('deletes a deferred upload by its temporary request id once the record arrives', async () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['request-uuid'],
pendingPastes: {},
};
mockState.files = new Map([['request-uuid', { file_id: 'request-uuid', progress: 0.4 }]]);
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
/** The cache keys the record by the server-assigned id and keeps the request uuid as
* its temp id; the discard was tracked under the request uuid. */
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.files = new Map();
mockState.fileList = [
{
file_id: 'server-id',
temp_file_id: 'request-uuid',
filepath: '/uploads/uploaded.txt',
source: 'local',
},
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{
file_id: 'server-id',
embedded: false,
filepath: '/uploads/uploaded.txt',
source: 'local',
},
],
});
});
it('keeps earlier deferred deletions when a second reset defers more', async () => {
mockState.saveDrafts = true;
mockState.filesDraft = { fileIds: ['upload-a'], pendingPastes: {} };
mockState.files = new Map([['upload-a', { file_id: 'upload-a', progress: 0.4 }]]);
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
/** A second new chat before the first upload completed, with a fresh upload of its own.
* The rerender stands in for the re-render the map change causes in a live composer. */
mockState.filesDraft = { fileIds: ['upload-b'], pendingPastes: {} };
mockState.files = new Map([['upload-b', { file_id: 'upload-b', progress: 0.4 }]]);
act(() => rerender());
act(() => result.current.startNewChat());
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.files = new Map();
mockState.fileList = [
{ file_id: 'upload-a', filepath: '/uploads/a.txt', source: 'local' },
{ file_id: 'upload-b', filepath: '/uploads/b.txt', source: 'local' },
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{ file_id: 'upload-a', embedded: false, filepath: '/uploads/a.txt', source: 'local' },
{ file_id: 'upload-b', embedded: false, filepath: '/uploads/b.txt', source: 'local' },
],
});
});
it('clears the pending draft a running response parked this pane under', () => {
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockClearAllDrafts).toHaveBeenCalledWith('pending');
expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
});
it('deletes pending-draft uploads before clearing them', () => {
mockState.saveDrafts = true;
mockState.pendingFilesDraft = {
fileIds: ['queued-file'],
pendingPastes: {},
};
mockState.files = new Map([['queued-file', { file_id: 'queued-file', progress: 1 }]]);
mockState.fileList = [
{ file_id: 'queued-file', filepath: '/uploads/queued.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{
file_id: 'queued-file',
embedded: false,
filepath: '/uploads/queued.txt',
source: 'local',
},
],
});
expect(mockDeleteFiles.mock.invocationCallOrder[0]).toBeLessThan(
mockClearAllDrafts.mock.invocationCallOrder[0],
);
expect(mockClearAllDrafts).toHaveBeenCalledWith('pending');
});
it('spares a pending draft another browser tab still owns', () => {
mockState.saveDrafts = true;
mockState.pendingFilesDraft = {
fileIds: ['other-pending-file'],
pendingPastes: {},
tabId: 'other-tab',
};
mockState.fileList = [
{ file_id: 'other-pending-file', filepath: '/uploads/other-pending.txt', source: 'local' },
];
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(mockClearAllDrafts).not.toHaveBeenCalledWith('pending');
expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
});
it('spares a reattached file from a retained deletion retry', async () => {
mockState.retainedDeletions = [
{ file_id: 'reattached-file', filepath: '/uploads/reattached.txt', source: 'local' },
];
mockState.files = new Map([['reattached-file', { file_id: 'reattached-file', progress: 1 }]]);
mockState.fileList = [
{ file_id: 'reattached-file', filepath: '/uploads/reattached.txt', source: 'local' },
];
const { result, rerender } = renderHook(() => useNewChat());
await act(async () => {
rerender();
});
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(mockState.retainedDeletions).toHaveLength(0);
expect(result.current).toBeDefined();
});
it('spares a submitted file from a retained deletion retry', async () => {
/** The tab that sent the message can be suspended, or have sent it longer ago than presence
* remembers, so neither its draft nor its published chips are here to speak for the file. The
* submitted ledger is durable and shared, and it is the only thing left that can. */
mockState.retainedDeletions = [
{ file_id: 'sent-file', filepath: '/uploads/sent.txt', source: 'local' },
];
mockState.submittedPasteIds = ['sent-file'];
mockState.fileList = [{ file_id: 'sent-file', filepath: '/uploads/sent.txt', source: 'local' }];
const { result, rerender } = renderHook(() => useNewChat());
await act(async () => {
rerender();
});
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(result.current).toBeDefined();
});
it('spares a discard whose server record a submission consumed under another id', async () => {
/** The discard is keyed by the temporary upload id while the pane that sent it marked only the
* server id, so the record has to be resolved before the ledger is consulted. */
mockState.persistedPendingDiscardIds = ['client-temp-id'];
mockState.submittedPasteIds = ['server-file-id'];
mockState.fileList = [
{
file_id: 'server-file-id',
temp_file_id: 'client-temp-id',
filepath: '/uploads/sent.txt',
source: 'local',
},
];
const { result, rerender } = renderHook(() => useNewChat());
await act(async () => {
rerender();
});
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(result.current).toBeDefined();
});
it('keeps retained deletions when the API reports a partial failure', async () => {
mockDeleteFiles.mockResolvedValueOnce({
message: 'Some files could not be deleted',
deletedFileIds: [],
failedFileIds: ['retained-file'],
});
mockState.retainedDeletions = [
{ file_id: 'retained-file', filepath: '/uploads/retained.txt', source: 'local' },
];
mockState.fileList = [
{ file_id: 'retained-file', filepath: '/uploads/retained.txt', source: 'local' },
];
const { rerender } = renderHook(() => useNewChat());
await act(async () => {
rerender();
});
expect(mockDeleteFiles).toHaveBeenCalledTimes(1);
expect(mockState.retainedDeletions).toHaveLength(1);
});
it('retries a retained deletion when the retain store notifies', async () => {
mockState.fileList = [
{ file_id: 'retained-file', filepath: '/uploads/retained.txt', source: 'local' },
];
renderHook(() => useNewChat());
mockState.retainedDeletions = [
{ file_id: 'retained-file', filepath: '/uploads/retained.txt', source: 'local' },
];
await act(async () => {
mockState.retainedListener?.();
});
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [{ file_id: 'retained-file', filepath: '/uploads/retained.txt', source: 'local' }],
});
});
it('resumes deferred discards persisted from a previous mount', async () => {
mockState.persistedPendingDiscardIds = ['late-paste'];
mockState.fileList = [
{ file_id: 'late-paste', filepath: '/uploads/late.txt', source: 'local' },
];
renderHook(() => useNewChat());
await act(async () => undefined);
expect(mockDeleteFiles).toHaveBeenCalledWith({
files: [
{
file_id: 'late-paste',
embedded: false,
filepath: '/uploads/late.txt',
source: 'local',
},
],
});
});
it('spares a deferred upload that came back attached to the fresh composer', async () => {
mockState.saveDrafts = true;
mockState.filesDraft = {
fileIds: ['in-flight'],
pendingPastes: {},
};
mockState.files = new Map([['in-flight', { file_id: 'in-flight', progress: 0.4 }]]);
const { result, rerender } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
/** The user immediately re-attached the same file (dedupe lands on the same id). */
mockState.filesDraft = { fileIds: [], pendingPastes: {} };
mockState.files = new Map([['in-flight', { file_id: 'in-flight', progress: 1 }]]);
mockState.fileList = [
{ file_id: 'in-flight', filepath: '/uploads/in-flight.txt', source: 'local' },
];
await act(async () => {
rerender();
});
expect(mockDeleteFiles).not.toHaveBeenCalled();
});
it('runs the optional callback after the reset', () => {
const onNewChat = jest.fn();
const { result } = renderHook(() => useNewChat({ onNewChat }));
act(() => result.current.startNewChat());
expect(onNewChat).toHaveBeenCalledTimes(1);
expect(mockNewConversation.mock.invocationCallOrder[0]).toBeLessThan(
onNewChat.mock.invocationCallOrder[0],
);
});
it('works without a callback', () => {
const { result } = renderHook(() => useNewChat());
expect(() => act(() => result.current.startNewChat())).not.toThrow();
expect(mockNewConversation).toHaveBeenCalledTimes(1);
});
it('takes over a plain left click', () => {
const { result } = renderHook(() => useNewChat());
const event = clickEvent();
act(() => result.current.handleNewChatClick(event));
expect(event.preventDefault).toHaveBeenCalledTimes(1);
expect(mockNewConversation).toHaveBeenCalledTimes(1);
});
it.each([
['ctrl', { ctrlKey: true }],
['meta', { metaKey: true }],
['shift', { shiftKey: true }],
['middle', { button: 1 }],
])('lets a %s click fall through to the browser', (_label, overrides) => {
const { result } = renderHook(() => useNewChat());
const event = clickEvent(overrides);
act(() => result.current.handleNewChatClick(event));
expect(event.preventDefault).not.toHaveBeenCalled();
expect(mockNewConversation).not.toHaveBeenCalled();
});
});