FabledScribe/tests/test_mcp_tool_search.py

"""search tool — proves the tool pattern (context + service call + dict shape).

Service call is mocked; no DB needed."""
from unittest.mock import AsyncMock, patch

import pytest

from scribe.mcp._context import _user_id_ctx
from scribe.mcp.tools.search import search
from tests.helpers import fake_note


@pytest.fixture(autouse=True)
def _reset_user_ctx():
    """Each test starts with no MCP context. Tests set it explicitly."""
    token = _user_id_ctx.set(None)
    yield
    _user_id_ctx.reset(token)


@pytest.mark.asyncio
async def test_fable_search_raises_without_context():
    with pytest.raises(RuntimeError, match="no MCP user context"):
        await search(q="anything")


@pytest.mark.asyncio
async def test_fable_search_returns_repackaged_results():
    _user_id_ctx.set(7)
    fake = fake_note(id=1, title="kafka rebalance", is_task=False, body="HPA details", tags=["ops"])
    with patch(
        "scribe.mcp.tools.search.semantic_search_notes",
        AsyncMock(return_value=[(0.93, fake)]),
    ):
        out = await search(q="kafka")

    assert out["total"] == 1
    assert len(out["results"]) == 1
    r = out["results"][0]
    assert r["id"] == 1
    assert r["title"] == "kafka rebalance"
    assert r["body"] == "HPA details"
    assert r["is_task"] is False
    assert r["tags"] == ["ops"]
    assert r["similarity"] == pytest.approx(0.93)


@pytest.mark.asyncio
async def test_fable_search_body_is_truncated_to_240_chars():
    _user_id_ctx.set(7)
    long_body = "x" * 500
    fake = fake_note(id=1, title="t", body=long_body)
    with patch(
        "scribe.mcp.tools.search.semantic_search_notes",
        AsyncMock(return_value=[(0.5, fake)]),
    ):
        out = await search(q="x")
    assert len(out["results"][0]["body"]) == 240


@pytest.mark.asyncio
async def test_fable_search_content_type_filters_at_service_layer():
    """content_type maps to the is_task kwarg passed to the service."""
    _user_id_ctx.set(7)
    mock_search = AsyncMock(return_value=[])
    with patch("scribe.mcp.tools.search.semantic_search_notes", mock_search):
        await search(q="x", content_type="task")
        assert mock_search.call_args.kwargs["is_task"] is True

        mock_search.reset_mock()
        await search(q="x", content_type="note")
        assert mock_search.call_args.kwargs["is_task"] is False

        mock_search.reset_mock()
        await search(q="x", content_type="all")
        assert mock_search.call_args.kwargs["is_task"] is None


@pytest.mark.asyncio
async def test_an_explicit_search_reaches_a_lesson_from_any_project():
    """The wiring half of milestone 385 step 3.

    A lesson records an insight that transfers, so a project filter that hid it
    would hide it precisely on the project that has not learned it yet. This is
    the EXPLICIT search — the operator asked — so it opts in; the unasked-for
    injection arms decide their own budget separately (step 5).

    Asserted on the kwarg rather than on results, because what can regress here
    is the wiring: the service grew the capability and a call site that never
    passes it leaves the whole kind unreachable, with every unit test still
    green.
    """
    _user_id_ctx.set(7)
    mock_search = AsyncMock(return_value=[])
    with patch("scribe.mcp.tools.search.semantic_search_notes", mock_search):
        await search(q="x", project_id=3)

    assert mock_search.call_args.kwargs["include_global_kinds"] is True


@pytest.mark.asyncio
async def test_fable_search_limit_is_clamped():
    _user_id_ctx.set(7)
    mock_search = AsyncMock(return_value=[])
    with patch("scribe.mcp.tools.search.semantic_search_notes", mock_search):
        await search(q="x", limit=999)
        assert mock_search.call_args.kwargs["limit"] == 50

        mock_search.reset_mock()
        await search(q="x", limit=0)
        assert mock_search.call_args.kwargs["limit"] == 1


@pytest.mark.asyncio
@pytest.mark.parametrize("project_id, scope", [
    (5, {"project_id": 5}),
    # No project: the explicit question is asked of the whole rulebook.
    (0, {"everywhere": True}),
])
async def test_rule_search_scopes_to_the_project_it_is_given(project_id, scope):
    """With a project: global rules plus that project's (milestone 414).
    Without one: every rule, because an unscoped "is there a rule about this"
    is asking the whole rulebook — unlike a hook, which speaks unasked."""
    _user_id_ctx.set(7)
    found = AsyncMock(return_value=[])
    with patch("scribe.mcp.tools.search.semantic_search_rules", found):
        await search(q="release tagging", content_type="rule", project_id=project_id)
    kwargs = found.await_args.kwargs
    assert {k: kwargs[k] for k in scope} == scope
    assert set(kwargs) & {"project_id", "everywhere"} == set(scope)


def test_a_milestone_is_embedded_by_what_it_is_for_then_its_plan():
    from scribe.services.embeddings import milestone_document

    assert milestone_document("M3", "metadata providers", "## Goal\nx") == (
        "M3 — metadata providers", "metadata providers\n\n## Goal\nx")
    # A roadmap milestone written with no description is still findable by its plan.
    assert milestone_document("M3", None, "the plan") == ("M3", "the plan")
    assert milestone_document(None, None, None) == (None, None)


@pytest.mark.asyncio
async def test_milestone_search_is_its_own_shape_and_scopes_to_the_project():
    """milestone 415: 'is there already a plan for this?' has a tool."""
    from unittest.mock import MagicMock

    _user_id_ctx.set(7)
    ms = MagicMock(id=339, title="M3 — Metadata", description="works, editions",
                   status="active", project_id=30)
    found = AsyncMock(return_value=[(0.81, ms)])
    summary = AsyncMock(return_value=[{"id": 339, "total": 0, "completed": 0}])
    with patch("scribe.mcp.tools.search.semantic_search_milestones", found), \
         patch("scribe.services.milestones.get_project_milestone_summary", summary):
        out = await search(q="book metadata", content_type="milestone", project_id=30)
    assert found.await_args.kwargs["project_id"] == 30
    assert out["results"] == [{
        "id": 339, "title": "M3 — Metadata", "description": "works, editions",
        "status": "active", "project_id": 30, "total": 0, "completed": 0,
        "similarity": 0.81,
    }]