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.

12.4 KB
Raw Blame
"""Manager-facing environment reads reject invalid configured values."""

import traceback

import pytest

from local_deep_research.settings.env_registry import (
    registry as shipped_registry,
)
from local_deep_research.settings.env_settings import (
    BooleanSetting,
    EnumSetting,
    EnvSetting,
    IntegerSetting,
    PathSetting,
    SecretSetting,
    SettingsRegistry,
    StringSetting,
)
from local_deep_research.settings.exceptions import SettingsValueError


def registry_with(setting):
    registry = SettingsRegistry()
    registry.register_category("strict", [setting])
    return registry


@pytest.mark.parametrize(
    "raw", ["not-an-integer", "1.5", "NaN", "inf", "0", "11"]
)
def test_invalid_integer_never_selects_another_value(monkeypatch, raw):
    setting = IntegerSetting(
        "strict.integer", "integer", default=5, min_value=1, max_value=10
    )
    registry = registry_with(setting)
    monkeypatch.setenv(setting.env_var, raw)

    with pytest.raises(SettingsValueError) as error:
        registry.get_strict(setting.key, default=9)

    assert error.value.key == setting.key
    assert error.value.source == "environment"
    assert error.value.__cause__ is None
    assert error.value.__context__ is None


@pytest.mark.parametrize("raw", ["", " \t"])
@pytest.mark.parametrize("strict_digits", [False, True])
@pytest.mark.parametrize("registered_default", [None, 5])
def test_blank_integer_is_unset_for_managed_and_bootstrap_reads(
    monkeypatch, raw, strict_digits, registered_default
):
    # Main's orchestrator compatibility applies to all integer readers,
    # including settings that opt into trust-boundary validation.
    setting = IntegerSetting(
        "strict.integer",
        "integer",
        default=registered_default,
        min_value=1,
        max_value=10,
        strict_digits=strict_digits,
        raise_on_validation_error=True,
    )
    registry = registry_with(setting)
    monkeypatch.setenv(setting.env_var, raw)

    expected = registered_default if registered_default is not None else 9
    assert setting.get_value() == registered_default
    assert registry.get(setting.key, default=9) == expected
    assert registry.get_strict(setting.key, default=9) == expected


@pytest.mark.parametrize(
    "raw, expected", [("1", 1), ("10", 10), (" +05 ", 5), ("1_0", 10)]
)
def test_valid_integer_and_boundaries_keep_their_values(
    monkeypatch, raw, expected
):
    setting = IntegerSetting(
        "strict.integer", "integer", default=5, min_value=1, max_value=10
    )
    monkeypatch.setenv(setting.env_var, raw)
    assert registry_with(setting).get_strict(setting.key) == expected


@pytest.mark.parametrize(
    "raw, expected",
    [
        ("true", True),
        (" TRUE ", True),
        ("1", True),
        ("yes", True),
        ("on", True),
        ("enabled", True),
        ("false", False),
        (" FALSE ", False),
        ("0", False),
        ("no", False),
        ("off", False),
        ("disabled", False),
        ("", False),
    ],
)
def test_explicit_boolean_tokens(monkeypatch, raw, expected):
    setting = BooleanSetting("strict.boolean", "boolean", default=not expected)
    monkeypatch.setenv(setting.env_var, raw)
    assert registry_with(setting).get_strict(setting.key) is expected


@pytest.mark.parametrize("raw", ["tru", "2", "not-false"])
def test_unknown_boolean_is_an_error_instead_of_false(monkeypatch, raw):
    setting = BooleanSetting("strict.boolean", "boolean", default=False)
    monkeypatch.setenv(setting.env_var, raw)
    with pytest.raises(SettingsValueError):
        registry_with(setting).get_strict(setting.key, default=False)


@pytest.mark.parametrize("raw", ["unexpected-sensitive-value", ""])
def test_invalid_enum_does_not_disclose_value_or_return_default(
    monkeypatch, raw
):
    setting = EnumSetting(
        "strict.enum", "enum", {"WAL", "DELETE"}, default="WAL"
    )
    monkeypatch.setenv(setting.env_var, raw)
    with pytest.raises(SettingsValueError) as error:
        registry_with(setting).get_strict(setting.key, default="DELETE")

    assert error.value.__context__ is None
    assert "InvalidEnvironmentValueError" not in "".join(
        traceback.format_exception(error.value)
    )
    if raw:
        assert raw not in str(error.value)


