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,10 @@ from fastapi import FastAPI
 from httpx import ASGITransport, AsyncClient
 from roboco.api.deps import get_agent_context, get_current_agent_id, get_db
 from roboco.api.routes.notifications import router as notifications_router
+from roboco.api.schemas.notifications import NotificationResponse
 from roboco.db.tables import AgentTable
 from roboco.models import AgentRole, AgentStatus, Team
+from roboco.models.base import NotificationPriority, NotificationType
 from roboco.models.permissions import AgentContext

 if TYPE_CHECKING:
@@ -72,7 +77,7 @@ _HDR = {"X-Agent-ID": str(uuid4()), "X-Agent-Role": "developer"}
 async def test_list_notifications_empty(notif_client: dict) -> None:
    client = notif_client["client"]
    response = await client.get("/api/notifications", headers=_HDR)
-    assert response.status_code == 200
+    assert response.status_code == HTTPStatus.OK
    body = response.json()
    assert body["items"] == []
    assert body["total"] == 0
@@ -82,21 +87,21 @@ async def test_list_notifications_empty(notif_client: dict) -> None:
 async def test_get_notification_not_found(notif_client: dict) -> None:
    client = notif_client["client"]
    response = await client.get(f"/api/notifications/{uuid4()}", headers=_HDR)
-    assert response.status_code in (404, 403)
+    assert response.status_code in (HTTPStatus.NOT_FOUND, HTTPStatus.FORBIDDEN)


@pytest.mark.asyncio
 async def test_acknowledge_notification_not_found(notif_client: dict) -> None:
    client = notif_client["client"]
    response = await client.post(f"/api/notifications/{uuid4()}/ack", headers=_HDR)
-    assert response.status_code in (404, 403)
+    assert response.status_code in (HTTPStatus.NOT_FOUND, HTTPStatus.FORBIDDEN)


@pytest.mark.asyncio
 async def test_mark_as_read_not_found(notif_client: dict) -> None:
    client = notif_client["client"]
    response = await client.post(f"/api/notifications/{uuid4()}/read", headers=_HDR)
-    assert response.status_code in (404, 403)
+    assert response.status_code in (HTTPStatus.NOT_FOUND, HTTPStatus.FORBIDDEN)


@pytest.mark.asyncio
@@ -105,4 +110,186 @@ async def test_list_with_filters(notif_client: dict) -> None:
    response = await client.get(
        "/api/notifications?unread_only=true&limit=20", headers=_HDR
    )
