~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
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.jsindex 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.jsnew file mode 100644index 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 };