Invoke learner transmission task only for enterprise learners

Invoke learner transmission task only for enterprise learners
ENT-2384

added docstring

Fixed brokent unit test

lms/djangoapps/grades/tests/test_course_grade_factory.py

@@ -100,21 +100,21 @@ class TestCourseGradeFactory(GradeTestBase):
         with self.assertNumQueries(4), mock_get_score(1, 2):
             _assert_read(expected_pass=False, expected_percent=0)  # start off with grade of 0
 
-        num_queries = 51
+        num_queries = 47
         with self.assertNumQueries(num_queries), mock_get_score(1, 2):
             grade_factory.update(self.request.user, self.course, force_update_subsections=True)
 
         with self.assertNumQueries(5):
             _assert_read(expected_pass=True, expected_percent=0.5)  # updated to grade of .5
 
-        num_queries = 13
+        num_queries = 9
         with self.assertNumQueries(num_queries), mock_get_score(1, 4):
             grade_factory.update(self.request.user, self.course, force_update_subsections=False)
 
         with self.assertNumQueries(5):
             _assert_read(expected_pass=True, expected_percent=0.5)  # NOT updated to grade of .25
 
-        num_queries = 30
+        num_queries = 26
         with self.assertNumQueries(num_queries), mock_get_score(2, 2):
             grade_factory.update(self.request.user, self.course, force_update_subsections=True)
 

openedx/features/enterprise_support/signals.py

@@ -15,8 +15,12 @@ from email_marketing.tasks import update_user
 from enterprise.models import EnterpriseCourseEnrollment, EnterpriseCustomer, EnterpriseCustomerUser
 from integrated_channels.integrated_channel.tasks import transmit_single_learner_data
 from openedx.core.djangoapps.signals.signals import COURSE_GRADE_NOW_PASSED
+from openedx.features.enterprise_support.api import enterprise_enabled
 from openedx.features.enterprise_support.tasks import clear_enterprise_customer_data_consent_share_cache
-from openedx.features.enterprise_support.utils import clear_data_consent_share_cache
+from openedx.features.enterprise_support.utils import (
+    clear_data_consent_share_cache,
+    is_enterprise_learner,
+)
 
 log = logging.getLogger(__name__)
 
@@ -73,8 +77,10 @@ def handle_enterprise_learner_passing_grade(sender, user, course_id, **kwargs):
     """
     Listen for a learner passing a course, transmit data to relevant integrated channel
     """
-    kwargs = {
-        'username': six.text_type(user.username),
-        'course_run_id': six.text_type(course_id)
-    }
-    transmit_single_learner_data.apply_async(kwargs=kwargs)
+    if enterprise_enabled() and is_enterprise_learner(user):
+        kwargs = {
+            'username': six.text_type(user.username),
+            'course_run_id': six.text_type(course_id)
+        }
+
+        transmit_single_learner_data.apply_async(kwargs=kwargs)

openedx/features/enterprise_support/tests/test_signals.py

@@ -5,6 +5,7 @@ import logging
 
 import ddt
 from django.test import TestCase
+from django.test.utils import override_settings
 from mock import patch
 
 from edx_django_utils.cache import TieredCache
@@ -18,6 +19,7 @@ from openedx.features.enterprise_support.tests.factories import (
     EnterpriseCustomerFactory,
     EnterpriseCustomerUserFactory
 )
+from openedx.features.enterprise_support.tests import FEATURES_WITH_ENTERPRISE_ENABLED
 from openedx.features.enterprise_support.utils import get_data_consent_share_cache_key
 
 log = logging.getLogger(__name__)
@@ -28,6 +30,7 @@ TEST_EMAIL = "test@edx.org"
 
 
 @ddt.ddt
