~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
/**
* Tests for utils/form-validation.js
*
* Tests the FormValidator class and built-in validator functions
* used for inline form validation with ARIA support.
*/
import '@js/utils/form-validation.js';
const FormValidator = window.FormValidator;
const validators = window.formValidators;
describe('FormValidator', () => {
let form;
let input;
let validator;
beforeEach(() => {
form = document.createElement('form');
input = document.createElement('input');
input.type = 'text';
input.id = 'test-field';
form.appendChild(input);
document.body.appendChild(form);
validator = new FormValidator();
});
afterEach(() => {
document.body.removeChild(form);
});
describe('addValidation', () => {
it('creates an error element next to the field', () => {
validator.addValidation(input, () => null);
const errorEl = document.getElementById('test-field-error');
expect(errorEl).not.toBeNull();
expect(errorEl.className).toBe('ldr-field-error');
});
it('sets aria-describedby on the field', () => {
validator.addValidation(input, () => null);
expect(input.getAttribute('aria-describedby')).toContain('test-field-error');
});
it('sets aria-live on error element', () => {
validator.addValidation(input, () => null);
const errorEl = document.getElementById('test-field-error');
expect(errorEl.getAttribute('aria-live')).toBe('polite');
});
it('accepts selector string instead of element', () => {
validator.addValidation('#test-field', () => null);
const errorEl = document.getElementById('test-field-error');
expect(errorEl).not.toBeNull();
});
it('does nothing for non-existent selector', () => {
expect(() => {
validator.addValidation('#nonexistent', () => null);
}).not.toThrow();
});
it('generates an id for fields without one', () => {
const noIdInput = document.createElement('input');
noIdInput.type = 'text';
form.appendChild(noIdInput);
validator.addValidation(noIdInput, () => null);
expect(noIdInput.id).toMatch(/^form-field-/);
});
});
describe('validateField', () => {
it('returns true when validator returns null (valid)', () => {
validator.addValidation(input, () => null);
expect(validator.validateField(input)).toBe(true);
});
it('returns false when validator returns error message', () => {
validator.addValidation(input, () => 'Error!');
expect(validator.validateField(input)).toBe(false);
});
it('adds ldr-field-invalid class on error', () => {
validator.addValidation(input, () => 'Error!');
validator.validateField(input);
expect(input.classList.contains('ldr-field-invalid')).toBe(true);
});
it('sets aria-invalid on error', () => {
validator.addValidation(input, () => 'Error!');
validator.validateField(input);
expect(input.getAttribute('aria-invalid')).toBe('true');
});
it('displays error message in error element', () => {
validator.addValidation(input, () => 'Field is required');
validator.validateField(input);
const errorEl = document.getElementById('test-field-error');
expect(errorEl.textContent).toBe('Field is required');
expect(errorEl.style.display).toBe('block');
});
it('clears error state when field becomes valid', () => {
validator.addValidation(input, (val) => (val ? null : 'Required'));
input.value = '';
validator.validateField(input);
expect(input.classList.contains('ldr-field-invalid')).toBe(true);
input.value = 'filled';
validator.validateField(input);
expect(input.classList.contains('ldr-field-invalid')).toBe(false);
expect(input.hasAttribute('aria-invalid')).toBe(false);
});
it('returns true for unregistered elements', () => {
const unknownInput = document.createElement('input');
expect(validator.validateField(unknownInput)).toBe(true);
});
});
describe('validateAll', () => {
it('returns true when all fields are valid', () => {
const input2 = document.createElement('input');
input2.id = 'field-2';
form.appendChild(input2);
validator.addValidation(input, () => null);
validator.addValidation(input2, () => null);
expect(validator.validateAll()).toBe(true);
});
it('returns false when any field is invalid', () => {
const input2 = document.createElement('input');
input2.id = 'field-2';
form.appendChild(input2);
validator.addValidation(input, () => null);
validator.addValidation(input2, () => 'Error');
expect(validator.validateAll()).toBe(false);
});
it('validates all fields (not short-circuit)', () => {
const input2 = document.createElement('input');
input2.id = 'field-2';
form.appendChild(input2);
validator.addValidation(input, () => 'Error 1');
validator.addValidation(input2, () => 'Error 2');
validator.validateAll();
// Both should show errors
expect(input.classList.contains('ldr-field-invalid')).toBe(true);
expect(input2.classList.contains('ldr-field-invalid')).toBe(true);
});
});
describe('clearErrors', () => {
it('removes error classes and messages from all fields', () => {
validator.addValidation(input, () => 'Error');
validator.validateField(input);
expect(input.classList.contains('ldr-field-invalid')).toBe(true);
validator.clearErrors();
expect(input.classList.contains('ldr-field-invalid')).toBe(false);
expect(input.hasAttribute('aria-invalid')).toBe(false);
const errorEl = document.getElementById('test-field-error');
expect(errorEl.textContent).toBe('');
expect(errorEl.style.display).toBe('none');
});
});
describe('showError', () => {
it('shows custom error on a field', () => {
validator.addValidation(input, () => null);
validator.showError(input, 'Custom error');
expect(input.classList.contains('ldr-field-invalid')).toBe(true);
expect(input.getAttribute('aria-invalid')).toBe('true');
const errorEl = document.getElementById('test-field-error');
expect(errorEl.textContent).toBe('Custom error');
expect(errorEl.getAttribute('aria-live')).toBe('polite');
});
it('can render a passive inline copy when another live region announces it', () => {
validator.addValidation(input, () => null);
validator.showError(input, 'Custom error', { announce: false });
const errorEl = document.getElementById('test-field-error');
expect(errorEl.textContent).toBe('Custom error');
expect(errorEl.getAttribute('aria-live')).toBeNull();
// A later ordinary validation error must restore the default
// polite announcement behavior.
validator.addValidation(input, () => 'Validated error');
validator.validateField(input);
expect(errorEl.textContent).toBe('Validated error');
expect(errorEl.getAttribute('aria-live')).toBe('polite');
// The default showError path also restores polite semantics.
validator.showError(input, 'Passive again', { announce: false });
validator.showError(input, 'Ordinary error');
expect(errorEl.textContent).toBe('Ordinary error');
expect(errorEl.getAttribute('aria-live')).toBe('polite');
});
it('accepts selector string', () => {
validator.addValidation(input, () => null);
validator.showError('#test-field', 'Custom error');
expect(input.classList.contains('ldr-field-invalid')).toBe(true);
});
it('does nothing for non-existent selector', () => {
expect(() => {
validator.showError('#nonexistent', 'Error');
}).not.toThrow();
});
});
});
describe('Built-in validators', () => {
describe('required', () => {
const required = validators.required();
it('returns null for non-empty value', () => {
expect(required('hello')).toBeNull();
});
it('returns error for empty string', () => {
expect(required('')).toBe('This field is required');
});
it('returns error for whitespace-only string', () => {
expect(required(' ')).toBe('This field is required');
});
it('returns error for null/undefined', () => {
expect(required(null)).toBe('This field is required');
expect(required(undefined)).toBe('This field is required');
});
it('accepts custom message', () => {
const custom = validators.required('Please fill this in');
expect(custom('')).toBe('Please fill this in');
});
});
describe('minLength', () => {
const minLen = validators.minLength(3);
it('returns null for values meeting minimum', () => {
expect(minLen('abc')).toBeNull();
expect(minLen('abcd')).toBeNull();
});
it('returns error for short values', () => {
expect(minLen('ab')).toBe('Must be at least 3 characters');
});
it('returns null for empty value (let required handle it)', () => {
expect(minLen('')).toBeNull();
expect(minLen(null)).toBeNull();
});
it('accepts custom message', () => {
const custom = validators.minLength(5, 'Too short!');
expect(custom('abc')).toBe('Too short!');
});
});
describe('maxLength', () => {
const maxLen = validators.maxLength(5);
it('returns null for values within limit', () => {
expect(maxLen('abc')).toBeNull();
expect(maxLen('abcde')).toBeNull();
});
it('returns error for values exceeding limit', () => {
expect(maxLen('abcdef')).toBe('Must be no more than 5 characters');
});
it('returns null for empty value', () => {
expect(maxLen('')).toBeNull();
expect(maxLen(null)).toBeNull();
});
});
describe('pattern', () => {
const emailLike = validators.pattern(/^[^@]+@[^@]+$/, 'Invalid email');
it('returns null for matching values', () => {
expect(emailLike('[email protected]')).toBeNull();
});
it('returns error for non-matching values', () => {
expect(emailLike('not-an-email')).toBe('Invalid email');
});
it('returns null for empty value', () => {
expect(emailLike('')).toBeNull();
expect(emailLike(null)).toBeNull();
});
it('uses default message when none provided', () => {
const digits = validators.pattern(/^\d+$/);
expect(digits('abc')).toBe('Invalid format');
});
});
});