100% Coverage

2026-08-03 07:23:24 +02:00 · 2026-05-06 21:02:31 +02:00
parent 64c48356d0
commit 9aa30fb945
106 changed files with 28143 additions and 423 deletions
@@ -2,7 +2,10 @@

 from __future__ import annotations

+from datetime import UTC, datetime
+from http import HTTPStatus
 from typing import TYPE_CHECKING
+from unittest.mock import AsyncMock, patch
 from uuid import uuid4

 import pytest
@@ -11,8 +14,11 @@ from fastapi import FastAPI
 from httpx import ASGITransport, AsyncClient
 from roboco.api.deps import get_current_agent_id, get_db
 from roboco.api.routes.messages import router as messages_router
+from roboco.api.schemas.messages import MessageResponse
 from roboco.db.tables import AgentTable
 from roboco.models import AgentRole, AgentStatus, Team
+from roboco.models.base import MessageType
+from roboco.services.base import NotFoundError

 if TYPE_CHECKING:
    from collections.abc import AsyncIterator
@@ -65,14 +71,14 @@ _HDR = {"X-Agent-ID": str(uuid4()), "X-Agent-Role": "developer"}
 async def test_list_messages_unknown_session(messages_client: dict) -> None:
    client = messages_client["client"]
    response = await client.get(f"/api/messages?session_id={uuid4()}", headers=_HDR)
-    assert response.status_code == 404
+    assert response.status_code == HTTPStatus.NOT_FOUND


@pytest.mark.asyncio
 async def test_get_message_not_found(messages_client: dict) -> None:
    client = messages_client["client"]
    response = await client.get(f"/api/messages/{uuid4()}", headers=_HDR)
-    assert response.status_code == 404
+    assert response.status_code == HTTPStatus.NOT_FOUND


@pytest.mark.asyncio
@@ -87,7 +93,11 @@ async def test_send_message_unknown_session(messages_client: dict) -> None:
        headers=_HDR,
    )
    # 400 if session not found / 422 if validation
-    assert response.status_code in (400, 404, 422)
+    assert response.status_code in (
+        HTTPStatus.BAD_REQUEST,
+        HTTPStatus.NOT_FOUND,
+        HTTPStatus.UNPROCESSABLE_ENTITY,
+    )


@pytest.mark.asyncio
@@ -98,11 +108,232 @@ async def test_edit_message_not_found(messages_client: dict) -> None:
        json={"new_content": "edited"},
        headers=_HDR,
    )
-    assert response.status_code in (404, 422)
+    assert response.status_code in (
+        HTTPStatus.NOT_FOUND,
+        HTTPStatus.UNPROCESSABLE_ENTITY,
+    )


@pytest.mark.asyncio
 async def test_delete_message_not_found(messages_client: dict) -> None:
    client = messages_client["client"]
    response = await client.delete(f"/api/messages/{uuid4()}", headers=_HDR)
