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.

29.3 KB
Raw Blame
/**
 * Runtime coverage for the embedding-settings page's FastAPI contracts.
 *
 * This page owns several direct requests and previously had no executable
 * Vitest import. Use the checked-in template as the DOM fixture so the test
 * exercises the same element graph and initialization order as the browser.
 */

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

const TEMPLATE_PATH = resolve(
    __dirname,
    '../../src/local_deep_research/web/templates/pages/embedding_settings.html',
);

const MODELS = {
    success: true,
    provider_options: [{
        value: 'sentence_transformers',
        label: 'Sentence Transformers',
        available: true,
    }],
    providers: {
        sentence_transformers: [
            {
                value: 'model-old',
                label: 'Old model - Existing default',
                is_embedding: true,
            },
            {
                value: 'model-new',
                label: 'New model - Migration candidate',
                is_embedding: true,
            },
        ],
    },
};

const SETTINGS = {
    success: true,
    settings: {
        embedding_provider: 'sentence_transformers',
        embedding_model: 'model-old',
        chunk_size: 640,
        chunk_overlap: 80,
        splitter_type: 'recursive',
        distance_metric: 'cosine',
        index_type: 'flat',
        normalize_vectors: true,
        text_separators: ['\\n\\n', ' '],
    },
};

function catalogRacePayload(betaModel) {
    return {
        success: true,
        provider_options: [
            {
                value: 'sentence_transformers',
                label: 'Sentence Transformers',
                available: true,
            },
            {
                value: 'catalog-alpha',
                label: 'Catalog Alpha',
                available: true,
            },
            {
                value: 'catalog-beta',
                label: 'Catalog Beta',
                available: true,
            },
        ],
        providers: {
            sentence_transformers: MODELS.providers.sentence_transformers,
            'catalog-alpha': [{
                value: 'alpha-initial-model',
                label: 'Alpha initial model',
                is_embedding: true,
            }],
            'catalog-beta': [{
                value: betaModel,
                label: betaModel,
                is_embedding: true,
            }],
        },
    };
}

const INITIAL_CATALOG = catalogRacePayload('beta-initial-model');
const NEWEST_CATALOG = catalogRacePayload('beta-newest-model');
const STALE_CATALOG = catalogRacePayload('beta-stale-fallback-model');

const OPENAI_MODELS = {
    success: true,
    provider_options: [
        {
            value: 'openai',
            label: 'OpenAI / Compatible',
            available: true,
        },
        {
            value: 'ollama',
            label: 'Ollama',
            available: true,
        },
    ],
    providers: {
        openai: [{
            value: 'text-embedding-3-small',
            label: 'text-embedding-3-small',
            is_embedding: true,
        }],
        ollama: [{
            value: 'nomic-embed-text',
            label: 'nomic-embed-text',
            is_embedding: true,
        }],
    },
};

const OPENAI_SETTINGS = {
    success: true,
    settings: {
        ...SETTINGS.settings,
        embedding_provider: 'openai',
        embedding_model: 'text-embedding-3-small',
    },
};

let documentListeners = [];

function jsonResponse(body, status = 200) {
    return new Response(JSON.stringify(body), { status });
}

function installFetch(modelPutResponse = () => (
    Promise.resolve(jsonResponse({ status: 'success' }))
)) {
    return vi.fn((url, options = {}) => {
        if (url === '/library/api/rag/models') {
            return Promise.resolve(jsonResponse(MODELS));
        }
        if (url === '/library/api/rag/settings') {
            return Promise.resolve(jsonResponse(SETTINGS));
        }
        if (url === '/settings/api/embeddings.ollama.url') {
            return Promise.resolve(jsonResponse({ value: 'http://ollama:11434' }));
        }
        if (url === '/settings/api/embeddings.ollama.num_ctx') {
            return Promise.resolve(jsonResponse({ value: 16384 }));
        }
        if (
            url === '/settings/api/local_search_embedding_model'
            && options.method === 'PUT'
        ) {
            return modelPutResponse(options);
        }
        if (url.startsWith('/settings/api/') && options.method === 'PUT') {
            return Promise.resolve(jsonResponse({ status: 'success' }));
        }
        throw new Error(`Unexpected request: ${url}`);
    });
}

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

