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.

6.2 KB
Raw Blame
"""
Tests for InMemorySettingsManager.get_settings_snapshot() and import_settings()
in api/settings_utils.py.

Tests cover:
- get_settings_snapshot: typed extraction, invalid stored shapes, missing optional values
- import_settings: overwrite=True, overwrite=False, delete_extra, type handling, empty
"""

from unittest.mock import patch, MagicMock

import pytest

from local_deep_research.settings.exceptions import SettingsValueError


def _make_manager_with_settings(settings_dict):
    """Create an InMemorySettingsManager with pre-loaded settings (no disk I/O)."""
    with patch(
        "local_deep_research.api.settings_utils.InMemorySettingsManager.__init__",
        lambda self: None,
    ):
        from local_deep_research.api.settings_utils import (
            InMemorySettingsManager,
        )

        mgr = InMemorySettingsManager()
        mgr._settings = settings_dict.copy()
        mgr._base_manager = MagicMock()
        mgr._base_manager.default_settings = {}
        return mgr


class TestGetSettingsSnapshot:
    """Tests for get_settings_snapshot()."""

    def test_full_format_extracts_value(self):
        """Dict-with-value entries → snapshot has just the value."""
        mgr = _make_manager_with_settings(
            {"key1": {"value": 42, "ui_element": "number"}}
        )
        snapshot = mgr.get_settings_snapshot()
        assert snapshot["key1"] == 42

    def test_scalar_store_entry_raises_but_remains_exportable(self):
        mgr = _make_manager_with_settings({"key1": "simple_value"})
        with pytest.raises(SettingsValueError, match="key1"):
            mgr.get_settings_snapshot()
        assert mgr.get_all_settings(include_environment_overrides=False) == {
            "key1": "simple_value"
        }

    def test_bad_entry_does_not_return_partial_snapshot(self):
        original = {
            "full_key": {"value": True, "ui_element": "checkbox"},
            "simple_key": 100,
        }
        mgr = _make_manager_with_settings(original)
        with pytest.raises(SettingsValueError, match="simple_key"):
            mgr.get_settings_snapshot()
        assert mgr._settings == original

    def test_missing_optional_value_keeps_its_metadata(self):
        original = {"optional": {"ui_element": "text"}}
        mgr = _make_manager_with_settings(original)
        assert mgr.get_setting("optional") is None
        assert mgr.get_settings_snapshot() == original

    def test_empty_settings(self):
        """Empty settings → empty snapshot."""
        mgr = _make_manager_with_settings({})
        assert mgr.get_settings_snapshot() == {}

    def test_none_value_in_full_format(self):
        """Full format with value=None → snapshot has None."""
        mgr = _make_manager_with_settings(
            {"key": {"value": None, "ui_element": "text"}}
        )
        snapshot = mgr.get_settings_snapshot()
        assert snapshot["key"] is None

    def test_snapshot_is_independent_copy(self):
        """Modifying snapshot doesn't affect internal settings."""
        mgr = _make_manager_with_settings(
            {"key": {"value": "original", "ui_element": "text"}}
        )
        snapshot = mgr.get_settings_snapshot()
        snapshot["key"] = "modified"
        # Internal still has original value
        assert mgr._settings["key"]["value"] == "original"

    def test_list_value(self):
        """Full format with list value → snapshot has the list."""
        mgr = _make_manager_with_settings(
            {"key": {"value": [1, 2, 3], "ui_element": "json"}}
        )
        snapshot = mgr.get_settings_snapshot()
        assert snapshot["key"] == [1, 2, 3]


class TestImportSettings:
    """Tests for import_settings()."""

    def test_import_overwrites_existing(self):
        """overwrite=True replaces existing settings."""
        mgr = _make_manager_with_settings({"key1": "old_value"})
        mgr.import_settings({"key1": "new_value"}, overwrite=True)
        assert mgr._settings["key1"] == "new_value"

    def test_import_no_overwrite_skips_existing(self):
        """overwrite=False skips keys that already exist."""
        mgr = _make_manager_with_settings({"key1": "original"})
        mgr.import_settings({"key1": "ignored", "key2": "new"}, overwrite=False)
        assert mgr._settings["key1"] == "original"
        assert mgr._settings["key2"] == "new"

    def test_import_adds_new_keys(self):
        """New keys are always added regardless of overwrite flag."""
        mgr = _make_manager_with_settings({})
        mgr.import_settings({"new_key": "value"}, overwrite=False)
        assert mgr._settings["new_key"] == "value"

    def test_delete_extra_clears_first(self):
        """delete_extra=True clears existing settings before importing."""
        mgr = _make_manager_with_settings({"old_key": "old_value"})
        mgr.import_settings({"new_key": "new_value"}, delete_extra=True)
        assert "old_key" not in mgr._settings
        assert mgr._settings["new_key"] == "new_value"

    def test_delete_extra_false_preserves(self):
        """delete_extra=False preserves existing settings."""
        mgr = _make_manager_with_settings({"old_key": "old_value"})
        mgr.import_settings({"new_key": "new_value"}, delete_extra=False)
        assert "old_key" in mgr._settings
        assert "new_key" in mgr._settings

    def test_import_full_format_with_type_conversion(self):
        """Full format values are converted by the real import path."""
        mgr = _make_manager_with_settings({})
        mgr.import_settings(
            {"key": {"value": "42", "ui_element": "number"}}, overwrite=True
        )
        assert mgr._settings["key"]["value"] == 42
        assert type(mgr.get_setting("key")) is int

    def test_import_simple_value_no_type_conversion(self):
        """Simple (non-dict) values are stored as-is without type conversion."""
        mgr = _make_manager_with_settings({})
        mgr._get_typed_value = MagicMock()
        mgr.import_settings({"key": "plain_string"}, overwrite=True)
        mgr._get_typed_value.assert_not_called()
        assert mgr._settings["key"] == "plain_string"

    def test_import_empty_dict(self):
        """Importing empty dict changes nothing."""
        mgr = _make_manager_with_settings({"existing": "value"})
        mgr.import_settings({})
        assert mgr._settings["existing"] == "value"