-    assert response.status_code in (204, 404)
+    assert response.status_code in (HTTPStatus.NO_CONTENT, HTTPStatus.NOT_FOUND)
+
+
+# ---------------------------------------------------------------------------
+# Service-level tests via mocking
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_list_messages_success_empty(messages_client: dict) -> None:
+    client = messages_client["client"]
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.list_messages_for_session = AsyncMock(return_value=([], False))
+        mock_get.return_value = instance
+        response = await client.get(f"/api/messages?session_id={uuid4()}", headers=_HDR)
+    assert response.status_code == HTTPStatus.OK
+
+
+@pytest.mark.asyncio
+async def test_get_message_after_send_failure(messages_client: dict) -> None:
+    """Get-message NotFoundError path."""
+    client = messages_client["client"]
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.get_message_or_raise = AsyncMock(side_effect=NotFoundError("missing"))
+        mock_get.return_value = instance
+        response = await client.get(f"/api/messages/{uuid4()}", headers=_HDR)
+    assert response.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_send_message_value_error(messages_client: dict) -> None:
+    client = messages_client["client"]
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.send_message = AsyncMock(side_effect=ValueError("session bad"))
+        mock_get.return_value = instance
+        response = await client.post(
+            "/api/messages",
+            json={
+                "session_id": str(uuid4()),
+                "content": "hi",
+                "type": "dialogue",
+            },
+            headers=_HDR,
+        )
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+
+
+@pytest.mark.asyncio
+async def test_edit_message_permission_error(messages_client: dict) -> None:
+    client = messages_client["client"]
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.edit_message_or_raise = AsyncMock(
+            side_effect=PermissionError("not yours")
+        )
+        mock_get.return_value = instance
+        response = await client.patch(
+            f"/api/messages/{uuid4()}",
+            json={"content": "edited"},
+            headers=_HDR,
+        )
+    assert response.status_code in (
+        HTTPStatus.FORBIDDEN,
+        HTTPStatus.UNPROCESSABLE_ENTITY,
+    )
+
+
+@pytest.mark.asyncio
+async def test_delete_message_permission_error(messages_client: dict) -> None:
+    client = messages_client["client"]
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.delete_message_or_raise = AsyncMock(
+            side_effect=PermissionError("not yours")
+        )
+        mock_get.return_value = instance
+        response = await client.delete(f"/api/messages/{uuid4()}", headers=_HDR)
+    assert response.status_code == HTTPStatus.FORBIDDEN
+
+
+@pytest.mark.asyncio
+async def test_get_message_returns_response_when_found(messages_client: dict) -> None:
+    """Line 79: get_message_or_raise returns a row → message_to_response (200)."""
+
+    client = messages_client["client"]
+    fake_msg = AsyncMock()
+    msg_id = uuid4()
+    fake_msg.id = msg_id
+    fake_response = MessageResponse(
+        id=msg_id,
+        agent_id=messages_client["agent"].id,
+        channel_id=uuid4(),
+        group_id=uuid4(),
+        session_id=uuid4(),
+        type=MessageType.DIALOGUE,
+        content="hello",
+        content_length=5,
+        is_reply=False,
+        reply_to=None,
+        mentions=[],
+        task_id=None,
+        commit_ref=None,
+        timestamp=datetime.now(UTC),
+        edited_at=None,
+        was_edited=False,
+    )
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.get_message_or_raise = AsyncMock(return_value=fake_msg)
+        mock_get.return_value = instance
+        with patch(
+            "roboco.api.routes.messages.message_to_response",
+            return_value=fake_response,
+        ):
+            response = await client.get(f"/api/messages/{fake_msg.id}", headers=_HDR)
+    assert response.status_code == HTTPStatus.OK
+
+
+@pytest.mark.asyncio
+async def test_send_message_success_returns_201(messages_client: dict) -> None:
+    """Line 113: success returns the message_to_response."""
+
+    fake_msg = AsyncMock()
+    fake_response = MessageResponse(
+        id=uuid4(),
+        agent_id=messages_client["agent"].id,
+        channel_id=uuid4(),
+        group_id=uuid4(),
+        session_id=uuid4(),
+        type=MessageType.DIALOGUE,
+        content="hi",
+        content_length=2,
+        is_reply=False,
+        reply_to=None,
+        mentions=[],
+        task_id=None,
+        commit_ref=None,
+        timestamp=datetime.now(UTC),
+        edited_at=None,
+        was_edited=False,
+    )
+    client = messages_client["client"]
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.send_message = AsyncMock(return_value=fake_msg)
+        mock_get.return_value = instance
+        with patch(
+            "roboco.api.routes.messages.message_to_response",
+            return_value=fake_response,
+        ):
+            response = await client.post(
+                "/api/messages",
+                json={
+                    "session_id": str(uuid4()),
+                    "content": "hello",
+                    "type": "dialogue",
+                },
+                headers=_HDR,
+            )
+    assert response.status_code == HTTPStatus.CREATED
+
+
+@pytest.mark.asyncio
+async def test_edit_message_not_found_404(messages_client: dict) -> None:
+    """Line 138: edit raises NotFoundError → 404."""
+    client = messages_client["client"]
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.edit_message_or_raise = AsyncMock(side_effect=NotFoundError("missing"))
+        mock_get.return_value = instance
+        response = await client.patch(
+            f"/api/messages/{uuid4()}",
+            json={"content": "edited"},
+            headers=_HDR,
+        )
+    assert response.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_edit_message_success_returns_response(messages_client: dict) -> None:
+    """Line 141: edit succeeds → message_to_response with was_edited=True."""
+
+    fake_msg = AsyncMock()
+    fake_response = MessageResponse(
+        id=uuid4(),
+        agent_id=messages_client["agent"].id,
+        channel_id=uuid4(),
+        group_id=uuid4(),
+        session_id=uuid4(),
+        type=MessageType.DIALOGUE,
+        content="edited",
+        content_length=6,
+        is_reply=False,
+        reply_to=None,
+        mentions=[],
+        task_id=None,
+        commit_ref=None,
+        timestamp=datetime.now(UTC),
+        edited_at=datetime.now(UTC),
+        was_edited=True,
+    )
+    client = messages_client["client"]
+    with patch("roboco.api.routes.messages.get_messaging_service") as mock_get:
+        instance = AsyncMock()
+        instance.edit_message_or_raise = AsyncMock(return_value=fake_msg)
+        mock_get.return_value = instance
+        with patch(
+            "roboco.api.routes.messages.message_to_response",
+            return_value=fake_response,
+        ):
+            response = await client.patch(
+                f"/api/messages/{uuid4()}",
+                json={"content": "edited"},
+                headers=_HDR,
+            )
+    assert response.status_code == HTTPStatus.OK