~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 API settings utilities."""
from unittest.mock import PropertyMock, patch
import pytest
from local_deep_research.api.settings_utils import (
InMemorySettingsManager,
get_default_settings_snapshot,
create_settings_snapshot,
extract_setting_value,
)
from local_deep_research.settings.manager import SettingsManager
from local_deep_research.settings.exceptions import SettingsValueError
class TestInMemorySettingsManager:
"""Tests for InMemorySettingsManager class."""
def test_init_loads_defaults(self):
"""Test that initialization loads default settings."""
with patch.object(
InMemorySettingsManager, "_load_defaults"
) as mock_load:
InMemorySettingsManager()
mock_load.assert_called_once()
def test_get_setting_existing_key(self):
"""Test getting an existing setting."""
manager = InMemorySettingsManager()
# llm.provider should be in defaults
value = manager.get_setting("llm.provider")
assert value is not None
def test_get_setting_missing_key_returns_default(self):
"""Test getting a missing setting returns the default."""
manager = InMemorySettingsManager()
value = manager.get_setting("nonexistent.key", default="default_value")
assert value == "default_value"
def test_get_setting_none_default(self):
"""Test getting a missing setting with None default."""
manager = InMemorySettingsManager()
value = manager.get_setting("nonexistent.key")
assert value is None
def test_set_setting_existing_key(self):
"""Test setting an existing key."""
manager = InMemorySettingsManager()
result = manager.set_setting("llm.provider", "openai")
assert result is True
assert manager.get_setting("llm.provider") == "openai"
def test_set_setting_nonexistent_key(self):
"""Test setting a nonexistent key returns False."""
manager = InMemorySettingsManager()
result = manager.set_setting("nonexistent.key", "value")
assert result is False
def test_get_all_settings_returns_dict(self):
"""Test get_all_settings returns a dictionary."""
manager = InMemorySettingsManager()
settings = manager.get_all_settings()
assert isinstance(settings, dict)
assert len(settings) > 0
def test_get_all_settings_returns_copy(self):
"""Test get_all_settings returns a deep copy."""
manager = InMemorySettingsManager()
settings1 = manager.get_all_settings()
settings2 = manager.get_all_settings()
assert settings1 is not settings2
def test_create_or_update_setting_with_dict(self):
"""Test creating a setting from a dict."""
manager = InMemorySettingsManager()
setting = {
"key": "new.setting",
"value": "test_value",
"ui_element": "text",
}
result = manager.create_or_update_setting(setting)
assert result is not None
assert manager.get_setting("new.setting") == "test_value"
def test_create_or_update_setting_without_key(self):
"""Test creating a setting without key returns None."""
manager = InMemorySettingsManager()
result = manager.create_or_update_setting({"value": "test"})
assert result is None
def test_delete_setting_existing(self):
"""Test deleting an existing setting."""
manager = InMemorySettingsManager()
# First ensure it exists
manager.create_or_update_setting(
{"key": "temp.setting", "value": "temp", "ui_element": "text"}
)
assert manager.get_setting("temp.setting") == "temp"
result = manager.delete_setting("temp.setting")
assert result is True
assert manager.get_setting("temp.setting") is None
def test_delete_setting_nonexistent(self):
"""Test deleting a nonexistent setting returns False."""
manager = InMemorySettingsManager()
result = manager.delete_setting("nonexistent.key")
assert result is False
def test_import_settings_basic(self):
"""Test importing settings."""
manager = InMemorySettingsManager()
new_settings = {
"imported.setting": {
"value": "imported_value",
"ui_element": "text",
},
}
manager.import_settings(new_settings)
assert manager.get_setting("imported.setting") == "imported_value"
def test_import_settings_with_delete_extra(self):
"""Test importing with delete_extra clears existing settings."""
manager = InMemorySettingsManager()
original_count = len(manager.get_all_settings())
assert original_count > 0
manager.import_settings(
{"only.setting": {"value": "only", "ui_element": "text"}},
delete_extra=True,
)
settings = manager.get_all_settings()
assert len(settings) == 1
assert "only.setting" in settings
def test_import_preserves_environment_locked_setting_with_delete_extra(
self, monkeypatch
):
manager = InMemorySettingsManager()
manager.set_setting("policy.egress_scope", "strict")
monkeypatch.setenv("LDR_POLICY_EGRESS_SCOPE", "adaptive")
manager.import_settings(
{
"policy.egress_scope": {
"value": "public_only",
"ui_element": "select",
},
"only.setting": {"value": "only", "ui_element": "text"},
},
delete_extra=True,
preserve_environment_locked=True,
)
assert (
manager.get_setting("policy.egress_scope", check_env=False)
== "strict"
)
assert manager.get_setting("only.setting") == "only"
def test_import_preserves_locked_value_and_refreshes_metadata(
self, monkeypatch
):
manager = InMemorySettingsManager()
key = "policy.egress_scope"
manager._settings[key] = {
"value": "strict",
"description": "Stale description",
"options": ["legacy"],
"ui_element": "text",
"min_value": 1,
"max_value": 2,
}
monkeypatch.setenv("LDR_POLICY_EGRESS_SCOPE", "adaptive")
canonical = {
"value": "public_only",
"description": "Fresh description",
"options": ["adaptive", "strict", "public_only"],
"ui_element": "select",
"min_value": 0,
"max_value": 10,
}
manager.import_settings(
{key: canonical}, preserve_environment_locked=True
)
refreshed = manager.get_all_settings(
include_environment_overrides=False
)[key]
assert refreshed["value"] == "strict"
assert refreshed["description"] == "Fresh description"
assert refreshed["options"] == ["adaptive", "strict", "public_only"]
assert refreshed["ui_element"] == "select"
assert refreshed["min_value"] == 0
assert refreshed["max_value"] == 10
manager.import_settings(
{key: {**canonical, "value": "adaptive"}},
preserve_environment_locked=False,
)
assert manager.get_all_settings()[key]["value"] == "adaptive"
def test_import_settings_no_overwrite(self):
"""Test importing without overwriting existing settings."""
manager = InMemorySettingsManager()
manager.create_or_update_setting(
{"key": "existing", "value": "original", "ui_element": "text"}
)
manager.import_settings(
{"existing": {"value": "new_value", "ui_element": "text"}},
overwrite=False,
)
assert manager.get_setting("existing") == "original"
def test_get_typed_value_checkbox(self):
"""Test type conversion for checkbox."""
manager = InMemorySettingsManager()
setting_data = {"ui_element": "checkbox"}
assert manager._get_typed_value(setting_data, "true") is True
assert manager._get_typed_value(setting_data, "false") is False
assert manager._get_typed_value(setting_data, "1") is True
assert manager._get_typed_value(setting_data, "yes") is True
def test_get_typed_value_number(self):
"""Test type conversion for number."""
manager = InMemorySettingsManager()
setting_data = {"ui_element": "number"}
assert manager._get_typed_value(setting_data, "42") == 42.0
assert manager._get_typed_value(setting_data, "3.14") == 3.14
def test_get_typed_value_text(self):
"""Test type conversion for text."""
manager = InMemorySettingsManager()
setting_data = {"ui_element": "text"}
assert manager._get_typed_value(setting_data, 123) == "123"
assert manager._get_typed_value(setting_data, "hello") == "hello"
def test_get_typed_value_unknown_type(self):
"""Unknown ui_element is an explicit configuration error."""
manager = InMemorySettingsManager()
setting_data = {"ui_element": "unknown_type"}
with pytest.raises(SettingsValueError):
manager._get_typed_value(setting_data, "value")
def test_load_from_defaults_file(self):
"""Test that load_from_defaults_file reloads defaults."""
manager = InMemorySettingsManager()
# Modify a setting
manager.set_setting("llm.provider", "modified")
assert manager.get_setting("llm.provider") == "modified"
# Reload defaults
manager.load_from_defaults_file()
# Should be back to default
# (exact value depends on defaults file)
def test_load_from_defaults_file_refuses_the_override_locked_bypass(self):
"""``load_from_defaults_file`` deliberately does not accept
``**kwargs`` (see the ``ISettingsManager`` contract, #5841): the
in-memory store has no settings lock, so the ``override_locked``
bypass is meaningless here -- and now also structurally rejected,
mirroring ``SettingsManager.load_from_defaults_file``'s equivalent
refusal pinned by
``test_load_from_defaults_file_refuses_the_override_locked_bypass``
in ``tests/settings/test_settings_manager.py``. This is #5738's
``override_locked`` landing on ``delete_setting`` and
``import_settings``, not on this wrapper -- a regression here
would let a caller typed on ``ISettingsManager`` believe it can
smuggle the bypass through the wrapper again.
"""
manager = InMemorySettingsManager()
with pytest.raises(TypeError):
manager.load_from_defaults_file(**{"override_locked": True})
def test_load_from_defaults_preserves_locked_value_and_refreshes_metadata(
self, monkeypatch
):
manager = InMemorySettingsManager()
manager._settings["policy.egress_scope"] = {
"value": "strict",
"description": "Stale description",
"options": ["legacy"],
"ui_element": "text",
"min_value": 1,
"max_value": 2,
}
manager._settings["app.debug"] = {
"value": "stale unlocked value",
"description": "Stale unlocked description",
"ui_element": "text",
}
monkeypatch.setenv("LDR_POLICY_EGRESS_SCOPE", "adaptive")
defaults = {
"policy.egress_scope": {
"value": "public_only",
"description": "Fresh description",
"options": ["adaptive", "strict", "public_only"],
"ui_element": "select",
"min_value": 0,
"max_value": 10,
},
"app.debug": {
"value": "canonical unlocked value",
"description": "Fresh unlocked description",
"ui_element": "text",
},
}
with patch.object(
SettingsManager,
"default_settings",
new_callable=PropertyMock,
return_value=defaults,
):
manager.load_from_defaults_file(preserve_environment_locked=True)
locked = manager.get_all_settings(include_environment_overrides=False)[
"policy.egress_scope"
]
assert locked["value"] == "strict"
assert locked["description"] == "Fresh description"
assert locked["options"] == ["adaptive", "strict", "public_only"]
assert locked["ui_element"] == "select"
assert locked["min_value"] == 0
assert locked["max_value"] == 10
assert (
manager.get_all_settings()["app.debug"]["value"]
== "canonical unlocked value"
)
def test_env_var_override(self, monkeypatch):
"""Test that environment variables override defaults."""
monkeypatch.setenv("LDR_LLM_PROVIDER", "env_provider")
InMemorySettingsManager()
# Check if env var was applied (depends on implementation)
class TestGetDefaultSettingsSnapshot:
"""Tests for get_default_settings_snapshot function."""
def test_returns_dict(self):
"""Test that function returns a dictionary."""
snapshot = get_default_settings_snapshot()
assert isinstance(snapshot, dict)
def test_contains_core_settings(self):
"""Test that snapshot contains core settings."""
snapshot = get_default_settings_snapshot()
# Check for some expected keys
assert "llm.provider" in snapshot
assert "llm.temperature" in snapshot or "llm.model" in snapshot
def test_settings_have_value_key(self):
"""Test that settings have a 'value' key."""
snapshot = get_default_settings_snapshot()
for key, setting in snapshot.items():
if isinstance(setting, dict):
assert "value" in setting, f"Setting {key} missing 'value' key"
class TestCreateSettingsSnapshot:
"""Tests for create_settings_snapshot function."""
def test_returns_dict(self):
"""Test that function returns a dictionary."""
snapshot = create_settings_snapshot()
assert isinstance(snapshot, dict)
def test_without_overrides(self):
"""Test creating snapshot without overrides uses defaults."""
snapshot = create_settings_snapshot()
assert len(snapshot) > 0
def test_with_overrides_dict(self):
"""Test creating snapshot with overrides dict."""
snapshot = create_settings_snapshot(
overrides={"llm.provider": "openai"}
)
assert snapshot["llm.provider"]["value"] == "openai"
def test_with_overrides_as_first_arg(self):
"""Test creating snapshot with overrides as first positional arg."""
snapshot = create_settings_snapshot({"llm.provider": "anthropic"})
assert snapshot["llm.provider"]["value"] == "anthropic"
def test_with_custom_base_settings(self):
"""Test creating snapshot with custom base settings."""
base = {"custom.setting": {"value": "base_value", "ui_element": "text"}}
snapshot = create_settings_snapshot(base_settings=base)
assert "custom.setting" in snapshot
assert snapshot["custom.setting"]["value"] == "base_value"
def test_override_unknown_key(self):
"""Test overriding with unknown key creates new entry."""
snapshot = create_settings_snapshot(
overrides={"new.unknown.key": "new_value"}
)
assert "new.unknown.key" in snapshot
assert snapshot["new.unknown.key"]["value"] == "new_value"
def test_provider_kwarg(self):
"""Test provider kwarg shortcut."""
snapshot = create_settings_snapshot(provider="openai")
assert snapshot["llm.provider"]["value"] == "openai"
def test_provider_with_api_key_kwarg(self):
"""Test provider and api_key kwargs together."""
snapshot = create_settings_snapshot(
provider="openai", api_key="sk-test-key"
)
assert snapshot["llm.provider"]["value"] == "openai"
assert "llm.openai.api_key" in snapshot
assert snapshot["llm.openai.api_key"]["value"] == "sk-test-key"
def test_temperature_kwarg(self):
"""Test temperature kwarg shortcut."""
snapshot = create_settings_snapshot(temperature=0.5)
assert snapshot["llm.temperature"]["value"] == 0.5
def test_max_search_results_kwarg(self):
"""Test max_search_results kwarg shortcut."""
snapshot = create_settings_snapshot(max_search_results=50)
assert snapshot["search.max_results"]["value"] == 50
def test_infer_ui_element_bool(self):
"""Test ui_element inference for boolean values."""
snapshot = create_settings_snapshot(overrides={"new.bool": True})
assert snapshot["new.bool"]["ui_element"] == "checkbox"
def test_infer_ui_element_number(self):
"""Test ui_element inference for numeric values."""
snapshot = create_settings_snapshot(overrides={"new.number": 42})
assert snapshot["new.number"]["ui_element"] == "number"
def test_infer_ui_element_dict(self):
"""Test ui_element inference for dict values."""
snapshot = create_settings_snapshot(
overrides={"new.dict": {"nested": "value"}}
)
assert snapshot["new.dict"]["ui_element"] == "json"
def test_internal_underscore_keys_are_refused(self):
"""Internal underscore keys are refused."""
with pytest.raises(ValueError, match="internal snapshot key"):
create_settings_snapshot(overrides={"_username": "attacker"})
with pytest.raises(ValueError, match="internal snapshot key"):
create_settings_snapshot(
overrides={
"_openai_endpoint_key_owner_url": "https://attacker.example:443",
"llm.openai_endpoint.url": "https://attacker.example/v1",
}
)
def test_same_call_endpoint_key_matches_a_normalized_provider(self):
"""Same call endpoint key matches a normalized provider."""
for provider in (
"openai_endpoint",
"OPENAI_ENDPOINT",
"OpenAI_Endpoint ",
):
snapshot = create_settings_snapshot(
provider=provider,
api_key="sk-call-key",
overrides={
"llm.openai_endpoint.url": "http://localhost:8000/v1"
},
)
assert snapshot["llm.openai_endpoint.api_key"] == "sk-call-key"
assert (
snapshot["_openai_endpoint_key_owner_url"]
== "http://localhost:8000"
)
class TestExtractSettingValue:
"""Tests for extract_setting_value function."""
def test_extract_with_value_key(self):
"""Test extracting value from dict with 'value' key."""
snapshot = {"test.key": {"value": "test_value"}}
result = extract_setting_value(snapshot, "test.key")
assert result == "test_value"
def test_extract_direct_value(self):
"""Test extracting direct value (not dict)."""
snapshot = {"test.key": "direct_value"}
result = extract_setting_value(snapshot, "test.key")
assert result == "direct_value"
def test_extract_missing_key(self):
"""Test extracting missing key returns default."""
snapshot = {"other.key": {"value": "value"}}
result = extract_setting_value(
snapshot, "missing.key", default="default"
)
assert result == "default"
def test_extract_from_none_snapshot(self):
"""Test extracting from None snapshot returns default."""
result = extract_setting_value(None, "any.key", default="default")
assert result == "default"
def test_extract_default_none(self):
"""Test default value is None when not specified."""
snapshot = {}
result = extract_setting_value(snapshot, "missing.key")
assert result is None
def test_extract_nested_dict_value(self):
"""Test extracting value that is itself a dict."""
snapshot = {"complex.key": {"value": {"nested": "data"}}}
result = extract_setting_value(snapshot, "complex.key")
assert result == {"nested": "data"}