feat: fixed fixtures in backend/e2e (#237)

* feat: fixed fixtures in backend/e2e
* feat: extract default exec request + removed redis client dep in sse routes tests
* fix: simple exec script as a fixture

Author: HardMax71

backend/tests/e2e/conftest.py

@@ -3,7 +3,6 @@
 from collections.abc import Callable
 
 import pytest
-import pytest_asyncio
 import redis.asyncio as redis
 from app.db.docs.saga import SagaDocument
 from app.domain.enums import EventType, UserRole
@@ -94,7 +93,7 @@ async def wait_for_notification(
 
 
 @pytest.fixture
-def simple_execution_request() -> ExecutionRequest:
+def exec_request() -> ExecutionRequest:
     """Simple python print execution."""
     return ExecutionRequest(script="print('test')", lang="python", lang_version="3.11")
 
@@ -155,74 +154,60 @@ def new_script_request() -> SavedScriptCreateRequest:
     )
 
 
-@pytest_asyncio.fixture
-async def created_execution(
-    test_user: AsyncClient, simple_execution_request: ExecutionRequest
+async def create_execution(
+    client: AsyncClient,
+    request: ExecutionRequest,
 ) -> ExecutionResponse:
-    """Execution created by test_user (does NOT wait for completion)."""
-    resp = await test_user.post(
-        "/api/v1/execute", json=simple_execution_request.model_dump()
-    )
+    """POST /execute and return response (does NOT wait for completion)."""
+    resp = await client.post("/api/v1/execute", json=request.model_dump())
     assert resp.status_code == 200
     return ExecutionResponse.model_validate(resp.json())
 
 
-@pytest_asyncio.fixture
-async def created_execution_admin(
-    test_admin: AsyncClient, simple_execution_request: ExecutionRequest
-) -> ExecutionResponse:
-    """Execution created by test_admin."""
-    resp = await test_admin.post(
-        "/api/v1/execute", json=simple_execution_request.model_dump()
-    )
-    assert resp.status_code == 200
-    return ExecutionResponse.model_validate(resp.json())
-
-
-@pytest_asyncio.fixture
-async def execution_with_saga(
+async def create_execution_with_saga(
+    client: AsyncClient,
     redis_client: redis.Redis,
-    created_execution: ExecutionResponse,
+    request: ExecutionRequest,
 ) -> tuple[ExecutionResponse, SagaStatusResponse]:
-    """Execution with saga guaranteed in MongoDB (via POD_CREATED event).
+    """Create execution, wait for POD_CREATED, return (execution, saga).
 
-    POD_CREATED arrives after the saga orchestrator has persisted the saga
-    document and dispatched the create-pod command.  We query Beanie directly
-    (same DB, no HTTP round-trip) for a deterministic, sleep-free lookup.
+    POD_CREATED implies the saga orchestrator persisted the document and
+    dispatched the create-pod command.
     """
-    await wait_for_pod_created(redis_client, created_execution.execution_id)
+    execution = await create_execution(client, request)
+    await wait_for_pod_created(redis_client, execution.execution_id)
 
-    doc = await SagaDocument.find_one(SagaDocument.execution_id == created_execution.execution_id)
+    doc = await SagaDocument.find_one(SagaDocument.execution_id == execution.execution_id)
     assert doc is not None, (
-        f"No saga document for {created_execution.execution_id} despite POD_CREATED received"
+        f"No saga document for {execution.execution_id} despite POD_CREATED received"
     )
 
     saga = SagaStatusResponse.model_validate(doc, from_attributes=True)
-    assert saga.execution_id == created_execution.execution_id
-    return created_execution, saga
+    return execution, saga
 
 
-@pytest_asyncio.fixture
-async def execution_with_notification(
-    test_user: AsyncClient,
+async def create_execution_with_notification(
+    client: AsyncClient,
     redis_client: redis.Redis,
-    created_execution: ExecutionResponse,
+    request: ExecutionRequest,
+    *,
+    timeout: float = 30.0,
 ) -> tuple[ExecutionResponse, NotificationResponse]:
-    """Execution with notification guaranteed in MongoDB.
+    """Create execution, wait for notification delivery, return (execution, notification).
 
-    Waits on sse:notif:{user_id} — the notification service publishes there
-    only after persisting to MongoDB.  Unlike RESULT_STORED (which comes from
-    an independent consumer group), this is a correct readiness signal.
+    Fetches user_id from /auth/me, waits on sse:notif:{user_id} (correct
+    signal — notification service publishes after MongoDB persist), then
+    queries the notification list.
     """
-    me_resp = await test_user.get("/api/v1/auth/me")
+    me_resp = await client.get("/api/v1/auth/me")
     assert me_resp.status_code == 200
     user_id = me_resp.json()["user_id"]
 
-    await wait_for_notification(redis_client, user_id)
+    execution = await create_execution(client, request)
+    await wait_for_notification(redis_client, user_id, timeout=timeout)
 
-    resp = await test_user.get("/api/v1/notifications", params={"limit": 10})
+    resp = await client.get("/api/v1/notifications", params={"limit": 10})
     assert resp.status_code == 200
     result = NotificationListResponse.model_validate(resp.json())
     assert result.notifications, "No notification after SSE delivery"
-    notification = result.notifications[0]
-    return created_execution, notification
+    return execution, result.notifications[0]

backend/tests/e2e/test_execution_routes.py

@@ -83,10 +83,10 @@ class TestExecutionHappyPath:
 
     @pytest.mark.asyncio
     async def test_execute_simple_script_completes(
-        self, test_user: AsyncClient, redis_client: redis.Redis, simple_execution_request: ExecutionRequest
+        self, test_user: AsyncClient, redis_client: redis.Redis, exec_request: ExecutionRequest
     ) -> None:
         """Simple script executes and completes successfully."""
-        exec_response, result = await submit_and_wait(test_user, redis_client, simple_execution_request)
+        exec_response, result = await submit_and_wait(test_user, redis_client, exec_request)
 
         assert exec_response.execution_id
         assert result.status == ExecutionStatus.COMPLETED

backend/tests/e2e/test_notifications_routes.py

@@ -1,16 +1,18 @@
 import pytest
+import redis.asyncio as redis
 from app.domain.enums import NotificationChannel, NotificationSeverity, NotificationStatus
-from app.schemas_pydantic.execution import ExecutionResponse
+from app.schemas_pydantic.execution import ExecutionRequest
 from app.schemas_pydantic.notification import (
     DeleteNotificationResponse,
     NotificationListResponse,
-    NotificationResponse,
     NotificationSubscription,
     SubscriptionsResponse,
     UnreadCountResponse,
 )
 from httpx import AsyncClient
 
+from tests.e2e.conftest import create_execution_with_notification
+
 pytestmark = [pytest.mark.e2e, pytest.mark.kafka]
 
 
@@ -104,10 +106,11 @@ async def test_mark_nonexistent_notification_read(
     async def test_mark_notification_read(
             self,
             test_user: AsyncClient,
-            execution_with_notification: tuple[ExecutionResponse, NotificationResponse],
+            redis_client: redis.Redis,
+            exec_request: ExecutionRequest,
     ) -> None:
         """Mark existing notification as read."""
-        _, notification = execution_with_notification
+        _, notification = await create_execution_with_notification(test_user, redis_client, exec_request)
 
         response = await test_user.put(
             f"/api/v1/notifications/{notification.notification_id}/read"
@@ -131,19 +134,19 @@ class TestMarkAllRead:
     async def test_mark_all_read(
             self,
             test_user: AsyncClient,
-            execution_with_notification: tuple[ExecutionResponse, NotificationResponse],
+            redis_client: redis.Redis,
+            exec_request: ExecutionRequest,
     ) -> None:
         """Mark all notifications as read returns 204."""
-        _, notification = execution_with_notification
+        _, notification = await create_execution_with_notification(test_user, redis_client, exec_request)
 
         response = await test_user.post("/api/v1/notifications/mark-all-read")
         assert response.status_code == 204
 
         # Verify the specific notification was marked as read.
         # We assert on the individual notification rather than global unread_count
-        # because other tests create executions (via created_execution without
-        # waiting for notifications) whose async notifications can arrive between
-        # mark-all-read and any subsequent count query.
+        # because other tests create executions whose async notifications can
+        # arrive between mark-all-read and any subsequent count query.
         resp = await test_user.get("/api/v1/notifications")
         assert resp.status_code == 200
         result = NotificationListResponse.model_validate(resp.json())
@@ -284,9 +287,12 @@ class TestUnreadCount:
     async def test_get_unread_count(
             self,
             test_user: AsyncClient,
-            execution_with_notification: tuple[ExecutionResponse, NotificationResponse],
+            redis_client: redis.Redis,
+            exec_request: ExecutionRequest,
     ) -> None:
         """Get unread notification count."""
+        await create_execution_with_notification(test_user, redis_client, exec_request)
+
         response = await test_user.get("/api/v1/notifications/unread-count")
 
         assert response.status_code == 200
@@ -313,10 +319,11 @@ async def test_delete_nonexistent_notification(
     async def test_delete_notification(
             self,
             test_user: AsyncClient,
-            execution_with_notification: tuple[ExecutionResponse, NotificationResponse],
+            redis_client: redis.Redis,
+            exec_request: ExecutionRequest,
     ) -> None:
         """Delete existing notification returns success."""
-        _, notification = execution_with_notification
+        _, notification = await create_execution_with_notification(test_user, redis_client, exec_request)
 
         response = await test_user.delete(
             f"/api/v1/notifications/{notification.notification_id}"
@@ -342,10 +349,11 @@ async def test_user_cannot_see_other_users_notifications(
             self,
             test_user: AsyncClient,
             another_user: AsyncClient,
-            execution_with_notification: tuple[ExecutionResponse, NotificationResponse],
+            redis_client: redis.Redis,
+            exec_request: ExecutionRequest,
     ) -> None:
         """User's notification list does not include other users' notifications."""
-        _, notification = execution_with_notification
+        _, notification = await create_execution_with_notification(test_user, redis_client, exec_request)
 
         response = await another_user.get("/api/v1/notifications")
         assert response.status_code == 200
@@ -360,10 +368,11 @@ async def test_cannot_mark_other_users_notification_read(
             self,
             test_user: AsyncClient,
             another_user: AsyncClient,
-            execution_with_notification: tuple[ExecutionResponse, NotificationResponse],
+            redis_client: redis.Redis,
+            exec_request: ExecutionRequest,
     ) -> None:
         """Cannot mark another user's notification as read."""
-        _, notification = execution_with_notification
+        _, notification = await create_execution_with_notification(test_user, redis_client, exec_request)
 
         response = await another_user.put(
             f"/api/v1/notifications/{notification.notification_id}/read"
@@ -382,10 +391,11 @@ async def test_cannot_delete_other_users_notification(
             self,
             test_user: AsyncClient,
             another_user: AsyncClient,
-            execution_with_notification: tuple[ExecutionResponse, NotificationResponse],
+            redis_client: redis.Redis,
+            exec_request: ExecutionRequest,
     ) -> None:
         """Cannot delete another user's notification."""
-        _, notification = execution_with_notification
+        _, notification = await create_execution_with_notification(test_user, redis_client, exec_request)
 
         response = await another_user.delete(
             f"/api/v1/notifications/{notification.notification_id}"