mattdrayer/api: Fixed NRE corner case for grades leaderboard

lms/djangoapps/api_manager/courses/tests.py

@@ -187,6 +187,11 @@ class CoursesApiTests(TestCase):
             display_name=u"test unit 2",
         )
 
+        self.empty_course = CourseFactory.create(
+            start=datetime(2014, 6, 16, 14, 30),
+            end=datetime(2015, 1, 16),
+            org="MTD"
+        )
 
         self.users = [UserFactory.create(username="testuser" + str(__), profile='test') for __ in xrange(USER_COUNT)]
 
@@ -1630,6 +1635,13 @@ class CoursesApiTests(TestCase):
         response = self.do_get(bogus_test_uri)
         self.assertEqual(response.status_code, 404)
 
+    def test_courses_metrics_grades_leaders_list_get_empty_course(self):
+        test_uri = '{}/{}/metrics/grades/leaders/'.format(self.base_courses_uri, unicode(self.empty_course.id))
+        response = self.do_get(test_uri)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data['course_avg'], 0)
+        self.assertEqual(len(response.data['leaders']), 0)
+
     def test_courses_completions_leaders_list_get(self):
         completion_uri = '{}/{}/completions/'.format(self.base_courses_uri, unicode(self.course.id))
         # Make last user as observer to make sure that data is being filtered out
@@ -1722,6 +1734,14 @@ class CoursesApiTests(TestCase):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(response.data['grades']), user_index)
 
+    def test_courses_metrics_grades_list_get_empty_course(self):
+        # Retrieve the list of grades for this course
+        # All the course/item/user scaffolding was handled in Setup
+        test_uri = '{}/{}/metrics/grades'.format(self.base_courses_uri, unicode(self.empty_course.id))
+        response = self.do_get(test_uri)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data['grade_count'], 0)
+        self.assertEqual(response.data['course_grade_maximum'], 0)
 
     def test_courses_grades_list_get_invalid_course(self):
         # Retrieve the list of grades for this course

lms/djangoapps/gradebook/models.py

@@ -56,52 +56,64 @@ class StudentGradebook(TimeStampedModel):
         have not yet submitted a response to a scored assessment which means no grade has been calculated.
         """
         data = {}
+        data['course_avg'] = 0
+        data['course_max'] = 0
+        data['course_min'] = 0
+        data['course_count'] = 0
+        data['queryset'] = []
+
         total_user_count = CourseEnrollment.users_enrolled_in(course_key).count()
-        queryset = StudentGradebook.objects.select_related('user')\
-            .filter(course_id__exact=course_key, user__is_active=True)
-        gradebook_user_count = len(queryset)
+        if total_user_count:
 
-        if exclude_users:
-            total_user_count = total_user_count - len(exclude_users)
-            queryset = queryset.exclude(user__in=exclude_users)
+            # Generate the base data set we're going to work with
+            queryset = StudentGradebook.objects.select_related('user')\
+                .filter(course_id__exact=course_key, user__is_active=True)
             gradebook_user_count = len(queryset)
 
-        # Calculate the class average
-        course_avg = queryset.aggregate(Avg('grade'))['grade__avg']
-        if gradebook_user_count < total_user_count:
-            # Take into account any ungraded students (assumes zeros for grades...)
-            course_avg = course_avg / total_user_count * gradebook_user_count
-        data['course_avg'] = course_avg
-        data['course_max'] = queryset.aggregate(Max('grade'))['grade__max']
-        data['course_min'] = queryset.aggregate(Min('grade'))['grade__min']
-        data['course_count'] = queryset.aggregate(Count('grade'))['grade__count']
-
-        # Construct the leaderboard as a queryset
-        data['queryset'] = queryset.values(
-            'user__id',
-            'user__username',
-            'user__profile__title',
-            'user__profile__avatar_url',
-            'grade',
-            'created')\
-            .order_by('-grade', 'created')[:count]
-
-        # If a user_id value was provided, we need to provide some additional user-specific data to the caller
-        if user_id:
-            user_grade = 0
-            user_time_scored = timezone.now()
-            try:
-                user_queryset = StudentGradebook.objects.get(course_id__exact=course_key, user__id=user_id)
-            except StudentGradebook.DoesNotExist:
-                user_queryset = None
-            if user_queryset:
-                user_grade = user_queryset.grade
-                user_time_scored = user_queryset.created
-            users_above = queryset.filter(grade__gte=user_grade)\
-                .exclude(user__id=user_id)\
-                .exclude(grade=user_grade, created__lt=user_time_scored)
-            data['user_position'] = len(users_above) + 1
-            data['user_grade'] = user_grade
+            # Remove any users who should not be considered for the statistics
+            if exclude_users:
+                total_user_count = total_user_count - len(exclude_users)
+                queryset = queryset.exclude(user__in=exclude_users)
+                gradebook_user_count = len(queryset)
+
+            # Calculate the class average
+            course_avg = queryset.aggregate(Avg('grade'))['grade__avg']
+            if gradebook_user_count < total_user_count:
+                # Take into account any ungraded students (assumes zeros for grades...)
+                course_avg = course_avg / total_user_count * gradebook_user_count
+
+            # Fill up the response container
+            data['course_avg'] = course_avg
+            data['course_max'] = queryset.aggregate(Max('grade'))['grade__max']
+            data['course_min'] = queryset.aggregate(Min('grade'))['grade__min']
+            data['course_count'] = queryset.aggregate(Count('grade'))['grade__count']
+
+            # Construct the leaderboard as a queryset
+            data['queryset'] = queryset.values(
+                'user__id',
+                'user__username',
+                'user__profile__title',
+                'user__profile__avatar_url',
+                'grade',
+                'created')\
+                .order_by('-grade', 'created')[:count]
+
+            # If a user_id value was provided, we need to provide some additional user-specific data to the caller
+            if user_id:
+                user_grade = 0
+                user_time_scored = timezone.now()
+                try:
+                    user_queryset = StudentGradebook.objects.get(course_id__exact=course_key, user__id=user_id)
+                except StudentGradebook.DoesNotExist:
+                    user_queryset = None
+                if user_queryset:
+                    user_grade = user_queryset.grade
+                    user_time_scored = user_queryset.created
+                users_above = queryset.filter(grade__gte=user_grade)\
+                    .exclude(user__id=user_id)\
+                    .exclude(grade=user_grade, created__lt=user_time_scored)
+                data['user_position'] = len(users_above) + 1
+                data['user_grade'] = user_grade
 
         return data