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.

14.2 KB
Raw Blame
/** Direct browser-runtime coverage for collection_upload.js. */

import { readFileSync } from 'node:fs';
import { resolve as resolvePath } from 'node:path';

const SUPPORTED_FORMATS_URL = '/library/api/config/supported-formats';
const UPLOAD_URL = '/library/api/collections/collection-direct-3299/upload';
const UPLOAD_TEMPLATE = readFileSync(resolvePath(
    __dirname,
    '../../src/local_deep_research/web/templates/pages/collection_upload.html',
), 'utf8');

let documentListeners = [];

function renderUploadPage() {
    document.body.innerHTML = `
        <form id="upload-files-form">
            <div id="drop-zone"><button type="button">Choose</button></div>
            <input id="files-input" type="file" multiple>
            <div id="selected-files" style="display:none"><ul id="file-list"></ul></div>
            <input type="radio" name="pdf_storage" value="none">
            <input type="radio" name="pdf_storage" value="database" checked>
            <button type="submit"><i></i>Upload</button>
        </form>
        <span id="format-details"></span>
        <div id="full-format-list"></div>
        <div id="upload-progress" style="display:none"></div>
        <div id="upload-results" style="display:none"></div>
    `;
    setInputFiles([]);
}

function renderCheckedInUploadPage() {
    // eslint-disable-next-line no-unsanitized/property -- checked-in repository template used as the browser fixture.
    document.body.innerHTML = UPLOAD_TEMPLATE;
    setInputFiles([]);
}

function setInputFiles(files) {
    Object.defineProperty(document.getElementById('files-input'), 'files', {
        configurable: true,
        value: files,
    });
}

function formatsResponse() {
    return {
        ok: true,
        json: vi.fn().mockResolvedValue({
            extensions: ['.pdf', '.md', '.txt'],
            accept_string: '.pdf,.md,.txt',
            count: 3,
        }),
    };
}

function installFakeXmlHttpRequest() {
    const requests = [];

    class FakeXMLHttpRequest {
        constructor() {
            this.headers = {};
            this.openCalls = [];
            this.upload = {};
            requests.push(this);
        }

        open(...args) {
            this.openCalls.push(args);
        }

        setRequestHeader(name, value) {
            this.headers[name] = value;
        }

        send(body) {
            this.body = body;
        }

        respond(status, body) {
            this.status = status;
            this.responseText = typeof body === 'string'
                ? body
                : JSON.stringify(body);
            this.onload();
        }

        failNetwork() {
            this.onerror();
        }
    }

    vi.stubGlobal('XMLHttpRequest', FakeXMLHttpRequest);
    return requests;
}

async function loadUploadPage(safeFetch = vi.fn().mockResolvedValue(formatsResponse())) {
    vi.stubGlobal('safeFetch', safeFetch);
    vi.stubGlobal('COLLECTION_ID', 'collection-direct-3299');
    vi.stubGlobal('URLS', {
        LIBRARY_API: {
            SUPPORTED_FORMATS: SUPPORTED_FORMATS_URL,
            COLLECTION_UPLOAD: '/library/api/collections/{id}/upload',
        },
    });
    vi.stubGlobal('URLBuilder', {
        build: (template, id) => template.replace('{id}', id),
    });
    window.api = { getCsrfToken: vi.fn(() => 'csrf-direct-upload') };

    await import('@js/security/xss-protection.js');
    await import('@js/collection_upload.js');
    document.dispatchEvent(new Event('DOMContentLoaded'));
    await vi.waitFor(() => expect(safeFetch).toHaveBeenCalledWith(
        SUPPORTED_FORMATS_URL,
    ));
    return safeFetch;
}

beforeEach(() => {
    vi.resetModules();
    documentListeners = [];
    const addDocumentListener = document.addEventListener.bind(document);
    vi.spyOn(document, 'addEventListener').mockImplementation(
        (type, listener, options) => {
            documentListeners.push([type, listener, options]);
            addDocumentListener(type, listener, options);
        },
    );
    renderUploadPage();
});

afterEach(() => {
    for (const [type, listener, options] of documentListeners) {
        document.removeEventListener(type, listener, options);
    }
    documentListeners = [];
    vi.clearAllTimers();
    vi.useRealTimers();
    vi.restoreAllMocks();
    vi.unstubAllGlobals();
    delete window.api;
    delete window.escapeHtml;
    delete window.escapeHtmlAttribute;
    delete window.__dropXss;
    document.body.replaceChildren();
});

