Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

14.4 KB
Raw Blame
"""Tests for MCP embedder resolution + degradation surfacing (issue #306).

When an explicitly-configured embedder fails to initialise (missing key,
missing SDK, unknown name) the MCP server must NOT silently masquerade as
healthy. It still falls back to MockEmbedder so non-RAG tools keep working, but
records the degradation so `build_meta` surfaces it in every tool's `_meta`.

These tests also pin the "all embedders work" contract: resolution goes through
the shared registry, so openrouter and custom-registered embedders are honoured
— not just the hardcoded openai/gemini branches that the old code special-cased.
"""

from __future__ import annotations

from pathlib import Path

import pytest

from repowise.core.providers.embedding.base import (
    KeylessEmbedder,
    MockEmbedder,
    is_semantic_embedder,
)
from repowise.core.providers.embedding.caching import CachingEmbedder
from repowise.server.mcp_server import _server, _state
from repowise.server.mcp_server._meta import build_meta

# Embedder env vars that, if present in the real environment, would let an
# explicitly-configured embedder succeed and break the "missing key" tests.
_EMBEDDER_ENV_VARS = (
    "REPOWISE_EMBEDDER",
    "REPOWISE_EMBEDDING_MODEL",
    "REPOWISE_EMBEDDING_DIMS",
    "OPENAI_API_KEY",
    "OPENAI_BASE_URL",
    "GEMINI_API_KEY",
    "GOOGLE_API_KEY",
    "OPENROUTER_API_KEY",
    "OLLAMA_BASE_URL",
    "OLLAMA_EMBEDDING_MODEL",
    "OLLAMA_EMBEDDING_DIMS",
)


@pytest.fixture(autouse=True)
def _clean_env_and_state(monkeypatch, tmp_path):
    """Strip embedder env vars + reset status so each test starts from scratch.

    ``Path.home()`` is redirected at an empty directory too: resolution falls
    back to the ``embedder_api_key`` saved in ``~/.repowise/config.yaml``, so a
    developer who has one would otherwise see the "missing key" tests resolve a
    real embedder and fail locally while passing in CI.
    """
    for var in _EMBEDDER_ENV_VARS:
        monkeypatch.delenv(var, raising=False)
    monkeypatch.setattr(_state, "_repo_path", None, raising=False)
    monkeypatch.setattr(_state, "_embedder_status", None, raising=False)
    empty_home = tmp_path / "empty-home"
    empty_home.mkdir()
    monkeypatch.setattr(Path, "home", classmethod(lambda cls: empty_home))
    yield
    _state._embedder_status = None


def test_no_config_uses_mock_not_degraded(monkeypatch):
    """Nothing configured → MockEmbedder is the intended default, not degraded."""
    embedder = _server._resolve_embedder()
    assert isinstance(embedder, MockEmbedder)
    assert _state._embedder_status == {
        "active": "mock",
        "requested": None,
        "degraded": False,
    }


def test_explicit_mock_not_degraded(monkeypatch):
    """Explicitly requesting mock is a deliberate choice, never a degradation."""
    monkeypatch.setenv("REPOWISE_EMBEDDER", "mock")
    embedder = _server._resolve_embedder()
    assert isinstance(embedder, MockEmbedder)
    assert _state._embedder_status["degraded"] is False


def test_openai_without_key_degrades_and_names_remediation(monkeypatch):
    """Explicit openai + no key → fall back to mock, flag degraded, name the key."""
    monkeypatch.setenv("REPOWISE_EMBEDDER", "openai")
    embedder = _server._resolve_embedder()

    assert isinstance(embedder, MockEmbedder)
    status = _state._embedder_status
    assert status["degraded"] is True
    assert status["active"] == "mock"
    assert status["requested"] == "openai"
    assert "OPENAI_API_KEY" in status["reason"]


def test_openrouter_without_key_degrades(monkeypatch):
    """openrouter is NOT one of the old hardcoded branches — it must still degrade
    (and not be silently treated as mock). Proves all registry embedders work."""
    monkeypatch.setenv("REPOWISE_EMBEDDER", "openrouter")
    embedder = _server._resolve_embedder()

    assert isinstance(embedder, MockEmbedder)
    status = _state._embedder_status
    assert status["degraded"] is True
    assert status["requested"] == "openrouter"
    assert "OPENROUTER_API_KEY" in status["reason"]


def test_ollama_resolves_without_api_key(monkeypatch):
    """Local Ollama embeddings do not require a cloud API key at construction."""
    from repowise.core.providers.embedding.ollama import OllamaEmbedder

    monkeypatch.setenv("REPOWISE_EMBEDDER", "ollama")
    monkeypatch.setenv("OLLAMA_EMBEDDING_MODEL", "qwen3-embedding:0.6b")

    embedder = _server._resolve_embedder()

    assert isinstance(embedder, OllamaEmbedder)
    assert _state._embedder_status == {
        "active": "ollama",
        "requested": "ollama",
        "degraded": False,
    }


