~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
"""Regression tests for #5589: `import_settings` must validate imported
values against the current-defaults schema.
A pre-upgrade export can contain values (and schema metadata) that are
invalid under the current defaults — e.g. a free-text
``search.time_period`` value (the field is a select
with an options list in current defaults, so free-text is invalid). Importing such a file
must not resurrect
those stale values for settings whose key is in the current defaults.
Note: constructing a ``SettingsManager`` against an empty database
auto-seeds all current defaults (``_ensure_settings_initialized``), so DB
tests assert that the stored value stays at its seeded default rather than
that no row exists.
"""
import os
import pytest
@pytest.fixture(autouse=True)
def clean_env():
"""Remove LDR_ environment overrides so they cannot mask stored values."""
original_env = {k: v for k, v in os.environ.items() if k.startswith("LDR_")}
for key in list(os.environ.keys()):
if key.startswith("LDR_"):
os.environ.pop(key, None)
yield
for key in list(os.environ.keys()):
if key.startswith("LDR_"):
os.environ.pop(key, None)
for key, value in original_env.items():
os.environ[key] = value
class TestSettingsManagerImportValidation:
"""DB-backed SettingsManager.import_settings validation."""
@pytest.fixture
def session(self):
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from local_deep_research.database.models import Base
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
yield session
session.close()
engine.dispose()
def test_import_rejects_value_outside_current_options(self, session):
"""A stale export value not in the current options list is skipped.
The imported row also carries stale free-text metadata for the
field — the exact resurrection shape from #5589 — so the check must
read constraints from current defaults, not from the import.
"""
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session) # seeds defaults
seeded = (
session.query(Setting)
.filter(Setting.key == "search.time_period")
.first()
)
assert seeded is not None # select with options d/w/m/y/all
manager.import_settings(
{
"search.time_period": {
"value": "stale_legacy_value",
"type": "SEARCH",
"name": "Time Period",
"ui_element": "select",
# Stale metadata resurrecting a pre-upgrade free-text
# field shape.
"options": ["stale_legacy_value", "another_stale_one"],
},
"search.max_results": {
"value": 5,
"type": "SEARCH",
"name": "Max Results",
},
},
commit=False,
)
setting = (
session.query(Setting)
.filter(Setting.key == "search.time_period")
.first()
)
assert setting.value == seeded.value # stale value did not land
# The valid entry in the same import still lands.
assert (
session.query(Setting)
.filter(Setting.key == "search.max_results")
.first()
.value
== 5
)
def test_import_accepts_value_in_current_options(self, session):
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
manager.import_settings(
{
"search.time_period": {
"value": "m",
"type": "SEARCH",
"name": "Time Period",
"ui_element": "select",
"options": ["d", "w", "m", "y", "all"],
},
},
commit=False,
)
setting = (
session.query(Setting)
.filter(Setting.key == "search.time_period")
.first()
)
assert setting.value == "m"
def test_import_rejects_number_outside_bounds(self, session):
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session) # seeds defaults
# Constraints come from the shipped defaults, not the imported file.
# Pick a current number key that actually declares an upper bound so
# this branch has coverage even if a particular key's max is null.
key, meta = next(
(
(k, m)
for k, m in manager.default_settings.items()
if m.get("ui_element") == "number"
and m.get("max_value") is not None
),
(None, None),
)
assert key is not None, "shipped defaults declare no numeric max_value"
assert meta is not None
too_high = meta["max_value"] + 1
seeded = session.query(Setting).filter(Setting.key == key).first()
assert seeded is not None
manager.import_settings(
{
key: {
"value": too_high,
"type": meta.get("type"),
"name": meta.get("name"),
"ui_element": "number",
"min_value": meta.get("min_value"),
"max_value": meta.get("max_value"),
},
},
commit=False,
)
setting = session.query(Setting).filter(Setting.key == key).first()
assert setting.value == seeded.value # seeded default untouched
def test_import_rejects_uncoercible_number(self, session):
"""Invalid typed input is rejected just like the save path."""
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
manager.import_settings(
{
"app.max_concurrent_researches": {
"value": "not-a-number",
"type": "APP",
"name": "Max",
"ui_element": "number",
},
},
commit=False,
)
setting = (
session.query(Setting)
.filter(Setting.key == "app.max_concurrent_researches")
.first()
)
assert setting.value == 3 # seeded default untouched
def test_import_skips_validation_for_dynamic_settings(self, session):
"""DYNAMIC_SETTINGS (llm.model etc.) never options-validate."""
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
manager.import_settings(
{
"llm.model": {
"value": "custom-org/my-finetuned-model",
"type": "LLM",
"name": "Model",
"ui_element": "select",
"options": ["gpt-4o", "llama3.1"],
},
},
commit=False,
)
setting = (
session.query(Setting).filter(Setting.key == "llm.model").first()
)
assert setting is not None
assert setting.value == "custom-org/my-finetuned-model"
def test_reconciliation_path_is_not_validated(self, session):
"""`overwrite=False` keeps stored values without re-validating them.
The version-bump reconciliation must refresh schema metadata while
preserving the stored value; stored values are trusted state, so an
out-of-options stored value still survives reconciliation unchanged.
"""
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
stored = (
session.query(Setting)
.filter(Setting.key == "search.time_period")
.first()
)
stored.value = "legacy_stored"
stored.options = ["legacy_stored"]
session.commit()
manager.import_settings(
{
"search.time_period": {
"value": "d",
"type": "SEARCH",
"name": "Time Period",
"ui_element": "select",
"options": ["d", "w", "m", "y", "all"],
},
},
overwrite=False,
commit=False,
)
setting = (
session.query(Setting)
.filter(Setting.key == "search.time_period")
.first()
)
# Stored value preserved (not re-validated), metadata refreshed.
assert setting.value == "legacy_stored"
assert setting.options == ["d", "w", "m", "y", "all"]
def test_reconciliation_keeps_an_invalid_stored_row_and_continues(
self, session, loguru_caplog
):
"""One invalid stored row must not stop the upgrade reconciliation.
The strict read of a number row holding a non-number raises
SettingsValueError. Login and initialize_default_settings run this
import, so it keeps that stored value (neither aborting nor
replacing it with the default), still seeds the other defaults,
and logs the key without the value.
"""
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
planted = "not-a-number-private"
manager = SettingsManager(db_session=session)
invalid = (
session.query(Setting)
.filter(Setting.key == "search.iterations")
.one()
)
assert invalid.ui_element == "number"
invalid.value = planted
# A default shipped by the upgrade has no row yet.
session.query(Setting).filter(
Setting.key == "search.questions_per_iteration"
).delete()
session.commit()
with loguru_caplog.at_level("WARNING"):
manager.import_settings(
manager.default_settings,
commit=False,
overwrite=False,
override_locked=True,
)
stored = (
session.query(Setting)
.filter(Setting.key == "search.iterations")
.one()
)
assert stored.value == planted
seeded = (
session.query(Setting)
.filter(Setting.key == "search.questions_per_iteration")
.one()
)
assert (
seeded.value
== (
manager.default_settings["search.questions_per_iteration"][
"value"
]
)
)
assert "'search.iterations'" in loguru_caplog.text
assert planted not in loguru_caplog.text
def test_reconciliation_keeps_a_valid_row_with_an_invalid_child(
self, session
):
"""An invalid child row does not cost the parent its own value."""
from local_deep_research.database.models import Setting, SettingType
from local_deep_research.settings.exceptions import SettingsValueError
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
stored = (
session.query(Setting).filter(Setting.key == "llm.provider").one()
)
stored.value = "openai"
session.add(
Setting(
key="llm.provider.extra",
value="not-a-number",
type=SettingType.LLM,
name="Extra",
ui_element="number",
)
)
session.commit()
with pytest.raises(SettingsValueError):
manager.get_setting("llm.provider", check_env=False)
manager.import_settings(
manager.default_settings, overwrite=False, override_locked=True
)
stored_value = (
session.query(Setting.value)
.filter(Setting.key == "llm.provider")
.scalar()
)
assert stored_value == "openai"
def test_reconciliation_keeps_a_scalar_row_with_child_rows(self, session):
"""Child rows never replace a stored value during reconciliation.
get_setting() folds child rows into a mapping, and its LIKE lookup
also matches ASCII case variants of the key. The version-bump
import must keep the row's own value instead of that mapping.
"""
from local_deep_research.database.models import Setting, SettingType
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
stored = (
session.query(Setting).filter(Setting.key == "llm.provider").one()
)
stored.value = "openai"
for child in ("llm.provider.extra", "LLM.PROVIDER.extra"):
session.add(
Setting(
key=child,
value="x",
type=SettingType.LLM,
name="Extra",
ui_element="text",
)
)
session.commit()
assert isinstance(manager.get_setting("llm.provider"), dict)
manager.import_settings(
manager.default_settings, overwrite=False, override_locked=True
)
stored_value = (
session.query(Setting.value)
.filter(Setting.key == "llm.provider")
.scalar()
)
assert stored_value == "openai"
def test_reconciliation_restores_a_missing_row_with_child_rows(
self, session
):
"""A missing row is re-seeded from its default, not its children."""
from local_deep_research.database.models import Setting, SettingType
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
key = "search.iterations"
default_value = manager.default_settings[key]["value"]
session.query(Setting).filter(Setting.key == key).delete()
session.add(
Setting(
key=f"{key}.extra",
value="x",
type=SettingType.SEARCH,
name="Extra",
ui_element="text",
)
)
session.commit()
manager.import_settings(
manager.default_settings, overwrite=False, override_locked=True
)
stored_value = (
session.query(Setting.value).filter(Setting.key == key).scalar()
)
assert stored_value == default_value
def test_reconciliation_keeps_a_dict_row_next_to_its_child_keys(
self, session
):
"""A dict-valued row keeps its own value beside its shipped children."""
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
key = "search.engine.web.gutenberg"
stored = (
session.query(Setting.value).filter(Setting.key == key).scalar()
)
child_keys = [
row[0]
for row in session.query(Setting.key).all()
if row[0].startswith(f"{key}.")
]
assert isinstance(stored, dict)
assert child_keys
manager.import_settings(
manager.default_settings, overwrite=False, override_locked=True
)
stored_after = (
session.query(Setting.value).filter(Setting.key == key).scalar()
)
assert stored_after == stored
def test_fresh_install_seeds_every_default(self, session):
"""Every current default imports cleanly through the validated path.
Guards against a defaults regression where the shipped default for
a key fails its own schema and would brick fresh installs (e.g.
``app.theme``'s default before this fix's equal-to-default guard).
"""
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
defaults = manager.default_settings
seeded = {row[0] for row in session.query(Setting.key).all()}
missing = sorted(set(defaults) - seeded)
assert not missing, f"defaults dropped on fresh install: {missing}"
class TestInMemoryImportValidation:
"""InMemorySettingsManager.import_settings validation."""
@pytest.fixture
def manager(self):
from local_deep_research.api.settings_utils import (
InMemorySettingsManager,
)
return InMemorySettingsManager()
def test_import_rejects_stale_value_for_known_key(self, manager):
"""Stale export values are skipped for keys in current defaults."""
manager.import_settings(
{
"search.time_period": {
"value": "stale_legacy_value",
"ui_element": "select",
"options": ["stale_legacy_value"],
},
},
overwrite=True,
)
# Known key: stale value skipped, loaded default untouched.
assert (
manager._settings["search.time_period"]["value"]
== manager._base_manager.default_settings["search.time_period"][
"value"
]
)
def test_import_accepts_valid_value_for_known_key(self, manager):
manager.import_settings(
{
"search.time_period": {
"value": "w",
"ui_element": "select",
"options": ["d", "w", "m", "y", "all"],
},
},
overwrite=True,
)
assert manager._settings["search.time_period"]["value"] == "w"
def test_import_rejects_uncoercible_number(self, manager):
manager.import_settings(
{
"app.max_concurrent_researches": {
"value": "not-a-number",
"ui_element": "number",
},
},
overwrite=True,
)
assert manager._settings["app.max_concurrent_researches"]["value"] == 3
def test_unknown_keys_import_without_validation(self, manager):
"""Keys outside defaults keep the documented custom-key behavior."""
manager.import_settings(
{
"custom.unknown_key": {
"value": "anything",
"ui_element": "select",
"options": ["anything"],
},
},
overwrite=True,
)
assert manager._settings["custom.unknown_key"]["value"] == "anything"
def test_bare_scalar_import_for_known_key_unchanged(self, manager):
"""Bare-scalar imports stay metadata-free and unvalidated."""
manager.import_settings({"search.time_period": "w"}, overwrite=True)
assert manager._settings["search.time_period"] == "w"
def test_delete_extra_with_invalid_value_keeps_default(self, manager):
"""delete_extra=True + invalid file value keeps the prior entry.
Mirrors the DB manager, where a rejected key keeps its existing
row: without this, an invalid file value plus delete_extra would
leave the key absent entirely — worse than keeping the default.
"""
manager.import_settings(
{
"search.time_period": {
"value": "stale_legacy_value",
"ui_element": "select",
"options": ["stale_legacy_value"],
},
},
delete_extra=True,
)
# The loaded default survives; the invalid file value did not win.
assert (
manager._settings["search.time_period"]["value"]
== manager._base_manager.default_settings["search.time_period"][
"value"
]
)
class TestDynamicSettingsSingleSource:
"""DYNAMIC_SETTINGS identity across import orders stays intact."""
def test_manager_is_source_of_truth(self):
from local_deep_research.settings import manager as manager_module
from local_deep_research.web.services import settings_service
assert (
settings_service.DYNAMIC_SETTINGS is manager_module.DYNAMIC_SETTINGS
)
class TestValidateImportedSettingValueSingleSource:
"""validate_imported_setting_value identity across import orders stays
intact (#5664) — mirrors TestDynamicSettingsSingleSource above."""
def test_api_settings_utils_is_source_of_truth(self):
from local_deep_research.api import settings_utils
from local_deep_research.settings import manager as manager_module
assert (
settings_utils.validate_imported_setting_value
is manager_module.validate_imported_setting_value
)
class TestUnknownUiElementImport:
"""Unsupported schemas are rejected without selecting another value."""
UNKNOWN_KEY = "app.future_knob"
UNKNOWN_META = {
"value": "shipped_default",
"type": "APP",
"name": "Future Knob",
"ui_element": "future_widget",
}
@pytest.fixture
def session(self):
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from local_deep_research.database.models import Base
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
session = sessionmaker(bind=engine)()
yield session
session.close()
engine.dispose()
@pytest.mark.parametrize("value", ["user_choice", "shipped_default"])
def test_unknown_ui_element_is_rejected(self, value):
from local_deep_research.settings.manager import (
validate_imported_setting_value,
)
assert (
validate_imported_setting_value(
self.UNKNOWN_KEY, value, dict(self.UNKNOWN_META)
)
== "Unsupported setting type"
)
def test_import_reports_unsupported_schema_without_storing_value(
self, session, loguru_caplog
):
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
manager = SettingsManager(db_session=session)
manager.default_settings = {
**manager.default_settings,
self.UNKNOWN_KEY: dict(self.UNKNOWN_META),
}
with loguru_caplog.at_level("WARNING"):
manager.import_settings(
{
self.UNKNOWN_KEY: {
**self.UNKNOWN_META,
"value": "user_choice",
}
},
overwrite=True,
)
assert "Unsupported setting type" in loguru_caplog.text
assert "user_choice" not in loguru_caplog.text
assert (
session.query(Setting).filter_by(key=self.UNKNOWN_KEY).first()
is None
)
def test_unknown_type_read_cannot_return_default(self):
from local_deep_research.settings.exceptions import SettingsValueError
from local_deep_research.settings.manager import get_typed_setting_value
with pytest.raises(
SettingsValueError, match="unsupported setting type"
) as caught:
get_typed_setting_value(
key=self.UNKNOWN_KEY,
value="user_choice",
ui_element="future_widget",
default="the_default",
check_env=False,
)
assert "user_choice" not in str(caught.value)
assert caught.value.__context__ is None
class TestImportSkipWarningNeverLogsValue:
"""The invalid-import skip WARNING must not interpolate the value.
#6201 changed this sink (``SettingsManager.import_settings``) from
logging the raw ``setting_values.get('value')`` to logging only its
type name. Round 8 / B3: that change had NO direct regression test
on this call path, so restoring the raw value passed every test in
this file. An imported value is exactly as plausible a secret
carrier as a stored one (a pre-upgrade export can carry an API key
under any key name), and the skip line fires at WARNING on every
rejected entry.
EXACT REVERT THIS CATCHES: restoring
``logger.warning("Skipping import of setting {!r}: value {!r} is "
"invalid under the current defaults schema - {}", key,
"setting_values.get('value'), invalid_reason)`` in
``settings/manager.py::import_settings`` -- the repr of the secret
then reaches the captured log.
The POSITIVE CONTROL is not optional (the package disables its own
loguru namespace at import): the skip WARNING itself, naming the
key, is the control line.
"""
KEY = "app.probe_import_sink_round8"
META = {
"value": "adaptive",
"type": "APP",
"name": "Probe Import Sink",
"ui_element": "select",
"options": [{"value": "adaptive"}, {"value": "strict"}],
}
@pytest.fixture
def session(self):
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from local_deep_research.database.models import Base
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
yield session
session.close()
engine.dispose()
def test_rejected_secret_value_never_logged(self, session, loguru_caplog):
from local_deep_research.database.models import Setting
from local_deep_research.settings.manager import SettingsManager
secret = "sk-live-import-must-not-reach-the-log-6201"
manager = SettingsManager(db_session=session)
manager.default_settings = {
**manager.default_settings,
self.KEY: dict(self.META),
}
with loguru_caplog.at_level("WARNING"):
manager.import_settings(
{self.KEY: {**self.META, "value": secret}},
overwrite=True,
)
# POSITIVE CONTROL: the skip fired, reached the sink, and names
# the key (the schema reason is built from the defaults metadata,
# never from the imported value).
assert "Skipping import of setting" in loguru_caplog.text
assert self.KEY in loguru_caplog.text
# The value itself -- a distinct secret fixture -- must not
# appear anywhere in the captured text.
assert secret not in loguru_caplog.text
# The line still carries the kept diagnostic: the value's TYPE
# name, so a bad row stays diagnosable without disclosure.
assert "str" in loguru_caplog.text
# Behavior pin: a rejected entry is skipped, not stored.
stored = session.query(Setting).filter(Setting.key == self.KEY).first()
assert stored is None