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.

9.8 KB
Raw Blame
from inspect import signature
from typing import Any
from unittest.mock import PropertyMock, patch

import pytest

from local_deep_research.api.settings_utils import InMemorySettingsManager
from local_deep_research.settings.base import ISettingsManager
from local_deep_research.settings.manager import SettingsManager
from local_deep_research.settings.exceptions import SettingsValueError


@pytest.fixture
def default_settings() -> dict[str, Any]:
    return {
        "app.port": {
            "value": 5000,
            "ui_element": "number",
            "editable": True,
            "description": "Server port",
        },
        "policy.egress_scope": {
            "value": "strict",
            "ui_element": "select",
            "editable": True,
            "description": "Stored egress policy",
            "options": ["adaptive", "strict", "public_only"],
        },
    }


def make_manager(default_settings: dict[str, Any]) -> InMemorySettingsManager:
    with patch.object(
        SettingsManager,
        "default_settings",
        new_callable=PropertyMock,
        return_value=default_settings,
    ):
        return InMemorySettingsManager()


def test_get_setting_uses_current_environment_value_after_manager_initialization(
    monkeypatch, default_settings
):
    # Given
    monkeypatch.setenv("LDR_APP_PORT", "8080")
    manager = make_manager(default_settings)
    monkeypatch.setenv("LDR_APP_PORT", "9090")

    # When
    value = manager.get_setting("app.port")

    # Then
    assert value == 9090
    assert manager.get_setting("app.port", check_env=False) == 5000


def test_get_setting_reveals_canonical_value_after_environment_override_removed(
    monkeypatch, default_settings
):
    # Given
    monkeypatch.setenv("LDR_APP_PORT", "8080")
    manager = make_manager(default_settings)
    monkeypatch.delenv("LDR_APP_PORT")

    # When
    value = manager.get_setting("app.port")

    # Then
    assert value == 5000


def test_get_all_settings_without_environment_overrides_returns_baseline_metadata(
    monkeypatch, default_settings
):
    # Given
    monkeypatch.setenv("LDR_APP_PORT", "8080")
    manager = make_manager(default_settings)

    # When
    baseline = manager.get_all_settings(include_environment_overrides=False)

    # Then
    assert baseline["app.port"]["value"] == 5000
    assert baseline["app.port"]["editable"] is True
    assert manager._settings["app.port"]["value"] == 5000


def test_get_all_settings_applies_current_environment_overlay_to_returned_copy(
    monkeypatch, default_settings
):
    # Given
    monkeypatch.setenv("LDR_APP_PORT", "8080")
    manager = make_manager(default_settings)
    monkeypatch.setenv("LDR_APP_PORT", "9090")

    # When
    effective = manager.get_all_settings()

    # Then
    assert effective["app.port"]["value"] == 9090
    assert effective["app.port"]["editable"] is False
    assert manager._settings["app.port"]["value"] == 5000
    assert manager._settings["app.port"]["editable"] is True


def test_get_settings_snapshot_remains_environment_aware_by_default(
    monkeypatch, default_settings
):
    # Given
    monkeypatch.setenv("LDR_APP_PORT", "8080")
    manager = make_manager(default_settings)

    # When
    snapshot = manager.get_settings_snapshot()

    # Then
    assert snapshot["app.port"] == 8080


def test_import_preserves_stored_baseline_and_refreshes_locked_metadata(
    monkeypatch, default_settings
):
    # Given
    monkeypatch.setenv("LDR_POLICY_EGRESS_SCOPE", "adaptive")
    manager = make_manager(default_settings)
    imported = {
        "policy.egress_scope": {
            "value": "public_only",
            "ui_element": "select",
            "editable": True,
            "description": "Fresh egress policy",
            "options": ["adaptive", "strict", "public_only"],
        }
    }

    # When
    manager.import_settings(imported, preserve_environment_locked=True)

    # Then
    baseline = manager.get_all_settings(include_environment_overrides=False)
    assert baseline["policy.egress_scope"]["value"] == "strict"
    assert (
        baseline["policy.egress_scope"]["description"] == "Fresh egress policy"
    )
    assert baseline["policy.egress_scope"]["options"] == [
        "adaptive",
        "strict",
        "public_only",
    ]
    assert manager.get_setting("policy.egress_scope") == "adaptive"


def test_preserved_value_does_not_validate_ignored_import_input(
    monkeypatch, default_settings
):
    manager = make_manager(default_settings)
    monkeypatch.setenv("LDR_APP_PORT", "8080")
    manager.import_settings(
        {
            "app.port": {
                "value": "invalid-ignored-input",
                "ui_element": "number",
                "description": "Updated description",
            }
        },
        preserve_environment_locked=True,
    )
    exported = manager.get_all_settings(include_environment_overrides=False)
    assert exported["app.port"]["value"] == 5000
    assert exported["app.port"]["description"] == "Updated description"
    assert manager.get_setting("app.port") == 8080
    assert manager.get_setting("app.port", check_env=False) == 5000


