def setUp(self):
super(TestLearnerInfoSerializer, self).setUp()
self.user = factories.UserFactory()
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
user_id=self.user.id)
# pylint: disable=invalid-name
self.enterprise_customer_identity_provider = factories.EnterpriseCustomerIdentityProviderFactory(
enterprise_customer=self.enterprise_customer_user.
enterprise_customer)
self.expected_data = {
'enterprise_sso_uid':
TEST_ENTERPRISE_SSO_UID,
'lms_user_id':
self.user.id,
'enterprise_user_id':
self.enterprise_customer_user.id,
'user_username':
self.user.username,
'user_account_creation_date':
self.user.date_joined.strftime("%Y-%m-%dT%H:%M:%SZ"),
'user_country_code':
'PK',
'user_email':
self.user.email
}
def test_update_course_ddt(self, course, provider_id, global_context,
expected_course):
"""
Test update_course method of EnterpriseCatalogCoursesReadOnlySerializer.
Verify that update_course for EnterpriseCatalogCoursesReadOnlySerializer returns
successfully without errors.
"""
enterprise_customer_id = 'd2fb4cb0-b538-4934-1926-684d48ff5865'
ecu = factories.EnterpriseCustomerUserFactory(
enterprise_customer__uuid=enterprise_customer_id,
user_id=self.user.id,
)
factories.EnterpriseCustomerIdentityProviderFactory(
enterprise_customer=ecu.enterprise_customer,
provider_id=provider_id,
)
with mock.patch('enterprise.utils.reverse',
return_value='course_modes/choose/'):
updated_course = self.serializer.update_course(
course, 1, ecu.enterprise_customer, global_context)
# Make sure global context passed in to update_course is added to the course.
for key, value in six.iteritems(global_context):
assert key in updated_course
assert updated_course[key] == value
assert expected_course == updated_course
def setUp(self):
self.user = factories.UserFactory(username='******', id=1)
self.course_id = 'course-v1:edX+DemoX+DemoCourse'
self.course_key = 'edX+DemoX'
self.enterprise_customer = factories.EnterpriseCustomerFactory()
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
user_id=self.user.id,
enterprise_customer=self.enterprise_customer,
)
self.data_sharing_consent = factories.DataSharingConsentFactory(
username=self.user.username,
course_id=self.course_id,
enterprise_customer=self.enterprise_customer,
granted=True,
)
self.config = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
sapsf_base_url='enterprise.successfactors.com',
key='key',
secret='secret',
active=True,
)
self.idp = factories.EnterpriseCustomerIdentityProviderFactory(
enterprise_customer=self.enterprise_customer
)
tpa_client_mock = mock.patch('enterprise.models.ThirdPartyAuthApiClient')
self.tpa_client = tpa_client_mock.start().return_value
# Default remote ID
self.tpa_client.get_remote_id.return_value = 'fake-remote-id'
self.addCleanup(tpa_client_mock.stop)
self.exporter = self.config.get_learner_data_exporter('dummy-user')
assert isinstance(self.exporter, LearnerExporter)
super(TestLearnerExporter, self).setUp()
def test_enterprise_catalog_courses(self, url, provider_id,
enterprise_customer,
mocked_catalog_courses, expected):
"""
Make sure enterprise catalog view returns correct data.
Arguments:
mocked_catalog_courses: This is used to mock catalog courses returned by catalog api.
expected: This is the expected catalog courses from enterprise api.
"""
# Populate database
ecu = factories.EnterpriseCustomerUserFactory(
user_id=self.user.id,
enterprise_customer__uuid=enterprise_customer,
)
factories.EnterpriseCustomerIdentityProviderFactory(
enterprise_customer=ecu.enterprise_customer,
provider_id=provider_id,
)
with mock.patch('enterprise.api.v1.views.CourseCatalogApiClient'
) as mock_catalog_api_client:
mock_catalog_api_client.return_value = mock.Mock(
get_paginated_catalog_courses=mock.Mock(
return_value=mocked_catalog_courses), )
response = self.client.get(url)
response = self.load_json(response.content)
assert response == expected
def setUp(self):
self.user = factories.UserFactory(username='******',
id=1,
email='*****@*****.**')
self.course_id = 'course-v1:edX+DemoX+DemoCourse'
self.enterprise_customer = factories.EnterpriseCustomerFactory()
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
user_id=self.user.id,
enterprise_customer=self.enterprise_customer,
)
self.data_sharing_consent = factories.DataSharingConsentFactory(
username=self.user.username,
course_id=self.course_id,
enterprise_customer=self.enterprise_customer,
granted=True,
)
self.config = factories.DegreedEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
active=True,
)
self.idp = factories.EnterpriseCustomerIdentityProviderFactory(
enterprise_customer=self.enterprise_customer)
tpa_client_mock = mock.patch(
'enterprise.models.ThirdPartyAuthApiClient')
self.tpa_client = tpa_client_mock.start()
self.tpa_client.return_value.get_remote_id.return_value = 'fake-remote-id'
self.addCleanup(tpa_client_mock.stop)
super(TestDegreedLearnerExporter, self).setUp()
def setUp(self):
self.api_user = factories.UserFactory(username='******', id=1)
self.user1 = factories.UserFactory(id=2, email='*****@*****.**')
self.user2 = factories.UserFactory(id=3, email='*****@*****.**')
self.course_id = COURSE_ID
self.enterprise_customer = factories.EnterpriseCustomerFactory(
name='Spaghetti Enterprise')
self.identity_provider = FakerFactory.create().slug() # pylint: disable=no-member
factories.EnterpriseCustomerIdentityProviderFactory(
provider_id=self.identity_provider,
enterprise_customer=self.enterprise_customer,
)
self.enterprise_customer_user1 = factories.EnterpriseCustomerUserFactory(
user_id=self.user1.id,
enterprise_customer=self.enterprise_customer,
)
self.enterprise_customer_user2 = factories.EnterpriseCustomerUserFactory(
user_id=self.user2.id,
enterprise_customer=self.enterprise_customer,
)
self.enrollment = factories.EnterpriseCourseEnrollmentFactory(
id=2,
enterprise_customer_user=self.enterprise_customer_user1,
course_id=self.course_id,
)
self.enrollment = factories.EnterpriseCourseEnrollmentFactory(
id=3,
enterprise_customer_user=self.enterprise_customer_user2,
course_id=self.course_id,
)
self.consent1 = factories.DataSharingConsentFactory(
username=self.user1.username,
course_id=self.course_id,
enterprise_customer=self.enterprise_customer,
)
self.consent2 = factories.DataSharingConsentFactory(
username=self.user2.username,
course_id=self.course_id,
enterprise_customer=self.enterprise_customer,
)
self.degreed = factories.DegreedEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
key='key',
secret='secret',
degreed_company_id='Degreed Company',
active=True,
degreed_base_url='https://www.degreed.com/',
)
self.degreed_global_configuration = factories.DegreedGlobalConfigurationFactory(
oauth_api_path='oauth/token', )
self.sapsf = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
sapsf_base_url='http://enterprise.successfactors.com/',
key='key',
secret='secret',
active=True,
)
self.sapsf_global_configuration = factories.SAPSuccessFactorsGlobalConfigurationFactory(
)
super(TestTransmitLearnerData, self).setUp()
def test_update_course_runs(
self,
course_run,
catalog_id,
provider_id,
enterprise_customer_uuid,
expected_fields,
expected_urls,
mock_config_helpers,
):
"""
Test update_course_runs method of EnterpriseCatalogCoursesReadOnlySerializer.
Verify that update_course for EnterpriseCatalogCoursesReadOnlySerializer returns
successfully without errors.
"""
# Populate database.
mock_config_helpers.get_value.return_value = 'http://testserver/'
ec_identity_provider = factories.EnterpriseCustomerIdentityProviderFactory(
enterprise_customer__uuid=enterprise_customer_uuid,
provider_id=provider_id,
)
course_run_url = 'course_modes/choose/course-v1:edX+DemoX+1T2017/'
with mock.patch('enterprise.utils.reverse',
return_value=course_run_url):
updated_course_runs = self.serializer.update_course_runs(
course_runs=[course_run],
catalog_id=catalog_id,
enterprise_customer=ec_identity_provider.enterprise_customer,
)
assert len(updated_course_runs) == 1
updated_course_run = updated_course_runs[0]
# Make sure all of the expected fields are present in data returned.
# This statement will also assert that all of the expected fields have same value.
for key, value in six.iteritems(expected_fields):
assert key in updated_course_run
assert value == updated_course_run[key]
# Make sure all expected urls are present in data returned.
for key, value in six.iteritems(expected_urls):
assert key in updated_course_run
self.assert_url(value, updated_course_run[key])
def setUp(self):
"""
Perform operations common for all tests.
Populate data base for api testing.
"""
super(TestEnterpriseCatalogCoursesSerializer, self).setUp()
faker = FakerFactory.create()
self.provider_id = faker.slug()
self.user = factories.UserFactory()
self.ecu = factories.EnterpriseCustomerUserFactory(
user_id=self.user.id, )
factories.EnterpriseCustomerIdentityProviderFactory(
enterprise_customer=self.ecu.enterprise_customer,
provider_id=self.provider_id,
)
# Create and authenticate a request
self.request = APIRequestFactory().get(reverse('catalogs-list'))
self.request.user = self.user
# instance is none as models for this serializer do not exist in enterprise.
self.instance = None
self.data = {
'count':
1,
'next':
None,
'previous':
None,
'results': [{
'owners': [{
'description': None,
'tags': [],
'name': '',
'homepage_url': None,
'key': 'edX',
'certificate_logo_image_url': None,
'marketing_url': None,
'logo_image_url': None,
'uuid': 'aa4aaad0-2ff0-44ce-95e5-1121d02f3b27'
}],
'uuid':
'd2fb4cb0-b538-4934-ba60-684d48ff5865',
'title':
'edX Demonstration Course',
'prerequisites': [],
'image':
None,
'expected_learning_items': [],
'sponsors': [],
'modified':
'2017-03-03T07:34:19.322916Z',
'full_description':
None,
'subjects': [],
'video':
None,
'key':
'edX+DemoX',
'short_description':
None,
'marketing_url':
'http://testserver/course/course-v1:edX+DemoX+1T2017/',
'level_type':
None,
'course_runs': [{
'key':
'course-v1:edX+DemoX+1T2017',
'uuid':
'57432370-0a6e-4d95-90fe-77b4fe64de2b',
'title':
'edX Demonstration Course',
'image': {
'width': None,
'src':
'http://testserver/image/promoted/screen_shot_2016-12-27_at_9.30.00_am.png',
'description': None,
'height': None
},
'short_description':
'edX Demonstration Course',
'marketing_url':
'http://testserver/course/course-edx-d103?utm_medium=affiliate_partner',
'start':
'2016-12-28T05:00:00Z',
'end':
'2018-12-28T00:00:00Z',
'enrollment_start':
None,
'enrollment_end':
None,
'pacing_type':
'instructor_paced',
'type':
'audit',
'course':
'edx+D103',
'full_description':
'edx demo course',
'announcement':
None,
'video':
None,
'seats': [{
'type': 'audit',
'price': '0.00',
'currency': 'USD',
'upgrade_deadline': None,
'credit_provider': None,
'credit_hours': None,
'sku': '2ADB190'
}],
'content_language':
'en-us',
'transcript_languages': [],
'instructors': [],
'staff': [],
'min_effort':
None,
'max_effort':
None,
'modified':
'2017-03-08T05:46:52.682549Z',
'level_type':
'Introductory',
'availability':
'Current',
'mobile_available':
False,
'hidden':
False,
'reporting_type':
'mooc'
}]
}]
}
self.validated_data = self.data
self.serializer = EnterpriseCatalogCoursesReadOnlySerializer(self.data)
