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.

20.0 KB
Raw Blame
"""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"}