def test_load_defaults_preserves_stored_baseline_and_refreshes_locked_metadata(
    monkeypatch, default_settings
):
    # Given
    monkeypatch.setenv("LDR_POLICY_EGRESS_SCOPE", "adaptive")
    manager = make_manager(default_settings)
    refreshed_defaults = {
        **default_settings,
        "policy.egress_scope": {
            "value": "public_only",
            "ui_element": "select",
            "editable": True,
            "description": "Refreshed egress policy",
            "options": ["adaptive", "strict", "public_only"],
        },
    }

    # When
    with patch.object(
        SettingsManager,
        "default_settings",
        new_callable=PropertyMock,
        return_value=refreshed_defaults,
    ):
        manager.load_from_defaults_file(preserve_environment_locked=True)

    # Then
    baseline = manager.get_all_settings(include_environment_overrides=False)
    assert baseline["policy.egress_scope"]["value"] == "strict"
    assert (
        baseline["policy.egress_scope"]["description"]
        == "Refreshed egress policy"
    )
    assert manager.get_setting("policy.egress_scope") == "adaptive"


def test_import_uses_canonical_value_for_environment_locked_key_absent_from_storage(
    monkeypatch, default_settings
):
    # Given
    monkeypatch.setenv("LDR_POLICY_NEW_SCOPE", "operator-value")
    manager = make_manager(default_settings)
    imported = {
        "policy.new_scope": {
            "value": "canonical-value",
            "ui_element": "text",
            "editable": True,
            "description": "New policy scope",
        }
    }

    # When
    manager.import_settings(imported, preserve_environment_locked=True)

    # Then
    baseline = manager.get_all_settings(include_environment_overrides=False)
    assert baseline["policy.new_scope"]["value"] == "canonical-value"
    assert manager.get_setting("policy.new_scope") == "operator-value"


def test_import_of_bare_scalar_keeps_environment_locked_entry_intact(
    monkeypatch, default_settings
):
    # Given a bare-scalar import (a supported settings_data shape) for a
    # key that is stored and environment-locked
    monkeypatch.setenv("LDR_APP_PORT", "8080")
    manager = make_manager(default_settings)

    # When
    manager.import_settings(
        {"app.port": 9999}, preserve_environment_locked=True
    )

    # Then the stored entry survives untouched (no metadata to merge)
    baseline = manager.get_all_settings(include_environment_overrides=False)
    assert baseline["app.port"]["value"] == 5000
    assert baseline["app.port"]["ui_element"] == "number"
    assert manager.get_setting("app.port") == 8080


def test_import_of_bare_scalar_still_replaces_unlocked_entry(
    monkeypatch, default_settings
):
    # Given no environment lock on the key
    monkeypatch.delenv("LDR_APP_PORT", raising=False)
    manager = make_manager(default_settings)

    # When
    manager.import_settings(
        {"app.port": 9999}, preserve_environment_locked=True
    )

    # Raw exports still expose the replaced value, but effective reads cannot
    # validate an entry that no longer carries type metadata.
    assert (
        manager.get_all_settings(include_environment_overrides=False)[
            "app.port"
        ]
        == 9999
    )
    with pytest.raises(SettingsValueError, match="app.port"):
        manager.get_all_settings()


def test_settings_managers_expose_environment_override_toggle():
    # Given
    methods = (
        ISettingsManager.get_all_settings,
        SettingsManager.get_all_settings,
        InMemorySettingsManager.get_all_settings,
    )

    # When
    parameters = [signature(method).parameters for method in methods]

    # Then
    assert all(
        "include_environment_overrides" in params for params in parameters
    )
    assert all(
        params["include_environment_overrides"].default is True
        for params in parameters
    )


def test_settings_managers_share_get_all_settings_parameter_order():
    parameter_names = [
        tuple(signature(method).parameters)
        for method in (
            ISettingsManager.get_all_settings,
            SettingsManager.get_all_settings,
            InMemorySettingsManager.get_all_settings,
        )
    ]

    assert parameter_names == [
        ("self", "bypass_cache", "include_environment_overrides", "strict"),
        ("self", "bypass_cache", "include_environment_overrides", "strict"),
        ("self", "bypass_cache", "include_environment_overrides", "strict"),
    ]


def test_positional_bypass_cache_does_not_disable_in_memory_environment_overlay(
    monkeypatch, default_settings
):
    monkeypatch.setenv("LDR_APP_PORT", "8080")
    manager = make_manager(default_settings)

    effective = manager.get_all_settings(False)

    assert effective["app.port"]["value"] == 8080