async function flushPromises(turns = 8) {
    for (let turn = 0; turn < turns; turn += 1) {
        await Promise.resolve();
    }
}

function installCatalogRaceFetch(loadOlderCatalog) {
    let modelGetCount = 0;
    return vi.fn((url, options = {}) => {
        if (url === '/library/api/rag/models') {
            modelGetCount += 1;
            if (modelGetCount === 1) {
                return Promise.resolve(jsonResponse(INITIAL_CATALOG));
            }
            if (modelGetCount === 2) return loadOlderCatalog();
            if (modelGetCount === 3) {
                return Promise.resolve(jsonResponse(NEWEST_CATALOG));
            }
            throw new Error(`Unexpected models request ${modelGetCount}`);
        }
        if (url === '/library/api/rag/settings') {
            return Promise.resolve(jsonResponse(SETTINGS));
        }
        if (url === '/settings/api/embeddings.ollama.url') {
            return Promise.resolve(jsonResponse({ value: 'http://ollama:11434' }));
        }
        if (url === '/settings/api/embeddings.ollama.num_ctx') {
            return Promise.resolve(jsonResponse({ value: 16384 }));
        }
        if (url.startsWith('/settings/api/') && options.method === 'PUT') {
            return Promise.resolve(jsonResponse({ status: 'success' }));
        }
        throw new Error(`Unexpected request: ${url}`);
    });
}

async function startCatalogRace(fetchMock) {
    await loadPage(fetchMock);
    const provider = document.getElementById('embedding-provider');
    provider.value = 'catalog-alpha';
    provider.dispatchEvent(new Event('change'));
    provider.value = 'catalog-beta';
    provider.dispatchEvent(new Event('change'));

    await vi.waitFor(() => {
        const modelGets = fetchMock.mock.calls.filter(([url]) => (
            url === '/library/api/rag/models'
        ));
        expect(modelGets).toHaveLength(3);
    });
    await vi.waitFor(() => {
        expect(document.getElementById('embedding-model').value)
            .toBe('beta-newest-model');
    });
}

function savedModelValues(fetchMock) {
    return fetchMock.mock.calls
        .filter(([url, options = {}]) => (
            url === '/settings/api/local_search_embedding_model' &&
            options.method === 'PUT'
        ))
        .map(([, options]) => JSON.parse(options.body).value);
}

function installOpenAIFetch(batchSizeResponse = () => jsonResponse({ value: 8 })) {
    let batchSizeGetCount = 0;
    return vi.fn((url, options = {}) => {
        if (url === '/library/api/rag/models') {
            return Promise.resolve(jsonResponse(OPENAI_MODELS));
        }
        if (url === '/library/api/rag/settings') {
            return Promise.resolve(jsonResponse(OPENAI_SETTINGS));
        }
        if (url === '/settings/api/embeddings.ollama.url') {
            return Promise.resolve(jsonResponse({ value: 'http://ollama:11434' }));
        }
        if (url === '/settings/api/embeddings.ollama.num_ctx') {
            return Promise.resolve(jsonResponse({ value: 16384 }));
        }
        if (url === '/settings/api/embeddings.openai.chunk_size') {
            if (options.method === 'PUT') {
                return Promise.resolve(jsonResponse({ status: 'success' }));
            }
            batchSizeGetCount += 1;
            return Promise.resolve(batchSizeResponse(batchSizeGetCount));
        }
        if (url.startsWith('/settings/api/') && options.method === 'PUT') {
            return Promise.resolve(jsonResponse({ status: 'success' }));
        }
        throw new Error(`Unexpected request: ${url}`);
    });
}

async function loadPage(fetchMock) {
    vi.stubGlobal('safeFetchWithAuth', fetchMock);
    await import('@js/embedding_settings.js');
    document.dispatchEvent(new Event('DOMContentLoaded'));
    await vi.waitFor(() => {
        expect(document.getElementById('embedding-model').value)
            .toBe('model-old');
    });
}

