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.2 KB
Raw Blame
"""Explicit engine choices are independent of automatic agent discovery."""

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

import pytest
from loguru import logger

from local_deep_research.settings.exceptions import SettingsValueError
from local_deep_research.web.routers import research, settings
from local_deep_research.web_search_engines import search_engines_config


@pytest.fixture
def engine_config(monkeypatch):
    config = {
        "collection_hidden": {
            "display_name": "Hidden collection",
            "agent_enabled": False,
            "requires_api_key": False,
        },
        "openlibrary": {
            "display_name": "Open Library",
            "agent_enabled": False,
            "requires_api_key": False,
        },
        "github": {
            "display_name": "GitHub",
            "agent_enabled": False,
            "requires_api_key": True,
        },
    }
    monkeypatch.setattr(
        search_engines_config, "search_config", lambda **kwargs: config
    )
    return config


@pytest.fixture
def manager():
    manager = Mock()
    manager.get_settings_snapshot.return_value = {}
    manager.get_setting.side_effect = lambda key, default=None: default
    return manager


@pytest.mark.parametrize("key", [None, "", "   ", "YOUR_API_KEY", "none"])
def test_required_key_is_reported_as_a_credential_problem(
    engine_config, manager, key
):
    manager.get_settings_snapshot.return_value = {
        "search.engine.web.github.api_key": {"value": key}
    }

    response = research._precheck_search_engine_api_key(
        manager, "github", "alice"
    )

    assert response.status_code == 400
    body = json.loads(response.body)
    assert body["reason"] == "search_api_key_missing"
    assert body["field"] == "search_engine"
    assert "GitHub requires an API key" in body["message"]
    assert "Settings" in body["message"]
    assert "collection" not in body["message"].lower()


@pytest.mark.parametrize("wrapped", [False, True])
def test_configured_required_key_allows_an_agent_hidden_engine(
    engine_config, manager, wrapped
):
    key = "configured-test-credential"
    manager.get_settings_snapshot.return_value = {
        "search.engine.web.github.api_key": {"value": key} if wrapped else key
    }

    assert (
        research._precheck_search_engine_api_key(manager, "github", "alice")
        is None
    )
    assert engine_config["github"]["agent_enabled"] is False


@pytest.mark.parametrize("engine", ["collection_hidden", "openlibrary"])
def test_optional_or_absent_credentials_do_not_block_selection(
    engine_config, manager, engine
):
    assert (
        research._precheck_search_engine_api_key(manager, engine, "alice")
        is None
    )
    assert engine_config[engine]["agent_enabled"] is False


def test_engine_config_credential_is_recognized(engine_config, manager):
    engine_config["github"]["api_key"] = "configured-test-credential"
    assert (
        research._precheck_search_engine_api_key(manager, "github", "alice")
        is None
    )


def test_credential_check_preserves_setting_diagnostics(engine_config, manager):
    error = SettingsValueError(
        "search.engine.web.github.requires_api_key",
        source="environment",
        reason="expected a valid checkbox value",
    )
    manager.get_settings_snapshot.side_effect = error
    response = research._precheck_search_engine_api_key(
        manager, "github", "alice"
    )
    assert response.status_code == 500
    assert json.loads(response.body)["message"] == str(error)


def test_credential_check_reports_an_internal_failure(engine_config, manager):
    manager.get_settings_snapshot.side_effect = RuntimeError("internal detail")
    response = research._precheck_search_engine_api_key(
        manager, "github", "alice"
    )
    assert response.status_code == 500
    assert "internal detail" not in response.body.decode()


@pytest.mark.parametrize("diagnose", [False, True])
@pytest.mark.parametrize("failure_stage", ["settings", "catalog"])
def test_credential_check_logs_unexpected_failure_by_type(
    monkeypatch, engine_config, manager, diagnose, failure_stage
):
    failure = RuntimeError("Configuration unavailable")
    if failure_stage == "settings":
        manager.get_settings_snapshot.side_effect = failure
    else:
        monkeypatch.setattr(
            search_engines_config, "search_config", Mock(side_effect=failure)
        )
    records = []
    logger.enable(research.__name__)
    sink = logger.add(
        lambda message: records.append(message.record),
        filter=lambda record: record["name"] == research.__name__,
        diagnose=diagnose,
    )
    try:
        response = research._precheck_search_engine_api_key(
            manager, "github", "alice"
        )
    finally:
        logger.remove(sink)
        logger.disable(research.__name__)

    assert response.status_code == 500
    assert "Configuration unavailable" not in response.body.decode()
    assert len(records) == 1
    assert records[0]["level"].name == "ERROR"
    assert records[0]["message"] == (
        "Failed to check search engine credentials (RuntimeError)"
    )
    assert records[0]["exception"] is None


