Skip to content

~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.

30.0 KB
Raw Blame
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');
    });
});