def setUp(self):
self.user = factories.UserFactory()
self.other_user = factories.UserFactory()
self.staff_user = factories.UserFactory(is_staff=True, is_active=True)
self.subdomain = 'fake-subdomain'
self.session_token = 'fake-session-token'
self.callback_url = '/services/x/content-online-content-api/v1'
self.user_guid = "fake-guid"
self.course_id = 'course-v1:edX+DemoX+DemoCourse'
self.course_key = 'edX+DemoX'
self.enterprise_customer = factories.EnterpriseCustomerFactory(
enable_audit_enrollment=True,
enable_audit_data_reporting=True,
)
self.config = factories.CornerstoneEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
active=True,
)
self.global_config = factories.CornerstoneGlobalConfigurationFactory(
key='test_key', secret='test_secret')
self.enterprise_course_enrollment = self._setup_enterprise_enrollment(
self.user, self.course_id, self.course_key)
course_catalog_api_client_mock = mock.patch(
'enterprise.api_client.discovery.CourseCatalogApiServiceClient')
course_catalog_client = course_catalog_api_client_mock.start()
setup_course_catalog_api_client_mock(course_catalog_client)
self.addCleanup(course_catalog_api_client_mock.stop)
super(TestCornerstoneLearnerExporter, 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 setUp(self):
self.user = factories.UserFactory(username='******')
self.enterprise_customer = factories.EnterpriseCustomerFactory(
catalog=1,
name='Veridian Dynamics',
)
self.degreed = factories.DegreedEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
key='key',
secret='secret',
degreed_company_id='Degreed Company',
degreed_base_url='https://www.degreed.com/',
)
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(
)
self.catalog_api_config_mock = self._make_patch(
self._make_catalog_api_location("CatalogIntegration"))
super(TestTransmitCourseMetadataManagementCommand, self).setUp()
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):
super(TestUtils, self).setUp()
self.faker = FakerFactory.create()
self.user = factories.UserFactory()
self.user.profile = mock.Mock(country=mock.Mock(code='PK'))
now = datetime.now()
# pylint: disable=no-member
self.course_overview_mock_data = dict(
id=self.faker.text(max_nb_chars=25), # pylint: disable=no-member
display_name=self.faker.text(max_nb_chars=25), # pylint: disable=no-member
short_description=self.faker.text(), # pylint: disable=no-member
marketing_url=self.faker.url(), # pylint: disable=no-member
effort=self.faker.text(max_nb_chars=10), # pylint: disable=no-member
start=now,
end=now + timedelta(weeks=3, days=4),
)
self.course_overview = mock.Mock(**self.course_overview_mock_data)
self.course_enrollment = mock.Mock(user=self.user,
course=self.course_overview)
self.course_grade = mock.Mock(percent=0.80, passed=True)
self.x_api_lrs_config = factories.XAPILRSConfigurationFactory()
self.x_api_client = EnterpriseXAPIClient(self.x_api_lrs_config)
def setUp(self):
super(TestCourseInfoSerializer, self).setUp()
self.faker = FakerFactory.create()
self.course_overview = factories.UserFactory()
now = datetime.now()
self.course_overview_mock_data = dict(
id=self.faker.text(max_nb_chars=25), # pylint: disable=no-member
display_name=self.faker.text(max_nb_chars=25), # pylint: disable=no-member
short_description=self.faker.text(), # pylint: disable=no-member
marketing_url=self.faker.url(), # pylint: disable=no-member
effort=self.faker.text(max_nb_chars=10), # pylint: disable=no-member
start=now,
end=now + timedelta(weeks=3, days=4),
)
self.course_overview = mock.Mock(**self.course_overview_mock_data)
self.expected_data = {
'course_description':
self.course_overview_mock_data['short_description'],
'course_title':
self.course_overview_mock_data['display_name'],
'course_duration':
self.course_overview_mock_data['end'] -
self.course_overview_mock_data['start'],
'course_effort':
self.course_overview_mock_data['effort'],
'course_details_url':
self.course_overview_mock_data['marketing_url'],
'course_id':
self.course_overview_mock_data['id'],
}
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 setUp(self):
super(TestUtils, self).setUp()
self.faker = FakerFactory.create()
self.user = factories.UserFactory()
self.user.profile = mock.Mock(country=mock.Mock(code='PK'))
self.mock_social_auth = mock.Mock(provider='tpa-saml',
uid='default:edxsso')
self.mock_save_statement_success = mock.Mock(name='response',
response=mock.Mock(
name='response',
status=200))
now = datetime.now()
# pylint: disable=no-member
self.course_overview_mock_data = dict(
id=self.faker.text(max_nb_chars=25), # pylint: disable=no-member
display_name=self.faker.text(max_nb_chars=25), # pylint: disable=no-member
short_description=self.faker.text(), # pylint: disable=no-member
marketing_url=self.faker.url(), # pylint: disable=no-member
effort=self.faker.text(max_nb_chars=10), # pylint: disable=no-member
start=now,
end=now + timedelta(weeks=3, days=4),
course_key='OrgX+Course101',
course_uuid='b1e7c719af3c42288c6f50e2124bb913',
)
self.course_overview = mock.Mock(**self.course_overview_mock_data)
self.course_enrollment = mock.Mock(user=self.user,
course=self.course_overview)
self.course_grade = mock.Mock(percent_grade=0.80,
passed_timestamp='2020-04-01')
self.x_api_lrs_config = factories.XAPILRSConfigurationFactory()
self.x_api_client = EnterpriseXAPIClient(self.x_api_lrs_config)
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 create_user(self, username=TEST_USERNAME, password=TEST_PASSWORD, **kwargs):
"""
Create a test user and set its password.
"""
self.user = factories.UserFactory(username=username, is_active=True, **kwargs)
self.user.set_password(password) # pylint: disable=no-member
self.user.save() # pylint: disable=no-member
def test_prefetch_users(self):
"""
Make sure prefetch_users method works as expected.
"""
# Import is placed here because if placed at the top it affects mocking.
from integrated_channels.xapi.management.commands.send_course_completions import Command
user = factories.UserFactory()
expected = {user.id: user}
assert Command.prefetch_users([mock.Mock(user_id=user.id)]) == expected
def test_get_course_completions_no_grade_record(self):
"""
Make sure get_course_completions works as expected
"""
# pylint: disable=import-outside-toplevel
from integrated_channels.xapi.management.commands.send_course_completions import Command
user = factories.UserFactory()
enterprise_course_enrollments = [mock.Mock(id=42, user_id=user.id)]
Command.get_course_completions(enterprise_course_enrollments)
def test_transmit_course_enrollments_transmit_fail_skip(self, mock_send_statement):
# pylint: disable=import-outside-toplevel
from integrated_channels.xapi.management.commands.send_course_enrollments import Command
lrs_configuration = factories.XAPILRSConfigurationFactory()
user = factories.UserFactory()
course = self.course_overview
Command.transmit_courserun_enrollment_statement(lrs_configuration, user, course)
assert mock_send_statement.called
def test_save_xapi_learner_data_transmission_audit(self):
# pylint: disable=import-outside-toplevel
from integrated_channels.xapi.management.commands.send_course_enrollments import Command
Command.save_xapi_learner_data_transmission_audit(
factories.UserFactory(),
'course-v1:edX+DemoX+Demo_Course',
42,
status=200,
error_message=None
)
def setUp(self):
super(TestUtils, self).setUp()
faker = FakerFactory.create()
self.user = factories.UserFactory()
# pylint: disable=no-member
self.course_overview = mock.Mock(display_name=faker.text(max_nb_chars=25), short_description=faker.text())
self.course_enrollment = mock.Mock(user=self.user, course=self.course_overview)
self.x_api_lrs_config = factories.XAPILRSConfigurationFactory()
self.x_api_client = EnterpriseXAPIClient(self.x_api_lrs_config)
def test_save_xapi_learner_data_transmission_audit_preexisting(self, mock_transmission_audit):
# pylint: disable=import-outside-toplevel
from integrated_channels.xapi.management.commands.send_course_enrollments import Command
mock_transmission_audit.objects.get_or_create.return_value = (mock.MagicMock(), False)
Command.save_xapi_learner_data_transmission_audit(
factories.UserFactory(),
'course-v1:edX+DemoX+Demo_Course',
42,
status=200,
error_message=None
)
def test_prefetch_users(self):
"""
Make sure prefetch_users method works as expected.
"""
# Import is placed here because if placed at the top it affects mocking.
# pylint: disable=import-outside-toplevel
from integrated_channels.xapi.management.commands.send_course_completions import Command
user = factories.UserFactory()
enrollment_grades = {42: mock.Mock(user_id=user.id)}
expected = {user.id: user}
assert Command.prefetch_users(enrollment_grades) == expected
def setUp(self):
"""
Perform operations common for all tests.
Populate data base for api testing.
"""
super(TestEnterpriseAPIThrottling, self).setUp()
user = factories.UserFactory()
enterprise_customer = factories.EnterpriseCustomerFactory()
factories.EnterpriseCustomerUserFactory(
enterprise_customer=enterprise_customer, user_id=user.id)
self.url = settings.TEST_SERVER + reverse('enterprise-customer-list')
def setUp(self):
super(TestLearnerCourseCompletionStatement, self).setUp()
faker = FakerFactory.create()
self.user = factories.UserFactory()
self.mock_social_auth = Mock(provider='tpa-saml', uid='default:edxsso')
# pylint: disable=no-member
self.course_overview = Mock(id='course-v1:edX+DemoX+Demo_Course',
display_name=faker.text(max_nb_chars=25),
short_description=faker.text())
self.course_grade = Mock(percent=0.80, passed=True)
self.expected = {
'verb': {
'id': X_API_VERB_COMPLETED,
'display': {
'en-US': 'completed'
}
},
'version': '1.0.1',
'actor': {
'mbox': 'mailto:{email}'.format(email=self.user.email),
'name': 'edxsso',
'objectType': 'Agent'
},
'object': {
'definition': {
'type': X_API_ACTIVITY_COURSE,
'description': {
'en-US': self.course_overview.short_description
},
'name': {
'en-US': self.course_overview.display_name
}
},
'id': self.course_overview.id,
'objectType': 'Activity'
},
'result': {
'score': {
'scaled': 0.8,
'raw': 80,
'min': 0,
'max': 100
},
'success': True,
'completion': True,
},
}
def test_get_course_completions(self, mock_persistent_course_grade):
"""
Make sure get_course_completions works as expected
"""
# pylint: disable=import-outside-toplevel
from integrated_channels.xapi.management.commands.send_course_completions import Command
user = factories.UserFactory()
enterprise_course_enrollments = [mock.Mock(id=42, user_id=user.id)]
Command.get_course_completions(enterprise_course_enrollments)
assert mock_persistent_course_grade.objects.filter.called
mock_persistent_course_grade.objects.filter.return_value = mock.MagicMock(
)
Command.get_course_completions(enterprise_course_enrollments)
def setUp(self):
"""
Perform operations common for all tests.
Populate data base for api testing.
"""
super(TestEnterpriseCustomerUserFilterBackend, self).setUp()
self.test_user = factories.UserFactory(username=self.username,
email=self.email,
is_active=True)
enterprise_customer = factories.EnterpriseCustomerFactory()
factories.EnterpriseCustomerUserFactory(
enterprise_customer=enterprise_customer, user_id=self.test_user.id)
self.url = settings.TEST_SERVER + reverse('enterprise-learner-list')
def setUp(self):
super().setUp()
self.enterprise_customer = factories.EnterpriseCustomerFactory()
self.course_run_id = 'course-v1:edX+DemoX+Demo_Course'
self.request = mock.MagicMock(path=reverse(
'enterprise_course_run_enrollment_page',
args=[self.enterprise_customer.uuid, self.course_run_id]),
user=factories.UserFactory())
self.kwargs = {
'enterprise_uuid': str(self.enterprise_customer.uuid),
'course_id': self.course_run_id,
}
views_mock = mock.patch('enterprise.views.RouterView.VIEWS')
self.views_mock = views_mock.start()
self.views_mock.__getitem__.side_effect = self.TEST_VIEWS.__getitem__
self.addCleanup(views_mock.stop)
analytics = mock.patch('enterprise.utils.segment')
self.analytics = analytics.start()
self.addCleanup(analytics.stop)
def test_transmit_content_metadata_task_no_channel(self):
"""
Test the data transmission task without any integrated channel.
"""
user = factories.UserFactory(username='******')
factories.EnterpriseCustomerFactory(
catalog=1,
name='Veridian Dynamics',
)
# Remove all integrated channels
SAPSuccessFactorsEnterpriseCustomerConfiguration.objects.all().delete()
DegreedEnterpriseCustomerConfiguration.objects.all().delete()
with LogCapture(level=logging.INFO) as log_capture:
call_command('transmit_content_metadata', '--catalog_user',
user.username)
# Because there are no IntegratedChannels, the process will end early.
assert not log_capture.records
def setUp(self):
super(TestLearnerCourseEnrollmentStatement, self).setUp()
faker = FakerFactory.create()
self.user = factories.UserFactory()
# pylint: disable=no-member
self.course_overview = Mock(id='course-v1:edX+DemoX+Demo_Course',
display_name=faker.text(max_nb_chars=25),
short_description=faker.text())
self.expected = {
'verb': {
'id': X_API_VERB_REGISTERED,
'display': {
'en-US': 'registered'
}
},
'version': '1.0.1',
'actor': {
'mbox': 'mailto:{email}'.format(email=self.user.email),
'name': self.user.email,
'objectType': 'Agent'
},
'object': {
'definition': {
'type': X_API_ACTIVITY_COURSE,
'description': {
'en-US': self.course_overview.short_description
},
'name': {
'en-US': self.course_overview.display_name
}
},
'id': self.course_overview.id,
'objectType': 'Activity'
},
}
def setUp(self):
super(TestLearnerCourseEnrollmentStatement, self).setUp()
faker = FakerFactory.create()
self.site = Mock(domain='xapi.testing.com')
self.user = factories.UserFactory()
self.mock_social_auth = Mock(provider='tpa-saml', uid='default:edxsso')
# pylint: disable=no-member
self.course_overview = Mock(
id='course-v1:edX+DemoX+Demo_Course',
display_name=faker.text(max_nb_chars=25),
short_description=faker.text(),
course_key='edX+DemoX',
course_uuid='b1e7c719af3c42288c6f50e2124bb913',
)
self.object_id_course = 'https://{domain}/xapi/activities/course/{activity_id}'.format(
domain=self.site.domain,
activity_id=self.course_overview.course_key)
self.object_id_courserun = 'https://{domain}/xapi/activities/courserun/{activity_id}'.format(
domain=self.site.domain,
activity_id=self.course_overview.id)
self.verb = {
'id': X_API_VERB_REGISTERED,
'display': {'en-US': 'registered'}
}
self.actor = {
'mbox': 'mailto:{email}'.format(email=self.user.email),
'name': 'edxsso',
'objectType': 'Agent'
}
self.extensions = {}
self.extension_course_key = 'https://{domain}/course/key'.format(domain=self.site.domain)
self.extensions[self.extension_course_key] = self.course_overview.course_key
self.extension_course_uuid = 'https://{domain}/course/uuid'.format(domain=self.site.domain)
self.extensions[self.extension_course_uuid] = self.course_overview.course_uuid
self.object_course = {
'definition':
{
'type': X_API_ACTIVITY_COURSE,
'description':
{
'en-US': self.course_overview.short_description
},
'name':
{
'en-US': self.course_overview.display_name
},
"extensions": self.extensions
},
'id': self.object_id_course,
'objectType': 'Activity'
}
self.object_courserun = {
'definition':
{
'type': X_API_ACTIVITY_COURSE,
'description':
{
'en-US': self.course_overview.short_description
},
'name':
{
'en-US': self.course_overview.display_name
},
"extensions": self.extensions
},
'id': self.object_id_courserun,
'objectType': 'Activity'
}
self.expected_course = {
'verb': self.verb,
'version': '1.0.1',
'actor': self.actor,
'object': self.object_course
}
self.expected_courserun = {
'verb': self.verb,
'version': '1.0.1',
'actor': self.actor,
'object': self.object_courserun
}
def setUp(self):
super(TestLearnerCourseCompletionStatement, self).setUp()
faker = FakerFactory.create()
self.site = Mock(domain='xapi.testing.com')
self.user = factories.UserFactory()
self.mock_social_auth = Mock(provider='tpa-saml', uid='default:edxsso')
# pylint: disable=no-member
self.course_overview = Mock(
id='course-v1:edX+DemoX+Demo_Course',
display_name=faker.text(max_nb_chars=25),
short_description=faker.text(),
course_key='edX+DemoX',
course_uuid='b1e7c719af3c42288c6f50e2124bb913',
)
self.course_grade = Mock(percent_grade=0.80,
passed_timestamp='2020-04-01')
self.course_grade_notpassed = Mock(percent_grade=0.50,
passed_timestamp=None)
self.object_id_course = 'https://{domain}/xapi/activities/course/{activity_id}'.format(
domain=self.site.domain,
activity_id=self.course_overview.course_key)
self.object_id_courserun = 'https://{domain}/xapi/activities/courserun/{activity_id}'.format(
domain=self.site.domain, activity_id=self.course_overview.id)
self.verb = {
'id': X_API_VERB_COMPLETED,
'display': {
'en-US': 'completed'
}
}
self.actor = {
'mbox': 'mailto:{email}'.format(email=self.user.email),
'name': 'edxsso',
'objectType': 'Agent'
}
self.extensions = {}
self.extension_course_key = 'https://{domain}/course/key'.format(
domain=self.site.domain)
self.extensions[
self.extension_course_key] = self.course_overview.course_key
self.extension_course_uuid = 'https://{domain}/course/uuid'.format(
domain=self.site.domain)
self.extensions[
self.extension_course_uuid] = self.course_overview.course_uuid
self.object_course = {
'definition': {
'type': X_API_ACTIVITY_COURSE,
'description': {
'en-US': self.course_overview.short_description
},
'name': {
'en-US': self.course_overview.display_name
},
"extensions": self.extensions
},
'id': self.object_id_course,
'objectType': 'Activity'
}
self.object_courserun = {
'definition': {
'type': X_API_ACTIVITY_COURSE,
'description': {
'en-US': self.course_overview.short_description
},
'name': {
'en-US': self.course_overview.display_name
},
"extensions": self.extensions
},
'id': self.object_id_courserun,
'objectType': 'Activity'
}
self.result = {
'score': {
'scaled': 0.8,
'raw': 80,
'min': 0,
'max': 100
},
'success': True,
'completion': True,
}
self.result_notpassed = {
'score': {
'scaled': 0.5,
'raw': 50,
'min': 0,
'max': 100
},
'success': False,
'completion': False,
}
self.expected_course = {
'verb': self.verb,
'version': '1.0.1',
'actor': self.actor,
'object': self.object_course,
'result': self.result,
}
self.expected_courserun = {
'verb': self.verb,
'version': '1.0.1',
'actor': self.actor,
'object': self.object_courserun,
'result': self.result,
}
self.expected_notpassed = {
'verb': self.verb,
'version': '1.0.1',
'actor': self.actor,
'object': self.object_course,
'result': self.result_notpassed,
}
def setUp(self):
super().setUp()
self.xapi_learner_transmission = factories.XAPILearnerDataTransmissionAuditFactory(
user_id=factories.UserFactory().id, course_id='dummy')
def setUp(self):
super(TestEcommerceApiClient, self).setUp()
self.user = factories.UserFactory()
def test_learner_data_multiple_courses(
self,
pacing,
grade,
mock_course_catalog_api,
mock_course_api,
mock_grades_api,
mock_certificate_api,
mock_enrollment_api
):
mock_course_catalog_api.return_value.get_course_id.return_value = self.course_key
enrollment1 = factories.EnterpriseCourseEnrollmentFactory(
enterprise_customer_user=self.enterprise_customer_user,
course_id=self.course_id,
)
course_id2 = 'course-v1:edX+DemoX+DemoCourse2'
enrollment2 = factories.EnterpriseCourseEnrollmentFactory(
enterprise_customer_user=self.enterprise_customer_user,
course_id=course_id2,
)
factories.DataSharingConsentFactory(
username=self.enterprise_customer_user.username,
course_id=course_id2,
enterprise_customer=self.enterprise_customer,
granted=True
)
enrollment3 = factories.EnterpriseCourseEnrollmentFactory(
enterprise_customer_user=factories.EnterpriseCustomerUserFactory(
user_id=factories.UserFactory(username='******', id=2).id,
enterprise_customer=self.enterprise_customer,
),
course_id=self.course_id,
)
factories.DataSharingConsentFactory(
username='******',
course_id=self.course_id,
enterprise_customer=self.enterprise_customer,
granted=True
)
def get_course_details(course_id):
"""
Mock course details - set course_id to match input
"""
return dict(
pacing=pacing,
course_id=course_id
)
mock_course_api.return_value.get_course_details.side_effect = get_course_details
def get_course_certificate(course_id, username):
"""
Mock certificate data - return depending on course_id
"""
if '2' in course_id:
return dict(
username=username,
is_passing=True,
grade=grade,
)
raise HttpNotFoundError
mock_certificate_api.return_value.get_course_certificate.side_effect = get_course_certificate
def get_course_grade(course_id, username):
"""
Mock grades data - set passed depending on course_id
"""
return dict(
passed='2' in course_id,
course_key=course_id,
username=username,
)
mock_grades_api.return_value.get_course_grade.side_effect = get_course_grade
# Mock enrollment data
mock_enrollment_api.return_value.get_course_enrollment.return_value = dict(
mode="verified"
)
# Collect the learner data, with time set to NOW
with freeze_time(self.NOW):
learner_data = list(self.exporter.export())
assert len(learner_data) == 6
assert learner_data[0].course_id == self.course_key
assert learner_data[1].course_id == self.course_id
for report1 in learner_data[0:1]:
assert report1.enterprise_course_enrollment_id == enrollment1.id
assert not report1.course_completed
assert report1.completed_timestamp is None
assert report1.grade == LearnerExporter.GRADE_INCOMPLETE
assert learner_data[2].course_id == self.course_key
assert learner_data[3].course_id == self.course_id
for report2 in learner_data[2:3]:
assert report2.enterprise_course_enrollment_id == enrollment3.id
assert not report2.course_completed
assert report2.completed_timestamp is None
assert report2.grade == LearnerExporter.GRADE_INCOMPLETE
assert learner_data[4].course_id == self.course_key
assert learner_data[5].course_id == course_id2
for report3 in learner_data[4:5]:
assert report3.enterprise_course_enrollment_id == enrollment2.id
# assert report3.course_id == course_id2
assert report3.course_completed
assert report3.completed_timestamp == self.NOW_TIMESTAMP
assert report3.grade == grade
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)
