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.5 KB
Raw Blame
"""
Coverage tests for local_deep_research/mcp/server.py

Focuses on branches NOT covered by existing tests/mcp/test_server.py and
tests/mcp/test_validation.py:
- _classify_error() for each error-type keyword
- _validate_iterations max_val enforcement
- _validate_questions_per_iteration upper bound
- _validate_max_results boundaries
- _build_settings_overrides with various parameter combinations
- analyze_documents validation (empty collection_name)
- generate_report searches_per_section validation
- list_strategies / get_configuration exception paths
"""

import pytest
from loguru import logger

from tests.mcp_sdk import is_mcp_installed

MCP_AVAILABLE = is_mcp_installed()

pytestmark = pytest.mark.skipif(
    not MCP_AVAILABLE, reason="MCP package not installed"
)


# ---------------------------------------------------------------------------
# _classify_error
# ---------------------------------------------------------------------------


class TestClassifyError:
    def _classify(self, msg):
        from local_deep_research.mcp.server import _classify_error

        return _classify_error(msg)

    def test_service_unavailable_503(self):
        assert self._classify("503 service error") == "service_unavailable"

    def test_service_unavailable_keyword(self):
        assert self._classify("service unavailable") == "service_unavailable"

    def test_model_not_found_404(self):
        assert self._classify("404 error") == "model_not_found"

    def test_model_not_found_keyword(self):
        assert self._classify("model not found") == "model_not_found"

    def test_auth_error_api_key(self):
        assert self._classify("invalid api key") == "auth_error"

    def test_auth_error_401(self):
        assert self._classify("401 unauthorized") == "auth_error"

    def test_timeout(self):
        assert self._classify("request timed out") == "timeout"

    def test_rate_limit_429(self):
        assert self._classify("429 too many requests") == "rate_limit"

    def test_rate_limit_keyword(self):
        assert self._classify("rate limit exceeded") == "rate_limit"

    def test_connection_error(self):
        assert self._classify("connection refused") == "connection_error"

    def test_validation_error(self):
        assert self._classify("invalid parameter") == "validation_error"

    def test_unknown(self):
        assert self._classify("some random error") == "unknown"


# ---------------------------------------------------------------------------
# _validate_iterations
# ---------------------------------------------------------------------------


class TestValidateIterations:
    def _vi(self, val, max_val=20):
        from local_deep_research.mcp.server import _validate_iterations

        return _validate_iterations(val, max_val)

    def test_none_returns_none(self):
        assert self._vi(None) is None

    def test_valid_value(self):
        assert self._vi(5) == 5

    def test_exceeds_max_raises(self):
        from local_deep_research.mcp.server import ValidationError

        with pytest.raises(ValidationError, match="cannot exceed"):
            self._vi(21, max_val=20)

    def test_zero_raises(self):
        from local_deep_research.mcp.server import ValidationError

        with pytest.raises(ValidationError, match="positive integer"):
            self._vi(0)

    def test_negative_raises(self):
        from local_deep_research.mcp.server import ValidationError

        with pytest.raises(ValidationError):
            self._vi(-3)

    def test_non_integer_raises(self):
        from local_deep_research.mcp.server import ValidationError

        with pytest.raises(ValidationError):
            self._vi(2.5)

    def test_exact_max_allowed(self):
        assert self._vi(20, max_val=20) == 20


# ---------------------------------------------------------------------------
# _validate_questions_per_iteration
# ---------------------------------------------------------------------------


class TestValidateQPI:
    def _vqpi(self, val):
        from local_deep_research.mcp.server import (
            _validate_questions_per_iteration,
        )

        return _validate_questions_per_iteration(val)

    def test_none_returns_none(self):
        assert self._vqpi(None) is None

    def test_valid(self):
        assert self._vqpi(3) == 3

    def test_zero_raises(self):
        from local_deep_research.mcp.server import ValidationError

        with pytest.raises(ValidationError):
            self._vqpi(0)

    def test_exceeds_10_raises(self):
        from local_deep_research.mcp.server import ValidationError

        with pytest.raises(ValidationError, match="cannot exceed 10"):
            self._vqpi(11)

    def test_exactly_10_allowed(self):
        assert self._vqpi(10) == 10


# ---------------------------------------------------------------------------
# _validate_max_results
# ---------------------------------------------------------------------------


