~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
import './helpers/safe-fetch-with-auth-to-fetch.js';
/**
* Browser contract for the unchanged research-page PDF consumer after the
* FastAPI migration. The collection uploader is a separate component; this
* handler owns /api/config/limits and /api/upload/pdf.
*/
function jsonResponse(body, status = 200) {
return new Response(JSON.stringify(body), { status });
}
function deferred() {
let resolvePromise;
const promise = new Promise(resolve => {
resolvePromise = resolve;
});
return { promise, resolve: resolvePromise };
}
let bodyListeners = [];
async function loadHandler(fetchMock, { waitForLimits = true } = {}) {
vi.resetModules();
bodyListeners = [];
const addBodyListener = document.body.addEventListener.bind(document.body);
vi.spyOn(document.body, 'addEventListener').mockImplementation(
(type, listener, options) => {
bodyListeners.push([type, listener, options]);
addBodyListener(type, listener, options);
},
);
document.body.innerHTML = `
<div>
<textarea id="query"></textarea>
<div class="ldr-search-hints"><div class="ldr-hint-row"></div></div>
</div>
`;
delete window.pdfUploadHandler;
vi.stubGlobal('URLS', {
API: {
CONFIG_LIMITS: '/api/config/limits',
UPLOAD_PDF: '/api/upload/pdf',
},
});
vi.stubGlobal('URLValidator', {
isSafeUrl: vi.fn(() => true),
});
vi.stubGlobal('fetch', fetchMock);
window.api = { getCsrfToken: vi.fn(() => 'csrf-pdf') };
window.formatBytes = bytes => `${bytes} bytes`;
await import('@js/pdf_upload_handler.js');
await vi.waitFor(() => expect(window.pdfUploadHandler).toBeTruthy());
if (waitForLimits) {
await vi.waitFor(() => {
expect(window.pdfUploadHandler.limitsLoaded).toBe(true);
});
}
return window.pdfUploadHandler;
}
afterEach(() => {
if (vi.isFakeTimers()) {
vi.clearAllTimers();
vi.useRealTimers();
}
for (const [type, listener, options] of bodyListeners) {
document.body.removeEventListener(type, listener, options);
}
bodyListeners = [];
vi.restoreAllMocks();
vi.unstubAllGlobals();
delete window.pdfUploadHandler;
delete window.api;
delete window.formatBytes;
delete window.__pdfUploadXss;
document.body.replaceChildren();
});
it('hydrates validation limits from the migrated config response', async () => {
const fetchMock = vi.fn((url) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({
max_file_size: 12_345_678,
max_files: 17,
allowed_mime_types: ['application/pdf'],
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
expect(fetchMock).toHaveBeenCalledOnce();
expect(fetchMock).toHaveBeenCalledWith('/api/config/limits');
expect(handler.maxFileSize).toBe(12_345_678);
expect(handler.maxFiles).toBe(17);
});
it('uploads multipart PDFs with CSRF and consumes the extraction envelope', async () => {
const fetchMock = vi.fn((url, options = {}) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({
max_file_size: 50 * 1024 * 1024,
max_files: 200,
}));
}
if (url === '/api/upload/pdf' && options.method === 'POST') {
return Promise.resolve(jsonResponse({
status: 'success',
processed_files: 1,
total_files: 1,
extracted_texts: [{
filename: 'migration.pdf',
text: 'FastAPI contract text',
size: 4,
pages: 2,
}],
combined_text: '--- From migration.pdf ---\nFastAPI contract text',
errors: [],
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
fetchMock.mockClear();
vi.spyOn(handler, 'showProcessing').mockImplementation(() => {});
vi.spyOn(handler, 'hideProcessing').mockImplementation(() => {});
const success = vi.spyOn(handler, 'showSuccess')
.mockImplementation(() => {});
const pdf = new File(['%PDF'], 'migration.pdf', {
type: 'application/pdf',
});
await handler.uploadAndExtractPDFs([pdf]);
expect(fetchMock).toHaveBeenCalledOnce();
const [url, options] = fetchMock.mock.calls[0];
expect(url).toBe('/api/upload/pdf');
expect(options.method).toBe('POST');
expect(options.headers).toEqual({ 'X-CSRFToken': 'csrf-pdf' });
expect(options.body).toBeInstanceOf(FormData);
expect(options.body.getAll('files')).toHaveLength(1);
expect(options.body.get('files').name).toBe('migration.pdf');
expect(document.getElementById('query').value).toContain(
'FastAPI contract text',
);
expect(handler.getUploadedPDFs()).toEqual([{
filename: 'migration.pdf',
size: 4,
text: 'FastAPI contract text',
pages: 2,
truncated: false,
}]);
expect(success).toHaveBeenCalledWith(1, []);
});
it('accepts a dropped PDF while the migrated limits request is still pending', async () => {
const limits = deferred();
const fetchMock = vi.fn((url, options = {}) => {
if (url === '/api/config/limits') return limits.promise;
if (url === '/api/upload/pdf' && options.method === 'POST') {
return Promise.resolve(jsonResponse({
status: 'success',
processed_files: 1,
extracted_texts: [{
filename: 'early-drop.pdf',
text: 'Dropped before limits hydration',
pages: 1,
}],
combined_text: 'Dropped before limits hydration',
errors: [],
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock, { waitForLimits: false });
const pdf = new File(['%PDF'], 'early-drop.pdf', {
type: 'application/pdf',
});
const drop = new Event('drop', { bubbles: true, cancelable: true });
Object.defineProperty(drop, 'dataTransfer', {
value: { files: [pdf] },
});
document.getElementById('query').dispatchEvent(drop);
await vi.waitFor(() => {
expect(handler.getUploadedPDFs()).toEqual([{
filename: 'early-drop.pdf',
size: 4,
text: 'Dropped before limits hydration',
pages: 1,
truncated: false,
}]);
});
expect(drop.defaultPrevented).toBe(true);
expect(document.getElementById('query').value)
.toContain('Dropped before limits hydration');
expect(fetchMock).toHaveBeenCalledWith(
'/api/upload/pdf',
expect.objectContaining({ method: 'POST' }),
);
limits.resolve(jsonResponse({
max_file_size: 12_345,
max_files: 7,
}));
await vi.waitFor(() => expect(handler.limitsLoaded).toBe(true));
expect(handler.maxFiles).toBe(7);
});
it('rejects invalid count and size selections before starting an upload', async () => {
const fetchMock = vi.fn((url) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({
max_file_size: 4,
max_files: 1,
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
vi.useFakeTimers();
fetchMock.mockClear();
const upload = vi.spyOn(handler, 'uploadAndExtractPDFs');
await handler.handleFiles([
new File(['plain'], 'notes.txt', { type: 'text/plain' }),
]);
expect(document.getElementById('pdf-upload-status').textContent)
.toContain('Please select PDF files only');
await handler.handleFiles([
new File(['a'], 'one.pdf', { type: 'application/pdf' }),
new File(['b'], 'two.pdf', { type: 'application/pdf' }),
]);
expect(document.getElementById('pdf-upload-status').textContent)
.toContain('Maximum 1 PDF files allowed at once');
await handler.handleFiles([
new File(['12345'], 'large.pdf', { type: 'application/pdf' }),
]);
const status = document.getElementById('pdf-upload-status');
expect(status.textContent).toContain('smaller than 4 bytes');
expect(status.style.display).toBe('block');
expect(upload).not.toHaveBeenCalled();
expect(fetchMock).not.toHaveBeenCalled();
expect(handler.statusTimers).toHaveLength(1);
await vi.advanceTimersByTimeAsync(5000);
expect(status.style.display).toBe('none');
});
it('keeps terminal upload feedback visible and escapes an API error message', async () => {
const hostileMessage = '<img src=x onerror="window.__pdfUploadXss=true">';
const fetchMock = vi.fn((url, options = {}) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({
max_file_size: 100,
max_files: 2,
}));
}
if (url === '/api/upload/pdf' && options.method === 'POST') {
return Promise.resolve(jsonResponse({
status: 'error',
message: hostileMessage,
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
vi.useFakeTimers();
delete window.__pdfUploadXss;
await handler.uploadAndExtractPDFs([
new File(['%PDF'], 'rejected.pdf', { type: 'application/pdf' }),
]);
const status = document.getElementById('pdf-upload-status');
expect(status.style.display).toBe('block');
expect(status.textContent).toContain(hostileMessage);
expect(status.querySelector('img')).toBeNull();
expect(window.__pdfUploadXss).toBeUndefined();
expect(status.querySelector('.fa-spinner')).toBeNull();
expect(status.querySelector('.fa-exclamation-triangle')).not.toBeNull();
await vi.advanceTimersByTimeAsync(4999);
expect(status.style.display).toBe('block');
await vi.advanceTimersByTimeAsync(1);
expect(status.style.display).toBe('none');
});
it('keeps successful upload feedback visible while updating existing query text', async () => {
const fetchMock = vi.fn((url, options = {}) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({
max_file_size: 100,
max_files: 2,
}));
}
if (url === '/api/upload/pdf' && options.method === 'POST') {
return Promise.resolve(jsonResponse({
status: 'success',
processed_files: 2,
extracted_texts: [
{ text: 'First paper', pages: 2 },
{ text: 'Second paper', pages: 3 },
],
combined_text: 'First paper\nSecond paper',
errors: ['one metadata warning'],
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
vi.useFakeTimers();
const query = document.getElementById('query');
query.value = 'Compare these sources';
const inputListener = vi.fn();
query.addEventListener('input', inputListener);
await handler.uploadAndExtractPDFs([
new File(['a'], 'one.pdf', { type: 'application/pdf' }),
new File(['b'], 'two.pdf', { type: 'application/pdf' }),
]);
const status = document.getElementById('pdf-upload-status');
expect(status.style.display).toBe('block');
expect(status.textContent).toContain('Successfully processed 2 PDFs');
expect(status.textContent).toContain('one metadata warning');
expect(query.value).toBe(
'Compare these sources\n\n--- PDF Content ---\n' +
'First paper\nSecond paper',
);
expect(query.placeholder).toContain('2 PDFs loaded, 5 pages total');
expect(inputListener).toHaveBeenCalledOnce();
expect(query.selectionStart).toBe(query.value.length);
expect(handler.getUploadedPDFs()).toHaveLength(2);
handler.clearUploadedPDFs();
expect(handler.getUploadedPDFs()).toEqual([]);
expect(query.placeholder).toContain('drop a PDF paper here');
});
it('keeps partial-extraction warnings visible and associates them with the successful file', async () => {
const filename = '<img src=x onerror="window.__pdfUploadXss=true">.pdf';
const combinedText = '--- From partial.pdf ---\n' +
'[Partial PDF extraction: only part of this document\'s text is included.]\n' +
'First 500 pages';
const fetchMock = vi.fn((url, options = {}) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({ max_file_size: 100, max_files: 2 }));
}
if (url === '/api/upload/pdf' && options.method === 'POST') {
return Promise.resolve(jsonResponse({
status: 'success',
processed_files: 1,
extracted_texts: [{ filename, size: 8, text: 'First 500 pages', pages: 501, truncated: true }],
combined_text: combinedText,
errors: ['broken.pdf: No extractable text found'],
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
vi.useFakeTimers();
await handler.uploadAndExtractPDFs([
new File(['bad'], 'broken.pdf', { type: 'application/pdf' }),
new File(['%PDFdata'], filename, { type: 'application/pdf' }),
]);
expect(handler.getUploadedPDFs()).toEqual([{
filename, size: 8, text: 'First 500 pages', pages: 501, truncated: true,
}]);
const query = document.getElementById('query');
expect(query.placeholder).toContain('1 PDF loaded, at least 501 pages, partial text');
expect(query.value).toBe(combinedText);
const status = document.getElementById('pdf-upload-status');
expect(status.textContent).toContain(`Only part of these PDFs was extracted: ${filename}`);
expect(status.textContent).toContain('Some content is missing');
expect(status.textContent).toContain('broken.pdf: No extractable text found');
expect(status.querySelector('.fa-exclamation-triangle')).not.toBeNull();
expect(status.querySelector('img')).toBeNull();
expect(window.__pdfUploadXss).toBeUndefined();
await vi.advanceTimersByTimeAsync(10_000);
expect(status.style.display).toBe('block');
handler.clearUploadedPDFs();
expect(status.style.display).toBe('none');
expect(query.placeholder).toContain('drop a PDF paper here');
});
it('retains partial-file warnings and lower-bound totals after another complete upload', async () => {
let uploads = 0;
const fetchMock = vi.fn((url, options = {}) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({ max_file_size: 100, max_files: 2 }));
}
if (url === '/api/upload/pdf' && options.method === 'POST') {
const partial = uploads++ === 0;
return Promise.resolve(jsonResponse({
status: 'success',
processed_files: 1,
extracted_texts: [{
filename: partial ? 'partial.pdf' : 'complete.pdf',
text: partial ? 'Partial paper' : 'Complete paper',
pages: partial ? 501 : 3,
truncated: partial,
}],
combined_text: partial ? 'Partial paper' : 'Complete paper',
errors: [],
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
vi.useFakeTimers();
for (const filename of ['partial.pdf', 'complete.pdf']) {
await handler.uploadAndExtractPDFs([
new File(['%PDF'], filename, { type: 'application/pdf' }),
]);
}
expect(handler.getUploadedPDFs().map(pdf => pdf.truncated)).toEqual([true, false]);
expect(document.getElementById('query').placeholder)
.toContain('2 PDFs loaded, at least 504 pages, partial text');
const status = document.getElementById('pdf-upload-status');
expect(status.textContent).toContain('Only part of these PDFs was extracted: partial.pdf.');
expect(status.textContent).not.toContain('Successfully processed');
await vi.advanceTimersByTimeAsync(10_000);
expect(status.style.display).toBe('block');
});
describe('partial PDF warning after transient feedback', () => {
const partialNotice = '[Partial PDF extraction: only part of this document\'s text is included.]';
const apiFilename = '<img src=x onerror="window.__pdfUploadXss=true">.pdf';
function uploadResponse(filename = apiFilename, truncated = true) {
const text = truncated ? `${partialNotice}\nPartial paper` : 'Complete paper';
return jsonResponse({
status: 'success',
processed_files: 1,
extracted_texts: [{ filename, text, pages: truncated ? 501 : 3, truncated }],
combined_text: text,
errors: [],
});
}
function pdf(filename = 'selected.pdf') {
return new File(['%PDF'], filename, { type: 'application/pdf' });
}
function invalidSelection(handler) {
return handler.handleFiles([
new File(['plain'], 'notes.txt', { type: 'text/plain' }),
]);
}
async function loadPartialUpload() {
const fetchMock = vi.fn((url, options = {}) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({ max_file_size: 100, max_files: 2 }));
}
if (url === '/api/upload/pdf' && options.method === 'POST') {
return Promise.resolve(uploadResponse());
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
vi.useFakeTimers();
await handler.handleFiles([pdf()]);
return { handler, fetchMock, status: document.getElementById('pdf-upload-status') };
}
it.each(['invalid selection', 'API error', 'network error', 'file too large'])(
'restores the retained partial warning five seconds after %s',
async (feedback) => {
const { handler, fetchMock, status } = await loadPartialUpload();
const query = document.getElementById('query');
const originalQuery = query.value;
const originalPlaceholder = query.placeholder;
const uploaded = handler.getUploadedPDFs();
expect(uploaded[0].truncated).toBe(true);
expect(originalQuery).toContain(partialNotice);
let message;
if (feedback === 'invalid selection') {
await invalidSelection(handler);
message = 'Please select PDF files only';
} else if (feedback === 'file too large') {
const big = new File([new Uint8Array(101)], 'big.pdf', { type: 'application/pdf' });
await handler.handleFiles([big]);
message = 'PDF files must be smaller than 100 bytes';
} else {
if (feedback === 'API error') {
fetchMock.mockResolvedValueOnce(jsonResponse({ status: 'error', message: 'Extraction failed' }));
message = 'Extraction failed';
} else {
fetchMock.mockRejectedValueOnce(new Error('Connection lost'));
message = 'Failed to upload PDFs. Please try again.';
}
await handler.handleFiles([pdf('failed.pdf')]);
}
expect(status.textContent).toContain(message);
await vi.advanceTimersByTimeAsync(4999);
expect(status.style.display).toBe('block');
expect(status.textContent).toContain(message);
await vi.advanceTimersByTimeAsync(1);
expect(handler.getUploadedPDFs()).toEqual(uploaded);
expect(query.value).toBe(originalQuery);
expect(query.placeholder).toBe(originalPlaceholder);
expect(status.style.display).toBe('block');
expect(status.textContent).toContain(`Only part of these PDFs was extracted: ${apiFilename}.`);
expect(status.textContent).toContain('Some content is missing');
expect(status.textContent).not.toContain(message);
expect(status.querySelector('.fa-exclamation-triangle')).not.toBeNull();
expect(status.querySelector('img')).toBeNull();
expect(window.__pdfUploadXss).toBeUndefined();
await vi.advanceTimersByTimeAsync(10_000);
expect(status.style.display).toBe('block');
},
);
it('does not restore a warning after clearing during an error timeout', async () => {
const { handler, status } = await loadPartialUpload();
await invalidSelection(handler);
await vi.advanceTimersByTimeAsync(1000);
handler.clearUploadedPDFs();
await vi.advanceTimersByTimeAsync(10_000);
expect(handler.getUploadedPDFs()).toEqual([]);
expect(status.style.display).toBe('none');
expect(document.getElementById('query').placeholder).toContain('drop a PDF paper here');
});
it('restores the session summary without re-showing the batch errors sub-line', async () => {
// A partial upload whose batch ALSO carried file errors: its
// showSuccess renders the "Some files had issues" sub-line, and a
// partial status has no hide timer, so the sub-line stays up. An
// unrelated transient error then replaces it. showError never
// renders that sub-line and a batch's errors are not stored (they
// are only passed to showSuccess), so the restore rebuilds the
// session summary from the retained uploads alone, without the
// sub-line. The restored partial warning has no hide timer either,
// so no status timer is left behind.
const fetchMock = vi.fn((url, options = {}) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({ max_file_size: 100, max_files: 2 }));
}
if (url === '/api/upload/pdf' && options.method === 'POST') {
return Promise.resolve(jsonResponse({
status: 'success',
processed_files: 1,
extracted_texts: [{
filename: 'partial.pdf',
text: `${partialNotice}\nPartial paper`,
pages: 501,
truncated: true,
}],
combined_text: `${partialNotice}\nPartial paper`,
errors: ['other.pdf was corrupt'],
}));
}
throw new Error(`Unexpected request: ${url}`);
});
const handler = await loadHandler(fetchMock);
vi.useFakeTimers();
await handler.handleFiles([pdf('partial.pdf')]);
const status = document.getElementById('pdf-upload-status');
// The direct path shows the batch's errors sub-line.
expect(status.textContent).toContain('Some files had issues: other.pdf was corrupt');
await invalidSelection(handler);
await vi.advanceTimersByTimeAsync(5000);
expect(status.textContent).toContain('Processed 1 PDF');
expect(status.textContent).toContain('Only part of these PDFs was extracted: partial.pdf.');
expect(status.textContent).not.toContain('Some files had issues');
expect(handler.statusTimers).toHaveLength(0);
});
it('keeps complete reupload feedback for its own timeout after clearing a partial PDF', async () => {
const { handler, fetchMock, status } = await loadPartialUpload();
await invalidSelection(handler);
await vi.advanceTimersByTimeAsync(4000);
handler.clearUploadedPDFs();
fetchMock.mockResolvedValueOnce(uploadResponse('complete.pdf', false));
await handler.handleFiles([pdf('complete.pdf')]);
await vi.advanceTimersByTimeAsync(1000);
expect(status.style.display).toBe('block');
expect(status.textContent).toContain('Successfully processed 1 PDF');
expect(status.textContent).not.toContain('Only part');
expect(handler.getUploadedPDFs().map(file => file.truncated)).toEqual([false]);
await vi.advanceTimersByTimeAsync(4000);
expect(status.style.display).toBe('none');
});
it('restores current partial filenames and totals from mixed uploads', async () => {
const { handler, fetchMock, status } = await loadPartialUpload();
fetchMock.mockResolvedValueOnce(uploadResponse('second-partial.pdf'));
await handler.handleFiles([pdf('second-partial.pdf')]);
fetchMock.mockResolvedValueOnce(uploadResponse('complete.pdf', false));
await handler.handleFiles([pdf('complete.pdf')]);
await invalidSelection(handler);
await vi.advanceTimersByTimeAsync(5000);
expect(handler.getUploadedPDFs().map(file => file.truncated)).toEqual([true, true, false]);
expect(status.style.display).toBe('block');
expect(status.textContent).toContain('Processed 3 PDFs');
expect(status.querySelector('p').textContent).toBe(
`Only part of these PDFs was extracted: ${apiFilename}; second-partial.pdf. Some content is missing.`,
);
expect(document.getElementById('query').placeholder)
.toContain('3 PDFs loaded, at least 1005 pages, partial text');
});
it('gives a replacement error its full timeout before restoring the partial warning', async () => {
const { handler, status } = await loadPartialUpload();
await invalidSelection(handler);
await vi.advanceTimersByTimeAsync(4000);
await handler.handleFiles([pdf('one.pdf'), pdf('two.pdf'), pdf('three.pdf')]);
await vi.advanceTimersByTimeAsync(4999);
expect(status.style.display).toBe('block');
expect(status.textContent).toContain('Maximum 2 PDF files allowed at once');
await vi.advanceTimersByTimeAsync(1);
expect(status.style.display).toBe('block');
expect(status.textContent).toContain(`Only part of these PDFs was extracted: ${apiFilename}.`);
});
it.each([500, 1500])('preserves a newer upload and its success when the response takes %i ms', async (delay) => {
const { handler, fetchMock, status } = await loadPartialUpload();
await invalidSelection(handler);
await vi.advanceTimersByTimeAsync(4000);
const response = deferred();
fetchMock.mockReturnValueOnce(response.promise);
const upload = handler.handleFiles([pdf('latest.pdf')]);
await vi.advanceTimersByTimeAsync(delay);
expect(status.style.display).toBe('block');
expect(status.textContent).toContain('Processing 1 PDF...');
expect(status.querySelector('.fa-spinner')).not.toBeNull();
response.resolve(uploadResponse('latest.pdf'));
await upload;
await vi.advanceTimersByTimeAsync(10_000);
expect(status.style.display).toBe('block');
expect(status.textContent).toContain(`${apiFilename}; latest.pdf`);
expect(status.querySelector('.fa-spinner')).toBeNull();
});
});
describe('shared truncated-upload predicate', () => {
// hasPersistentTruncated() is the one place that asks whether any
// upload was only partially extracted. Each consumer must ask it
// instead of re-reading uploadedPDFs, so the consumer tests below make
// the predicate DISAGREE with the stored uploads: a consumer that
// re-derives the answer inline keeps following the uploads and fails.
async function loadWithUploads(truncatedFlags) {
const handler = await loadHandler(vi.fn((url) => {
if (url === '/api/config/limits') {
return Promise.resolve(jsonResponse({ max_file_size: 100, max_files: 2 }));
}
throw new Error(`Unexpected request: ${url}`);
}));
handler.addPDFsToUploaded([], truncatedFlags.map((truncated, index) => ({
filename: `upload-${index}.pdf`,
text: 'text',
pages: 3,
truncated,
})));
return handler;
}
it.each([
['no uploads', [], false],
['only complete uploads', [false, false], false],
['a single partial upload', [true], true],
['a partial upload between complete ones', [false, true, false], true],
])('is true exactly when some upload is partial: %s', async (_case, flags, expected) => {
const handler = await loadWithUploads(flags);
expect(handler.hasPersistentTruncated()).toBe(expected);
});
it('drives the placeholder page summary', async () => {
const handler = await loadWithUploads([true, false]);
vi.spyOn(handler, 'hasPersistentTruncated').mockReturnValue(false);
handler.updatePlaceholder();
expect(document.getElementById('query').placeholder)
.toContain('2 PDFs loaded, 6 pages total');
});
it('drives showSuccess wording and its hide timer', async () => {
const handler = await loadWithUploads([true, false]);
vi.useFakeTimers();
vi.spyOn(handler, 'hasPersistentTruncated').mockReturnValue(false);
handler.showSuccess(2, []);
const status = document.getElementById('pdf-upload-status');
expect(status.textContent).toContain('Successfully processed 2 PDFs');
expect(status.textContent).not.toContain('Only part of these PDFs');
expect(handler.statusTimers).toHaveLength(1);
await vi.advanceTimersByTimeAsync(5000);
expect(status.style.display).toBe('none');
});
it('drives the restore decision after an error', async () => {
const handler = await loadWithUploads([true, false]);
vi.useFakeTimers();
vi.spyOn(handler, 'hasPersistentTruncated').mockReturnValue(false);
handler.showError('A transient error');
const status = document.getElementById('pdf-upload-status');
await vi.advanceTimersByTimeAsync(5000);
expect(status.style.display).toBe('none');
});
});