FabledScribe/tests/test_mcp_tool_notes.py

"""Tests for fable_*_note tools."""
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from fabledassistant.mcp._context import _user_id_ctx
from fabledassistant.mcp.tools.notes import (
    fable_list_notes, fable_get_note, fable_create_note,
    fable_update_note, fable_delete_note,
)


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


def _fake_note(**overrides) -> MagicMock:
    note = MagicMock()
    base = {"id": 1, "title": "t", "body": "b", "tags": [], "is_task": False}
    base.update(overrides)
    note.to_dict.return_value = base
    return note


@pytest.mark.asyncio
async def test_list_notes_repackages_tuple_into_dict():
    rows = [_fake_note(id=1), _fake_note(id=2)]
    with patch(
        "fabledassistant.mcp.tools.notes.notes_svc.list_notes",
        AsyncMock(return_value=(rows, 2)),
    ):
        out = await fable_list_notes()
    assert out["total"] == 2
    assert len(out["notes"]) == 2


@pytest.mark.asyncio
async def test_list_notes_passes_is_task_false():
    mock = AsyncMock(return_value=([], 0))
    with patch("fabledassistant.mcp.tools.notes.notes_svc.list_notes", mock):
        await fable_list_notes()
    assert mock.call_args.kwargs["is_task"] is False


@pytest.mark.asyncio
async def test_list_notes_tag_filter_maps_to_list():
    """The single-tag string param maps to a one-element list at the service layer."""
    mock = AsyncMock(return_value=([], 0))
    with patch("fabledassistant.mcp.tools.notes.notes_svc.list_notes", mock):
        await fable_list_notes(tag="ops")
    assert mock.call_args.kwargs["tags"] == ["ops"]


@pytest.mark.asyncio
async def test_list_notes_empty_tag_means_no_filter():
    mock = AsyncMock(return_value=([], 0))
    with patch("fabledassistant.mcp.tools.notes.notes_svc.list_notes", mock):
        await fable_list_notes(tag="")
    assert mock.call_args.kwargs["tags"] is None


@pytest.mark.asyncio
async def test_list_notes_search_text_maps_to_q():
    mock = AsyncMock(return_value=([], 0))
    with patch("fabledassistant.mcp.tools.notes.notes_svc.list_notes", mock):
        await fable_list_notes(search_text="kafka")
    assert mock.call_args.kwargs["q"] == "kafka"


@pytest.mark.asyncio
async def test_list_notes_limit_clamped():
    mock = AsyncMock(return_value=([], 0))
    with patch("fabledassistant.mcp.tools.notes.notes_svc.list_notes", mock):
        await fable_list_notes(limit=9999)
    assert mock.call_args.kwargs["limit"] == 100


@pytest.mark.asyncio
async def test_get_note_returns_dict():
    fake = _fake_note(id=5, title="found")
    with patch(
        "fabledassistant.mcp.tools.notes.notes_svc.get_note",
        AsyncMock(return_value=fake),
    ):
        out = await fable_get_note(note_id=5)
    assert out["id"] == 5
    assert out["title"] == "found"


@pytest.mark.asyncio
async def test_get_note_raises_when_not_found():
    with patch(
        "fabledassistant.mcp.tools.notes.notes_svc.get_note",
        AsyncMock(return_value=None),
    ):
        with pytest.raises(ValueError, match="note 999 not found"):
            await fable_get_note(note_id=999)


@pytest.mark.asyncio
async def test_create_note_passes_through():
    fake = _fake_note(id=10, title="new")
    mock = AsyncMock(return_value=fake)
    with patch("fabledassistant.mcp.tools.notes.notes_svc.create_note", mock):
        out = await fable_create_note(title="new", body="x", tags=["a"], project_id=5)
    assert out["id"] == 10
    assert mock.call_args.kwargs["title"] == "new"
    assert mock.call_args.kwargs["project_id"] == 5


@pytest.mark.asyncio
async def test_create_note_project_zero_becomes_none():
    """project_id=0 sentinel must become None at the service layer (orphan note)."""
    fake = _fake_note()
    mock = AsyncMock(return_value=fake)
    with patch("fabledassistant.mcp.tools.notes.notes_svc.create_note", mock):
        await fable_create_note(title="t", project_id=0)
    assert mock.call_args.kwargs["project_id"] is None


@pytest.mark.asyncio
async def test_update_note_only_sends_non_default_fields():
    """Omitted (default) fields must NOT reach the service — otherwise they'd
    overwrite real data with empty strings."""
    fake = _fake_note()
    mock = AsyncMock(return_value=fake)
    with patch("fabledassistant.mcp.tools.notes.notes_svc.update_note", mock):
        await fable_update_note(note_id=1, title="new title")
    # Service got user_id, note_id positional + only the title kwarg
    args, kwargs = mock.call_args
    assert args == (7, 1)
    assert kwargs == {"title": "new title"}


@pytest.mark.asyncio
async def test_update_note_empty_tags_clears_explicitly():
    """tags=[] is an explicit clear, distinct from tags=None (omit)."""
    fake = _fake_note()
    mock = AsyncMock(return_value=fake)
    with patch("fabledassistant.mcp.tools.notes.notes_svc.update_note", mock):
        await fable_update_note(note_id=1, tags=[])
    assert mock.call_args.kwargs == {"tags": []}


@pytest.mark.asyncio
async def test_update_note_tags_none_means_omit():
    fake = _fake_note()
    mock = AsyncMock(return_value=fake)
    with patch("fabledassistant.mcp.tools.notes.notes_svc.update_note", mock):
        await fable_update_note(note_id=1, tags=None)
    assert "tags" not in mock.call_args.kwargs


@pytest.mark.asyncio
async def test_update_note_raises_when_not_found():
    with patch(
        "fabledassistant.mcp.tools.notes.notes_svc.update_note",
        AsyncMock(return_value=None),
    ):
        with pytest.raises(ValueError, match="note 999 not found"):
            await fable_update_note(note_id=999, title="x")


@pytest.mark.asyncio
async def test_delete_note_returns_confirmation_string():
    with patch(
        "fabledassistant.mcp.tools.notes.notes_svc.delete_note",
        AsyncMock(return_value=True),
    ):
        result = await fable_delete_note(note_id=7)
    assert result == "Note 7 deleted."


@pytest.mark.asyncio
async def test_delete_note_raises_when_not_found():
    with patch(
        "fabledassistant.mcp.tools.notes.notes_svc.delete_note",
        AsyncMock(return_value=False),
    ):
        with pytest.raises(ValueError, match="note 999 not found"):
            await fable_delete_note(note_id=999)