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.

7.3 KB
Raw Blame
/** Direct browser-runtime coverage for stale subscription-folder loads. */

function deferred() {
    let resolve;
    let reject;
    const promise = new Promise((resolvePromise, rejectPromise) => {
        resolve = resolvePromise;
        reject = rejectPromise;
    });
    return { promise, resolve, reject };
}

function jsonResponse(payload, status = 200) {
    return {
        ok: status >= 200 && status < 300,
        status,
        statusText: status === 200 ? 'OK' : 'Request failed',
        json: vi.fn().mockResolvedValue(payload),
    };
}

function installDom() {
    document.body.innerHTML = `
        <header class="ldr-page-header"><h1>Subscriptions</h1></header>
        <span id="total-subscriptions">0</span>
        <span id="active-subscriptions">0</span>
        <span id="paused-subscriptions">0</span>
        <span id="updates-today">0</span>
        <span id="status-indicator"></span>
        <span id="status-text"></span>
        <span id="scheduler-details"></span>
        <div class="ldr-folder-list">
            <div class="ldr-folder-item active" data-folder="all">
                All <span class="ldr-folder-count">0</span>
            </div>
            <div class="ldr-folder-item" data-folder="uncategorized">
                Uncategorized <span class="ldr-folder-count">0</span>
            </div>
        </div>
        <button id="add-folder-btn"></button>
        <button id="create-subscription-btn"></button>
        <input id="subscription-search">
        <select id="status-filter"><option value="all">All</option></select>
        <select id="frequency-filter"><option value="all">All</option></select>
        <main id="subscriptions-grid"></main>
    `;
}

let registeredDocumentListeners;

beforeEach(async () => {
    vi.resetModules();
    vi.useFakeTimers();
    registeredDocumentListeners = [];
    installDom();

    const purify = {
        isSupported: true,
        addHook: vi.fn(),
        sanitize: vi.fn(dirty => String(dirty)),
    };
    globalThis.DOMPurify = purify;
    window.DOMPurify = purify;
    await import('@js/security/xss-protection.js');
    await import('@js/utils/alert-helpers.js');

    window.api = { getCsrfToken: vi.fn(() => 'csrf-folder-race') };
    vi.stubGlobal('prompt', vi.fn(() => '  Created Folder  '));
});

afterEach(() => {
    registeredDocumentListeners.forEach(([type, listener, options]) => {
        document.removeEventListener(type, listener, options);
    });
    vi.clearAllTimers();
    vi.useRealTimers();
    vi.restoreAllMocks();
    vi.unstubAllGlobals();
    document.body.replaceChildren();
    delete window.api;
    delete window.DOMPurify;
    delete window.runSubscriptionNow;
    delete window.toggleSubscription;
    delete window.viewSubscriptionHistory;
    delete window.deleteSubscriptionDirect;
    delete window.showSchedulerInfo;
    delete window.formatNextUpdate;
});

async function startFolderRace(staleStage) {
    const staleGate = deferred();
    const staleFolderPayload = {
        folders: [{ id: 'folder-stale', name: 'Stale Folder' }],
    };
    const staleJson = vi.fn(() => (
        staleStage === 'body'
            ? staleGate.promise
            : Promise.resolve(staleFolderPayload)
    ));
    const staleResponse = {
        ok: true,
        status: 200,
        statusText: 'OK',
        json: staleJson,
    };
    const createdFolder = { id: 'folder-created', name: 'Created Folder' };
    let folderGetCount = 0;

    const fetchMock = vi.fn((input, options = {}) => {
        const url = String(input);
        if (url === '/news/api/subscriptions/current') {
            return Promise.resolve(jsonResponse({ subscriptions: [] }));
        }
        if (url === '/news/api/scheduler/status') {
            return Promise.resolve(jsonResponse({
                scheduler_available: true,
                is_running: true,
                active_users: 1,
                scheduled_jobs: 0,
            }));
        }
        if (url === '/news/api/subscription/folders' && options.method === 'POST') {
            return Promise.resolve(jsonResponse(createdFolder));
        }
        if (url === '/news/api/subscription/folders') {
            folderGetCount += 1;
            if (folderGetCount === 1) {
                if (staleStage === 'body') return Promise.resolve(staleResponse);
                return staleGate.promise;
            }
            return Promise.resolve(jsonResponse({ folders: [createdFolder] }));
        }
        return Promise.reject(new Error(`Unexpected request: ${url}`));
    });
    vi.stubGlobal('fetch', fetchMock);

    const originalDocumentAdd = document.addEventListener.bind(document);
    const documentAddSpy = vi.spyOn(document, 'addEventListener')
        .mockImplementation((type, listener, options) => {
            registeredDocumentListeners.push([type, listener, options]);
            originalDocumentAdd(type, listener, options);
        });
    try {
        await import('@js/pages/subscriptions.js');
        document.dispatchEvent(new Event('DOMContentLoaded'));
    } finally {
        documentAddSpy.mockRestore();
    }

    if (staleStage === 'body') {
        await vi.waitFor(() => expect(staleJson).toHaveBeenCalledOnce());
    }

    document.getElementById('add-folder-btn').click();
    await vi.waitFor(() => {
        expect(document.querySelector('[data-folder="folder-created"]')).not.toBeNull();
    });

    return {
        fetchMock,
        folderGetCount: () => folderGetCount,
        staleGate,
        staleJson,
        staleResponse,
    };
}

it.each([
    { staleStage: 'response', description: 'late response' },
    { staleStage: 'body', description: 'late response body' },
])('keeps the created folder after an older initial GET $description', async ({ staleStage }) => {
    const race = await startFolderRace(staleStage);

    if (staleStage === 'response') race.staleGate.resolve(race.staleResponse);
    else race.staleGate.resolve({ folders: [{ id: 'folder-stale', name: 'Stale Folder' }] });
    await race.staleGate.promise;
    await Promise.resolve();

    expect(document.querySelector('[data-folder="folder-created"]')).not.toBeNull();
    expect(document.querySelector('[data-folder="folder-stale"]')).toBeNull();
    expect(race.folderGetCount()).toBe(2);
    if (staleStage === 'response') expect(race.staleJson).not.toHaveBeenCalled();

    const createCall = race.fetchMock.mock.calls.find(([url, options]) => (
        url === '/news/api/subscription/folders' && options.method === 'POST'
    ));
    expect(createCall[1]).toMatchObject({
        method: 'POST',
        credentials: 'same-origin',
        headers: {
            'Content-Type': 'application/json',
            'X-CSRFToken': 'csrf-folder-race',
        },
    });
    expect(JSON.parse(createCall[1].body)).toEqual({ name: 'Created Folder' });
});

it('silences an older initial GET rejection after the created folder owns the UI', async () => {
    const errorLog = vi.spyOn(SafeLogger, 'error');
    const race = await startFolderRace('rejection');

    race.staleGate.reject(new Error('older folder request failed'));
    await expect(race.staleGate.promise).rejects.toThrow('older folder request failed');
    await Promise.resolve();

    expect(document.querySelector('[data-folder="folder-created"]')).not.toBeNull();
    expect(errorLog).not.toHaveBeenCalled();
    expect(race.folderGetCount()).toBe(2);
});