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.

12.7 KB
Raw Blame
/**
 * Results-page rendering contracts across current and transitional report
 * response shapes. These exercise the real component bootstrap rather than a
 * duplicate renderer so metadata, navigation, downloads, and XSS fallbacks
 * stay wired together.
 */

import '@js/config/urls.js';

const RESEARCH_ID = 'results-display-3299';
const REPORT_URL = `/api/report/${RESEARCH_ID}`;
const CONTEXT_URL = `/api/research/${RESEARCH_ID}/context-overflow`;
const originalReadyState = Object.getOwnPropertyDescriptor(
    document,
    'readyState',
);

function renderPage() {
    document.body.innerHTML = `
        <button id="back-to-history">History</button>
        <button id="view-metrics-btn">Metrics</button>
        <button id="export-markdown-btn" disabled>Markdown</button>
        <button id="download-pdf-btn" disabled>PDF</button>
        <span id="result-query"></span>
        <span id="result-date"></span>
        <span id="result-mode"></span>
        <main id="results-content"></main>
        <div id="context-overflow-warning" style="display: none">
            <span id="context-overflow-message"></span>
            <a id="context-overflow-action">Details</a>
        </div>
    `;
}

function responseJson(payload) {
    return {
        ok: true,
        json: vi.fn().mockResolvedValue(payload),
    };
}

function installFetch(payload, contextResponse = { ok: false, status: 404 }) {
    const fetchMock = vi.fn(input => {
        const url = String(input);
        if (url === REPORT_URL) return Promise.resolve(responseJson(payload));
        if (url === CONTEXT_URL) return Promise.resolve(contextResponse);
        throw new Error(`Unexpected request: ${url}`);
    });
    vi.stubGlobal('fetch', fetchMock);
    return fetchMock;
}

function bootstrap() {
    document.dispatchEvent(new Event('DOMContentLoaded'));
}

beforeAll(async () => {
    Object.defineProperty(document, 'readyState', {
        configurable: true,
        get: () => 'loading',
    });
    await import('@js/components/results.js');
});

beforeEach(() => {
    renderPage();
    window.history.replaceState({}, '', `/results/${RESEARCH_ID}`);
    vi.stubGlobal('alert', vi.fn());
    vi.stubGlobal('URLValidator', {
        safeAssign: vi.fn((target, attribute, value) => {
            if (target instanceof Element) target.setAttribute(attribute, value);
            return true;
        }),
    });
});

afterEach(() => {
    vi.restoreAllMocks();
    vi.unstubAllGlobals();
    delete window.ui;
    delete window.Prism;
    delete window.sanitizeHtml;
    delete window.escapeHtml;
    document.body.replaceChildren();
    window.history.replaceState({}, '', '/');
});

afterAll(() => {
    if (originalReadyState) {
        Object.defineProperty(document, 'readyState', originalReadyState);
    } else {
        delete document.readyState;
    }
});

it('renders FastAPI report metadata and keeps both page routes canonical', async () => {
    const renderMarkdown = vi.fn(() => '<article>Rendered report</article>');
    const highlightAllUnder = vi.fn();
    window.ui = { renderMarkdown };
    window.Prism = { highlightAllUnder };
    vi.spyOn(window.formatting, 'formatDate').mockReturnValue('Sep 1, 2026');
    vi.spyOn(window.formatting, 'formatMode').mockReturnValue('Detailed Report');

    const fetchMock = installFetch({
        content: '# Report body',
        created_at: '2026-09-01T10:00:00Z',
        metadata: {
            processed_query: 'Processed subscription query',
            query: 'Original query',
            duration_seconds: 125,
            mode: 'detailed',
        },
    });

    bootstrap();

    await vi.waitFor(() => {
        expect(document.querySelector('#results-content article')?.textContent)
            .toBe('Rendered report');
    });
    expect(fetchMock).toHaveBeenCalledWith(REPORT_URL);
    expect(renderMarkdown).toHaveBeenCalledWith('# Report body');
    expect(highlightAllUnder).toHaveBeenCalledWith(
        document.getElementById('results-content'),
    );
    expect(document.getElementById('result-query').textContent)
        .toBe('Processed subscription query');
    expect(document.getElementById('result-date').textContent)
        .toBe('Sep 1, 2026 (2m 5s)');
    expect(document.getElementById('result-mode').textContent)
        .toBe('Detailed Report');
    expect(document.getElementById('export-markdown-btn').disabled).toBe(false);
    expect(document.getElementById('download-pdf-btn').disabled).toBe(false);

    document.getElementById('view-metrics-btn').click();
    document.getElementById('back-to-history').click();

    expect(URLValidator.safeAssign).toHaveBeenNthCalledWith(
        1,
        window.location,
        'href',
        `/details/${RESEARCH_ID}`,
    );
    expect(URLValidator.safeAssign).toHaveBeenNthCalledWith(
        2,
        window.location,
        'href',
        '/history/',
    );
});

