~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
"""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