def test_case_insensitive_enum_keeps_canonical_value(monkeypatch):
    setting = EnumSetting(
        "strict.enum", "enum", {"WAL", "DELETE"}, default="DELETE"
    )
    monkeypatch.setenv(setting.env_var, "wAl")
    assert registry_with(setting).get_strict(setting.key) == "WAL"


@pytest.mark.parametrize("setting_type", [StringSetting, SecretSetting])
def test_missing_required_setting_is_an_error(monkeypatch, setting_type):
    setting = setting_type("strict.required", "required", required=True)
    monkeypatch.delenv(setting.env_var, raising=False)
    with pytest.raises(SettingsValueError) as error:
        registry_with(setting).get_strict(setting.key, default="caller-default")
    assert error.value.source == "default"


@pytest.mark.parametrize("setting_type", [StringSetting, SecretSetting])
@pytest.mark.parametrize("raw", ["", "  keep whitespace  "])
def test_string_values_are_not_reinterpreted(monkeypatch, setting_type, raw):
    setting = setting_type("strict.string", "string", default="registered")
    monkeypatch.setenv(setting.env_var, raw)
    assert registry_with(setting).get_strict(setting.key, "caller") == raw


def test_legacy_alias_and_canonical_precedence(monkeypatch):
    setting = IntegerSetting(
        "strict.alias", "alias", default=5, deprecated_env_var="LDR_STRICT_OLD"
    )
    registry = registry_with(setting)
    monkeypatch.delenv(setting.env_var, raising=False)
    monkeypatch.setenv("LDR_STRICT_OLD", "7")
    assert registry.get_strict(setting.key) == 7

    monkeypatch.setenv(setting.env_var, "9")
    assert registry.get_strict(setting.key) == 9

    monkeypatch.setenv(setting.env_var, "invalid-canonical")
    with pytest.raises(SettingsValueError):
        registry.get_strict(setting.key, default=11)

    assert registry.get_strict(setting.key, check_env=False) == 5


def test_invalid_legacy_alias_is_not_replaced_by_a_default(monkeypatch):
    setting = IntegerSetting(
        "strict.alias", "alias", default=5, deprecated_env_var="LDR_STRICT_OLD"
    )
    monkeypatch.delenv(setting.env_var, raising=False)
    monkeypatch.setenv("LDR_STRICT_OLD", "invalid-legacy")
    with pytest.raises(SettingsValueError) as error:
        registry_with(setting).get_strict(setting.key, default=9)
    assert error.value.source == "environment"


@pytest.mark.parametrize("raw", ["", " \t"])
def test_blank_canonical_integer_does_not_select_deprecated_alias(
    monkeypatch, raw
):
    setting = IntegerSetting(
        "strict.alias", "alias", default=5, deprecated_env_var="LDR_STRICT_OLD"
    )
    registry = registry_with(setting)
    monkeypatch.setenv("LDR_STRICT_OLD", "7")
    monkeypatch.setenv(setting.env_var, raw)

    assert registry.get_strict(setting.key, default=9) == 5
    assert registry.get(setting.key, default=9) == 5
    monkeypatch.delenv(setting.env_var)
    assert registry.get_strict(setting.key, default=9) == 7


def test_optional_and_unknown_missing_values_retain_defaults(monkeypatch):
    setting = StringSetting("strict.optional", "optional")
    monkeypatch.delenv(setting.env_var, raising=False)
    registry = registry_with(setting)
    sentinel = object()
    assert registry.get_strict(setting.key) is None
    assert registry.get_strict(setting.key, sentinel) is sentinel
    assert registry.get_strict("strict.unknown", sentinel) is sentinel


def test_all_shipped_defaults_work_without_reading_environment(monkeypatch):
    sentinel = object()

    def unexpected_lookup():
        pytest.fail("check_env=False attempted to read the environment")

    for key in shipped_registry.list_all_settings():
        setting = shipped_registry.get_setting_object(key)
        monkeypatch.setattr(setting, "_get_raw_value", unexpected_lookup)
        expected = setting.default if setting.default is not None else sentinel
        result = shipped_registry.get_strict(key, sentinel, check_env=False)
        assert result == expected, key
        assert type(result) is type(expected), key


