Task/badge implementation in frontend

backend/apps/github/api/internal/nodes/user.py

@@ -30,16 +30,23 @@ class UserNode:
 
     @strawberry.field
     def badges(self) -> list[BadgeNode]:
-        """Return user badges."""
+        """List badges assigned to the user sorted by weight and name."""
         user_badges = (
-            self.user_badges.select_related("badge")
-            .filter(is_active=True)
-            .order_by(
-                "badge__weight",
-                "badge__name",
-            )
+            self.badges.filter(is_active=True)
+            .select_related("badge")
+            .order_by("-badge__weight", "badge__name")
+        )
+        return [user_badge.badge for user_badge in user_badges]
+
+    @strawberry.field
+    def badge_count(self) -> int:
+        """Resolve badge count."""
+        return ( 
+            self.badges.filter(is_active=True)
+            .value("badge_id")
+            .distinct()
+            .count()
         )
-        return [ub.badge for ub in user_badges]
 
     @strawberry.field
     def created_at(self) -> float:

backend/apps/nest/api/internal/nodes/badge.py

@@ -1,20 +1,18 @@
 """GraphQL node for Badge model."""
-
-import strawberry
 import strawberry_django
+from apps.nest.models import Badge
 
-from apps.nest.models.badge import Badge
 
 
 @strawberry_django.type(
     Badge,
     fields=[
-        "css_class",
-        "description",
         "id",
         "name",
+        "description",
         "weight",
+        "css_class",
     ],
 )
-class BadgeNode(strawberry.relay.Node):
+class BadgeNode:
     """GraphQL node for Badge model."""

backend/tests/apps/github/api/internal/nodes/user_test.py

@@ -5,6 +5,7 @@
 import pytest
 
 from apps.github.api.internal.nodes.user import UserNode
+from apps.nest.api.internal.nodes.badge import BadgeNode
 
 
 class TestUserNode:
