~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.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
/**
* 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');
});