def test_path_is_not_created_or_read_when_environment_is_disabled(
    monkeypatch, tmp_path
):
    target = tmp_path / "new-directory"
    setting = PathSetting("strict.path", "path", create_if_missing=True)
    registry = registry_with(setting)
    monkeypatch.setenv(setting.env_var, str(target))

    assert registry.get_strict(setting.key, check_env=False) is None
    assert (
        registry.get_strict(setting.key, "caller", check_env=False) == "caller"
    )
    assert not target.exists()

    assert registry.get_strict(setting.key) == str(target)
    assert target.is_dir()


def test_path_expansion_is_preserved(monkeypatch, tmp_path):
    setting = PathSetting("strict.path", "path", must_exist=True)
    monkeypatch.setenv("STRICT_TEST_PATH_BASE", str(tmp_path))
    monkeypatch.setenv(setting.env_var, "$STRICT_TEST_PATH_BASE")
    assert registry_with(setting).get_strict(setting.key) == str(tmp_path)


@pytest.mark.parametrize("raw", ["", "  "])
def test_empty_path_is_invalid(monkeypatch, raw):
    setting = PathSetting("strict.path", "path", create_if_missing=True)
    monkeypatch.setenv(setting.env_var, raw)
    with pytest.raises(SettingsValueError):
        registry_with(setting).get_strict(setting.key, default="caller")


def test_missing_required_path_is_not_replaced(monkeypatch, tmp_path):
    setting = PathSetting("strict.path", "path", must_exist=True)
    monkeypatch.setenv(setting.env_var, str(tmp_path / "missing-private-path"))
    with pytest.raises(SettingsValueError) as error:
        registry_with(setting).get_strict(setting.key, default=str(tmp_path))
    assert "missing-private-path" not in str(error.value)
    assert error.value.__context__ is None


def test_existing_file_cannot_be_used_as_a_directory(monkeypatch, tmp_path):
    target = tmp_path / "a-file"
    target.write_text("data")
    setting = PathSetting("strict.path", "path", create_if_missing=True)
    monkeypatch.setenv(setting.env_var, str(target))
    with pytest.raises(SettingsValueError):
        registry_with(setting).get_strict(setting.key, default=str(tmp_path))
    assert target.read_text() == "data"


@pytest.mark.parametrize("failure", ["os", "security"])
def test_directory_creation_failure_is_explicit_and_safe(
    monkeypatch, tmp_path, failure
):
    from local_deep_research.security import directory_creation

    setting = PathSetting("strict.path", "path", create_if_missing=True)
    private_path = tmp_path / "private-path-marker"
    monkeypatch.setenv(setting.env_var, str(private_path))

    def denied(*args, **kwargs):
        error_type = (
            PermissionError
            if failure == "os"
            else directory_creation.DirectoryCreationSecurityError
        )
        raise error_type(f"private-error-marker: {private_path}")

    monkeypatch.setattr(directory_creation, "create_directory", denied)
    with pytest.raises(SettingsValueError) as error:
        registry_with(setting).get_strict(setting.key, default=str(tmp_path))

    rendered = "".join(traceback.format_exception(error.value))
    assert "private-error-marker" not in rendered
    assert "private-path-marker" not in rendered
    assert error.value.__cause__ is None
    assert error.value.__context__ is None
    assert not private_path.exists()


def test_unknown_setting_type_is_rejected_without_invoking_converter(
    monkeypatch,
):
    class UnknownSetting(EnvSetting[str]):
        def _convert_value(self, raw, **kwargs):
            pytest.fail("unsupported converter was invoked")

    setting = UnknownSetting("strict.unknown_type", "unknown")
    monkeypatch.setenv(setting.env_var, "private-value-marker")
    with pytest.raises(SettingsValueError) as error:
        registry_with(setting).get_strict(setting.key, default="caller")
    assert "unsupported" in str(error.value)
    assert "private-value-marker" not in str(error.value)


def test_legacy_bootstrap_reader_keeps_its_existing_contract(monkeypatch):
    integer = IntegerSetting("strict.integer", "integer", default=5)
    boolean = BooleanSetting("strict.boolean", "boolean", default=True)
    registry = SettingsRegistry()
    registry.register_category("legacy", [integer, boolean])
    monkeypatch.setenv(integer.env_var, "invalid")
    monkeypatch.setenv(boolean.env_var, "invalid")
    assert registry.get(integer.key, default=9) == 5
    assert registry.get(boolean.key, default=True) is False