async function loadOpenAIPage(fetchMock, expectedBatchSize = '8') {
    vi.stubGlobal('safeFetchWithAuth', fetchMock);
    await import('@js/embedding_settings.js');
    document.dispatchEvent(new Event('DOMContentLoaded'));
    await vi.waitFor(() => {
        expect(document.getElementById('embedding-provider').value)
            .toBe('openai');
        expect(document.getElementById('openai-embedding-batch-size').value)
            .toBe(expectedBatchSize);
        expect(document.getElementById('openai-embedding-batch-size-group').hidden)
            .toBe(false);
    });
}

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);
        },
    );
    // eslint-disable-next-line no-unsanitized/property -- checked-in repository template used as the browser fixture
    document.body.innerHTML = readFileSync(TEMPLATE_PATH, 'utf8');
    vi.stubGlobal('LDR_CONSTANTS', {
        DEFAULT_LOCAL_SEARCH_TEXT_SEPARATORS: ['\\n\\n', '\\n', ' '],
    });
    vi.stubGlobal('escapeHtml', value => String(value));
    window.escapeHtml = value => String(value);
    window.XSSProtection = { escapeHtml: value => String(value) };
    window.api = { getCsrfToken: vi.fn(() => 'csrf-embedding') };
    window.ui = { showMessage: vi.fn() };
});

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

it('hydrates the real form from the migrated models and settings endpoints', async () => {
    const fetchMock = installFetch();
    await loadPage(fetchMock);

    expect(fetchMock.mock.calls.slice(0, 4).map(([url]) => url)).toEqual([
        '/library/api/rag/models',
        '/library/api/rag/settings',
        '/settings/api/embeddings.ollama.url',
        '/settings/api/embeddings.ollama.num_ctx',
    ]);
    expect(document.getElementById('embedding-provider').value)
        .toBe('sentence_transformers');
    expect(Array.from(
        document.getElementById('embedding-model').options,
        option => option.value,
    )).toEqual(['model-old', 'model-new']);
    expect(document.getElementById('chunk-size').value).toBe('640');
    expect(document.getElementById('chunk-overlap').value).toBe('80');
    expect(document.getElementById('normalize-vectors').checked).toBe(true);
    expect(document.getElementById('ollama-url').value)
        .toBe('http://ollama:11434');
    expect(document.getElementById('ollama-num-ctx').value).toBe('16384');
});

it.each([
    [false, 'blocked by egress policy', 'Blocked by egress policy'],
    [true, 'unavailable', 'Not reachable'],
])('distinguishes provider policy denial from reachability (allowed=%s)', async (policyAllowed, optionStatus, cardStatus) => {
    const catalog = {
        ...MODELS,
        provider_options: [...MODELS.provider_options, {
            value: 'ollama', label: 'Ollama', available: false,
            policy_allowed: policyAllowed,
        }],
        providers: { ...MODELS.providers, ollama: [] },
    };
    const defaultFetch = installFetch();
    const fetchMock = vi.fn((url, options = {}) => (
        url === '/library/api/rag/models'
            ? Promise.resolve(jsonResponse(catalog))
            : defaultFetch(url, options)
    ));
    await loadPage(fetchMock);

    const provider = document.getElementById('embedding-provider');
    const option = Array.from(provider.options).find(item => item.value === 'ollama');
    expect(option.textContent).toBe(`Ollama (${optionStatus})`);
    expect(option.disabled).toBe(false);
    provider.value = 'ollama';
    provider.dispatchEvent(new Event('change'));
    await vi.waitFor(() => {
        const warning = document.getElementById('provider-unavailable-warning');
        expect(warning.textContent).toContain(
            policyAllowed ? 'not reachable' : 'blocked by your egress policy',
        );
        if (!policyAllowed) {
            expect(warning.textContent).not.toContain('not reachable');
        }
    });
    const card = Array.from(document.querySelectorAll('#provider-info .ldr-stat-card'))
        .find(item => item.querySelector('h4').textContent === 'Ollama');
    expect(card.querySelector('.ldr-provider-status').textContent).toContain(cardStatus);
});