@pytest.mark.parametrize(
    "key", [None, "YOUR_API_KEY", "configured-test-credential"]
)
@pytest.mark.parametrize("query", [{}, {"egress_scope": "private_only"}])
def test_picker_exposes_only_credential_presence(
    monkeypatch, engine_config, manager, key, query
):
    manager.get_settings_snapshot.return_value = {
        "search.engine.web.github.api_key": {"value": key}
    }
    monkeypatch.setattr(
        settings, "get_user_db_session", lambda *a, **k: nullcontext(Mock())
    )
    monkeypatch.setattr(settings, "get_settings_manager", lambda *a: manager)
    # Other tests cover policy decisions; this pins the credential contract
    # both with and without the scope-aware response overlay.
    monkeypatch.setattr(settings, "_apply_guarded_url_overlay", Mock())
    monkeypatch.setattr(settings, "_classify_options_for_egress", Mock())

    result = settings.api_get_available_search_engines(
        SimpleNamespace(query_params=query), "alice"
    )

    options = {option["value"]: option for option in result["engine_options"]}
    assert options["github"]["has_api_key"] is (
        key == "configured-test-credential"
    )
    assert options["github"]["agent_enabled"] is False
    assert options["openlibrary"]["has_api_key"] is False
    assert options["openlibrary"]["requires_api_key"] is False
    assert (
        result["engines"]["github"]["has_api_key"]
        is options["github"]["has_api_key"]
    )
    if key:
        assert key not in json.dumps(result)


@pytest.mark.parametrize(
    "strategy",
    ["langgraph-agent", "langgraph_agent", "mcp", "agentic", "source-based"],
)
@pytest.mark.parametrize(
    ("engine", "key", "expected_status"),
    [
        ("collection_hidden", None, 401),
        ("openlibrary", None, 401),
        ("github", "configured-test-credential", 401),
        ("github", None, 400),
    ],
)
def test_start_checks_keys_independently_of_agent_tool_membership(
    monkeypatch, engine_config, manager, strategy, engine, key, expected_status
):
    from local_deep_research import settings as settings_package
    from local_deep_research.database import session_context

    manager.get_settings_snapshot.return_value = {
        "search.engine.web.github.api_key": key
    }
    # Stop at the normal expired-session guard, before creating any research
    # records or starting a worker. The old collection check returned 400.
    session = Mock()
    session.query.return_value.filter.return_value.first.return_value = (
        SimpleNamespace(name="Hidden collection", agent_enabled=False)
    )
    session.query.return_value.filter_by.return_value.count.return_value = 0
    monkeypatch.setattr(
        research, "get_user_db_session", lambda *a: nullcontext(session)
    )
    monkeypatch.setattr(
        session_context, "get_user_db_session", lambda *a: nullcontext(session)
    )
    monkeypatch.setattr(
        settings_package, "SettingsManager", lambda *a, **k: manager
    )
    policy = Mock(return_value=None)
    monkeypatch.setattr(research, "_precheck_engine_policy", policy)
    monkeypatch.setattr(
        research, "user_research_start_gate", lambda *a: nullcontext()
    )
    password = Mock(return_value=(None, True))
    monkeypatch.setattr(research, "resolve_user_password", password)
    monkeypatch.setattr(
        "local_deep_research.web.routes.globals.reclaim_stale_user_active_research",
        Mock(return_value=False),
    )

    response = research._start_research_sync(
        {
            "query": "A test question",
            "model_provider": "ollama",
            "model": "test-model",
            "search_engine": engine,
            "iterations": 1,
            "questions_per_iteration": 1,
            "strategy": strategy,
        },
        "alice",
        "http://testserver",
        None,
    )

    assert response.status_code == expected_status
    if expected_status == 401:
        password.assert_called_once_with("alice")
    else:
        password.assert_not_called()
        assert json.loads(response.body)["reason"] == "search_api_key_missing"
    policy.assert_called_once()
    assert engine_config[engine]["agent_enabled"] is False