def test_unlink_user_pending_link(self, email): other_email = "*****@*****.**" enterprise_customer = EnterpriseCustomerFactory() PendingEnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer, user_email=email) PendingEnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer, user_email=other_email) assert len(PendingEnterpriseCustomerUser.objects.all()) == 2 query_method = PendingEnterpriseCustomerUser.objects.filter EnterpriseCustomerUser.objects.unlink_user(enterprise_customer, email) # removes what was asked assert len(query_method(enterprise_customer=enterprise_customer, user_email=email)) == 0 # keeps records of other users assert len(query_method(user_email=other_email)) == 1
def setUp(self): email = '*****@*****.**' course_id = 'course-v1:edX+DemoX+DemoCourse' pending_link = PendingEnterpriseCustomerUserFactory(user_email=email) self.enrollment = PendingEnrollmentFactory(user=pending_link, course_id=course_id) self.user = UserFactory(email=email) super(TestPendingEnrollment, self).setUp()
def test_handle_user_post_save_modified_user_already_linked(self): email = "*****@*****.**" user = UserFactory(id=1, email=email) enterprise_customer1, enterprise_customer2 = EnterpriseCustomerFactory(), EnterpriseCustomerFactory() EnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer1, user_id=user.id) PendingEnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer2, user_email=email) assert EnterpriseCustomerUser.objects.filter(user_id=user.id).count() == 1, "Precondition check: links exists" assert PendingEnterpriseCustomerUser.objects.filter(user_email=email).count() == 1, \ "Precondition check: pending link exists" parameters = {"instance": user, "created": False} handle_user_post_save(mock.Mock(), **parameters) assert EnterpriseCustomerUser.objects.filter(user_id=user.id).count() == 2, "Should return 2 existing links" link_1 = EnterpriseCustomerUser.objects.get( user_id=user.id, enterprise_customer=enterprise_customer1, ) link_2 = EnterpriseCustomerUser.objects.get( user_id=user.id, enterprise_customer=enterprise_customer2, ) assert link_1.enterprise_customer == enterprise_customer1 assert link_2.enterprise_customer == enterprise_customer2 assert PendingEnterpriseCustomerUser.objects.count() == 0, "Should delete pending link"
def test_handle_user_post_save_with_pending_course_enrollment( self, mock_course_enrollment, mock_course_key): mock_course_key.from_string.return_value = None mock_course_enrollment.enroll.return_value = None email = "*****@*****.**" user = UserFactory(id=1, email=email) pending_link = PendingEnterpriseCustomerUserFactory(user_email=email) pending_enrollment = PendingEnrollmentFactory(user=pending_link) assert len(EnterpriseCustomerUser.objects.filter( user_id=user.id)) == 0, "Precondition check: no links exists" assert len(PendingEnterpriseCustomerUser.objects.filter(user_email=email)) == 1, \ "Precondition check: pending link exists" assert len(PendingEnrollment.objects.filter( user=pending_link)) == 1, 'Check that only one enrollment exists.' parameters = {'instance': user, "created": False} handle_user_post_save(mock.Mock(), **parameters) assert len(PendingEnterpriseCustomerUser.objects.all()) == 0 assert len( EnterpriseCustomerUser.objects.filter( enterprise_customer=pending_link.enterprise_customer, user_id=user.id)) == 1 assert len(PendingEnrollment.objects.all()) == 0 assert len(EnterpriseCourseEnrollment.objects.all()) == 1 mock_course_enrollment.enroll.assert_called_once_with( user, None, mode='audit', check_access=True) mock_course_key.from_string.assert_called_once_with( pending_enrollment.course_id)
def test_handle_user_post_save_modified_user_already_linked(self): email = "*****@*****.**" user = UserFactory(id=1, email=email) enterprise_customer1, enterprise_customer2 = EnterpriseCustomerFactory( ), EnterpriseCustomerFactory() existing_link = EnterpriseCustomerUserFactory( enterprise_customer=enterprise_customer1, user_id=user.id) PendingEnterpriseCustomerUserFactory( enterprise_customer=enterprise_customer2, user_email=email) assert len(EnterpriseCustomerUser.objects.filter( user_id=user.id)) == 1, "Precondition check: links exists" assert len(PendingEnterpriseCustomerUser.objects.filter(user_email=email)) == 1, \ "Precondition check: pending link exists" parameters = {"instance": user, "created": False} handle_user_post_save(mock.Mock(), **parameters) link = EnterpriseCustomerUser.objects.get(user_id=user.id) # TODO: remove suppression when https://github.com/landscapeio/pylint-django/issues/78 is fixed assert link.id == existing_link.id, "Should keep existing link intact" # pylint: disable=no-member assert link.enterprise_customer == enterprise_customer1, "Should keep existing link intact" assert len(PendingEnterpriseCustomerUser.objects.all() ) == 0, "Should delete pending link"
def test_clean_existing_pending_link(self, existing_email): PendingEnterpriseCustomerUserFactory(user_email=existing_email) form = self._make_bound_form(existing_email) assert form.is_valid() cleaned_data = form.clean() assert cleaned_data[ManageLearnersForm.Fields.EMAIL_OR_USERNAME] == existing_email
def test_handle_user_post_save_with_pending_course_enrollment(self, mock_course_enrollment, mock_track_enrollment): mock_course_enrollment.enroll.return_value = None email = "*****@*****.**" user = UserFactory(id=1, email=email) pending_link = PendingEnterpriseCustomerUserFactory(user_email=email) course_id = 'course-v1:edX+DemoX+Demo_Course' PendingEnrollmentFactory(user=pending_link, course_id=course_id) assert EnterpriseCustomerUser.objects.filter(user_id=user.id).count() == 0, "Precondition check: no links exist" assert PendingEnterpriseCustomerUser.objects.filter(user_email=email).count() == 1, \ "Precondition check: pending link exists" assert PendingEnrollment.objects.filter(user=pending_link).count() == 1, \ 'Precondition check: only one enrollment exists.' parameters = {'instance': user, "created": False} handle_user_post_save(mock.Mock(), **parameters) assert PendingEnterpriseCustomerUser.objects.count() == 0 assert EnterpriseCustomerUser.objects.filter( enterprise_customer=pending_link.enterprise_customer, user_id=user.id ).count() == 1 assert PendingEnrollment.objects.count() == 0 assert EnterpriseCourseEnrollment.objects.count() == 1 mock_course_enrollment.enroll.assert_called_once_with( user, CourseKey.from_string(course_id), mode='audit', check_access=True ) mock_track_enrollment.assert_called_once_with('pending-admin-enrollment', user.id, course_id)
def test_unlink_user_pending_link(self, email): other_email = "*****@*****.**" enterprise_customer1, enterprise_customer2 = EnterpriseCustomerFactory(), EnterpriseCustomerFactory() PendingEnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer1, user_email=email) PendingEnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer1, user_email=other_email) PendingEnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer2, user_email=email) assert len(PendingEnterpriseCustomerUser.objects.all()) == 3 query_method = PendingEnterpriseCustomerUser.objects.filter EnterpriseCustomerUser.objects.unlink_user(enterprise_customer1, email) # removes what was asked assert len(query_method(enterprise_customer=enterprise_customer1, user_email=email)) == 0 # keeps records of the same user with different EC (though it shouldn't be the case) assert len(query_method(enterprise_customer=enterprise_customer2, user_email=email)) == 1 # keeps records of other users assert len(query_method(user_email=other_email)) == 1
def test_clean_existing_pending_link(self, existing_email): existing_record = PendingEnterpriseCustomerUserFactory(user_email=existing_email) form = self._make_bound_form(existing_email) assert not form.is_valid() errors = form.errors error_message = ValidationMessages.USER_ALREADY_REGISTERED.format( email=existing_email, ec_name=existing_record.enterprise_customer.name ) assert errors == {ManageLearnersForm.Fields.EMAIL_OR_USERNAME: [error_message]}
def test_clean_existing_pending_link(self, existing_email): existing_record = PendingEnterpriseCustomerUserFactory( user_email=existing_email) form = self._make_bound_form(existing_email) assert not form.is_valid() errors = form.errors error_message = "User with email {email} is already registered with Enterprise Customer {ec_name}".format( email=existing_email, ec_name=existing_record.enterprise_customer.name) assert errors == {"email": [error_message]}
def test_string_conversion(self, method): """ Test ``EnterpriseCustomerUser`` conversion to string. """ customer_user_id, user_email = 15, "*****@*****.**" customer_user = PendingEnterpriseCustomerUserFactory(id=customer_user_id, user_email=user_email) expected_to_str = "<PendingEnterpriseCustomerUser {ID}>: {enterprise_name} - {user_email}".format( ID=customer_user_id, enterprise_name=customer_user.enterprise_customer.name, user_email=user_email ) self.assertEqual(method(customer_user), expected_to_str)
def test_get_existing_and_pending_links(self): assert self.client.login( username=self.user.username, password="******") # make sure we've logged in linked_learners = [ EnterpriseCustomerUserFactory( enterprise_customer=self.enterprise_customer), EnterpriseCustomerUserFactory( enterprise_customer=self.enterprise_customer), EnterpriseCustomerUserFactory( enterprise_customer=self.enterprise_customer), ] pending_linked_learners = [ PendingEnterpriseCustomerUserFactory( enterprise_customer=self.enterprise_customer), PendingEnterpriseCustomerUserFactory( enterprise_customer=self.enterprise_customer), ] response = self.client.get(self.view_url) self._test_get_response(response, linked_learners, pending_linked_learners)
def test_handle_user_post_save_created_user_multiple_enterprises(self): email = "*****@*****.**" user = UserFactory(id=1, email=email) enterprise_customer = EnterpriseCustomerFactory() enterprise_customer_2 = EnterpriseCustomerFactory() PendingEnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer, user_email=email) PendingEnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer_2, user_email=email) assert EnterpriseCustomerUser.objects.filter(user_id=user.id).count() == 0, "Precondition check: no links exist" assert PendingEnterpriseCustomerUser.objects.filter(user_email=email).count() == 2, \ "Precondition check: pending link exists" parameters = {"instance": user, "created": True} with transaction.atomic(): handle_user_post_save(mock.Mock(), **parameters) assert PendingEnterpriseCustomerUser.objects.count() == 0 assert EnterpriseCustomerUser.objects.filter( enterprise_customer=enterprise_customer, user_id=user.id ).count() == 1 assert EnterpriseCustomerUser.objects.filter( enterprise_customer=enterprise_customer_2, user_id=user.id ).count() == 1
def test_handle_user_post_save_raw(self): email = "*****@*****.**" user = UserFactory(id=1, email=email) PendingEnterpriseCustomerUserFactory(user_email=email) assert EnterpriseCustomerUser.objects.filter(user_id=user.id).count() == 0, "Precondition check: no links exist" assert PendingEnterpriseCustomerUser.objects.filter(user_email=email).count() == 1, \ "Precondition check: pending link exists" parameters = {"instance": user, "created": False, "raw": True} handle_user_post_save(mock.Mock(), **parameters) assert EnterpriseCustomerUser.objects.filter(user_id=user.id).count() == 0, "Link have been created" assert PendingEnterpriseCustomerUser.objects.filter(user_email=email).count() == 1, \ "Pending link should be kept"
def test_handle_user_post_save_modified_user_not_linked(self): email = "*****@*****.**" user = User(id=1, email=email) pending_link = PendingEnterpriseCustomerUserFactory(user_email=email) assert len(EnterpriseCustomerUser.objects.filter(user_id=user.id)) == 0, "Precondition check: no links exists" assert len(PendingEnterpriseCustomerUser.objects.filter(user_email=email)) == 1, \ "Precondition check: pending link exists" parameters = {"instance": user, "created": False} handle_user_post_save(mock.Mock(), **parameters) assert len(PendingEnterpriseCustomerUser.objects.all()) == 0 assert len(EnterpriseCustomerUser.objects.filter( enterprise_customer=pending_link.enterprise_customer, user_id=user.id )) == 1
def test_validate_email_to_link_existing_pending_record(self, ignore_existing): email = FAKER.email() # pylint: disable=no-member existing_record = PendingEnterpriseCustomerUserFactory(user_email=email) assert PendingEnterpriseCustomerUser.objects.get(user_email=email) == existing_record, \ "Precondition check - should have PendingEnterpriseCustomerUser" assert not EnterpriseCustomerUser.objects.exists(), \ "Precondition check - should not have EnterpriseCustomerUser" if ignore_existing: exists = validate_email_to_link(email, ignore_existing=True) assert exists else: expected_message = ValidationMessages.USER_ALREADY_REGISTERED.format( email=email, ec_name=existing_record.enterprise_customer.name ) with raises(ValidationError, match=expected_message): exists = validate_email_to_link(email)
def test_post_existing_pending_record(self): # precondition checks: assert self.client.login( username=self.user.username, password="******") # make sure we've logged in email = FAKER.email() PendingEnterpriseCustomerUserFactory(user_email=email) assert len( PendingEnterpriseCustomerUser.objects.filter( user_email=email)) == 1 response = self.client.post(self.view_url, data={"email": email}) self._test_post_existing_record_response(response) assert len( PendingEnterpriseCustomerUser.objects.filter( user_email=email)) == 1
def test_handle_user_post_save_with_pending_course_enrollment( self, mock_course_enrollment, mock_track_enrollment, mock_track_event # pylint: disable=unused-argument ): mock_course_enrollment.enroll.return_value = None email = "*****@*****.**" user = UserFactory(id=1, email=email) pending_link = PendingEnterpriseCustomerUserFactory(user_email=email) pending_link.enterprise_customer.enable_autocohorting = True pending_link.enterprise_customer.save() course_id = 'course-v1:edX+DemoX+Demo_Course' PendingEnrollmentFactory(user=pending_link, course_id=course_id, cohort_name=u'test_cohort') assert EnterpriseCustomerUser.objects.filter( user_id=user.id).count() == 0, "Precondition check: no links exist" assert PendingEnterpriseCustomerUser.objects.filter(user_email=email).count() == 1, \ "Precondition check: pending link exists" assert PendingEnrollment.objects.filter(user=pending_link).count() == 1, \ 'Precondition check: only one enrollment exists.' mock_course_enrollment.return_value = mock.Mock( get_course_enrollment=mock.Mock( side_effect=[None, { 'is_active': False, 'mode': 'verified' }]), enroll_user_in_course=mock.Mock()) parameters = {'instance': user, "created": False} with transaction.atomic(): handle_user_post_save(mock.Mock(), **parameters) assert PendingEnterpriseCustomerUser.objects.count() == 0 assert EnterpriseCustomerUser.objects.filter( enterprise_customer=pending_link.enterprise_customer, user_id=user.id).count() == 1 assert PendingEnrollment.objects.count() == 0 assert EnterpriseCourseEnrollment.objects.count() == 1 mock_course_enrollment.return_value.enroll_user_in_course.assert_called_once_with( user.username, course_id, 'audit', cohort=u'test_cohort') mock_track_enrollment.assert_called_once_with( 'pending-admin-enrollment', user.id, course_id)
def test_delete_linked_pending(self): assert self.client.login( username=self.user.username, password="******") # make sure we've logged in email = FAKER.email() query_string = six.moves.urllib.parse.urlencode( {"unlink_email": email}) PendingEnterpriseCustomerUserFactory( enterprise_customer=self.enterprise_customer, user_email=email) assert len( PendingEnterpriseCustomerUser.objects.filter( user_email=email)) == 1 response = self.client.delete(self.view_url + "?" + query_string) assert response.status_code == 200 assert json.loads(response.content.decode("utf-8")) == {} assert len( PendingEnterpriseCustomerUser.objects.filter( user_email=email)) == 0
def test_get_link_by_email_pending_link(self, email): existing_pending_link = PendingEnterpriseCustomerUserFactory(user_email=email) assert EnterpriseCustomerUser.objects.get_link_by_email(email) == existing_pending_link