it('ignores an older model catalog before reading its response body', async () => {
    const olderRequest = deferred();
    const olderResponse = {
        ok: true,
        json: vi.fn().mockResolvedValue(STALE_CATALOG),
    };
    const fetchMock = installCatalogRaceFetch(() => olderRequest.promise);

    await startCatalogRace(fetchMock);
    await vi.waitFor(() => {
        expect(savedModelValues(fetchMock)).toContain('beta-newest-model');
    });
    olderRequest.resolve(olderResponse);
    await flushPromises();

    expect(olderResponse.json).not.toHaveBeenCalled();
    expect(document.getElementById('embedding-model').value)
        .toBe('beta-newest-model');
    expect(Array.from(
        document.getElementById('embedding-model').options,
        option => option.value,
    )).toEqual(['beta-newest-model']);
    expect(savedModelValues(fetchMock))
        .not.toContain('beta-stale-fallback-model');
});

it('ignores an older model catalog whose JSON body finishes last', async () => {
    const olderBody = deferred();
    const olderResponse = {
        ok: true,
        json: vi.fn(() => olderBody.promise),
    };
    const fetchMock = installCatalogRaceFetch(
        () => Promise.resolve(olderResponse),
    );

    await startCatalogRace(fetchMock);
    expect(olderResponse.json).toHaveBeenCalledOnce();
    await vi.waitFor(() => {
        expect(savedModelValues(fetchMock)).toContain('beta-newest-model');
    });
    olderBody.resolve(STALE_CATALOG);
    await flushPromises();

    expect(document.getElementById('embedding-model').value)
        .toBe('beta-newest-model');
    expect(Array.from(
        document.getElementById('embedding-model').options,
        option => option.value,
    )).toEqual(['beta-newest-model']);
    expect(savedModelValues(fetchMock))
        .not.toContain('beta-stale-fallback-model');
});

it('does not show an error from an older model catalog request', async () => {
    const olderRequest = deferred();
    const fetchMock = installCatalogRaceFetch(() => olderRequest.promise);

    await startCatalogRace(fetchMock);
    await vi.waitFor(() => {
        expect(savedModelValues(fetchMock)).toContain('beta-newest-model');
    });
    olderRequest.reject(new Error('obsolete model catalog failed'));
    await flushPromises();

    expect(document.querySelector('.ldr-alert-danger')).toBeNull();
    expect(document.getElementById('embedding-model').value)
        .toBe('beta-newest-model');
    expect(savedModelValues(fetchMock))
        .not.toContain('beta-stale-fallback-model');
});

it('persists a model change through the single-setting FastAPI route', async () => {
    const fetchMock = installFetch();
    await loadPage(fetchMock);

    const model = document.getElementById('embedding-model');
    model.value = 'model-new';
    model.dispatchEvent(new Event('change'));

    await vi.waitFor(() => {
        expect(fetchMock).toHaveBeenCalledWith(
            '/settings/api/local_search_embedding_model',
            expect.objectContaining({ method: 'PUT' }),
        );
    });
    const [, options] = fetchMock.mock.calls.find(
        ([url]) => url === '/settings/api/local_search_embedding_model',
    );
    expect(options.headers).toEqual({
        'Content-Type': 'application/json',
        'X-CSRFToken': 'csrf-embedding',
    });
    expect(JSON.parse(options.body)).toEqual({ value: 'model-new' });
    await vi.waitFor(() => {
        expect(window.ui.showMessage).toHaveBeenCalledWith(
            'Embedding model: model-old → model-new',
            'success',
            6000,
        );
    });
});

