def setUp(self):
"""
Test set up.
"""
super(TestEnterpriseCustomerReportingConfigAdminForm, self).setUp()
self.ent_customer1 = EnterpriseCustomerFactory()
self.ent_customer2 = EnterpriseCustomerFactory()
self.ent_catalogs1 = [
EnterpriseCustomerCatalogFactory(
enterprise_customer=self.ent_customer1) for _ in range(3)
]
self.ent_catalogs2 = [
EnterpriseCustomerCatalogFactory(
enterprise_customer=self.ent_customer2) for _ in range(2)
]
self.form_data = {
'enterprise_customer': self.ent_customer1.uuid,
'data_type': 'progress',
'report_type': 'csv',
'delivery_method': 'email',
'frequency': 'daily',
'hour_of_day': 1,
'email': '*****@*****.**',
'decrypted_password': '******',
}
def test_unlink_user_existing_user(self, email):
other_email = "*****@*****.**"
user1, user2 = UserFactory(email=email), UserFactory(email=other_email)
enterprise_customer1, enterprise_customer2 = EnterpriseCustomerFactory(
), EnterpriseCustomerFactory()
EnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer1,
user_id=user1.id)
EnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer1,
user_id=user2.id)
EnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer2,
user_id=user1.id)
assert len(EnterpriseCustomerUser.objects.all()) == 3
query_method = EnterpriseCustomerUser.objects.filter
EnterpriseCustomerUser.objects.unlink_user(enterprise_customer1, email)
# removes what was asked
assert len(
query_method(enterprise_customer=enterprise_customer1,
user_id=user1.id)) == 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_id=user1.id)) == 1
# keeps records of other users
assert len(query_method(user_id=user2.id)) == 1
def test_handle_enterprise_logistration_user_multiple_enterprises_linking(self):
"""
Test that if user has multiple enterprise_customers then active status of latest
enterprise_customer with which user is logged in will be marked as True and active
status of other enterprise_customers will be marked as False.
"""
backend = self.get_mocked_sso_backend()
self.user = UserFactory(is_active=True)
with mock.patch('enterprise.tpa_pipeline.get_enterprise_customer_for_running_pipeline') as fake_get_ec:
enterprise_customer = EnterpriseCustomerFactory(
enable_data_sharing_consent=False
)
enterprise_customer_old = EnterpriseCustomerFactory(
enable_data_sharing_consent=False
)
EnterpriseCustomerUser.objects.create(
enterprise_customer=enterprise_customer_old,
user_id=self.user.id,
active=True
)
fake_get_ec.return_value = enterprise_customer
assert handle_enterprise_logistration(backend, self.user) is None
assert EnterpriseCustomerUser.objects.filter(
enterprise_customer=enterprise_customer,
user_id=self.user.id,
active=True
).count() == 1
assert EnterpriseCustomerUser.objects.filter(
enterprise_customer=enterprise_customer_old,
user_id=self.user.id,
active=False
).count() == 1
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_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_get_course_enrollment_url_no_site_config(self):
"""
Test get_course_enrollment_url when the site_configuration package could not be imported.
"""
customer = EnterpriseCustomerFactory()
error = 'This package must be installed in an EdX environment to look up configuration.'
with raises(NotConnectedToOpenEdX, message=error):
customer.get_course_enrollment_url('course_id')
def setUp(self):
"""
DRY method for TestEnterpriseApiClient.
"""
self.enterprise_customer = EnterpriseCustomerFactory(
catalog=1,
name='Veridian Dynamics',
)
super(TestEnterpriseApiClient, self).setUp()
self.catalog_api_config_mock = self._make_patch(self._make_catalog_api_location("CatalogIntegration"))
self.user = UserFactory(is_staff=True)
def test_active_customers_get_queryset_returns_only_active(self):
"""
Test that get_queryset on custom model manager returns only active customers.
"""
customer1 = EnterpriseCustomerFactory(active=True)
customer2 = EnterpriseCustomerFactory(active=True)
inactive_customer = EnterpriseCustomerFactory(active=False)
active_customers = EnterpriseCustomer.active_customers.all()
self.assertTrue(all(customer.active for customer in active_customers))
self.assertIn(customer1, active_customers)
self.assertIn(customer2, active_customers)
self.assertNotIn(inactive_customer, active_customers)
def test_invalid_catalog_value(self):
"""
Test that when we pass an empty string to the form, it gets saved to the database
as a null value, rather than being ignored or raising an error.
"""
self.catalog_api.get_all_catalogs.return_value = [{
"id": 99,
"name": "My Catalog"
}, {
"id":
1,
"name":
"Other catalog!"
}]
customer = EnterpriseCustomerFactory(catalog=99, )
form = EnterpriseCustomerAdminForm(
{
'catalog': 5,
'enforce_data_sharing_consent':
customer.enforce_data_sharing_consent,
'site': customer.site.id,
'name': customer.name,
'active': customer.active
},
instance=customer,
)
assert not form.is_valid()
def setUp(self):
self.user = UserFactory.create(username='******',
is_staff=True,
is_active=True)
self.user.set_password("QWERTY")
self.user.save()
self.client = Client()
get_dsc = mock.patch('enterprise.views.get_data_sharing_consent')
self.get_data_sharing_consent = get_dsc.start()
self.addCleanup(get_dsc.stop)
course_catalog_api_client = mock.patch(
'enterprise.api_client.discovery.CourseCatalogApiServiceClient')
self.course_catalog_api_client = course_catalog_api_client.start()
self.addCleanup(course_catalog_api_client.stop)
self.enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
self.ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id, enterprise_customer=self.enterprise_customer)
self.valid_get_params = {
'enterprise_customer_uuid': self.enterprise_customer.uuid,
'next': 'https://google.com/',
'failure_url': 'https://facebook.com/',
'program_uuid': 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
}
self.valid_post_params = {
'enterprise_customer_uuid': self.enterprise_customer.uuid,
'redirect_url': 'https://google.com/',
'failure_url': 'https://facebook.com/',
'program_uuid': 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
'data_sharing_consent': 'true',
}
super(TestProgramDataSharingPermissions, self).setUp()
def test_post_course_specific_consent_no_user(self, reverse_mock,
course_api_client_mock,
*args): # pylint: disable=unused-argument
course_id = 'course-v1:edX+DemoX+Demo_Course'
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id, enterprise_customer=enterprise_customer)
EnterpriseCourseEnrollment.objects.create(enterprise_customer_user=ecu,
course_id=course_id)
DataSharingConsentFactory(
username=self.user.username,
course_id=course_id,
enterprise_customer=enterprise_customer,
)
client = course_api_client_mock.return_value
client.get_course_details.return_value = {
'name': 'edX Demo Course',
}
reverse_mock.return_value = '/dashboard'
resp = self.client.post(
self.url,
data={
'course_id': course_id,
'redirect_url': '/successful_enrollment',
},
)
assert resp.status_code == 302
self.assertRedirects(
resp,
'/accounts/login/?next=/enterprise/grant_data_sharing_permissions',
fetch_redirect_response=False)
def test_get_course_specific_consent_not_needed(
self,
course_api_client_mock,
course_catalog_api_client_mock,
): # pylint: disable=unused-argument
self._login()
course_id = 'course-v1:edX+DemoX+Demo_Course'
course_catalog_api_client = course_catalog_api_client_mock.return_value
course_catalog_api_client.is_course_in_catalog.return_value = False
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
client = course_api_client_mock.return_value
client.get_course_details.return_value = {
'name': 'edX Demo Course',
}
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id, enterprise_customer=enterprise_customer)
EnterpriseCourseEnrollment.objects.create(
enterprise_customer_user=ecu,
course_id=course_id,
)
DataSharingConsentFactory(username=self.user.username,
course_id=course_id,
enterprise_customer=enterprise_customer,
granted=True)
response = self.client.get(
self.url +
'?course_id=course-v1%3AedX%2BDemoX%2BDemo_Course&next=https%3A%2F%2Fgoogle.com',
)
assert response.status_code == 404
def test_post_patch_real_social_auth_enabled(
self,
mock_get_ec,
mock_get_rsa,
mock_get_ec2,
mock_url,
mock_render,
mock_config,
mock_lift,
mock_quarantine,
): # pylint: disable=unused-argument
"""
Test an enforced request with consent and rendering patched in.
"""
customer = EnterpriseCustomerFactory()
mock_get_ec.return_value = customer
mock_get_ec2.return_value = customer
mock_get_rsa.return_value = mock.MagicMock(user=UserFactory())
mock_url.return_value = '/'
client = Client()
session = client.session
session['partial_pipeline'] = {'backend': 'fake_backend'}
session.save()
response = client.post(self.url, {'data_sharing_consent': True})
assert UserDataSharingConsentAudit.objects.all().count() == 1
assert EnterpriseCustomerUser.objects.all().count() == 1
assert UserDataSharingConsentAudit.objects.all()[0].enabled
assert response.status_code == 302
def test_post_program_enrollment_view_redirect_to_program_dashboard(
self, course_catalog_api_client_mock, program_data_extender_mock,
*args): # pylint: disable=unused-argument,invalid-name
"""
The user is redirected to the program dashboard on POST if already certificate eligible for the program.
"""
program_data_extender_mock = self._setup_program_data_extender(
program_data_extender_mock)
for course in program_data_extender_mock.return_value.extend.return_value[
'courses']:
course['course_runs'][0].update({
"is_enrolled": True,
"upgrade_url": None,
})
setup_course_catalog_api_client_mock(course_catalog_api_client_mock)
enterprise_customer = EnterpriseCustomerFactory()
program_enrollment_page_url = reverse(
'enterprise_program_enrollment_page',
args=[enterprise_customer.uuid, self.dummy_program_uuid],
)
self._login()
response = self.client.post(program_enrollment_page_url)
assert response.status_code == 302
self.assertRedirects(
response,
'http://lms.example.com/dashboard/programs/52ad909b-c57d-4ff1-bab3-999813a2479b',
fetch_redirect_response=False)
def test_get_program_enrollment_page_for_inactive_user(
self, registry_mock, *args): # pylint: disable=unused-argument
"""
The user is redirected to the login screen to sign in with an enterprise-linked SSO when inactive.
"""
enterprise_customer = EnterpriseCustomerFactory()
faker = FakerFactory.create()
provider_id = faker.slug() # pylint: disable=no-member
self._setup_registry_mock(registry_mock, provider_id)
EnterpriseCustomerIdentityProviderFactory(
provider_id=provider_id, enterprise_customer=enterprise_customer)
program_enrollment_page_url = reverse(
'enterprise_program_enrollment_page',
args=[enterprise_customer.uuid, self.dummy_program_uuid],
)
response = self.client.get(program_enrollment_page_url)
expected_base_url = (
'/login?next=%2Fenterprise%2F{enterprise_customer_uuid}%2F'
'program%2F{program_uuid}%2Fenroll%2F').format(
enterprise_customer_uuid=enterprise_customer.uuid,
program_uuid=self.dummy_program_uuid)
expected_fragments = ('tpa_hint%3D{provider_id}'.format(
provider_id=provider_id, ), 'new_enterprise_login%3Dyes')
assert response.status_code == 302
assert expected_base_url in response.url
for fragment in expected_fragments:
assert fragment in response.url
def setUp(self):
self.user = UserFactory.create(is_staff=True, is_active=True)
self.enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy', )
self.enterprise_catalog = EnterpriseCustomerCatalogFactory(
enterprise_customer=self.enterprise_customer)
super().setUp()
def test_post_course_specific_consent_bad_api_response(
self, reverse_mock, *args): # pylint: disable=unused-argument
self._login()
course_id = 'course-v1:does+not+exist'
data_sharing_consent = True
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id, enterprise_customer=enterprise_customer)
EnterpriseCourseEnrollment.objects.create(enterprise_customer_user=ecu,
course_id=course_id)
dsc = DataSharingConsentFactory(
username=self.user.username,
course_id=course_id,
enterprise_customer=enterprise_customer,
granted=False,
)
reverse_mock.return_value = '/dashboard'
resp = self.client.post(
self.url,
data={
'course_id': course_id,
'data_sharing_consent': data_sharing_consent,
'redirect_url': '/successful_enrollment',
'enterprise_customer_uuid':
'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
},
)
assert resp.status_code == 404
dsc.refresh_from_db()
assert dsc.granted is False
def test_get_course_specific_consent_improperly_configured_course_catalog(
self, course_catalog_api_client_mock, *args): # pylint: disable=unused-argument,invalid-name
course_id = 'course-v1:edX+DemoX+Demo_Course'
course_catalog_api_client_mock.side_effect = ImproperlyConfigured(
"There is no active CatalogIntegration.")
self._login()
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
content_filter = {
'key': [
course_id,
]
}
EnterpriseCustomerCatalogFactory(
enterprise_customer=enterprise_customer,
content_filter=content_filter)
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id, enterprise_customer=enterprise_customer)
EnterpriseCourseEnrollment.objects.create(enterprise_customer_user=ecu,
course_id=course_id)
params = {
'course_id': course_id,
'enterprise_customer_uuid': str(enterprise_customer.uuid),
'next': 'https://google.com',
'failure_url': 'https://facebook.com',
'defer_creation': True,
}
with mock.patch('enterprise.views.render') as mock_render:
mock_render.return_value = HttpResponse()
self.client.get(self.url, data=params)
assert mock_render.call_args_list[0][1]['status'] == 404
def test_post_course_specific_consent_no_user(
self,
reverse_mock,
course_api_client_mock,
*args # pylint: disable=unused-argument
):
course_id = 'course-v1:edX+DemoX+Demo_Course'
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id,
enterprise_customer=enterprise_customer
)
EnterpriseCourseEnrollment.objects.create(
enterprise_customer_user=ecu,
course_id=course_id
)
client = course_api_client_mock.return_value
client.get_course_details.return_value = {
'name': 'edX Demo Course',
}
reverse_mock.return_value = '/dashboard'
resp = self.client.post(
self.url,
data={
'course_id': course_id,
'redirect_url': '/successful_enrollment'
},
)
assert resp.status_code == 404
def test_get_course_specific_consent_not_needed(
self,
course_api_client_mock,
render_mock, # pylint: disable=unused-argument
mock_config,
*args # pylint: disable=unused-argument
):
self._login()
course_id = 'course-v1:edX+DemoX+Demo_Course'
mock_config.get_value.return_value = 'My Platform'
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
client = course_api_client_mock.return_value
client.get_course_details.return_value = {
'name': 'edX Demo Course',
}
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id,
enterprise_customer=enterprise_customer
)
EnterpriseCourseEnrollment.objects.create(
enterprise_customer_user=ecu,
course_id=course_id,
consent_granted=True,
)
response = self.client.get(
self.url + '?course_id=course-v1%3AedX%2BDemoX%2BDemo_Course&next=https%3A%2F%2Fgoogle.com'
)
assert response.status_code == 404
def test_get_course_specific_consent(
self,
enrollment_deferred,
supply_customer_uuid,
course_api_client_mock,
render_mock, # pylint: disable=unused-argument
mock_config,
*args # pylint: disable=unused-argument
):
course_id = 'course-v1:edX+DemoX+Demo_Course'
mock_config.get_value.return_value = 'My Platform'
client = course_api_client_mock.return_value
client.get_course_details.return_value = {
'name': 'edX Demo Course',
}
self._login()
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id,
enterprise_customer=enterprise_customer
)
EnterpriseCourseEnrollment.objects.create(
enterprise_customer_user=ecu,
course_id=course_id
)
params = {
'course_id': 'course-v1:edX+DemoX+Demo_Course',
'next': 'https://google.com'
}
if enrollment_deferred:
params['enrollment_deferred'] = True
if supply_customer_uuid:
params['enterprise_id'] = str(enterprise_customer.uuid)
response = self.client.get(self.url, data=params)
assert response.status_code == 200
for key, value in {
"platform_name": "My Platform",
"data_sharing_consent": "required",
"messages": {
"note": (
"Courses from Starfleet Academy require data sharing consent. If you do not agree to "
"share your data, you will be redirected to your dashboard."
),
"warning": (
"Are you sure? If you do not agree to share your data "
"with Starfleet Academy, you cannot access edX Demo Course."
),
},
"course_id": "course-v1:edX+DemoX+Demo_Course",
"course_name": "edX Demo Course",
"redirect_url": "https://google.com",
"enterprise_customer_name": ecu.enterprise_customer.name,
"course_specific": True,
"enrollment_deferred": enrollment_deferred,
}.items():
assert response.context[key] == value # pylint:disable=no-member
def test_get_program_enrollment_page_no_price_info_found_message(
self, program_data_extender_mock, course_catalog_api_client_mock,
embargo_api_mock, *args): # pylint: disable=unused-argument,invalid-name
"""
The message about no price information found is rendered if the program extender fails to get price info.
"""
self._setup_embargo_api(embargo_api_mock)
program_data_extender_mock = self._setup_program_data_extender(
program_data_extender_mock)
program_data_extender_mock.return_value.extend.return_value[
'discount_data'] = {}
setup_course_catalog_api_client_mock(course_catalog_api_client_mock)
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy')
program_enrollment_page_url = reverse(
'enterprise_program_enrollment_page',
args=[enterprise_customer.uuid, self.dummy_program_uuid],
)
self._login()
response = self.client.get(program_enrollment_page_url)
messages = self._get_messages_from_response_cookies(response)
assert messages
self._assert_request_message(messages[0], 'warning', (
'<strong>We could not gather price information for <em>Program Title 1</em>.</strong> '
'<span>If you continue to have these issues, please contact '
'<a href="{enterprise_support_link}" target="_blank">{platform_name} support</a>.</span>'
).format(
enterprise_support_link=settings.ENTERPRISE_SUPPORT_URL,
platform_name=settings.PLATFORM_NAME,
))
def test_get_program_enrollment_page_program_unenrollable(
self, enrollable, program_data_extender_mock,
course_catalog_api_client_mock, embargo_api_mock, *args): # pylint: disable=unused-argument,invalid-name
"""
The message about the program being unenrollable is displayed.
"""
self._setup_embargo_api(embargo_api_mock)
program_data_extender_mock = self._setup_program_data_extender(
program_data_extender_mock).return_value
program_data_extender_mock.extend.return_value[
'is_learner_eligible_for_one_click_purchase'] = enrollable
setup_course_catalog_api_client_mock(course_catalog_api_client_mock)
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy')
program_enrollment_page_url = reverse(
'enterprise_program_enrollment_page',
args=[enterprise_customer.uuid, self.dummy_program_uuid],
)
self._login()
response = self.client.get(program_enrollment_page_url)
messages = self._get_messages_from_response_cookies(response)
if enrollable:
assert not messages
else:
assert messages
self._assert_request_message(
messages[0], 'info',
('<strong>Something happened.</strong> '
'<span>This program is not currently open to new learners. '
'Please start over and select a different program.</span>'))
def _make_bound_form(email,
file_attached=False,
course="",
course_mode="",
notify="",
reason="tests",
discount=0.0):
"""
Builds bound ManageLearnersForm.
"""
form_data = {
ManageLearnersForm.Fields.EMAIL_OR_USERNAME: email,
ManageLearnersForm.Fields.COURSE: course,
ManageLearnersForm.Fields.COURSE_MODE: course_mode,
ManageLearnersForm.Fields.NOTIFY: notify,
ManageLearnersForm.Fields.REASON: reason,
ManageLearnersForm.Fields.DISCOUNT: discount,
}
file_data = {}
if file_attached:
mock_file = mock.Mock(spec=File)
mock_file.name = "some_file.csv"
mock_file.read.return_value = "fake file contents"
file_data = {ManageLearnersForm.Fields.BULK_UPLOAD: mock_file}
customer = EnterpriseCustomerFactory()
return ManageLearnersForm(form_data,
file_data,
enterprise_customer=customer)
def test_get_program_enrollment_page_for_certificate_eligible_user(
self, program_data_extender_mock, course_catalog_api_client_mock,
*args): # pylint: disable=unused-argument,invalid-name
"""
The user will be redirected to the program's dashboard when already certificate-eligible for the program.
"""
program_data_extender_mock = self._setup_program_data_extender(
program_data_extender_mock)
for course in program_data_extender_mock.return_value.extend.return_value[
'courses']:
course['course_runs'][0].update({
"is_enrolled": True,
"upgrade_url": None,
})
setup_course_catalog_api_client_mock(course_catalog_api_client_mock)
enterprise_customer = EnterpriseCustomerFactory()
program_enrollment_page_url = reverse(
'enterprise_program_enrollment_page',
args=[enterprise_customer.uuid, self.dummy_program_uuid],
)
self._login()
response = self.client.get(program_enrollment_page_url)
self.assertRedirects(
response,
'http://lms.example.com/dashboard/programs/{program_uuid}'.format(
program_uuid=self.dummy_program_uuid),
fetch_redirect_response=False,
)
def test_get_course_specific_consent_unauthenticated_user(
self, course_api_client_mock, *args): # pylint: disable=unused-argument
course_id = 'course-v1:edX+DemoX+Demo_Course'
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
client = course_api_client_mock.return_value
client.get_course_details.return_value = {
'name': 'edX Demo Course',
}
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id, enterprise_customer=enterprise_customer)
EnterpriseCourseEnrollment.objects.create(enterprise_customer_user=ecu,
course_id=course_id)
DataSharingConsentFactory(
username=self.user.username,
course_id=course_id,
enterprise_customer=enterprise_customer,
)
response = self.client.get(
self.url +
'?course_id=course-v1%3AedX%2BDemoX%2BDemo_Course&next=https%3A%2F%2Fgoogle.com'
)
assert response.status_code == 302
self.assertRedirects(response, (
'/accounts/login/?next=/enterprise/grant_data_sharing_permissions%3Fcourse_id%3Dcourse-v1'
'%253AedX%252BDemoX%252BDemo_Course%26next%3Dhttps%253A%252F%252Fgoogle.com'
),
fetch_redirect_response=False)
def test_post_program_enrollment_view_redirect_to_dsc(
self, program_data_extender_mock, course_catalog_api_client_mock,
get_dsc_mock, *args): # pylint: disable=unused-argument
"""
The user is redirected to the DSC page when DSC is needed.
"""
self._setup_program_data_extender(program_data_extender_mock)
setup_course_catalog_api_client_mock(course_catalog_api_client_mock)
self._setup_get_data_sharing_consent(get_dsc_mock, required=True)
enterprise_customer = EnterpriseCustomerFactory()
program_enrollment_page_url = reverse(
'enterprise_program_enrollment_page',
args=[enterprise_customer.uuid, self.dummy_program_uuid],
)
self._login()
response = self.client.post(program_enrollment_page_url)
assert response.status_code == 302
self.assertRedirects(
response,
'/enterprise/grant_data_sharing_permissions?{}'.format(
urlencode({
'next':
'http://localhost:18130/basket/add/?sku=sku1&sku=sku2'
'&bundle=52ad909b-c57d-4ff1-bab3-999813a2479b',
'failure_url':
program_enrollment_page_url,
'enterprise_customer_uuid':
enterprise_customer.uuid,
'program_uuid':
self.dummy_program_uuid,
})),
fetch_redirect_response=False)
def test_post_patch_real_social_auth_enforced(
self,
mock_get_ec,
mock_get_rsa,
mock_get_ec2,
mock_url,
mock_render,
mock_config,
mock_lift,
mock_quarantine,
): # pylint: disable=unused-argument
"""
Test an enforecd request without consent.
"""
customer = EnterpriseCustomerFactory()
mock_get_ec.return_value = customer
mock_get_ec2.return_value = customer
mock_get_rsa.return_value = mock.MagicMock(user=UserFactory())
with raises(NoReverseMatch) as excinfo:
client = Client()
session = client.session
session['partial_pipeline'] = True
session.save()
client.post(self.url)
expected = (
'Reverse for \'dashboard\' with arguments \'()\' and keyword '
'arguments \'{}\' not found. 0 pattern(s) tried: []'
)
assert str(excinfo.value) == expected
# Ensure that when consent hasn't been provided, we don't link the user to the Enterprise Customer.
assert UserDataSharingConsentAudit.objects.all().count() == 0
assert EnterpriseCustomerUser.objects.all().count() == 0
def test_with_mocked_get_edx_data(self):
self.catalog_api.get_all_catalogs.return_value = [
{
"id": self.catalog_id,
"name": "My Catalog"
},
{
"id": 1,
"name": "Other catalog!"
}
]
customer = EnterpriseCustomerFactory(
catalog=99,
)
form = EnterpriseCustomerAdminForm(
{
'catalog': '',
'enforce_data_sharing_consent': customer.enforce_data_sharing_consent,
'site': customer.site.id,
'name': customer.name,
'active': customer.active
},
instance=customer,
)
assert isinstance(form.fields['catalog'], forms.ChoiceField)
assert form.fields['catalog'].choices == BLANK_CHOICE_DASH + [
(self.catalog_id, 'My Catalog'),
(1, 'Other catalog!'),
]
def test_get_course_specific_consent_invalid_get_params(
self, course_api_client_mock, *args): # pylint: disable=unused-argument
course_id = 'course-v1:edX+DemoX+Demo_Course'
client = course_api_client_mock.return_value
client.get_course_details.return_value = {
'name': 'edX Demo Course',
}
self._login()
enterprise_customer = EnterpriseCustomerFactory(
name='Starfleet Academy',
enable_data_sharing_consent=True,
enforce_data_sharing_consent='at_enrollment',
)
ecu = EnterpriseCustomerUserFactory(
user_id=self.user.id, enterprise_customer=enterprise_customer)
EnterpriseCourseEnrollment.objects.create(enterprise_customer_user=ecu,
course_id=course_id)
DataSharingConsentFactory(
username=self.user.username,
course_id=course_id,
enterprise_customer=enterprise_customer,
)
params = {
'enterprise_customer_uuid': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
'course_id': 'course-v1:edX+DemoX+Demo_Course',
'next': 'https://google.com',
'defer_creation': True,
}
response = self.client.get(self.url, data=params)
assert response.status_code == 404
