Add integration tests for remaining aggregation APIs

Author: dacharyc

server/python/tests/README.md

@@ -29,11 +29,11 @@ The test suite is organized into three categories:
 - Requires a running MongoDB instance with MFlix dataset
 - Uses a real server running in a subprocess
 - Tests are idempotent (clean up after themselves)
-- **8 tests** (7 passing, 1 skipped due to known bug) covering:
-  - End-to-end CRUD operations
-  - Search against real data
-  - Batch operations with cleanup
-  - Aggregation queries
+- **10 tests** covering:
+  - CRUD operations
+  - Batch operations
+  - Search functionality
+  - Aggregation pipelines
 
 ## Running Tests
 
@@ -56,23 +56,23 @@ The test suite is organized into three categories:
 pytest tests/ -v
 ```
 
-**Expected output:** 69 passed in ~5 seconds
+**Expected output:** 71 passed in ~6 seconds
 
 ### Run Only Unit Tests (Fast, No Database Required)
 
 ```bash
 pytest -m unit -v
 ```
 
-**Expected output:** 61 passed, 8 deselected in ~1 second
+**Expected output:** 61 passed, 10 deselected in ~1.5 seconds
 
 ### Run Only Integration Tests (Requires Database)
 
 ```bash
 pytest -m integration -v
 ```
 
-**Expected output:** 8 passed, 61 deselected in ~4 seconds
+**Expected output:** 10 passed, 61 deselected in ~5 seconds
 
 ### Run Specific Test File
 

server/python/tests/integration/test_movie_routes_integration.py

@@ -323,3 +323,65 @@ async def test_aggregate_movies_by_year(self, client):
         assert "lowestRating" in first_result
         assert "totalVotes" in first_result
 
+    @pytest.mark.asyncio
+    async def test_aggregate_movies_by_comments(self, client):
+        """
+        Test aggregation reporting by comments.
+
+        This test demonstrates:
+        - $lookup aggregation (joining collections)
+        - Testing against existing dataset with comments
+        - Validating nested data structures
+        """
+        response = await client.get("/api/movies/aggregations/reportingByComments?limit=5")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is True
+
+        # Should return movies that have comments
+        if len(data["data"]) > 0:
+            first_result = data["data"][0]
+            # Validate structure of aggregation results
+            assert "_id" in first_result
+            assert "title" in first_result
+            assert "year" in first_result
+            assert "totalComments" in first_result
+            assert "recentComments" in first_result
+            assert isinstance(first_result["recentComments"], list)
+
+            # If there are recent comments, validate their structure
+            if len(first_result["recentComments"]) > 0:
+                comment = first_result["recentComments"][0]
+                assert "userName" in comment
+                assert "userEmail" in comment
+                assert "text" in comment
+                assert "date" in comment
+
+    @pytest.mark.asyncio
+    async def test_aggregate_directors_most_movies(self, client):
+        """
+        Test aggregation reporting by directors.
+
+        This test demonstrates:
+        - $unwind aggregation (array flattening)
+        - Grouping and sorting operations
+        - Testing against existing dataset
+        """
+        response = await client.get("/api/movies/aggregations/reportingByDirectors?limit=10")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is True
+        assert len(data["data"]) > 0
+
+        # Validate structure of aggregation results
+        first_result = data["data"][0]
+        assert "director" in first_result
+        assert "movieCount" in first_result
+        assert "averageRating" in first_result
+
+        # Verify results are sorted by movieCount (descending)
+        if len(data["data"]) > 1:
+            assert data["data"][0]["movieCount"] >= data["data"][1]["movieCount"]
+