-    assert response.status_code == 200
+    assert response.status_code == HTTPStatus.OK
+
+
+# ---------------------------------------------------------------------------
+# System role list path
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_list_notifications_system_role(db_session) -> None:
+    """System role triggers list_system_notifications branch."""
+    sys_agent = AgentTable(
+        id=uuid4(),
+        name="Sys",
+        slug=f"system-{uuid4().hex[:8]}",
+        role=AgentRole.SYSTEM,
+        team=None,
+        status=AgentStatus.ACTIVE,
+        model_config={},
+        system_prompt="sys",
+        capabilities=[],
+        permissions={},
+        metrics={},
+    )
+    db_session.add(sys_agent)
+    await db_session.flush()
+
+    app = FastAPI()
+    app.include_router(notifications_router, prefix="/api/notifications")
+
+    async def _override_db():
+        yield db_session
+
+    async def _override_agent() -> AgentContext:
+        return AgentContext(agent_id=sys_agent.id, role=AgentRole.SYSTEM, team=None)
+
+    async def _override_agent_id():
+        return sys_agent.id
+
+    app.dependency_overrides[get_db] = _override_db
+    app.dependency_overrides[get_agent_context] = _override_agent
+    app.dependency_overrides[get_current_agent_id] = _override_agent_id
+
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        response = await client.get("/api/notifications", headers=_HDR)
+    app.dependency_overrides.clear()
+    assert response.status_code == HTTPStatus.OK
+
+
+@pytest.mark.asyncio
+async def test_get_notification_permission_error(notif_client: dict) -> None:
+    client = notif_client["client"]
+    with patch(
+        "roboco.api.routes.notifications.get_notification_delivery_service"
+    ) as mock_get:
+        instance = AsyncMock()
+        instance.get_for_recipient_and_mark_read = AsyncMock(
+            side_effect=PermissionError("denied")
+        )
+        mock_get.return_value = instance
+        response = await client.get(f"/api/notifications/{uuid4()}", headers=_HDR)
+    assert response.status_code == HTTPStatus.FORBIDDEN
+
+
+@pytest.mark.asyncio
+async def test_acknowledge_value_error(notif_client: dict) -> None:
+    client = notif_client["client"]
+    with patch(
+        "roboco.api.routes.notifications.get_notification_delivery_service"
+    ) as mock_get:
+        instance = AsyncMock()
+        instance.acknowledge_for_recipient = AsyncMock(
+            side_effect=ValueError("bad data")
+        )
+        mock_get.return_value = instance
+        response = await client.post(f"/api/notifications/{uuid4()}/ack", headers=_HDR)
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+
+
+@pytest.mark.asyncio
+async def test_mark_read_permission_error(notif_client: dict) -> None:
+    client = notif_client["client"]
+    with patch(
+        "roboco.api.routes.notifications.get_notification_delivery_service"
+    ) as mock_get:
+        instance = AsyncMock()
+        instance.mark_read_for_recipient = AsyncMock(
+            side_effect=PermissionError("nope")
+        )
+        mock_get.return_value = instance
+        response = await client.post(f"/api/notifications/{uuid4()}/read", headers=_HDR)
+    assert response.status_code == HTTPStatus.FORBIDDEN
+
+
+@pytest.mark.asyncio
+async def test_get_notification_returns_response(notif_client: dict) -> None:
+    """Line 98: get success → notification_to_response."""
+
+    client = notif_client["client"]
+    fake_notif = AsyncMock()
+    fake_response = NotificationResponse(
+        id=uuid4(),
+        type=NotificationType.TASK_ASSIGNMENT,
+        priority=NotificationPriority.NORMAL,
+        from_agent=uuid4(),
+        to_agents=[uuid4()],
+        subject="x",
+        body="y",
+        requires_ack=False,
+        is_acknowledged=False,
+        is_fully_acknowledged=False,
+        is_read=True,
+        related_task_id=None,
+        timestamp=datetime.now(UTC),
+        expires_at=None,
+    )
+    with patch(
+        "roboco.api.routes.notifications.get_notification_delivery_service"
+    ) as mock_get:
+        instance = AsyncMock()
+        instance.get_for_recipient_and_mark_read = AsyncMock(return_value=fake_notif)
+        mock_get.return_value = instance
+        with patch(
+            "roboco.api.routes.notifications.notification_to_response",
+            return_value=fake_response,
+        ):
+            response = await client.get(f"/api/notifications/{uuid4()}", headers=_HDR)
+    assert response.status_code == HTTPStatus.OK
+
+
+@pytest.mark.asyncio
+async def test_acknowledge_permission_error(notif_client: dict) -> None:
+    """Line 121: PermissionError on ack → 403."""
+    client = notif_client["client"]
+    with patch(
+        "roboco.api.routes.notifications.get_notification_delivery_service"
+    ) as mock_get:
+        instance = AsyncMock()
+        instance.acknowledge_for_recipient = AsyncMock(
+            side_effect=PermissionError("nope")
+        )
+        mock_get.return_value = instance
+        response = await client.post(f"/api/notifications/{uuid4()}/ack", headers=_HDR)
+    assert response.status_code == HTTPStatus.FORBIDDEN
+
+
+@pytest.mark.asyncio
+async def test_acknowledge_returns_response(notif_client: dict) -> None:
+    """Line 126: ack success → notification_to_response."""
+
+    client = notif_client["client"]
+    fake_notif = AsyncMock()
+    fake_response = NotificationResponse(
+        id=uuid4(),
+        type=NotificationType.TASK_ASSIGNMENT,
+        priority=NotificationPriority.NORMAL,
+        from_agent=uuid4(),
+        to_agents=[uuid4()],
+        subject="x",
+        body="y",
+        requires_ack=True,
+        is_acknowledged=True,
+        is_fully_acknowledged=True,
+        is_read=True,
+        related_task_id=None,
+        timestamp=datetime.now(UTC),
+        expires_at=None,
+    )
+    with patch(
+        "roboco.api.routes.notifications.get_notification_delivery_service"
+    ) as mock_get:
+        instance = AsyncMock()
+        instance.acknowledge_for_recipient = AsyncMock(return_value=fake_notif)
+        mock_get.return_value = instance
+        with patch(
+            "roboco.api.routes.notifications.notification_to_response",
+            return_value=fake_response,
+        ):
+            response = await client.post(
+                f"/api/notifications/{uuid4()}/ack", headers=_HDR
+            )
+    assert response.status_code == HTTPStatus.OK