feat: add tests for optimized member enrichment function in group service

Author: Devasy

backend/tests/expenses/test_expense_service.py

@@ -2109,5 +2109,122 @@ async def test_get_group_analytics_group_not_found(expense_service):
         mock_db.users.find_one.assert_not_called()
 
 
+@pytest.mark.asyncio
+async def test_get_friends_balance_summary_aggregation_error(expense_service):
+    """Test friends balance summary when aggregation fails"""
+    user_id_str = str(ObjectId())
+
+    with patch("app.expenses.service.mongodb") as mock_mongodb:
+        mock_db = MagicMock()
+        mock_mongodb.database = mock_db
+
+        # Mock groups
+        mock_groups = [
+            {
+                "_id": ObjectId(),
+                "name": "Test Group",
+                "members": [{"userId": user_id_str}, {"userId": str(ObjectId())}],
+            }
+        ]
+        mock_groups_cursor = AsyncMock()
+        mock_groups_cursor.to_list.return_value = mock_groups
+        mock_db.groups.find.return_value = mock_groups_cursor
+
+        # Mock aggregation failure
+        mock_agg_cursor = AsyncMock()
+        mock_agg_cursor.to_list.side_effect = Exception("Aggregation failed")
+        mock_db.settlements.aggregate.return_value = mock_agg_cursor
+
+        result = await expense_service.get_friends_balance_summary(user_id_str)
+
+        # Should return empty results on error
+        assert len(result["friendsBalance"]) == 0
+        assert result["summary"]["totalOwedToYou"] == 0
+        assert result["summary"]["totalYouOwe"] == 0
+        assert result["summary"]["friendCount"] == 0
+
+
+@pytest.mark.asyncio
+async def test_get_friends_balance_summary_user_fetch_error(expense_service):
+    """Test friends balance summary when fetching user details fails"""
+    user_id_str = str(ObjectId())
+    friend_id_str = str(ObjectId())
+
+    with patch("app.expenses.service.mongodb") as mock_mongodb:
+        mock_db = MagicMock()
+        mock_mongodb.database = mock_db
+
+        # Mock groups
+        mock_groups = [
+            {
+                "_id": ObjectId(),
+                "name": "Test Group",
+                "members": [{"userId": user_id_str}, {"userId": friend_id_str}],
+            }
+        ]
+        mock_groups_cursor = AsyncMock()
+        mock_groups_cursor.to_list.return_value = mock_groups
+        mock_db.groups.find.return_value = mock_groups_cursor
+
+        # Mock aggregation success
+        mock_agg_cursor = AsyncMock()
+        mock_agg_cursor.to_list.return_value = [
+            {
+                "_id": friend_id_str,
+                "totalBalance": 50.0,
+                "groups": [{"groupId": str(mock_groups[0]["_id"]), "balance": 50.0}],
+            }
+        ]
+        mock_db.settlements.aggregate.return_value = mock_agg_cursor
+
+        # Mock user fetch failure
+        mock_users_cursor = AsyncMock()
+        mock_users_cursor.to_list.side_effect = Exception("User fetch failed")
+        mock_db.users.find.return_value = mock_users_cursor
+
+        result = await expense_service.get_friends_balance_summary(user_id_str)
+
+        # Should still return results but with "Unknown" for user names
+        assert len(result["friendsBalance"]) == 1
+        assert result["friendsBalance"][0]["userName"] == "Unknown"
+        assert result["friendsBalance"][0]["netBalance"] == 50.0
+
+
+@pytest.mark.asyncio
+async def test_get_friends_balance_summary_zero_balance_filtering(expense_service):
+    """Test that friends with zero balance are filtered out"""
+    user_id_str = str(ObjectId())
+
+    with patch("app.expenses.service.mongodb") as mock_mongodb:
+        mock_db = MagicMock()
+        mock_mongodb.database = mock_db
+
+        # Mock groups
+        mock_groups = [
+            {
+                "_id": ObjectId(),
+                "name": "Test Group",
+                "members": [{"userId": user_id_str}],
+            }
+        ]
+        mock_groups_cursor = AsyncMock()
+        mock_groups_cursor.to_list.return_value = mock_groups
+        mock_db.groups.find.return_value = mock_groups_cursor
+
+        # Mock aggregation returns no results (all filtered by zero balance)
+        mock_agg_cursor = AsyncMock()
+        mock_agg_cursor.to_list.return_value = []
+        mock_db.settlements.aggregate.return_value = mock_agg_cursor
+
+        result = await expense_service.get_friends_balance_summary(user_id_str)
+
+        # Should return empty friend balance
+        assert len(result["friendsBalance"]) == 0
+        assert result["summary"]["totalOwedToYou"] == 0
+        assert result["summary"]["totalYouOwe"] == 0
+        assert result["summary"]["friendCount"] == 0
+        assert result["summary"]["activeGroups"] == 1
+
+
 if __name__ == "__main__":
     pytest.main([__file__])