def test_unknown_embedder_name_degrades(monkeypatch):
    """A typo'd / unknown embedder name surfaces as degraded, not silent mock."""
    monkeypatch.setenv("REPOWISE_EMBEDDER", "definitely-not-an-embedder")
    embedder = _server._resolve_embedder()

    assert isinstance(embedder, MockEmbedder)
    status = _state._embedder_status
    assert status["degraded"] is True
    assert status["requested"] == "definitely-not-an-embedder"


def test_custom_registered_embedder_is_honoured(monkeypatch):
    """A custom embedder registered via register_embedder must resolve cleanly —
    the server resolves through the shared registry, not a hardcoded subset."""
    from repowise.core.providers.embedding import register_embedder
    from repowise.core.providers.embedding.registry import _custom_embedders

    class _FakeEmbedder:
        dimensions = 4

        async def embed(self, texts, *, kind="document"):
            del kind
            return [[0.0, 0.0, 0.0, 1.0] for _ in texts]

    register_embedder("fake-test-embedder", lambda **kw: _FakeEmbedder())
    try:
        monkeypatch.setenv("REPOWISE_EMBEDDER", "fake-test-embedder")
        embedder = _server._resolve_embedder()
        assert isinstance(embedder, _FakeEmbedder)
        assert _state._embedder_status == {
            "active": "fake-test-embedder",
            "requested": "fake-test-embedder",
            "degraded": False,
        }
    finally:
        _custom_embedders.pop("fake-test-embedder", None)


def test_config_yaml_embedder_is_read(monkeypatch, tmp_path):
    """The embedder name is read from .repowise/config.yaml when no env var set."""
    repo_dir = tmp_path / "repo"
    (repo_dir / ".repowise").mkdir(parents=True)
    (repo_dir / ".repowise" / "config.yaml").write_text(
        "provider: deepseek\nembedder: openai\n", encoding="utf-8"
    )
    monkeypatch.setattr(_state, "_repo_path", str(repo_dir))

    embedder = _server._resolve_embedder()
    assert isinstance(embedder, MockEmbedder)  # no key → fell back
    assert _state._embedder_status["requested"] == "openai"
    assert _state._embedder_status["degraded"] is True


def test_repo_dotenv_supplies_missing_embedder_key(monkeypatch, tmp_path):
    """The key persisted in the repo's .repowise/.env is used when env has none.

    `repowise mcp` loads that file for the repo it is pointed at, but workspace
    siblings and embedded run_mcp() callers never get it — without this fallback
    the server queries an openai-embedded index with mock vectors.
    """
    from repowise.core.providers.embedding.openai import OpenAIEmbedder

    repo_dir = tmp_path / "repo"
    (repo_dir / ".repowise").mkdir(parents=True)
    (repo_dir / ".repowise" / "config.yaml").write_text("embedder: openai\n", encoding="utf-8")
    (repo_dir / ".repowise" / ".env").write_text(
        "OPENAI_API_KEY=sk-from-dotenv\n", encoding="utf-8"
    )
    monkeypatch.setattr(_state, "_repo_path", str(repo_dir))

    embedder = _server._resolve_embedder()

    assert isinstance(embedder, OpenAIEmbedder)
    assert _state._embedder_status == {
        "active": "openai",
        "requested": "openai",
        "degraded": False,
    }


def test_global_config_supplies_missing_embedder_key(monkeypatch, tmp_path):
    """`repowise serve` restores embedder_api_key from ~/.repowise/config.yaml —
    the MCP server must resolve the same credential from the same place."""
    from repowise.core.providers.embedding.openai import OpenAIEmbedder

    home = tmp_path / "home"
    (home / ".repowise").mkdir(parents=True)
    (home / ".repowise" / "config.yaml").write_text(
        "embedder: openai\nembedder_api_key: sk-from-global\n", encoding="utf-8"
    )
    monkeypatch.setattr(Path, "home", classmethod(lambda cls: home))
    monkeypatch.setenv("REPOWISE_EMBEDDER", "openai")

    embedder = _server._resolve_embedder()

    assert isinstance(embedder, OpenAIEmbedder)
    assert _state._embedder_status["degraded"] is False


def test_global_config_key_not_used_for_a_different_embedder(monkeypatch, tmp_path):
    """A saved openai key must not be handed to gemini — that fails confusingly."""
    home = tmp_path / "home"
    (home / ".repowise").mkdir(parents=True)
    (home / ".repowise" / "config.yaml").write_text(
        "embedder: openai\nembedder_api_key: sk-from-global\n", encoding="utf-8"
    )
    monkeypatch.setattr(Path, "home", classmethod(lambda cls: home))
    monkeypatch.setenv("REPOWISE_EMBEDDER", "gemini")

    embedder = _server._resolve_embedder()

    assert isinstance(embedder, MockEmbedder)
    assert _state._embedder_status["degraded"] is True


