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.

5.0 KB
Raw Blame
/**
 * Direct initialization and failure contracts for the browser help service.
 * The older unit suite covers successful public actions; these cases bind the
 * FastAPI bulk-state envelope and the recovery paths used during page startup.
 */

let HelpService;
let bulkFetch;
let originalFetch;

function panel(id, { collapsed = false } = {}) {
    const element = document.createElement('section');
    element.id = `help-panel-${id}`;
    element.className = `ldr-help-panel${collapsed ? ' collapsed' : ''}`;
    element.dataset.panelId = id;
    const header = document.createElement('button');
    header.className = 'ldr-help-panel-header';
    header.setAttribute('aria-expanded', String(!collapsed));
    element.appendChild(header);
    document.body.appendChild(element);
    return element;
}

beforeAll(async () => {
    originalFetch = globalThis.fetch;
    document.body.replaceChildren();
    localStorage.clear();
    const restored = panel('alpha /');
    const dismissed = panel('beta');
    const tooltip = document.createElement('button');
    tooltip.className = 'ldr-help-tooltip';
    tooltip.setAttribute('aria-expanded', 'false');
    document.body.appendChild(tooltip);
    localStorage.setItem('ldr_panel_collapsed_alpha /', 'true');

    let resolveBulk;
    bulkFetch = vi.fn(() => new Promise(resolve => {
        resolveBulk = resolve;
    }));
    globalThis.fetch = bulkFetch;
    window.api = { getCsrfToken: vi.fn(() => 'csrf-help') };
    window.ui = { showMessage: vi.fn() };

    await import('@js/services/help.js');
    HelpService = window.HelpService;

    const keyboardEvent = new KeyboardEvent('keydown', {
        key: 'Enter',
        cancelable: true,
    });
    tooltip.dispatchEvent(keyboardEvent);
    expect(keyboardEvent.defaultPrevented).toBe(true);
    expect(tooltip.getAttribute('aria-expanded')).toBe('true');

    await HelpService.init();
    expect(globalThis.fetch).toHaveBeenCalledOnce();
    resolveBulk({
        ok: true,
        json: () => Promise.resolve({
            success: true,
            settings: {
                'app.ui.help_dismissed_beta': { value: 'True' },
            },
        }),
    });

    await vi.waitFor(() => {
        expect(dismissed.style.display).toBe('none');
    });
    expect(restored.classList.contains('collapsed')).toBe(true);
    expect(restored.querySelector('.ldr-help-panel-header')
        .getAttribute('aria-expanded')).toBe('false');
});

afterAll(() => {
    document.body.replaceChildren();
    localStorage.clear();
    delete window.HelpService;
    delete window.api;
    delete window.ui;
    globalThis.fetch = originalFetch;
});

beforeEach(() => {
    // Failure-path cases replace fetch; restore the bootstrap spy so shuffled
    // test order cannot change which request the bulk-load contract observes.
    globalThis.fetch = bulkFetch;
    window.ui.showMessage.mockClear();
});

it('loads encoded panel keys once and recognizes the backend truth value', () => {
    expect(bulkFetch).toHaveBeenCalledWith(
        '/settings/api/bulk?keys[]=app.ui.help_dismissed_alpha%20%2F'
            + '&keys[]=app.ui.help_dismissed_beta',
    );
    expect(HelpService.isPanelDismissed('beta')).toBe(true);
    expect(HelpService.isPanelDismissed('alpha /')).toBe(false);
});

it('keeps a panel visible when FastAPI rejects its dismissal', async () => {
    const retained = panel('retained');
    globalThis.fetch = vi.fn().mockResolvedValue({ ok: false, status: 503 });

    await HelpService.dismissPanel('retained');

    expect(retained.style.display).toBe('');
    expect(HelpService.isPanelDismissed('retained')).toBe(false);
    expect(window.ui.showMessage)
        .toHaveBeenCalledWith('Failed to save preference', 'error');
});

it('contains a network failure while dismissing a panel', async () => {
    const retained = panel('offline');
    globalThis.fetch = vi.fn().mockRejectedValue(new Error('offline'));
    const error = vi.spyOn(SafeLogger, 'error').mockImplementation(() => {});

    await expect(HelpService.dismissPanel('offline')).resolves.toBeUndefined();

    expect(retained.style.display).toBe('');
    expect(error).toHaveBeenCalledWith(
        'Error dismissing panel:',
        expect.objectContaining({ message: 'offline' }),
    );
    expect(window.ui.showMessage)
        .toHaveBeenCalledWith('Failed to save preference', 'error');
    error.mockRestore();
});

it('persists collapsed state even when storage is unavailable', () => {
    const retained = panel('storage-failure');
    const warn = vi.spyOn(SafeLogger, 'warn').mockImplementation(() => {});
    const storage = vi.spyOn(window.localStorage, 'setItem')
        .mockImplementation(() => {
            throw new Error('blocked');
        });

    expect(() => HelpService.togglePanel('storage-failure')).not.toThrow();

    expect(retained.classList.contains('collapsed')).toBe(true);
    expect(warn).toHaveBeenCalledWith(
        'Failed to save panel state:',
        expect.objectContaining({ message: 'blocked' }),
    );
    storage.mockRestore();
    warn.mockRestore();
});