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.

10.0 KB
Raw Blame
"""Invalid configured values must stop work at consumer fallback boundaries."""

import json
from contextlib import nullcontext
from threading import RLock
from types import SimpleNamespace
from unittest.mock import Mock

import pytest

from local_deep_research.settings.exceptions import SettingsValueError


@pytest.fixture
def settings_error():
    return SettingsValueError(
        "llm.temperature", source="environment", reason="expected a number"
    )


@pytest.mark.parametrize("source", ["snapshot", "database"])
def test_search_config_does_not_replace_invalid_settings(
    monkeypatch, settings_error, source
):
    from local_deep_research.web_search_engines import search_engines_config

    reader = Mock(side_effect=settings_error)
    database_reader = Mock()
    manager = SimpleNamespace(get_setting=database_reader)
    manager_factory = Mock(return_value=manager)
    monkeypatch.setattr(
        search_engines_config, "get_setting_from_snapshot", reader
    )
    monkeypatch.setattr(
        search_engines_config, "get_settings_manager", manager_factory
    )
    if source == "database":
        database_reader.side_effect = settings_error

    with pytest.raises(SettingsValueError) as raised:
        search_engines_config._get_setting(
            "llm.temperature",
            default_value=0.7,
            db_session=object(),
            settings_snapshot={"present": True}
            if source == "snapshot"
            else None,
        )

    assert raised.value is settings_error
    if source == "snapshot":
        manager_factory.assert_not_called()


def test_availability_probe_does_not_treat_invalid_settings_as_available(
    monkeypatch, settings_error
):
    from local_deep_research.security import module_whitelist
    from local_deep_research.web_search_engines import search_engines_config
    from local_deep_research.web_search_engines.search_engine_base import (
        BaseSearchEngine,
    )

    class InvalidSettingsEngine(BaseSearchEngine):
        @classmethod
        def is_available(cls, settings_snapshot=None):
            raise settings_error

    monkeypatch.setattr(
        module_whitelist,
        "get_safe_module_class",
        lambda *args: InvalidSettingsEngine,
    )

    with pytest.raises(SettingsValueError) as raised:
        search_engines_config._engine_class_is_available(
            "probe",
            {"module_path": ".probe", "class_name": "Probe"},
            {"present": True},
        )

    assert raised.value is settings_error


def test_engine_constructor_error_does_not_become_a_default_engine(
    monkeypatch, settings_error
):
    from local_deep_research.security.egress import policy
    from local_deep_research.web_search_engines import search_engine_factory

    constructions = []

    class InvalidSettingsEngine:
        def __init__(self, settings_snapshot=None):
            constructions.append(settings_snapshot)
            raise settings_error

    monkeypatch.setattr(
        search_engine_factory.retriever_registry, "get", lambda *a, **k: None
    )
    monkeypatch.setattr(
        search_engine_factory,
        "search_config",
        lambda **kwargs: {
            "probe": {"module_path": ".probe", "class_name": "Probe"}
        },
    )
    monkeypatch.setattr(
        search_engine_factory,
        "get_safe_module_class",
        lambda *args: InvalidSettingsEngine,
    )
    monkeypatch.setattr(
        policy,
        "evaluate_engine",
        lambda *args, **kwargs: policy.Decision(True, "test_allowed"),
    )

    with pytest.raises(SettingsValueError) as raised:
        search_engine_factory.create_search_engine(
            "probe", settings_snapshot={"search.tool": "probe"}
        )

    assert raised.value is settings_error
    assert len(constructions) == 1


def test_full_search_constructor_error_does_not_return_the_base_engine(
    monkeypatch, settings_error
):
    from local_deep_research.web_search_engines import search_engine_factory

    class InvalidSettingsWrapper:
        def __init__(self, settings_snapshot=None):
            raise settings_error

    monkeypatch.setattr(
        search_engine_factory,
        "get_safe_module_class",
        lambda *args: InvalidSettingsWrapper,
    )

    with pytest.raises(SettingsValueError) as raised:
        search_engine_factory._create_full_search_wrapper(
            "probe",
            base_engine=object(),
            engine_config={
                "full_search_module": ".probe",
                "full_search_class": "Probe",
            },
            llm=None,
            params={},
            settings_snapshot={"present": True},
        )

    assert raised.value is settings_error


@pytest.mark.parametrize(
    "invalid_key",
    [
        "search.cross_engine_max_results",
        "search.cross_engine_max_context_items",
    ],
)
def test_filter_does_not_replace_invalid_settings_with_limits(
    monkeypatch, settings_error, invalid_key
):
    from local_deep_research.advanced_search_system.filters.cross_engine_filter import (
        CrossEngineFilter,
    )
    from local_deep_research.config import thread_settings

    def read(key, default=None, **kwargs):
        if key == invalid_key:
            raise settings_error
        return default

    monkeypatch.setattr(thread_settings, "get_setting_from_snapshot", read)

    with pytest.raises(SettingsValueError) as raised:
        CrossEngineFilter(model=Mock(), settings_snapshot={"present": True})

    assert raised.value is settings_error


