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