class TestValidateMaxResults:
    def _vmr(self, val):
        from local_deep_research.mcp.server import _validate_max_results

        return _validate_max_results(val)

    def test_valid(self):
        assert self._vmr(10) == 10

    def test_zero_raises(self):
        from local_deep_research.mcp.server import ValidationError

        with pytest.raises(ValidationError):
            self._vmr(0)

    def test_exceeds_100_raises(self):
        from local_deep_research.mcp.server import ValidationError

        with pytest.raises(ValidationError, match="cannot exceed 100"):
            self._vmr(101)

    def test_exactly_100_allowed(self):
        assert self._vmr(100) == 100


# ---------------------------------------------------------------------------
# _build_settings_overrides
# ---------------------------------------------------------------------------


class TestBuildSettingsOverrides:
    def test_empty_params_returns_empty_dict(self):
        from local_deep_research.mcp.server import _build_settings_overrides

        result = _build_settings_overrides()
        assert result == {}

    def test_iterations_added(self):
        from local_deep_research.mcp.server import _build_settings_overrides

        result = _build_settings_overrides(iterations=3)
        assert result.get("search.iterations") == 3

    def test_temperature_added(self):
        from local_deep_research.mcp.server import _build_settings_overrides

        result = _build_settings_overrides(temperature=0.5)
        assert result.get("llm.temperature") == pytest.approx(0.5)

    def test_qpi_added(self):
        from local_deep_research.mcp.server import _build_settings_overrides

        result = _build_settings_overrides(questions_per_iteration=4)
        assert result.get("search.questions_per_iteration") == 4


# ---------------------------------------------------------------------------
# analyze_documents – empty collection_name
# ---------------------------------------------------------------------------


class TestAnalyzeDocumentsValidation:
    def test_empty_collection_name_returns_error(self):
        from local_deep_research.mcp.server import analyze_documents

        result = analyze_documents(query="test query", collection_name="")
        assert result["status"] == "error"
        assert result["error_type"] == "validation_error"

    def test_whitespace_collection_name_returns_error(self):
        from local_deep_research.mcp.server import analyze_documents

        result = analyze_documents(query="test query", collection_name="   ")
        assert result["status"] == "error"
        assert result["error_type"] == "validation_error"


# ---------------------------------------------------------------------------
# generate_report – searches_per_section validation
# ---------------------------------------------------------------------------


class TestGenerateReportValidation:
    def test_searches_per_section_zero_returns_error(self):
        from local_deep_research.mcp.server import generate_report

        result = generate_report(query="test", searches_per_section=0)
        assert result["status"] == "error"
        assert result["error_type"] == "validation_error"

    def test_searches_per_section_over_10_returns_error(self):
        from local_deep_research.mcp.server import generate_report

        result = generate_report(query="test", searches_per_section=11)
        assert result["status"] == "error"
        assert result["error_type"] == "validation_error"


# ---------------------------------------------------------------------------
# run_server wires phase-1 legacy-plaintext migration
# ---------------------------------------------------------------------------
class TestRunServerRunsPhase1Migration:
    """An MCP-only deployment (ldr-mcp) must still purge pre-existing legacy
    plaintext .pkl docstores — run_server() calls migrate_legacy_docstores()
    before handing off to mcp.run()."""

    @pytest.fixture(autouse=True)
    def _loguru_core_untouched(self):
        """run_server() must not reconfigure the worker's logger.

        It calls configure_mcp_logging(), which runs logger.enable() and
        logger.configure(patcher=...) against loguru's single per-process
        _core. Mocking logger.remove and logger.add lets both of those
        through, and logger.configure(patcher=None) does not undo them
        afterwards: None means "leave unchanged".
        """
        core = logger._core
        before = (
            core.patcher,
            list(core.activation_list),
            core.activation_none,
        )
        yield
        assert (
            core.patcher,
            list(core.activation_list),
            core.activation_none,
        ) == before

    def test_run_server_calls_migrate_legacy_docstores(self, mocker):
        from local_deep_research.mcp import server as mcp_server

        mocker.patch.object(mcp_server, "logger")
        mocker.patch.object(mcp_server.mcp, "run")
        migrate = mocker.patch(
            "local_deep_research.vector_stores.legacy_cleanup.migrate_legacy_docstores"
        )

        mcp_server.run_server()

        migrate.assert_called_once_with()

    def test_run_server_survives_migration_failure(self, mocker):
        """A migration error must never block the MCP server from starting."""
        from local_deep_research.mcp import server as mcp_server

        mocker.patch.object(mcp_server, "logger")
        run = mocker.patch.object(mcp_server.mcp, "run")
        mocker.patch(
            "local_deep_research.vector_stores.legacy_cleanup.migrate_legacy_docstores",
            side_effect=OSError("disk gone"),
        )

        mcp_server.run_server()  # must not raise

        run.assert_called_once_with(transport="stdio")