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.

test(ui): add settings save error toast test (#5310)

LearningCircuitaec331d75018
diff --git a/tests/ui_tests/run_all_tests.js b/tests/ui_tests/run_all_tests.js
index 603b065863..013cbdf5c4 100644
--- a/tests/ui_tests/run_all_tests.js
+++ b/tests/ui_tests/run_all_tests.js
@@ -229,7 +229,7 @@ const tests = [
},
// =====================================================================
- // Shard: settings-core (4 tests)
+ // Shard: settings-core (5 tests)
// =====================================================================
{
name: 'Settings Page Test',
@@ -255,6 +255,12 @@ const tests = [
shard: 'settings-core',
description: 'Tests tabs, search, toggles, save, raw config'
},
+ {
+ name: 'Settings Save Error CI Tests',
+ file: 'test_settings_save_error_ci.js',
+ shard: 'settings-core',
+ description: 'Injects 5xx on save endpoint via request interception, asserts error toast renders in #notification-banner-assertive.'
+ },
// =====================================================================
// Shard: settings-pages (3 tests)
diff --git a/tests/ui_tests/test_settings_save_error_ci.js b/tests/ui_tests/test_settings_save_error_ci.js
new file mode 100644
index 0000000000..6b339a2f75
--- /dev/null
+++ b/tests/ui_tests/test_settings_save_error_ci.js
@@ -0,0 +1,498 @@
+#!/usr/bin/env node
+const { setupTest, teardownTest, TestResults, log, navigateTo } = require('./test_lib');
+
+const checkboxSelector = 'input.ldr-settings-checkbox:not([disabled])';
+const errorBannerSelector = '#notification-banner-assertive';
+const saveEndpointPath = '/settings/save_all_settings';
+const responseWaitTimeoutMs = 8000;
+
+function assertCondition(condition, message) {
+ if (!condition) throw new Error(message);
+}
+
+function getSaveUrl(baseUrl) {
+ return new URL(saveEndpointPath, baseUrl).href;
+}
+
+function isSaveEndpointVariant(url) {
+ try {
+ return new URL(url).pathname.replace(/\/+$/, '') === saveEndpointPath;
+ } catch {
+ return false;
+ }
+}
+
+function createInterceptionState() {
+ return { requestHandlers: new Set(), interceptionEnabled: false };
+}
+
+async function disableSaveInterception(page, interceptionState) {
+ try {
+ for (const requestHandler of interceptionState.requestHandlers) {
+ page.off('request', requestHandler);
+ }
+ interceptionState.requestHandlers.clear();
+ } finally {
+ if (interceptionState.interceptionEnabled) {
+ interceptionState.interceptionEnabled = false;
+ await page.setRequestInterception(false);
+ }
+ }
+}
+
+function createExactResponseWaiter(page, expectedUrl, timeoutMs = responseWaitTimeoutMs) {
+ let resolveResponse;
+ let rejectResponse;
+ let settled = false;
+ const responseHandler = (response) => {
+ try {
+ if (response.url() !== expectedUrl || response.request().method() !== 'POST') return;
+ settle(resolveResponse, response);
+ } catch (error) {
+ settle(rejectResponse, error);
+ }
+ };
+ const cleanup = () => {
+ clearTimeout(timeoutId);
+ page.off('response', responseHandler);
+ };
+ const settle = (settler, value) => {
+ if (settled) return;
+ settled = true;
+ cleanup();
+ settler(value);
+ };
+ const responsePromise = new Promise((resolve, reject) => {
+ resolveResponse = resolve;
+ rejectResponse = reject;
+ });
+
+ const timeoutId = setTimeout(
+ () => settle(rejectResponse, new Error(`Timed out waiting for POST ${expectedUrl}`)),
+ timeoutMs,
+ );
+ page.on('response', responseHandler);
+ return {
+ wait: () => responsePromise,
+ cancel: () => settle(resolveResponse, null),
+ };
+}
+
+async function navigateToSettings(page, baseUrl) {
+ await navigateTo(page, `${baseUrl}/settings/`);
+ await page.waitForSelector(checkboxSelector, { timeout: 15000 });
+}
+
+async function readCheckboxState(page, baseline) {
+ return page.evaluate((selector, expectedId, expectedKey) => {
+ const checkbox = Array.from(document.querySelectorAll(selector)).find(
+ input => !expectedId || (input.id === expectedId && input.name === expectedKey)
+ );
+ if (!checkbox?.id || !checkbox.name) {
+ throw new Error('Enabled settings checkbox with an id and name was not found');
+ }
+
+ const hiddenFallback = checkbox.dataset.hiddenFallback
+ ? document.getElementById(checkbox.dataset.hiddenFallback)
+ : null;
+ return {
+ id: checkbox.id,
+ key: checkbox.name,
+ domChecked: checkbox.checked,
+ hiddenFallbackDisabled: hiddenFallback ? hiddenFallback.disabled : null,
+ };
+ }, checkboxSelector, baseline?.id || null, baseline?.key || null);
+}
+
+async function captureCheckboxBaseline(page, baseUrl) {
+ await navigateToSettings(page, baseUrl);
+ const initialState = await readCheckboxState(page);
+
+ await page.reload({ waitUntil: 'domcontentloaded' });
+ await page.waitForSelector(checkboxSelector, { timeout: 15000 });
+ const persistedState = await readCheckboxState(page, initialState);
+
+ return {
+ ...persistedState,
+ initialDomChecked: initialState.domChecked,
+ persistedChecked: persistedState.domChecked,
+ };
+}
+
+async function getTargetCheckbox(page, baseline) {
+ const checkbox = await page.$(checkboxSelector);
+ assertCondition(checkbox, `Checkbox ${baseline.key} was not found`);
+ const identity = await checkbox.evaluate(input => ({ id: input.id, key: input.name }));
+ assertCondition(
+ identity.id === baseline.id && identity.key === baseline.key,
+ `Expected checkbox ${baseline.id}/${baseline.key}, found ${identity.id}/${identity.key}`,
+ );
+ return checkbox;
+}
+
+async function restoreCheckboxDom(page, baseline) {
+ return page.evaluate((selector, id, key, checked, hiddenFallbackDisabled) => {
+ const checkbox = Array.from(document.querySelectorAll(selector)).find(
+ input => input.id === id && input.name === key
+ );
+ if (!checkbox) throw new Error(`Checkbox ${id}/${key} was not found for DOM restoration`);
+
+ // Do not dispatch change: a failed request must not produce another save.
+ checkbox.checked = checked;
+ const hiddenFallback = checkbox.dataset.hiddenFallback
+ ? document.getElementById(checkbox.dataset.hiddenFallback)
+ : null;
+ if (hiddenFallback && hiddenFallbackDisabled !== null) {
+ hiddenFallback.disabled = hiddenFallbackDisabled;
+ }
+ return {
+ domChecked: checkbox.checked,
+ hiddenFallbackDisabled: hiddenFallback ? hiddenFallback.disabled : null,
+ };
+ }, checkboxSelector, baseline.id, baseline.key, baseline.domChecked, baseline.hiddenFallbackDisabled);
+}
+
+function getRequestContractFailures(request, expectedUrl, baseline, expectedChecked) {
+ if (!request) return [`expected one request to ${expectedUrl}, but observed none`];
+
+ const failures = [];
+ if (request.url !== expectedUrl) failures.push(`expected URL ${expectedUrl}, got ${request.url}`);
+ if (request.method !== 'POST') failures.push(`expected POST, got ${request.method}`);
+
+ let payload;
+ try {
+ payload = JSON.parse(request.postData || '');
+ } catch {
+ failures.push(`request body was not JSON: ${request.postData || '<empty>'}`);
+ return failures;
+ }
+
+ const isPlainObject = payload !== null &&
+ typeof payload === 'object' &&
+ !Array.isArray(payload) &&
+ Object.getPrototypeOf(payload) === Object.prototype;
+ if (!isPlainObject) {
+ failures.push('request body was not a plain object');
+ return failures;
+ }
+
+ const keys = Object.keys(payload);
+ if (keys.length !== 1 || keys[0] !== baseline.key || payload[baseline.key] !== expectedChecked) {
+ failures.push(
+ `expected one-key payload ${JSON.stringify({ [baseline.key]: expectedChecked })}, got ${request.postData}`,
+ );
+ }
+ return failures;
+}
+
+async function triggerFailedSave(page, baseUrl, baseline, status, message, interceptionState = createInterceptionState()) {
+ await navigateToSettings(page, baseUrl);
+ const expectedUrl = getSaveUrl(baseUrl);
+ const expectedChecked = !baseline.domChecked;
+ const expectedToast = `Error saving settings: ${message}`;
+ const observedRequests = [];
+ let attemptedSave = false;
+ let afterFailedSave;
+ let restoredState;
+
+ const requestHandler = async (request) => {
+ const observedRequest = {
+ url: request.url(),
+ method: request.method(),
+ postData: request.postData(),
+ };
+ if (!isSaveEndpointVariant(observedRequest.url)) {
+ await request.continue();
+ return;
+ }
+ observedRequests.push(observedRequest);
+ await request.respond({
+ status,
+ contentType: 'application/json',
+ body: JSON.stringify({ message }),
+ });
+ };
+
+ try {
+ await page.setRequestInterception(true);
+ interceptionState.interceptionEnabled = true;
+ page.on('request', requestHandler);
+ interceptionState.requestHandlers.add(requestHandler);
+
+ const beforeSave = await readCheckboxState(page, baseline);
+ assertCondition(
+ beforeSave.domChecked === baseline.domChecked,
+ `Checkbox ${baseline.key} did not start at the captured DOM baseline`,
+ );
+ const checkbox = await getTargetCheckbox(page, baseline);
+ attemptedSave = true;
+ await checkbox.click();
+ await page.waitForFunction(
+ (selector, expectedText) =>
+ document.querySelector(`${selector} span`)?.textContent.trim() === expectedText,
+ { timeout: 8000 },
+ errorBannerSelector,
+ expectedToast,
+ );
+ afterFailedSave = await readCheckboxState(page, baseline);
+ } finally {
+ try {
+ if (attemptedSave) {
+ const requestCountBeforeRestore = observedRequests.length;
+ restoredState = await restoreCheckboxDom(page, baseline);
+ assertCondition(
+ observedRequests.length === requestCountBeforeRestore,
+ 'Restoring the failed checkbox DOM state issued another request',
+ );
+ }
+ } finally {
+ await disableSaveInterception(page, interceptionState);
+ }
+ }
+
+ const result = await page.evaluate((bannerSelector, selector, id, key) => {
+ const input = Array.from(document.querySelectorAll(selector)).find(
+ checkbox => checkbox.id === id && checkbox.name === key
+ );
+ const loadingContainer = input?.closest('.ldr-checkbox-label') || input;
+ return {
+ toastText: document.querySelector(`${bannerSelector} span`)?.textContent.trim() || '',
+ hasSuccess: input?.classList.contains('ldr-save-success') === true,
+ hasSaving: loadingContainer?.classList.contains('ldr-saving') === true,
+ };
+ }, errorBannerSelector, checkboxSelector, baseline.id, baseline.key);
+ const observedRequest = observedRequests.length === 1 ? observedRequests[0] : null;
+ const failures = getRequestContractFailures(
+ observedRequest,
+ expectedUrl,
+ baseline,
+ expectedChecked,
+ );
+ if (observedRequests.length !== 1) {
+ failures.push(`expected one save-endpoint request, got ${observedRequests.length}`);
+ }
+ if (afterFailedSave.domChecked !== expectedChecked) {
+ failures.push(`checkbox did not toggle to ${expectedChecked} before the failed save`);
+ }
+ if (result.toastText !== expectedToast) failures.push(`expected toast "${expectedToast}", got "${result.toastText}"`);
+ if (result.hasSuccess) failures.push('failed save showed a success indicator');
+ if (result.hasSaving) failures.push('failed save left the checkbox loading');
+ if (restoredState.domChecked !== baseline.domChecked ||
+ restoredState.hiddenFallbackDisabled !== baseline.hiddenFallbackDisabled) {
+ failures.push('failed save did not restore the captured DOM checkbox state');
+ }
+
+ return {
+ passed: failures.length === 0,
+ message: failures.length === 0
+ ? `${status} POST ${saveEndpointPath} sent ${baseline.key}=${expectedChecked} and rendered the exact error toast`
+ : `${status} save contract failed: ${failures.join('; ')}`,
+ };
+}
+
+async function saveCheckboxValue(page, expectedUrl, baseline, expectedChecked) {
+ const beforeSave = await readCheckboxState(page, baseline);
+ assertCondition(
+ beforeSave.domChecked !== expectedChecked,
+ `Checkbox ${baseline.key} was already ${expectedChecked} before normal save`,
+ );
+ const responseWaiter = createExactResponseWaiter(page, expectedUrl);
+ try {
+ const checkbox = await getTargetCheckbox(page, baseline);
+ await checkbox.click();
+ const response = await responseWaiter.wait();
+ assertCondition(response.ok(), `Normal save returned HTTP ${response.status()}`);
+
+ const request = response.request();
+ const failures = getRequestContractFailures({
+ url: request.url(),
+ method: request.method(),
+ postData: request.postData(),
+ }, expectedUrl, baseline, expectedChecked);
+ assertCondition(failures.length === 0, `Normal save contract failed: ${failures.join('; ')}`);
+
+ await page.waitForFunction((selector, id, key, expected) => {
+ const input = Array.from(document.querySelectorAll(selector)).find(
+ candidate => candidate.id === id && candidate.name === key
+ );
+ const loadingContainer = input?.closest('.ldr-checkbox-label') || input;
+ return input?.checked === expected &&
+ input.classList.contains('ldr-save-success') &&
+ !loadingContainer?.classList.contains('ldr-saving');
+ }, { timeout: 8000 }, checkboxSelector, baseline.id, baseline.key, expectedChecked);
+ } finally {
+ responseWaiter.cancel();
+ }
+}
+
+async function restorePersistedCheckboxState(page, baseUrl, baseline) {
+ await navigateToSettings(page, baseUrl);
+ await page.reload({ waitUntil: 'domcontentloaded' });
+ await page.waitForSelector(checkboxSelector, { timeout: 15000 });
+ const expectedUrl = getSaveUrl(baseUrl);
+ const currentState = await readCheckboxState(page, baseline);
+ if (currentState.domChecked !== baseline.persistedChecked) {
+ await saveCheckboxValue(page, expectedUrl, baseline, baseline.persistedChecked);
+ }
+ await page.reload({ waitUntil: 'domcontentloaded' });
+ await page.waitForSelector(checkboxSelector, { timeout: 15000 });
+ const reloadedState = await readCheckboxState(page, baseline);
+ assertCondition(
+ reloadedState.domChecked === baseline.persistedChecked,
+ `Checkbox ${baseline.key} did not restore its persisted baseline`,
+ );
+}
+
+const SettingsSaveErrorTests = {
+ async serverErrorShowsToast(page, baseUrl, baseline, interceptionState) {
+ return triggerFailedSave(
+ page,
+ baseUrl,
+ baseline,
+ 500,
+ 'Internal server error (test injection)',
+ interceptionState,
+ );
+ },
+
+ async csrfExpiryShowsToast(page, baseUrl, baseline, interceptionState) {
+ return triggerFailedSave(
+ page,
+ baseUrl,
+ baseline,
+ 400,
+ 'CSRF token expired',
+ interceptionState,
+ );
+ },
+
+ async normalSaveShowsSuccess(page, baseUrl, baseline) {
+ await navigateToSettings(page, baseUrl);
+ const initialState = await readCheckboxState(page, baseline);
+ assertCondition(
+ initialState.domChecked === baseline.persistedChecked,
+ `Checkbox ${baseline.key} did not start normal save at its persisted baseline`,
+ );
+
+ let needsPersistedRestore = true;
+ try {
+ const expectedUrl = getSaveUrl(baseUrl);
+ await saveCheckboxValue(page, expectedUrl, baseline, !baseline.persistedChecked);
+ await saveCheckboxValue(page, expectedUrl, baseline, baseline.persistedChecked);
+ await page.reload({ waitUntil: 'domcontentloaded' });
+ await page.waitForSelector(checkboxSelector, { timeout: 15000 });
+ const reloadedState = await readCheckboxState(page, baseline);
+ assertCondition(
+ reloadedState.domChecked === baseline.persistedChecked,
+ `Normal save did not restore ${baseline.key} after reload`,
+ );
+ needsPersistedRestore = false;
+ return {
+ passed: true,
+ message: `Normal POST save toggled ${baseline.key} and restored its persisted baseline after reload`,
+ };
+ } finally {
+ if (needsPersistedRestore) await restorePersistedCheckboxState(page, baseUrl, baseline);
+ }
+ },
+};
+
+async function runSettingsSaveErrorSuite(
+ page,
+ baseUrl,
+ recordResult,
+ testFunctions = SettingsSaveErrorTests,
+) {
+ const interceptionState = createInterceptionState();
+ let checkboxBaseline;
+ let baselineReady = false;
+
+ async function run(name, testFn) {
+ let result;
+ try {
+ result = await testFn(page, baseUrl, checkboxBaseline, interceptionState);
+ } catch (error) {
+ recordResult(name, false, `Error: ${error.message}`);
+ throw error;
+ }
+
+ recordResult(name, result.passed, result.message, result.skipped);
+ if (!result.skipped && !result.passed) {
+ throw new Error(`${name} failed: ${result.message}`);
+ }
+ }
+
+ try {
+ checkboxBaseline = await captureCheckboxBaseline(page, baseUrl);
+ assertCondition(
+ checkboxBaseline.initialDomChecked === checkboxBaseline.persistedChecked,
+ `Checkbox ${checkboxBaseline.key} changed before the test could establish a persisted baseline`,
+ );
+ baselineReady = true;
+ await run('5xx shows exact error toast', testFunctions.serverErrorShowsToast);
+ await run('CSRF expiry shows exact error toast', testFunctions.csrfExpiryShowsToast);
+ await run('Normal save restores original value', testFunctions.normalSaveShowsSuccess);
+ } catch (error) {
+ if (!baselineReady) {
+ recordResult('Capture checkbox baseline', false, `Error: ${error.message}`);
+ }
+ } finally {
+ let interceptionDisabled = false;
+ try {
+ await disableSaveInterception(page, interceptionState);
+ interceptionDisabled = true;
+ } catch (error) {
+ recordResult('Disable save interception', false, `Cleanup error: ${error.message}`);
+ }
+
+ if (checkboxBaseline && interceptionDisabled) {
+ try {
+ await restorePersistedCheckboxState(page, baseUrl, checkboxBaseline);
+ } catch (error) {
+ recordResult('Restore original persisted checkbox value', false, `Cleanup error: ${error.message}`);
+ }
+ } else if (checkboxBaseline) {
+ recordResult(
+ 'Restore original persisted checkbox value',
+ false,
+ 'Cleanup error: request interception could not be disabled before persisted restoration',
+ );
+ }
+ }
+}
+
+async function main() {
+ log.section('Settings Save Error CI Tests');
+ const ctx = await setupTest({ authenticate: true });
+ const results = new TestResults('Settings Save Error CI Tests');
+ const { page } = ctx;
+ const { baseUrl } = ctx.config;
+
+ try {
+ await runSettingsSaveErrorSuite(
+ page,
+ baseUrl,
+ (name, passed, message, skipped) => {
+ if (skipped) {
+ results.skip('Save Error', name, message);
+ } else {
+ results.add('Save Error', name, passed, message);
+ }
+ },
+ );
+ } finally {
+ results.print();
+ results.save();
+ await teardownTest(ctx);
+ process.exit(results.exitCode());
+ }
+}
+
+if (require.main === module) {
+ main().catch((error) => {
+ console.error('Test runner failed:', error);
+ process.exit(1);
+ });
+}
+
+module.exports = { SettingsSaveErrorTests, runSettingsSaveErrorSuite };