@@ -19,6 +20,7 @@ def test_meta_configuration(self):
         field_names = {field.name for field in UserNode.__strawberry_definition__.fields}
         expected_field_names = {
             "avatar_url",
+            "badge_count",
             "badges",
             "bio",
             "company",
@@ -81,42 +83,119 @@ def test_url_field(self):
         result = UserNode.url(mock_user)
         assert result == "https://github.com/testuser"
 
-    def test_badges_resolver_behavior(self):
-        """Unit test verifies the badges method returns badges sorted by weight."""
-        badge_high = Mock()
-        badge_high.weight = 1
-        badge_high.name = "High Priority Badge"
-
-        badge_medium = Mock()
-        badge_medium.weight = 5
-        badge_medium.name = "Medium Priority Badge"
+    def test_badge_count_field(self):
+        """Test badge_count field resolution."""
+        mock_user = Mock()
+        mock_badges_queryset = Mock()
+        mock_badges_queryset.filter.return_value.count.return_value = 3
+        mock_user.badges = mock_badges_queryset
 
-        badge_low = Mock()
-        badge_low.weight = 10
-        badge_low.name = "Low Priority Badge"
+        result = UserNode.badge_count(mock_user)
+        assert result == 3
+        mock_badges_queryset.filter.assert_called_once_with(is_active=True)
 
-        user_badge_high = Mock()
-        user_badge_high.badge = badge_high
+    def test_badges_field_empty(self):
+        """Test badges field resolution with no badges."""
+        mock_user = Mock()
+        mock_badges_queryset = Mock()
+        (
+            mock_badges_queryset.filter.return_value.select_related.return_value.order_by.return_value
+        ) = []
+        mock_user.badges = mock_badges_queryset
 
-        user_badge_medium = Mock()
-        user_badge_medium.badge = badge_medium
+        result = UserNode.badges(mock_user)
+        assert result == []
 
-        user_badge_low = Mock()
-        user_badge_low.badge = badge_low
+    def test_badges_field_single_badge(self):
+        """Test badges field resolution with single badge."""
+        mock_user = Mock()
+        mock_badge = Mock(spec=BadgeNode)
+        mock_user_badge = Mock()
+        mock_user_badge.badge = mock_badge
 
-        sorted_user_badges = [user_badge_high, user_badge_medium, user_badge_low]
+        mock_badges_queryset = Mock()
+        (
+            mock_badges_queryset.filter.return_value.select_related.return_value.order_by.return_value
+        ) = [mock_user_badge]
+        mock_user.badges = mock_badges_queryset
 
+        result = UserNode.badges(mock_user)
+        assert result == [mock_badge]
+
+    def test_badges_field_sorted_by_weight_and_name(self):
+        """Test badges field resolution with multiple badges sorted by weight and name."""
+        # Create mock badges with different weights and names
+        mock_badge_high_weight = Mock(spec=BadgeNode)
+        mock_badge_high_weight.weight = 100
+        mock_badge_high_weight.name = "High Weight Badge"
+
+        mock_badge_medium_weight_a = Mock(spec=BadgeNode)
+        mock_badge_medium_weight_a.weight = 50
+        mock_badge_medium_weight_a.name = "Medium Weight A"
+
+        mock_badge_medium_weight_b = Mock(spec=BadgeNode)
+        mock_badge_medium_weight_b.weight = 50
+        mock_badge_medium_weight_b.name = "Medium Weight B"
+
+        mock_badge_low_weight = Mock(spec=BadgeNode)
+        mock_badge_low_weight.weight = 10
+        mock_badge_low_weight.name = "Low Weight Badge"
+
+        # Create mock user badges
+        mock_user_badge_high = Mock()
+        mock_user_badge_high.badge = mock_badge_high_weight
+
+        mock_user_badge_medium_a = Mock()
+        mock_user_badge_medium_a.badge = mock_badge_medium_weight_a
+
+        mock_user_badge_medium_b = Mock()
+        mock_user_badge_medium_b.badge = mock_badge_medium_weight_b
+
+        mock_user_badge_low = Mock()
+        mock_user_badge_low.badge = mock_badge_low_weight
+
+        # Set up the mock queryset to return badges in the expected sorted order
+        # (highest weight first, then by name for same weight)
+        mock_badges_queryset = Mock()
+        (
+            mock_badges_queryset.filter.return_value.select_related.return_value.order_by.return_value
+        ) = [
+            mock_user_badge_high,  # weight 100
+            mock_user_badge_medium_a,  # weight 50, name "Medium Weight A"
+            mock_user_badge_medium_b,  # weight 50, name "Medium Weight B"
+            mock_user_badge_low,  # weight 10
+        ]
         mock_user = Mock()
-        mock_queryset = Mock()
-        mock_queryset.filter.return_value.order_by.return_value = sorted_user_badges
-        mock_user.user_badges.select_related.return_value = mock_queryset
+        mock_user.badges = mock_badges_queryset
 
         result = UserNode.badges(mock_user)
 
-        mock_user.user_badges.select_related.assert_called_once_with("badge")
-        mock_queryset.filter.assert_called_once_with(is_active=True)
-        mock_queryset.filter.return_value.order_by.assert_called_once_with(
-            "badge__weight", "badge__name"
+        # Verify the badges are returned in the correct order
+        expected_badges = [
+            mock_badge_high_weight,
+            mock_badge_medium_weight_a,
+            mock_badge_medium_weight_b,
+            mock_badge_low_weight,
+        ]
+        assert result == expected_badges
+
+        # Verify the queryset was called with correct ordering
+        mock_badges_queryset.filter.assert_called_once_with(is_active=True)
+        mock_badges_queryset.filter.return_value.select_related.assert_called_once_with("badge")
+        mock_badges_queryset.filter.return_value.select_related.return_value.order_by.assert_called_once_with(
+            "-badge__weight", "badge__name"
         )
 
-        assert result == [ub.badge for ub in sorted_user_badges]
+    def test_badges_field_filters_inactive_badges(self):
+        """Test badges field only returns active badges."""
+        mock_user = Mock()
+        mock_badges_queryset = Mock()
+        (
+            mock_badges_queryset.filter.return_value.select_related.return_value.order_by.return_value
+        ) = []
+        mock_user.badges = mock_badges_queryset
+
+        UserNode.badges(mock_user)
+
+        # Verify that only active badges are filtered
+        mock_badges_queryset.filter.assert_called_once_with(is_active=True)

cspell/custom-dict.txt

@@ -57,6 +57,12 @@ dismissable
 dsn
 env
 facebookexternalhit
+fas
+far
+fab
+fa-solid
+fa-regular
+fa-brands
 gamesec
 geocoders
 geoloc