adding unit tests for assessment level reporting and hashing cache key.

lms/djangoapps/grades/subsection_grade_factory.py

@@ -106,7 +106,7 @@ class SubsectionGradeFactory(object):
             self._update_saved_subsection_grade(subsection.location, grade_model)
 
             COURSE_ASSESSMENT_GRADE_CHANGED.send_robust(
-                sender=None,
+                sender=self,
                 user=self.student,
                 subsection_id=calculated_grade.location,
                 subsection_grade=calculated_grade.graded_total.earned

lms/djangoapps/grades/tests/test_subsection_grade_factory.py

@@ -55,8 +55,12 @@ class TestSubsectionGradeFactory(ProblemSubmissionTestMixin, GradeTestBase):
         test that the score is calculated properly.
         """
         with mock_get_score(1, 2):
-            grade = self.subsection_grade_factory.update(self.sequence)
+            with patch(
+                'openedx.core.djangoapps.signals.signals.COURSE_ASSESSMENT_GRADE_CHANGED.send_robust'
+            ) as mock_update_grades_signal:
+                grade = self.subsection_grade_factory.update(self.sequence)
         self.assert_grade(grade, 1, 2)
+        assert mock_update_grades_signal.called
 
     def test_write_only_if_engaged(self):
         """

openedx/features/enterprise_support/tests/test_signals.py

@@ -17,7 +17,7 @@ from common.djangoapps.course_modes.tests.factories import CourseModeFactory
 from lms.djangoapps.certificates.signals import listen_for_passing_grade
 from openedx.core.djangoapps.commerce.utils import ECOMMERCE_DATE_FORMAT
 from openedx.core.djangoapps.credit.tests.test_api import TEST_ECOMMERCE_WORKER
-from openedx.core.djangoapps.signals.signals import COURSE_GRADE_NOW_PASSED
+from openedx.core.djangoapps.signals.signals import COURSE_GRADE_NOW_PASSED, COURSE_ASSESSMENT_GRADE_CHANGED
 from openedx.features.enterprise_support.tests import FEATURES_WITH_ENTERPRISE_ENABLED
 from openedx.features.enterprise_support.tests.factories import (
     EnterpriseCourseEnrollmentFactory,
@@ -207,3 +207,39 @@ class EnterpriseSupportSignals(SharedModuleStoreTestCase):
             COURSE_GRADE_NOW_PASSED.send(sender=None, user=self.user, course_id=course_key)
             mock_task_apply.assert_called_once_with(kwargs=task_kwargs)
             COURSE_GRADE_NOW_PASSED.connect(listen_for_passing_grade, dispatch_uid='new_passing_learner')
+
+    def test_handle_enterprise_learner_subsection(self):
+        """
+        Test to assert transmit_subsection_learner_data is called when COURSE_ASSESSMENT_GRADE_CHANGED signal is fired.
+        """
+        with patch(
+            'integrated_channels.integrated_channel.tasks.transmit_subsection_learner_data.apply_async',
+            return_value=None
+        ) as mock_task_apply:
+            course_key = CourseKey.from_string(self.course_id)
+            COURSE_ASSESSMENT_GRADE_CHANGED.disconnect()
+            COURSE_ASSESSMENT_GRADE_CHANGED.send(
+                sender=None,
+                user=self.user,
+                course_id=course_key,
+                subsection_id='subsection_id',
+                subsection_grade=1.0
+            )
+            self.assertFalse(mock_task_apply.called)
+
+            self._create_enterprise_enrollment(self.user.id, self.course_id)
+            task_kwargs = {
+                'username': self.user.username,
+                'course_run_id': self.course_id,
+                'subsection_id': 'subsection_id',
+                'grade': '1.0'
+            }
+            COURSE_ASSESSMENT_GRADE_CHANGED.send(
+                sender=None,
+                user=self.user,
+                course_id=course_key,
+                subsection_id='subsection_id',
+                subsection_grade=1.0
+            )
+            mock_task_apply.assert_called_once_with(kwargs=task_kwargs)
+            COURSE_ASSESSMENT_GRADE_CHANGED.connect(listen_for_passing_grade)

openedx/features/enterprise_support/tests/test_utils.py

@@ -450,11 +450,21 @@ class TestEnterpriseUtils(TestCase):
         assert '' == generic_name
 
     def test_is_enterprise_learner(self):
-        EnterpriseCustomerUserFactory.create(active=True, user_id=self.user.id)
-        self.assertTrue(is_enterprise_learner(self.user))
+        with mock.patch(
+            'django.core.cache.cache.set'
+        ) as mock_cache_set:
+            EnterpriseCustomerUserFactory.create(active=True, user_id=self.user.id)
+            self.assertTrue(is_enterprise_learner(self.user))
+
+        self.assertTrue(mock_cache_set.called)
 
     def test_is_enterprise_learner_no_enterprise_user(self):
-        self.assertFalse(is_enterprise_learner(self.user))
+        with mock.patch(
+            'django.core.cache.cache.set'
+        ) as mock_cache_set:
+            self.assertFalse(is_enterprise_learner(self.user))
+
+        self.assertFalse(mock_cache_set.called)
 
     @mock.patch('openedx.features.enterprise_support.utils.reverse')
     def test_get_enterprise_slug_login_url_no_reverse_match(self, mock_reverse):

openedx/features/enterprise_support/utils.py

@@ -34,6 +34,13 @@ def get_data_consent_share_cache_key(user_id, course_id):
     return get_cache_key(type='data_sharing_consent_needed', user_id=user_id, course_id=course_id)
 
 
+def get_is_enterprise_cache_key(user_id):
+    """
+        Returns cache key for the enterprise learner validation method needed against user_id.
+    """
+    return get_cache_key(type='is_enterprise_learner', user_id=user_id)
+
+
 def clear_data_consent_share_cache(user_id, course_id):
     """
         clears data_sharing_consent_needed cache
@@ -394,7 +401,7 @@ def get_enterprise_learner_generic_name(request):
 
 def is_enterprise_learner(user):
     """
-    Check if the given user belongs to an enterprise.
+    Check if the given user belongs to an enterprise. Cache the value if an enterprise learner is found.
 
     Arguments:
         user (User): Django User object.
@@ -402,13 +409,13 @@ def is_enterprise_learner(user):
     Returns:
         (bool): True if given user is an enterprise learner.
     """
-    cached_is_enterprise_key = '{}:user_is_enterprise'.format(user.id)
+    cached_is_enterprise_key = get_is_enterprise_cache_key(user.id)
     if cache.get(cached_is_enterprise_key):
         return True
 
     if EnterpriseCustomerUser.objects.filter(user_id=user.id).exists():
         # Cache the enterprise user for one hour.
-        cache.set(cached_is_enterprise_key, True, expiry=3600)
+        cache.set(cached_is_enterprise_key, True, 3600)
         return True
     return False