fix: address second-round review feedback on user_activity epic (#13-#18)

- Bound per-partition fetch limit to MAX_ACTIVITY_ROWS // 30 (#13)
- Pass viewer_user_id from endpoint to record_video_view (#14)
- Change early-return to pass so activity tracking isn't skipped (#14)
- Pass video_id as activity_id in view tracking (#14)
- Patch record_user_activity contract in comment tests, not DB internals (#15)
- Add totalPages==0 assertion and invalid activity_type 422 test (#17)
- Graceful error handling in record_user_activity with logger.warning (#18)
- Add test verifying warning is logged on DB failure (#18)

172 tests pass, 0 new failures.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pmcfadin

app/api/v1/endpoints/video_catalog.py

@@ -256,7 +256,10 @@ async def record_view(
         )
 
     # READY – record the view
-    await video_service.record_video_view(video_id_path)
+    await video_service.record_video_view(
+        video_id_path,
+        viewer_user_id=current_user.userid if current_user else None,
+    )
     return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 

app/main.py

@@ -28,6 +28,7 @@
     reco_internal,
     flags,
     moderation,
+    user_activity,
 )
 
 # --------------------------------------------------------------
@@ -67,6 +68,7 @@
 api_router_v1.include_router(reco_internal.router)
 api_router_v1.include_router(flags.router)
 api_router_v1.include_router(moderation.router)
+api_router_v1.include_router(user_activity.router)
 
 app.include_router(api_router_v1)
 

app/services/user_activity_service.py

@@ -50,15 +50,23 @@ async def record_user_activity(
     now_utc = datetime.now(timezone.utc)
     day_partition = now_utc.strftime("%Y-%m-%d")
 
-    await db_table.insert_one(
-        {
-            "userid": str(userid),
-            "day": day_partition,
-            "activity_type": activity_type,
-            "activity_id": str(activity_id),
-            "activity_timestamp": now_utc.isoformat(),
-        }
-    )
+    try:
+        await db_table.insert_one(
+            {
+                "userid": str(userid),
+                "day": day_partition,
+                "activity_type": activity_type,
+                "activity_id": str(activity_id),
+                "activity_timestamp": now_utc.isoformat(),
+            }
+        )
+    except Exception:
+        logger.warning(
+            "Failed to record user activity for userid=%s activity_type=%s; skipping.",
+            userid,
+            activity_type,
+            exc_info=True,
+        )
 
 
 async def _fetch_day_rows(

tests/api/v1/endpoints/test_user_activity.py

@@ -73,6 +73,7 @@ async def test_get_user_activity_empty():
         body = resp.json()
         assert body["data"] == []
         assert body["pagination"]["totalItems"] == 0
+        assert body["pagination"]["totalPages"] == 0
 
 
 @pytest.mark.asyncio
@@ -131,3 +132,13 @@ async def test_get_user_activity_pagination(sample_activities):
         assert body["pagination"]["pageSize"] == 1
         assert body["pagination"]["totalItems"] == 2
         assert body["pagination"]["totalPages"] == 2
+
+
+@pytest.mark.asyncio
+async def test_get_user_activity_invalid_type_returns_422():
+    """An unrecognised activity_type value must produce a 422 validation error."""
+    async with AsyncClient(app=app, base_url="http://test") as ac:
+        resp = await ac.get(
+            f"{settings.API_V1_STR}/users/{uuid4()}/activity?activity_type=invalid"
+        )
+    assert resp.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY

tests/services/test_comment_service.py

@@ -87,33 +87,32 @@ async def test_add_comment_calls_record_user_activity(viewer_user: User, sample_
             "app.services.comment_service.get_table", new_callable=AsyncMock
         ) as mock_get_table,
         patch(
-            "app.services.user_activity_service.get_table", new_callable=AsyncMock
-        ) as mock_ua_get_table,
+            "app.services.comment_service.record_user_activity",
+            new_callable=AsyncMock,
+        ) as mock_record_activity,
     ):
         mock_get_vid.return_value = sample_video
         mock_table_video = AsyncMock()
         mock_table_user = AsyncMock()
         mock_get_table.side_effect = [mock_table_video, mock_table_user]
-        mock_ua_table = AsyncMock()
-        mock_ua_get_table.return_value = mock_ua_table
 
         comment = await comment_service.add_comment_to_video(
             video_id=sample_video.videoid,
             request=request,
             current_user=viewer_user,
         )
 
-        # Verify record_user_activity was called via DB insert
-        mock_ua_table.insert_one.assert_awaited_once()
-        doc = mock_ua_table.insert_one.call_args.args[0] if mock_ua_table.insert_one.call_args.args else mock_ua_table.insert_one.call_args.kwargs
-        assert doc["userid"] == str(viewer_user.userid)
-        assert doc["activity_type"] == "comment"
-        assert doc["activity_id"] == str(comment.commentid)
+        # Verify record_user_activity was called with the correct contract arguments
+        mock_record_activity.assert_awaited_once_with(
+            userid=viewer_user.userid,
+            activity_type="comment",
+            activity_id=comment.commentid,
+        )
 
 
 @pytest.mark.asyncio
 async def test_add_comment_user_activity_failure_does_not_break(viewer_user: User, sample_video: Video):
-    """If user_activity insert fails, the comment still succeeds."""
+    """If record_user_activity raises, the comment operation still succeeds."""
     request = CommentCreateRequest(text="Still works!")
     sample_video.status = VideoStatusEnum.READY
 
@@ -126,18 +125,17 @@ async def test_add_comment_user_activity_failure_does_not_break(viewer_user: Use
             "app.services.comment_service.get_table", new_callable=AsyncMock
         ) as mock_get_table,
         patch(
-            "app.services.user_activity_service.get_table", new_callable=AsyncMock
-        ) as mock_ua_get_table,
+            "app.services.comment_service.record_user_activity",
+            new_callable=AsyncMock,
+        ) as mock_record_activity,
     ):
         mock_get_vid.return_value = sample_video
         mock_table_video = AsyncMock()
         mock_table_user = AsyncMock()
         mock_get_table.side_effect = [mock_table_video, mock_table_user]
-        mock_ua_table = AsyncMock()
-        mock_ua_table.insert_one.side_effect = Exception("DB error")
-        mock_ua_get_table.return_value = mock_ua_table
+        mock_record_activity.side_effect = Exception("activity service error")
 
-        # Should NOT raise despite user_activity failure
+        # Should NOT raise despite record_user_activity failure
         comment = await comment_service.add_comment_to_video(
             video_id=sample_video.videoid,
             request=request,

tests/services/test_user_activity_service.py

@@ -334,18 +334,23 @@ def mock_find(filter=None, **kwargs):
 
 
 @pytest.mark.asyncio
-async def test_record_user_activity_db_failure_raises():
-    """record_user_activity raises on DB failure; callers must wrap in try/except."""
+async def test_record_user_activity_db_failure_graceful():
+    """record_user_activity does not raise on DB failure — it logs a warning instead."""
     mock_table = AsyncMock()
     mock_table.insert_one.side_effect = Exception("DB connection lost")
 
-    with pytest.raises(Exception, match="DB connection lost"):
+    with patch("app.services.user_activity_service.logger") as mock_logger:
+        # Should NOT raise
         await record_user_activity(
             userid=uuid4(),
             activity_type="view",
             db_table=mock_table,
         )
 
+        mock_logger.warning.assert_called_once()
+        warning_msg = mock_logger.warning.call_args[0][0]
+        assert "Failed to record user activity" in warning_msg
+
 
 @pytest.mark.asyncio
 async def test_record_user_activity_each_activity_type():