it('persists the remaining embedding controls through their dotted settings routes', async () => {
    const fetchMock = installFetch();
    await loadPage(fetchMock);

    const changes = [
        ['chunk-size', '880', 'blur'],
        ['chunk-overlap', '120', 'blur'],
        ['splitter-type', 'token', 'change'],
        ['distance-metric', 'l2', 'change'],
        ['index-type', 'hnsw', 'change'],
        ['ollama-num-ctx', '32768', 'blur'],
    ];
    for (const [id, value, eventType] of changes) {
        const element = document.getElementById(id);
        element.value = value;
        element.dispatchEvent(new Event(eventType));
    }
    const normalize = document.getElementById('normalize-vectors');
    normalize.checked = false;
    normalize.dispatchEvent(new Event('change'));
    const separators = document.getElementById('text-separators');
    separators.value = JSON.stringify(['\\n\\n', '---']);
    separators.dispatchEvent(new Event('blur'));
    const ollamaUrl = document.getElementById('ollama-url');
    ollamaUrl.value = 'http://ollama-new:11434';
    ollamaUrl.dispatchEvent(new Event('blur'));

    const expected = new Map([
        ['local_search_chunk_size', 880],
        ['local_search_chunk_overlap', 120],
        ['local_search_splitter_type', 'token'],
        ['local_search_distance_metric', 'l2'],
        ['local_search_index_type', 'hnsw'],
        ['local_search_normalize_vectors', false],
        ['local_search_text_separators', ['\\n\\n', '---']],
        ['embeddings.ollama.num_ctx', 32768],
        ['embeddings.ollama.url', 'http://ollama-new:11434'],
    ]);
    await vi.waitFor(() => {
        const puts = fetchMock.mock.calls.filter(([, request = {}]) => (
            request.method === 'PUT'
        ));
        expect(puts).toHaveLength(expected.size);
    });

    for (const [key, value] of expected) {
        expect(fetchMock).toHaveBeenCalledWith(`/settings/api/${key}`, {
            method: 'PUT',
            headers: {
                'Content-Type': 'application/json',
                'X-CSRFToken': 'csrf-embedding',
            },
            body: JSON.stringify({ value }),
        });
    }
});

it('rejects out-of-range chunk and Ollama context values before fetch', async () => {
    const fetchMock = installFetch();
    await loadPage(fetchMock);

    for (const [id, value] of [
        ['chunk-size', '99'],
        ['chunk-overlap', '1001'],
        ['ollama-num-ctx', '511'],
    ]) {
        const element = document.getElementById(id);
        element.value = value;
        element.dispatchEvent(new Event('blur'));
    }
    await Promise.resolve();

    const puts = fetchMock.mock.calls.filter(([, request = {}]) => (
        request.method === 'PUT'
    ));
    expect(puts).toHaveLength(0);
});

it('serializes rapid model changes, including a return to the stored value', async () => {
    const olderSave = deferred();
    const newerSave = deferred();
    let putCount = 0;
    const fetchMock = installFetch(() => {
        putCount += 1;
        return putCount === 1 ? olderSave.promise : newerSave.promise;
    });
    await loadPage(fetchMock);

    const model = document.getElementById('embedding-model');
    model.value = 'model-new';
    model.dispatchEvent(new Event('change'));
    model.value = 'model-old';
    model.dispatchEvent(new Event('change'));

    await vi.waitFor(() => {
        const puts = fetchMock.mock.calls.filter(([url, request = {}]) => (
            url === '/settings/api/local_search_embedding_model' &&
            request.method === 'PUT'
        ));
        expect(puts).toHaveLength(1);
        expect(JSON.parse(puts[0][1].body)).toEqual({ value: 'model-new' });
    });

    olderSave.resolve(jsonResponse({ status: 'success' }));
    await vi.waitFor(() => {
        const puts = fetchMock.mock.calls.filter(([url, request = {}]) => (
            url === '/settings/api/local_search_embedding_model' &&
            request.method === 'PUT'
        ));
        expect(puts).toHaveLength(2);
        expect(JSON.parse(puts[1][1].body)).toEqual({ value: 'model-old' });
    });
    expect(window.ui.showMessage).not.toHaveBeenCalled();

    newerSave.resolve(jsonResponse({ status: 'success' }));
    await vi.waitFor(() => {
        expect(window.ui.showMessage).toHaveBeenCalledOnce();
    });
    expect(window.ui.showMessage).toHaveBeenCalledWith(
        'Embedding model: model-new → model-old',
        'success',
        6000,
    );
});