it('infers a detailed mode for stored FastAPI reports whose mode is null', async () => {
    window.ui = { renderMarkdown: vi.fn(() => '<article>Detailed body</article>') };
    const formatMode = vi.spyOn(window.formatting, 'formatMode')
        .mockReturnValue('Detailed Report');
    installFetch({
        content: '# Report\n## Section\n### Finding',
        metadata: {
            query: 'Older stored report',
            mode: null,
        },
    });

    bootstrap();

    await vi.waitFor(() => {
        expect(document.getElementById('result-mode').textContent)
            .toBe('Detailed Report');
    });
    expect(formatMode).toHaveBeenCalledWith('detailed');
});

it('extracts display metadata from a transitional markdown-only report', async () => {
    window.ui = {
        renderMarkdown: vi.fn(content => `<article>${content}</article>`),
    };
    vi.spyOn(window.formatting, 'formatDate').mockReturnValue('Formatted date');
    installFetch({
        content: [
            '# Table of Contents',
            'Navigation',
            '## Actual research question',
            'Generated at: 2026-08-31T20:00:00Z',
            '### Detailed findings',
        ].join('\n'),
    });

    bootstrap();

    await vi.waitFor(() => {
        expect(document.getElementById('result-query').textContent)
            .toBe('Actual research question');
    });
    expect(document.getElementById('result-date').textContent)
        .toBe('Formatted date');
    expect(document.getElementById('result-mode').textContent)
        .toBe('Detailed');
    expect(window.ui.renderMarkdown).toHaveBeenCalledOnce();
});

it('supports the nested research response used by stored legacy reports', async () => {
    window.ui = {
        renderMarkdown: vi.fn(() => '<article>Legacy report</article>'),
    };
    const createObjectURL = vi.spyOn(URL, 'createObjectURL')
        .mockReturnValue('blob:stored-report');
    vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {});
    vi.spyOn(window.HTMLAnchorElement.prototype, 'click')
        .mockImplementation(() => {});
    vi.spyOn(window.formatting, 'formatDate').mockReturnValue('Legacy date');
    vi.spyOn(window.formatting, 'formatMode').mockReturnValue('Quick Summary');
    installFetch({
        research: {
            content: '# Stored report',
            prompt: 'Stored research prompt',
            created_at: '2025-01-01T00:00:00Z',
            duration: 9,
            research_mode: 'quick',
        },
    });

    bootstrap();

    await vi.waitFor(() => {
        expect(document.querySelector('#results-content article')?.textContent)
            .toBe('Legacy report');
    });
    expect(window.ui.renderMarkdown).toHaveBeenCalledWith('# Stored report');
    expect(document.getElementById('result-query').textContent)
        .toBe('Stored research prompt');
    expect(document.getElementById('result-date').textContent)
        .toBe('Legacy date (9 seconds)');
    expect(document.getElementById('result-mode').textContent)
        .toBe('Quick Summary');

    document.getElementById('export-markdown-btn').click();
    const exportedBlob = createObjectURL.mock.calls[0][0];
    expect(await exportedBlob.text()).toContain('# Stored report');
    expect(await exportedBlob.text()).not.toContain('```json');
});

it('sanitizes an HTML report even when its metadata omits a mode', async () => {
    const unsafeHtml = '<img src=x onerror="alert(1)"><p>Trusted text</p>';
    window.sanitizeHtml = vi.fn(() => '<p>Sanitized report</p>');
    installFetch({
        html: unsafeHtml,
        metadata: { query: 'Stored HTML report' },
    });

    bootstrap();

    await vi.waitFor(() => {
        expect(document.getElementById('results-content').textContent)
            .toBe('Sanitized report');
    });
    expect(window.sanitizeHtml).toHaveBeenCalledWith(unsafeHtml, { SAFE_FOR_TEMPLATES: false });
    expect(document.querySelector('#results-content img')).toBeNull();
    expect(document.getElementById('result-query').textContent)
        .toBe('Stored HTML report');
    expect(document.getElementById('result-mode').textContent).toBe('Quick');
});