backend/tests/groups/test_enrich_members.py

@@ -0,0 +1,215 @@
+"""Tests for the optimized _enrich_members_with_user_details function"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from app.groups.service import GroupService
+from bson import ObjectId
+
+
+class TestEnrichMembersOptimized:
+    """Test cases for _enrich_members_with_user_details optimized function"""
+
+    def setup_method(self):
+        """Setup for each test method"""
+        self.service = GroupService()
+
+    @pytest.mark.asyncio
+    async def test_enrich_members_with_user_details_success(self):
+        """Test successful enrichment of members with user details"""
+        user_id_1 = str(ObjectId())
+        user_id_2 = str(ObjectId())
+        user_id_3 = str(ObjectId())
+
+        members = [
+            {"userId": user_id_1, "role": "admin", "joinedAt": "2023-01-01"},
+            {"userId": user_id_2, "role": "member", "joinedAt": "2023-01-02"},
+            {"userId": user_id_3, "role": "member", "joinedAt": "2023-01-03"},
+        ]
+
+        mock_users = [
+            {"_id": ObjectId(user_id_1), "name": "Admin User", "imageUrl": "admin.jpg"},
+            {
+                "_id": ObjectId(user_id_2),
+                "name": "Member One",
+                "imageUrl": "member1.jpg",
+            },
+            {"_id": ObjectId(user_id_3), "name": "Member Two", "imageUrl": None},
+        ]
+
+        mock_db = MagicMock()
+        mock_users_collection = MagicMock()
+        mock_db.users = mock_users_collection
+
+        # Mock the find operation
+        mock_cursor = AsyncMock()
+        mock_cursor.to_list.return_value = mock_users
+        mock_users_collection.find.return_value = mock_cursor
+
+        with patch.object(self.service, "get_db", return_value=mock_db):
+            enriched = await self.service._enrich_members_with_user_details(members)
+
+        assert len(enriched) == 3
+        assert enriched[0]["userId"] == user_id_1
+        assert enriched[0]["user"]["name"] == "Admin User"
+        assert enriched[0]["user"]["imageUrl"] == "admin.jpg"
+        assert enriched[0]["role"] == "admin"
+
+        assert enriched[1]["userId"] == user_id_2
+        assert enriched[1]["user"]["name"] == "Member One"
+        assert enriched[1]["user"]["imageUrl"] == "member1.jpg"
+
+        assert enriched[2]["userId"] == user_id_3
+        assert enriched[2]["user"]["name"] == "Member Two"
+        assert enriched[2]["user"]["imageUrl"] is None
+
+        # Verify the query was made correctly with $in operator
+        mock_users_collection.find.assert_called_once()
+        call_args = mock_users_collection.find.call_args
+        assert "_id" in call_args[0][0]
+        assert "$in" in call_args[0][0]["_id"]
+
+    @pytest.mark.asyncio
+    async def test_enrich_members_empty_list(self):
+        """Test enrichment with empty members list"""
+        mock_db = MagicMock()
+
+        with patch.object(self.service, "get_db", return_value=mock_db):
+            enriched = await self.service._enrich_members_with_user_details([])
+
+        assert enriched == []
+        # Verify no database call was made
+        mock_db.users.find.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_enrich_members_missing_user_data(self):
+        """Test enrichment when some users are not found in database"""
+        user_id_1 = str(ObjectId())
+        user_id_2 = str(ObjectId())
+
+        members = [
+            {"userId": user_id_1, "role": "admin", "joinedAt": "2023-01-01"},
+            {"userId": user_id_2, "role": "member", "joinedAt": "2023-01-02"},
+        ]
+
+        # Only return data for user_id_1, not user_id_2
+        mock_users = [
+            {"_id": ObjectId(user_id_1), "name": "Admin User", "imageUrl": "admin.jpg"},
+        ]
+
+        mock_db = MagicMock()
+        mock_users_collection = MagicMock()
+        mock_db.users = mock_users_collection
+
+        mock_cursor = AsyncMock()
+        mock_cursor.to_list.return_value = mock_users
+        mock_users_collection.find.return_value = mock_cursor
+
+        with patch.object(self.service, "get_db", return_value=mock_db):
+            enriched = await self.service._enrich_members_with_user_details(members)
+
+        assert len(enriched) == 2
+        assert enriched[0]["user"]["name"] == "Admin User"
+        # Missing user should have fallback name
+        assert "User" in enriched[1]["user"]["name"]  # Will be "User <last4digits>"
+
+    @pytest.mark.asyncio
+    async def test_enrich_members_database_error(self):
+        """Test enrichment when database query fails"""
+        user_id_1 = str(ObjectId())
+
+        members = [
+            {"userId": user_id_1, "role": "admin", "joinedAt": "2023-01-01"},
+        ]
+
+        mock_db = MagicMock()
+        mock_users_collection = MagicMock()
+        mock_db.users = mock_users_collection
+
+        # Simulate database error
+        mock_cursor = AsyncMock()
+        mock_cursor.to_list.side_effect = Exception("Database connection error")
+        mock_users_collection.find.return_value = mock_cursor
+
+        with patch.object(self.service, "get_db", return_value=mock_db):
+            enriched = await self.service._enrich_members_with_user_details(members)
+
+        # Should still return members with fallback user data
+        assert len(enriched) == 1
+        assert "User" in enriched[0]["user"]["name"]  # Fallback name
+        assert enriched[0]["user"]["imageUrl"] is None
+
+    @pytest.mark.asyncio
+    async def test_enrich_members_preserves_member_fields(self):
+        """Test that enrichment preserves all original member fields"""
+        user_id_1 = str(ObjectId())
+
+        members = [
+            {
+                "userId": user_id_1,
+                "role": "admin",
+                "joinedAt": "2023-01-01",
+                "customField": "custom_value",
+            },
+        ]
+
+        mock_users = [
+            {"_id": ObjectId(user_id_1), "name": "Admin User", "imageUrl": "admin.jpg"},
+        ]
+
+        mock_db = MagicMock()
+        mock_users_collection = MagicMock()
+        mock_db.users = mock_users_collection
+
+        mock_cursor = AsyncMock()
+        mock_cursor.to_list.return_value = mock_users
+        mock_users_collection.find.return_value = mock_cursor
+
+        with patch.object(self.service, "get_db", return_value=mock_db):
+            enriched = await self.service._enrich_members_with_user_details(members)
+
+        # Verify all fields are preserved
+        assert enriched[0]["userId"] == user_id_1
+        assert enriched[0]["role"] == "admin"
+        assert enriched[0]["joinedAt"] == "2023-01-01"
+        # Note: customField won't be in the output as the function creates a new structure
+        # It only preserves userId, role, and joinedAt
+        assert enriched[0]["user"]["name"] == "Admin User"
+        assert enriched[0]["user"]["imageUrl"] == "admin.jpg"
+
+    @pytest.mark.asyncio
+    async def test_enrich_members_batch_query_optimization(self):
+        """Test that the function uses a single batch query instead of N queries"""
+        # Create 10 members
+        members = []
+        user_ids = []
+        for i in range(10):
+            user_id = str(ObjectId())
+            user_ids.append(user_id)
+            members.append(
+                {"userId": user_id, "role": "member", "joinedAt": f"2023-01-{i+1:02d}"}
+            )
+
+        mock_users = [
+            {"_id": ObjectId(uid), "name": f"User {i}", "imageUrl": None}
+            for i, uid in enumerate(user_ids)
+        ]
+
+        mock_db = MagicMock()
+        mock_users_collection = MagicMock()
+        mock_db.users = mock_users_collection
+
+        mock_cursor = AsyncMock()
+        mock_cursor.to_list.return_value = mock_users
+        mock_users_collection.find.return_value = mock_cursor
+
+        with patch.object(self.service, "get_db", return_value=mock_db):
+            enriched = await self.service._enrich_members_with_user_details(members)
+
+        # Verify only ONE database call was made (batch query)
+        assert mock_users_collection.find.call_count == 1
+
+        # Verify all 10 members were enriched
+        assert len(enriched) == 10
+        for i, member in enumerate(enriched):
+            assert member["user"]["name"] == f"User {i}"