it('retries a failed rollback from the committed stale-success baseline', async () => {
    const saveToNew = deferred();
    const failedRollback = deferred();
    const retriedRollback = deferred();
    const saves = [saveToNew, failedRollback, retriedRollback];
    let putCount = 0;
    const fetchMock = installFetch(() => {
        const save = saves[putCount];
        putCount += 1;
        return save.promise;
    });
    await loadPage(fetchMock);

    const model = document.getElementById('embedding-model');
    model.value = 'model-new';
    model.dispatchEvent(new Event('change'));
    model.value = 'model-old';
    model.dispatchEvent(new Event('change'));

    await vi.waitFor(() => expect(putCount).toBe(1));
    saveToNew.resolve(jsonResponse({ status: 'success' }));
    await vi.waitFor(() => expect(putCount).toBe(2));
    expect(window.ui.showMessage).not.toHaveBeenCalled();

    failedRollback.resolve(jsonResponse({
        error: 'rollback rejected',
    }, 500));
    await vi.waitFor(() => {
        expect(window.ui.showMessage).toHaveBeenCalledWith(
            'Failed to save Embedding model: rollback rejected',
            'error',
        );
    });
    window.ui.showMessage.mockClear();

    // The form is already back on model-old. The successful stale first PUT
    // nevertheless committed model-new, so this retry must not be skipped as
    // an apparent no-op against the original page-load value.
    model.dispatchEvent(new Event('change'));
    await vi.waitFor(() => expect(putCount).toBe(3));

    const puts = fetchMock.mock.calls.filter(([url, request = {}]) => (
        url === '/settings/api/local_search_embedding_model' &&
        request.method === 'PUT'
    ));
    expect(puts.map(([, request]) => JSON.parse(request.body))).toEqual([
        { value: 'model-new' },
        { value: 'model-old' },
        { value: 'model-old' },
    ]);

    retriedRollback.resolve(jsonResponse({ status: 'success' }));
    await vi.waitFor(() => {
        expect(window.ui.showMessage).toHaveBeenCalledWith(
            'Embedding model: model-new → model-old',
            'success',
            6000,
        );
    });
});

it('hydrates and saves the OpenAI request batch size through its dotted key', async () => {
    const fetchMock = installOpenAIFetch();
    await loadOpenAIPage(fetchMock);

    const batchSize = document.getElementById('openai-embedding-batch-size');
    batchSize.value = '13';
    batchSize.dispatchEvent(new Event('input'));
    batchSize.dispatchEvent(new Event('blur'));

    await vi.waitFor(() => {
        expect(fetchMock).toHaveBeenCalledWith(
            '/settings/api/embeddings.openai.chunk_size',
            expect.objectContaining({ method: 'PUT' }),
        );
    });
    const [, options] = fetchMock.mock.calls.find(([url, request = {}]) => (
        url === '/settings/api/embeddings.openai.chunk_size' &&
        request.method === 'PUT'
    ));
    expect(options.headers).toEqual({
        'Content-Type': 'application/json',
        'X-CSRFToken': 'csrf-embedding',
    });
    expect(JSON.parse(options.body)).toEqual({ value: 13 });
    await vi.waitFor(() => {
        expect(window.ui.showMessage).toHaveBeenCalledWith(
            'Embedding request batch size: 8 → 13',
            'success',
            6000,
        );
    });
});

it.each([
    ['zero', '0'],
    ['a fraction', '1.5'],
    ['an empty value', ''],
])('rejects %s for the OpenAI request batch size without issuing a PUT', async (_label, value) => {
    const fetchMock = installOpenAIFetch();
    await loadOpenAIPage(fetchMock);
    const batchSize = document.getElementById('openai-embedding-batch-size');

    batchSize.value = value;
    batchSize.dispatchEvent(new Event('input'));
    batchSize.dispatchEvent(new Event('blur'));
    await Promise.resolve();

    const batchSizePuts = fetchMock.mock.calls.filter(([url, request = {}]) => (
        url === '/settings/api/embeddings.openai.chunk_size' &&
        request.method === 'PUT'
    ));
    expect(batchSizePuts).toHaveLength(0);
    expect(batchSize.classList.contains('ldr-field-invalid')).toBe(true);
    expect(batchSize.getAttribute('aria-invalid')).toBe('true');
    const error = document.getElementById('openai-embedding-batch-size-error');
    expect(error.style.display).toBe('block');
    expect(error.textContent).toBe('Enter a whole number of at least 1.');
});