@pytest.mark.parametrize("allow_default_settings", [False, True])
def test_api_default_opt_in_does_not_waive_invalid_configuration(
    monkeypatch, settings_error, allow_default_settings
):
    from local_deep_research.web.routers import api_v1

    manager = Mock()
    manager.get_settings_snapshot.side_effect = settings_error
    monkeypatch.setattr(
        api_v1, "get_user_db_session", lambda *args: nullcontext(object())
    )
    monkeypatch.setattr(api_v1, "get_settings_manager", lambda *args: manager)
    params = {}

    refused = api_v1._load_user_context_into_params(
        params, "alice", allow_default_settings=allow_default_settings
    )

    # Refused with the repair diagnostic instead of the app-wide generic
    # 500, and before the opt-in branch could run with an empty snapshot.
    assert "settings_snapshot" not in params
    assert refused is not None and refused.status_code == 503
    body = json.loads(refused.body)
    assert body["reason"] == "invalid_setting"
    assert str(settings_error) in body["error"]
    assert "allow_default_settings does not bypass" in body["how_to_fix"]


def test_benchmark_fails_without_launching_a_worker_for_invalid_settings(
    monkeypatch, settings_error
):
    from local_deep_research import settings
    from local_deep_research.benchmarks.web_api import benchmark_service
    from local_deep_research.database import session_context

    run = SimpleNamespace(
        id=1,
        status=None,
        error_message=None,
        config_hash="test-config",
        datasets_config={},
        search_config={},
        evaluation_config={},
    )
    session = Mock()
    session.query.return_value.filter.return_value.first.return_value = run
    monkeypatch.setattr(
        session_context,
        "get_user_db_session",
        lambda *args: nullcontext(session),
    )
    manager = Mock()
    manager.get_all_settings.side_effect = settings_error
    monkeypatch.setattr(settings, "SettingsManager", lambda *args: manager)
    monkeypatch.setattr(
        "local_deep_research.utilities.request_context.get_current_session_id",
        lambda: None,
    )
    thread = Mock()
    monkeypatch.setattr(benchmark_service.threading, "Thread", thread)
    service = benchmark_service.BenchmarkService(socket_service=Mock())

    assert service.start_benchmark(1, username="alice") is False

    assert run.status == benchmark_service.BenchmarkStatus.FAILED
    assert run.error_message == str(settings_error)
    assert service.active_runs == {}
    thread.assert_not_called()


def test_scheduler_does_not_cache_or_return_default_configuration(
    monkeypatch, settings_error
):
    from local_deep_research.database import session_context
    from local_deep_research.scheduler.background import BackgroundJobScheduler
    from local_deep_research.settings import manager as settings_manager

    scheduler = object.__new__(BackgroundJobScheduler)
    scheduler._settings_cache_lock = RLock()
    scheduler._settings_cache = {}
    scheduler.user_sessions = {"alice": {"active": True}}
    scheduler._credential_store = Mock()
    scheduler._credential_store.retrieve.return_value = "test-password"
    monkeypatch.setattr(
        session_context,
        "get_user_db_session",
        lambda *args: nullcontext(object()),
    )
    manager = Mock()
    manager.get_setting.side_effect = settings_error
    monkeypatch.setattr(
        settings_manager, "SettingsManager", lambda *args: manager
    )

    with pytest.raises(SettingsValueError) as raised:
        scheduler._get_document_scheduler_settings("alice")

    assert raised.value is settings_error
    assert scheduler._settings_cache == {}


def test_stream_usage_error_does_not_use_model_capability(
    monkeypatch, settings_error
):
    from local_deep_research.config import thread_settings
    from local_deep_research.config.llm_config import ProcessingLLMWrapper

    reader = Mock(side_effect=settings_error)
    monkeypatch.setattr(thread_settings, "get_setting_from_snapshot", reader)
    wrapper = ProcessingLLMWrapper(
        SimpleNamespace(disable_streaming=False, stream_usage=True),
        provider="openai_endpoint",
        settings_snapshot={"present": True},
    )

    with pytest.raises(SettingsValueError) as raised:
        wrapper._stream_cancel_allowed()

    assert raised.value is settings_error


def test_absent_optional_filter_settings_still_use_documented_defaults():
    from local_deep_research.advanced_search_system.filters.cross_engine_filter import (
        CrossEngineFilter,
    )

    filtering = CrossEngineFilter(model=Mock(), settings_snapshot={})

    assert filtering.max_results == 100
    assert filtering.max_context_items == 30