it('hydrates formats and renders an inert selected-file preview', async () => {
    await loadUploadPage();

    expect(document.getElementById('files-input').accept)
        .toBe('.pdf,.md,.txt');
    expect(document.getElementById('format-details').textContent)
        .toBe('(3 formats supported)');
    expect(document.getElementById('full-format-list').textContent)
        .toBe('All supported: PDF, MD, TXT');

    const hostileFile = new File(
        ['payload'],
        '<img src=x onerror="window.__uploadXss=true">.txt',
    );
    setInputFiles([hostileFile]);
    document.getElementById('files-input').dispatchEvent(new Event('change'));

    const preview = document.getElementById('selected-files');
    expect(preview.style.display).toBe('block');
    expect(preview.textContent).toContain(hostileFile.name);
    expect(preview.querySelector('img')).toBeNull();
    expect(window.__uploadXss).toBeUndefined();

    setInputFiles([]);
    document.getElementById('files-input').dispatchEvent(new Event('change'));
    expect(preview.style.display).toBe('none');
});

it('owns Browse once and uploads files dropped on the checked-in surface', async () => {
    vi.useFakeTimers();
    renderCheckedInUploadPage();
    const requests = installFakeXmlHttpRequest();
    await loadUploadPage();

    const dropZone = document.getElementById('drop-zone');
    const browseButton = dropZone.querySelector('button[type="button"]');
    const fileInput = document.getElementById('files-input');
    const inputClick = vi.spyOn(fileInput, 'click').mockImplementation(() => {});

    expect(browseButton.hasAttribute('onclick')).toBe(false);
    browseButton.querySelector('i').dispatchEvent(new MouseEvent('click', {
        bubbles: true,
    }));
    expect(inputClick).toHaveBeenCalledOnce();
    browseButton.dispatchEvent(new MouseEvent('click', { bubbles: true }));
    expect(inputClick).toHaveBeenCalledTimes(2);

    const dragOver = new Event('dragover', {
        bubbles: true,
        cancelable: true,
    });
    dropZone.dispatchEvent(dragOver);
    expect(dragOver.defaultPrevented).toBe(true);
    expect(dropZone.classList).toContain('ldr-drag-over');

    const droppedFile = new File(
        ['dropped evidence'],
        '<img src=x onerror="window.__dropXss=true">.txt',
        { type: 'text/plain' },
    );
    const drop = new Event('drop', { bubbles: true, cancelable: true });
    Object.defineProperty(drop, 'dataTransfer', {
        value: { files: [droppedFile], types: ['Files'] },
    });
    dropZone.dispatchEvent(drop);

    expect(drop.defaultPrevented).toBe(true);
    expect(dropZone.classList).not.toContain('ldr-drag-over');
    const preview = document.getElementById('selected-files');
    expect(preview.style.display).toBe('block');
    expect(preview.textContent).toContain(droppedFile.name);
    expect(preview.querySelector('img')).toBeNull();
    expect(window.__dropXss).toBeUndefined();

    document.querySelector('input[name="pdf_storage"][value="database"]')
        .checked = true;
    document.getElementById('upload-files-form').dispatchEvent(new Event(
        'submit',
        { bubbles: true, cancelable: true },
    ));
    await vi.waitFor(() => expect(requests).toHaveLength(1));
    expect(requests[0].openCalls).toEqual([['POST', UPLOAD_URL]]);
    expect(requests[0].headers).toEqual({
        'X-CSRFToken': 'csrf-direct-upload',
    });
    expect(requests[0].body.getAll('files')).toEqual([droppedFile]);
    expect(requests[0].body.get('pdf_storage')).toBe('database');

    requests[0].failNetwork();
    await vi.waitFor(() => {
        expect(document.querySelector('button[type="submit"]').disabled)
            .toBe(false);
    });
});

it('degrades the format help when supported-format hydration fails', async () => {
    const safeFetch = vi.fn().mockResolvedValue({ ok: false, status: 503 });
    await loadUploadPage(safeFetch);

    await vi.waitFor(() => {
        expect(document.getElementById('full-format-list').textContent)
            .toBe('Could not load format list');
    });
    expect(document.getElementById('format-details').textContent).toBe('');
    expect(document.getElementById('files-input').accept).toBe('');
});