it.each([
    ['invalid JSON', '["\\n"'],
    ['a non-array JSON value', '{"separator":"\\n"}'],
])('rejects %s for text separators without issuing a PUT', async (_label, value) => {
    const fetchMock = installFetch();
    await loadPage(fetchMock);
    const separators = document.getElementById('text-separators');

    separators.value = value;
    separators.dispatchEvent(new Event('blur'));
    await Promise.resolve();

    const separatorPuts = fetchMock.mock.calls.filter(([url, request = {}]) => (
        url === '/settings/api/local_search_text_separators' &&
        request.method === 'PUT'
    ));
    expect(separatorPuts).toHaveLength(0);
    expect(separators.classList.contains('ldr-field-invalid')).toBe(true);
    const error = document.getElementById('text-separators-error');
    expect(error.style.display).toBe('block');
    expect(error.textContent).toMatch(/JSON array|Invalid JSON format/);
});

it('does not let late OpenAI hydration overwrite a user edit', async () => {
    const lateHydration = deferred();
    const fetchMock = installOpenAIFetch((getCount) => (
        getCount === 1
            ? jsonResponse({ value: 8 })
            : lateHydration.promise
    ));
    await loadOpenAIPage(fetchMock);

    const provider = document.getElementById('embedding-provider');
    provider.dispatchEvent(new Event('change'));
    await vi.waitFor(() => {
        const hydrationGets = fetchMock.mock.calls.filter(([url, request = {}]) => (
            url === '/settings/api/embeddings.openai.chunk_size' &&
            request.method !== 'PUT'
        ));
        expect(hydrationGets).toHaveLength(2);
    });

    const batchSize = document.getElementById('openai-embedding-batch-size');
    batchSize.value = '21';
    batchSize.dispatchEvent(new Event('input'));
    lateHydration.resolve(jsonResponse({ value: 3 }));

    await vi.waitFor(() => {
        expect(document.getElementById('openai-embedding-batch-size-group').hidden)
            .toBe(false);
    });
    expect(batchSize.value).toBe('21');
    const batchSizePuts = fetchMock.mock.calls.filter(([url, request = {}]) => (
        url === '/settings/api/embeddings.openai.chunk_size' &&
        request.method === 'PUT'
    ));
    expect(batchSizePuts).toHaveLength(0);
});

it('does not let late OpenAI hydration undo a provider switch', async () => {
    const lateHydration = deferred();
    const lateJson = vi.fn().mockResolvedValue({ value: 99 });
    const fetchMock = installOpenAIFetch((getCount) => {
        if (getCount === 1) return jsonResponse({ value: 8 });
        return lateHydration.promise;
    });
    await loadOpenAIPage(fetchMock);

    const provider = document.getElementById('embedding-provider');
    provider.dispatchEvent(new Event('change'));
    await vi.waitFor(() => {
        const hydrationGets = fetchMock.mock.calls.filter(([url, request = {}]) => (
            url === '/settings/api/embeddings.openai.chunk_size' &&
            request.method !== 'PUT'
        ));
        expect(hydrationGets).toHaveLength(2);
    });

    provider.value = 'ollama';
    provider.dispatchEvent(new Event('change'));
    expect(document.getElementById('openai-embedding-batch-size-group').hidden)
        .toBe(true);

    lateHydration.resolve({ ok: true, json: lateJson });
    await vi.waitFor(() => {
        expect(lateJson).toHaveBeenCalledOnce();
    });
    await Promise.resolve();
    await Promise.resolve();

    expect(provider.value).toBe('ollama');
    expect(document.getElementById('openai-embedding-batch-size-group').hidden)
        .toBe(true);
    expect(document.getElementById('openai-embedding-batch-size').value)
        .toBe('8');
});