+@override_settings(FEATURES=FEATURES_WITH_ENTERPRISE_ENABLED)
 class EnterpriseSupportSignals(TestCase):
     """
     Tests for the enterprise support signals.
@@ -36,6 +39,7 @@ class EnterpriseSupportSignals(TestCase):
     def setUp(self):
         self.user = UserFactory.create(username='test', email=TEST_EMAIL)
         self.course_id = 'course-v1:edX+DemoX+Demo_Course'
+        self.enterprise_customer = EnterpriseCustomerFactory()
         super(EnterpriseSupportSignals, self).setUp()
 
     @staticmethod
@@ -49,20 +53,29 @@ class EnterpriseSupportSignals(TestCase):
         data_sharing_consent_needed_cache = TieredCache.get_cached_response(consent_cache_key)
         return data_sharing_consent_needed_cache.is_found
 
+    def _create_enterprise_enrollment(self, user_id, course_id):
+        """
+        Create enterprise user and enrollment
+        """
+        enterprise_customer_user = EnterpriseCustomerUserFactory(
+            user_id=user_id,
+            enterprise_customer=self.enterprise_customer
+        )
+        EnterpriseCourseEnrollmentFactory(
+            course_id=course_id,
+            enterprise_customer_user=enterprise_customer_user,
+        )
+
     @patch('openedx.features.enterprise_support.signals.update_user.delay')
     def test_register_user(self, mock_update_user):
         """
         make sure marketing enterprise user call invokes update_user
         """
-        enterprise_customer = EnterpriseCustomerFactory()
-        EnterpriseCustomerUserFactory(
-            user_id=self.user.id,
-            enterprise_customer=enterprise_customer
-        )
+        self._create_enterprise_enrollment(self.user.id, self.course_id)
         mock_update_user.assert_called_with(
             sailthru_vars={
                 'is_enterprise_learner': True,
-                'enterprise_name': enterprise_customer.name,
+                'enterprise_name': self.enterprise_customer.name,
             },
             email=self.user.email
         )
@@ -76,12 +89,7 @@ class EnterpriseSupportSignals(TestCase):
         self._create_dsc_cache(self.user.id, self.course_id)
         self.assertTrue(self._is_dsc_cache_found(self.user.id, self.course_id))
 
-        # Enrolling user to Course
-        enterprise_customer_user = EnterpriseCustomerUserFactory(user_id=self.user.id)
-        EnterpriseCourseEnrollmentFactory(
-            course_id=self.course_id,
-            enterprise_customer_user=enterprise_customer_user,
-        )
+        self._create_enterprise_enrollment(self.user.id, self.course_id)
         self.assertFalse(self._is_dsc_cache_found(self.user.id, self.course_id))
 
     def test_signal_update_dsc_cache_on_enterprise_customer_update(self):
@@ -90,23 +98,13 @@ class EnterpriseSupportSignals(TestCase):
          enable_data_sharing_consent flag is changed.
         """
 
-        # Enrolling user to Course
-        enterprise_customer = EnterpriseCustomerFactory()
-        enterprise_customer_user = EnterpriseCustomerUserFactory(
-            user_id=self.user.id,
-            enterprise_customer=enterprise_customer
-        )
-        EnterpriseCourseEnrollmentFactory(
-            course_id=self.course_id,
-            enterprise_customer_user=enterprise_customer_user,
-        )
-
+        self._create_enterprise_enrollment(self.user.id, self.course_id)
         self._create_dsc_cache(self.user.id, self.course_id)
         self.assertTrue(self._is_dsc_cache_found(self.user.id, self.course_id))
 
         # updating enable_data_sharing_consent flag
-        enterprise_customer.enable_data_sharing_consent = False
-        enterprise_customer.save()
+        self.enterprise_customer.enable_data_sharing_consent = False
+        self.enterprise_customer.save()
 
         self.assertFalse(self._is_dsc_cache_found(self.user.id, self.course_id))
 
@@ -121,9 +119,13 @@ class EnterpriseSupportSignals(TestCase):
             course_key = CourseKey.from_string(self.course_id)
             COURSE_GRADE_NOW_PASSED.disconnect(dispatch_uid='new_passing_learner')
             COURSE_GRADE_NOW_PASSED.send(sender=None, user=self.user, course_id=course_key)
+            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
             }
+            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')