it('executes a single XHR upload, progress update, and delayed completion', async () => {
    vi.useFakeTimers();
    const requests = installFakeXmlHttpRequest();
    await loadUploadPage();
    const file = new File(['direct upload'], 'direct.txt');
    setInputFiles([file]);
    document.getElementById('files-input').dispatchEvent(new Event('change'));

    document.getElementById('upload-files-form').dispatchEvent(new Event(
        'submit',
        { bubbles: true, cancelable: true },
    ));
    await vi.waitFor(() => expect(requests).toHaveLength(1));
    const [request] = requests;
    expect(request.openCalls).toEqual([['POST', UPLOAD_URL]]);
    expect(request.headers).toEqual({ 'X-CSRFToken': 'csrf-direct-upload' });
    expect(request.timeout).toBe(600000);
    expect(request.body.getAll('files')).toEqual([file]);
    expect(request.body.get('pdf_storage')).toBe('database');

    request.upload.onprogress({
        lengthComputable: true,
        loaded: 512,
        total: 1024,
    });
    expect(document.getElementById('progress-bar-fill').style.width)
        .toBe('50%');
    expect(document.getElementById('progress-summary').textContent)
        .toContain('50%');

    request.respond(201, {
        success: true,
        uploaded: [{ filename: file.name, status: 'uploaded' }],
        errors: [],
    });
    await vi.waitFor(() => {
        expect(document.querySelector('button[type="submit"]').disabled)
            .toBe(false);
    });
    expect(document.getElementById('progress-summary').textContent)
        .toContain('1 uploaded');

    await vi.advanceTimersByTimeAsync(500);
    expect(document.getElementById('upload-results').textContent)
        .toContain('direct.txt');
    expect(document.getElementById('upload-results').style.display)
        .toBe('block');
    expect(document.getElementById('selected-files').style.display)
        .toBe('none');
});

it('continues a batched upload after one batch fails', async () => {
    vi.useFakeTimers();
    const requests = installFakeXmlHttpRequest();
    await loadUploadPage();
    const files = Array.from({ length: 16 }, (_, index) => new File(
        [`batch-${index}`],
        `batch-${index}.txt`,
    ));
    setInputFiles(files);
    document.getElementById('files-input').dispatchEvent(new Event('change'));

    document.getElementById('upload-files-form').dispatchEvent(new Event(
        'submit',
        { bubbles: true, cancelable: true },
    ));
    await vi.waitFor(() => expect(requests).toHaveLength(1));
    expect(requests[0].body.getAll('files')).toHaveLength(15);
    requests[0].failNetwork();

    await vi.waitFor(() => expect(requests).toHaveLength(2));
    expect(requests[1].body.getAll('files')).toEqual([files[15]]);
    requests[1].respond(200, {
        uploaded: [{ filename: files[15].name, status: 'uploaded' }],
        errors: [],
    });
    await vi.waitFor(() => {
        expect(document.querySelector('button[type="submit"]').disabled)
            .toBe(false);
    });
    expect(document.getElementById('progress-summary').textContent)
        .toContain('1 uploaded, 15 failed');

    await vi.advanceTimersByTimeAsync(500);
    const results = document.getElementById('upload-results');
    expect(results.textContent).toContain('New uploads (1)');
    expect(results.textContent).toContain('Failed (15)');
    expect(results.textContent).toContain('Network error');
});

it('renders a non-OK upload response as inert error text and recovers', async () => {
    const requests = installFakeXmlHttpRequest();
    await loadUploadPage();
    const file = new File(['bad'], 'bad.txt');
    setInputFiles([file]);
    document.getElementById('files-input').dispatchEvent(new Event('change'));
    document.getElementById('upload-files-form').dispatchEvent(new Event(
        'submit',
        { bubbles: true, cancelable: true },
    ));
    await vi.waitFor(() => expect(requests).toHaveLength(1));

    requests[0].respond(
        422,
        '<img src=x onerror="window.__uploadErrorXss=true">',
    );
    await vi.waitFor(() => {
        expect(document.getElementById('upload-results').style.display)
            .toBe('block');
    });

    const results = document.getElementById('upload-results');
    expect(results.querySelector('img')).toBeNull();
    expect(results.textContent).toContain('Server returned 422');
    expect(window.__uploadErrorXss).toBeUndefined();
    expect(document.querySelector('button[type="submit"]').disabled)
        .toBe(false);
});

it('returns to the collection from Cancel through a listener, not an inline handler', async () => {
    renderCheckedInUploadPage();
    const cancelButton = [...document.querySelectorAll('.ldr-form-actions button')]
        .find(button => button.textContent.trim() === 'Cancel');
    expect(cancelButton).toBeDefined();
    expect(cancelButton.hasAttribute('onclick')).toBe(false);
    // The template renders the route's collection ID into this attribute. The
    // test value goes in through the DOM API, never through markup.
    cancelButton.setAttribute('data-collection-id', "collection\"&<');//?#");

    const ownLocation = Object.getOwnPropertyDescriptor(window, 'location');
    Object.defineProperty(window, 'location', {
        configurable: true,
        writable: true,
        value: { href: '/library/collections/collection-direct-3299/upload' },
    });
    try {
        await loadUploadPage();
        cancelButton.querySelector('i').click();

        expect(window.location.href).toBe(
            "/library/collections/collection%22%26%3C')%3B%2F%2F%3F%23",
        );
    } finally {
        if (ownLocation) {
            Object.defineProperty(window, 'location', ownLocation);
        } else {
            delete window.location;
        }
    }
});