def test_process_env_key_wins_over_persisted(monkeypatch, tmp_path):
    """An explicitly exported key stays authoritative over the persisted one."""
    from repowise.core.providers.embedding.openai import OpenAIEmbedder

    repo_dir = tmp_path / "repo"
    (repo_dir / ".repowise").mkdir(parents=True)
    (repo_dir / ".repowise" / ".env").write_text("OPENAI_API_KEY=sk-persisted\n", encoding="utf-8")
    monkeypatch.setattr(_state, "_repo_path", str(repo_dir))
    monkeypatch.setenv("REPOWISE_EMBEDDER", "openai")
    monkeypatch.setenv("OPENAI_API_KEY", "sk-exported")

    embedder = _server._resolve_embedder()

    assert isinstance(embedder, OpenAIEmbedder)
    assert embedder._api_key == "sk-exported"


def test_keyless_embedder_needs_no_persisted_lookup(monkeypatch):
    """Embedders outside the keyed map resolve without touching the config files."""
    assert _server._persisted_embedder_key("ollama") is None
    assert _server._persisted_embedder_key("mock") is None


def test_build_meta_surfaces_degraded_embedder(monkeypatch):
    """A degraded embedder shows up in the _meta envelope so callers can detect it."""
    monkeypatch.setattr(
        _state,
        "_embedder_status",
        {"active": "mock", "requested": "openai", "degraded": True, "reason": "boom"},
    )
    meta = build_meta(timing_ms=1.0)
    assert meta["embedder"] == "mock"
    assert meta["embedder_degraded"] is True
    assert meta["embedder_warning"] == "boom"


def test_build_meta_clean_when_healthy(monkeypatch):
    """A healthy embedder adds no prose, only the explicit not-degraded verdict.

    ``embedder_degraded: False`` is the whole point: the check runs on every
    call, so a key written only when degraded reads as a 100% degradation rate
    to anything that aggregates it.
    """
    monkeypatch.setattr(
        _state,
        "_embedder_status",
        {"active": "openai", "requested": "openai", "degraded": False},
    )
    meta = build_meta(timing_ms=1.0)
    assert meta["embedder_degraded"] is False
    assert "semantic_search" not in meta
    assert "embedder" not in meta
    assert "embedder_warning" not in meta


@pytest.mark.parametrize(
    ("status", "expected"),
    [
        ({"active": "openai", "requested": "openai", "degraded": False}, True),
        ({"active": "mock", "requested": "mock", "degraded": False}, False),
        ({"active": "mock", "requested": "openai", "degraded": True}, False),
        (None, None),
    ],
)
def test_semantic_search_state_is_three_valued(monkeypatch, status, expected):
    """Telemetry needs the third state named, not inferred.

    A signal that only ever reports ``False`` cannot be told apart, by anything
    aggregating it, from one this version does not report at all — which is what
    hid the keyless population, the larger one, behind ``embedder_degraded``.
    Absent means "never evaluated" and stays distinct from an explicit ``False``.
    """
    from repowise.server.mcp_server._meta import semantic_search_state

    monkeypatch.setattr(_state, "_embedder_status", status)
    assert semantic_search_state() is expected


def test_build_meta_marks_a_keyless_index_full_text_only(monkeypatch):
    """The keyless install: nothing broken, but retrieval really is FTS-only."""
    monkeypatch.setattr(
        _state,
        "_embedder_status",
        {"active": "mock", "requested": "mock", "degraded": False},
    )
    meta = build_meta(timing_ms=1.0)
    assert meta["embedder_degraded"] is False
    assert meta["semantic_search"] is False
    assert meta["embedder"] == "mock"


def test_build_meta_omits_degraded_when_embedder_unresolved(monkeypatch):
    """Nothing resolved → the check never ran, so neither value is honest."""
    monkeypatch.setattr(_state, "_embedder_status", None)
    meta = build_meta(timing_ms=1.0)
    assert "embedder_degraded" not in meta
    assert "semantic_search" not in meta


class TestQueryEmbedderWrapping:
    """``_query_embedder`` is what the server's stores actually embed with.

    It memoizes repeated queries, but must never wrap a keyless embedder:
    ``is_semantic_embedder`` identifies that one by type in order to switch the
    vector leg off, and a wrapper would report as semantic and silently
    reactivate a leg whose vectors carry no signal.
    """

    def test_configured_embedder_is_wrapped_for_caching(self, monkeypatch, tmp_path):
        monkeypatch.setenv("REPOWISE_EMBEDDER", "openai")
        monkeypatch.setenv("OPENAI_API_KEY", "sk-test")

        embedder = _server._query_embedder()

        assert isinstance(embedder, CachingEmbedder)
        assert is_semantic_embedder(embedder)

    def test_unconfigured_keyless_is_left_unwrapped(self):
        embedder = _server._query_embedder()

        assert isinstance(embedder, KeylessEmbedder)
        assert not is_semantic_embedder(embedder), "the vector leg must stay off"

    def test_degraded_fallback_is_left_unwrapped(self, monkeypatch):
        """A configured embedder that cannot initialise falls back to keyless —
        wrapping that would hide it from the vector-leg check."""
        monkeypatch.setenv("REPOWISE_EMBEDDER", "openai")

        embedder = _server._query_embedder()

        assert _state._embedder_status["degraded"] is True
        assert isinstance(embedder, KeylessEmbedder)
        assert not is_semantic_embedder(embedder)