it('preserves a valid empty FastAPI report for rendering and markdown export', async () => {
    const renderMarkdown = vi.fn(() => '<article data-empty>Empty report</article>');
    window.ui = { renderMarkdown };
    const createObjectURL = vi.spyOn(URL, 'createObjectURL')
        .mockReturnValue('blob:empty-report');
    vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {});
    vi.spyOn(window.HTMLAnchorElement.prototype, 'click')
        .mockImplementation(() => {});
    installFetch({
        content: '',
        summary: '',
        sources: [],
        findings: [],
        metadata: {
            query: 'Research with no generated text',
            mode: null,
            created_at: null,
        },
    });

    bootstrap();

    await vi.waitFor(() => {
        expect(document.querySelector('[data-empty]')?.textContent)
            .toBe('Empty report');
    });
    expect(renderMarkdown).toHaveBeenCalledWith('');
    expect(document.getElementById('result-query').textContent)
        .toBe('Research with no generated text');
    expect(document.getElementById('result-mode').textContent).toBe('Quick');

    document.getElementById('export-markdown-btn').click();
    const exportedText = await createObjectURL.mock.calls[0][0].text();
    expect(exportedText).toContain(
        '# Research Results: Research with no generated text',
    );
    expect(exportedText).not.toContain('```json');
    expect(exportedText).not.toContain('"content"');
});

it('escapes report markdown when the shared renderer is unavailable', async () => {
    const unsafeReport = '# <img src=x onerror="alert(1)"> & findings';
    installFetch({
        content: unsafeReport,
        metadata: { query: 'Security fallback' },
    });

    bootstrap();

    await vi.waitFor(() => {
        expect(document.querySelector('#results-content pre')?.textContent)
            .toBe(unsafeReport);
    });
    expect(document.querySelector('#results-content img')).toBeNull();
    expect(document.getElementById('results-content').innerHTML)
        .toContain('&lt;img src=x onerror="alert(1)"&gt;');
});

it('downloads the displayed report as markdown and releases its object URL', async () => {
    window.ui = { renderMarkdown: vi.fn(() => '<article>Export me</article>') };
    const createObjectURL = vi.spyOn(URL, 'createObjectURL')
        .mockReturnValue('blob:markdown-report');
    const revokeObjectURL = vi.spyOn(URL, 'revokeObjectURL')
        .mockImplementation(() => {});
    const anchorClick = vi.spyOn(window.HTMLAnchorElement.prototype, 'click')
        .mockImplementation(() => {});
    installFetch({
        content: '## Final findings',
        created_at: '2026-09-01T10:00:00Z',
        metadata: {
            query: 'Exported query',
            mode: 'quick',
        },
    });

    bootstrap();
    await vi.waitFor(() => {
        expect(document.getElementById('export-markdown-btn').disabled)
            .toBe(false);
    });

    document.getElementById('export-markdown-btn').click();

    expect(anchorClick).toHaveBeenCalledOnce();
    const blob = createObjectURL.mock.calls[0][0];
    expect(blob.type).toBe('text/markdown');
    expect(await blob.text()).toContain('# Research Results: Exported query');
    expect(await blob.text()).toContain('- **Mode:** Quick Summary');
    expect(await blob.text()).toContain('## Final findings');
    expect(URLValidator.safeAssign).toHaveBeenCalledWith(
        expect.any(window.HTMLAnchorElement),
        'href',
        'blob:markdown-report',
    );
    const downloadLink = URLValidator.safeAssign.mock.calls.find(
        ([, attribute, value]) => (
            attribute === 'href' && value === 'blob:markdown-report'
        ),
    )[0];
    expect(downloadLink.download).toBe(`research_${RESEARCH_ID}.md`);
    expect(createObjectURL.mock.calls[0][0]).toBe(blob);
    expect(revokeObjectURL).toHaveBeenCalledWith('blob:markdown-report');
});