FabledScribe/tests/test_mcp_tool_processes.py

"""Tests for MCP process tools — patches the service layer."""
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from scribe.mcp._context import _user_id_ctx


@pytest.fixture(autouse=True)
def _bind_user():
    token = _user_id_ctx.set(7)
    yield
    _user_id_ctx.reset(token)


def _fake_note(id=1, title="Drift Audit", note_type="process", user_id=7):
    n = MagicMock()
    n.id = id
    n.title = title
    n.note_type = note_type
    # Must be a real int, not an auto-attribute: the provenance check compares it
    # against the bound caller (7) to decide whether the record is shared.
    n.user_id = user_id
    n.to_dict.return_value = {"id": id, "title": title, "note_type": note_type}
    return n


@pytest.mark.asyncio
async def test_create_process_requires_title_and_body():
    from scribe.mcp.tools.processes import create_process
    with pytest.raises(ValueError):
        await create_process(title="", body="something")
    with pytest.raises(ValueError):
        await create_process(title="X", body="   ")


@pytest.mark.asyncio
async def test_create_process_sets_note_type():
    created = _fake_note()
    with patch("scribe.services.notes.create_note",
               AsyncMock(return_value=created)) as mock_create:
        from scribe.mcp.tools.processes import create_process
        out = await create_process(title="Drift Audit", body="the prompt", tags=["audit"])
    assert out["note_type"] == "process"
    # the service was asked to create a process
    assert mock_create.await_args.kwargs["note_type"] == "process"
    assert mock_create.await_args.kwargs["title"] == "Drift Audit"


@pytest.mark.asyncio
async def test_get_process_returns_body_and_candidates():
    note = _fake_note(id=7)
    with patch("scribe.services.notes.resolve_process",
               AsyncMock(return_value=(note, [{"id": 9, "title": "Drift Audit Notes"}]))):
        from scribe.mcp.tools.processes import get_process
        out = await get_process("drift")
    assert out["id"] == 7
    assert out["other_matches"] == [{"id": 9, "title": "Drift Audit Notes"}]
    # The caller's own process carries no provenance marker — absence of the flag
    # is what makes it read as theirs.
    assert "shared" not in out


@pytest.mark.asyncio
async def test_get_process_flags_another_users_process():
    """A shared Process must arrive labelled. get_process's contract is 'follow
    the returned body', so an unlabelled one would put someone else's procedure
    in charge of the session."""
    note = _fake_note(id=7, user_id=9)
    with patch("scribe.services.notes.resolve_process",
               AsyncMock(return_value=(note, []))), \
         patch("scribe.services.access.describe_provenance",
               AsyncMock(return_value={"shared": True, "owner": "alex",
                                       "permission": "viewer"})):
        from scribe.mcp.tools.processes import get_process
        out = await get_process("deploy")
    assert out["shared"] is True
    assert out["owner"] == "alex"


@pytest.mark.asyncio
async def test_get_process_not_found_raises():
    with patch("scribe.services.notes.resolve_process",
               AsyncMock(return_value=(None, []))):
        from scribe.mcp.tools.processes import get_process
        with pytest.raises(ValueError):
            await get_process("missing")


@pytest.mark.asyncio
async def test_update_process_rejects_non_process_note():
    # Resolves share-aware now, so the patch target is get_note_for_user, which
    # returns (note, permission).
    plain = _fake_note(id=3, note_type="note")
    plain.deleted_at = None
    with patch("scribe.services.notes.get_note_for_user",
               AsyncMock(return_value=(plain, "owner"))):
        from scribe.mcp.tools.processes import update_process
        with pytest.raises(ValueError):
            await update_process(process_id=3, title="x")


@pytest.mark.asyncio
async def test_update_process_refuses_a_read_only_share_with_the_reason():
    """An editor grant lets the holder edit someone else's process; a viewer
    grant must be refused, and saying "not found" about a process the caller can
    open would just send them looking for a missing id."""
    theirs = _fake_note(id=5, user_id=9)
    theirs.deleted_at = None
    with patch("scribe.services.notes.get_note_for_user",
               AsyncMock(return_value=(theirs, "viewer"))), \
         patch("scribe.services.access.can_write_note", AsyncMock(return_value=False)), \
         patch("scribe.services.notes.update_note", AsyncMock()) as mock_update:
        from scribe.mcp.tools.processes import update_process
        with pytest.raises(ValueError, match="read-only"):
            await update_process(process_id=5, title="x")
    mock_update.assert_not_awaited()


def test_register_attaches_four_tools():
    from scribe.mcp.tools import processes
    names: list[str] = []

    class FakeMcp:
        def tool(self, name):
            names.append(name)
            def deco(fn):
                return fn
            return deco

    processes.register(FakeMcp())
    assert set(names) == {
        "list_processes", "create_process", "get_process", "update_process",
    }