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.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.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 setUp(self):
super(TestContentMetadataTransmitter, self).setUp()
enterprise_customer = factories.EnterpriseCustomerFactory(name='Starfleet Academy')
# We need some non-abstract configuration for these things to work,
# so it's okay for it to be any arbitrary channel. We randomly choose SAPSF.
self.enterprise_config = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=enterprise_customer,
key="client_id",
sapsf_base_url="http://test.successfactors.com/",
sapsf_company_id="company_id",
sapsf_user_id="user_id",
secret="client_secret",
)
self.global_config = factories.SAPSuccessFactorsGlobalConfigurationFactory()
# Mocks
create_content_metadata_mock = mock.patch(
'integrated_channels.integrated_channel.client.IntegratedChannelApiClient.create_content_metadata'
)
self.create_content_metadata_mock = create_content_metadata_mock.start()
self.addCleanup(create_content_metadata_mock.stop)
update_content_metadata_mock = mock.patch(
'integrated_channels.integrated_channel.client.IntegratedChannelApiClient.update_content_metadata'
)
self.update_content_metadata_mock = update_content_metadata_mock.start()
self.addCleanup(update_content_metadata_mock.stop)
delete_content_metadata_mock = mock.patch(
'integrated_channels.integrated_channel.client.IntegratedChannelApiClient.delete_content_metadata'
)
self.delete_content_metadata_mock = delete_content_metadata_mock.start()
self.addCleanup(delete_content_metadata_mock.stop)
def setUp(self):
super(TestSapSuccessFactorsContentMetadataTransmitter, self).setUp()
self.url_base = 'http://test.successfactors.com/'
self.oauth_api_path = 'learning/oauth-api/rest/v1/token'
self.completion_status_api_path = 'learning/odatav4/public/admin/ocn/v1/current-user/item/learning-event'
self.course_api_path = 'learning/odatav4/public/admin/ocn/v1/OcnCourses'
self.expires_in = 1800
self.access_token = 'access_token'
self.expected_token_response_body = {
'expires_in': self.expires_in,
'access_token': self.access_token
}
enterprise_customer = factories.EnterpriseCustomerFactory(
name='Starfleet Academy')
self.enterprise_config = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=enterprise_customer,
key='client_id',
sapsf_base_url=self.url_base,
sapsf_company_id='company_id',
sapsf_user_id='user_id',
secret='client_secret',
)
factories.SAPSuccessFactorsGlobalConfiguration.objects.create(
completion_status_api_path=self.completion_status_api_path,
course_api_path=self.course_api_path,
oauth_api_path=self.oauth_api_path)
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.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):
super(TestUserFilterBackend, self).setUp()
self.enterprise_customer = factories.EnterpriseCustomerFactory(
uuid=FAKE_UUIDS[0])
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
enterprise_customer=self.enterprise_customer,
user_id=self.user.id,
)
def setUpClass(cls):
"""
Perform operations common for all tests once.
"""
super(TestEnterpriseCustomerUserWriteSerializer, cls).setUpClass()
cls.ent_user_link_url = settings.TEST_SERVER + reverse('enterprise-learner-list')
cls.permission = Permission.objects.get(name='Can add Enterprise Customer Learner')
cls.enterprise_uuids = FAKE_UUIDS[:4]
for enterprise_uuid in cls.enterprise_uuids:
factories.EnterpriseCustomerFactory(uuid=enterprise_uuid)
def setUp(self):
self.enterprise_customer = factories.EnterpriseCustomerFactory()
self.config = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer)
# Mocks
jwt_builder = mock.patch('enterprise.api_client.lms.JwtBuilder',
mock.Mock())
self.jwt_builder = jwt_builder.start()
self.addCleanup(jwt_builder.stop)
super(TestSapSuccessFactorsContentMetadataExporter, self).setUp()
def test_error_for_missing_lrs_configuration(self):
"""
Make sure CommandError is raised if XAPILRSConfiguration does not exis for the given enterprise customer.
"""
enterprise_customer = factories.EnterpriseCustomerFactory()
with raises(
CommandError,
match='No xAPI Configuration found for '
'"{enterprise_customer}"'.format(enterprise_customer=enterprise_customer.name)
):
call_command('send_course_enrollments', days=1, enterprise_customer_uuid=enterprise_customer.uuid)
def setUp(self):
super(TestEnterpriseLinkedUserFilterBackend, self).setUp()
self.url = settings.TEST_SERVER + ENTERPRISE_CUSTOMER_LIST_ENDPOINT
self.enterprise_customer_data = {
'active': True,
'slug': 'test-enterprise1',
'uuid': FAKE_UUIDS[0],
'name': 'Test Enterprise Customer',
'enable_data_sharing_consent': True,
}
self.enterprise_customer = factories.EnterpriseCustomerFactory(
**self.enterprise_customer_data)
def test_has_explicit_access(self, permission, feature_role,
get_current_request_mock):
get_current_request_mock.return_value = self.get_request_with_jwt_cookie(
)
feature_role_object, __ = EnterpriseFeatureRole.objects.get_or_create(
name=feature_role)
enterprise_customer = factories.EnterpriseCustomerFactory(
uuid=TEST_UUID)
factories.EnterpriseCustomerUserFactory(
user_id=self.user.id, enterprise_customer=enterprise_customer)
EnterpriseFeatureUserRoleAssignment.objects.create(
user=self.user, role=feature_role_object)
assert self.user.has_perm(permission, TEST_UUID)
def setUp(self):
super().setUp()
self.user.is_superuser = True
self.user.save()
self.enterprise_customer = factories.EnterpriseCustomerFactory(
uuid=FAKE_UUIDS[0])
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
enterprise_customer=self.enterprise_customer,
user_id=self.user.id,
)
self.enterprise_customer_conf = factories.BlackboardEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer, )
def setUp(self):
self.enterprise_customer = factories.EnterpriseCustomerFactory()
self.config = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer)
# Mocks
self.mock_ent_courses_api_with_pagination(
enterprise_uuid=str(self.enterprise_customer.uuid),
course_run_ids=['course-v1:edX+DemoX+Demo_Course_1'])
jwt_builder = mock.patch('enterprise.api_client.lms.JwtBuilder',
mock.Mock())
self.jwt_builder = jwt_builder.start()
self.addCleanup(jwt_builder.stop)
super(TestSapSuccessFactorsContentMetadataExporter, self).setUp()
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().setUp()
self.set_jwt_cookie(self.client, [(ENTERPRISE_ADMIN_ROLE, ENTERPRISE_ID)])
self.client.force_authenticate(user=self.user)
self.enterprise_customer = factories.EnterpriseCustomerFactory(uuid=ENTERPRISE_ID)
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
enterprise_customer=self.enterprise_customer,
user_id=self.user.id,
)
self.moodle_config = factories.MoodleEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer
)
def test_filter_for_list(self, is_staff, expected_data_length):
"""
Filter objects based off of user ID -- show all for staff, but only the authenticated user himself otherwise.
Note that the choice of endpoint below is arbitrary.
This test could use any endpoint that makes use of the ``UserFilterBackend`` filter.
"""
self.user.is_staff = is_staff
self.user.save()
factories.EnterpriseCustomerFactory()
response = self.client.get(settings.TEST_SERVER +
reverse('enterprise-customer-list'))
assert response.status_code == status.HTTP_200_OK
data = self.load_json(response.content)
assert len(data['results']) == expected_data_length
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.global_config = factories.SAPSuccessFactorsGlobalConfigurationFactory(
)
self.enterprise_customer = factories.EnterpriseCustomerFactory()
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
enterprise_customer=self.enterprise_customer)
self.enterprise_course_enrollment = factories.EnterpriseCourseEnrollmentFactory(
id=5, enterprise_customer_user=self.enterprise_customer_user)
self.enterprise_config = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
key="client_id",
sapsf_base_url="http://test.successfactors.com/",
sapsf_company_id="company_id",
sapsf_user_id="user_id",
secret="client_secret")
self.payloads = [
SapSuccessFactorsLearnerDataTransmissionAudit(
enterprise_course_enrollment_id=self.
enterprise_course_enrollment.id,
sapsf_user_id='sap_user',
course_id='course-v1:edX+DemoX+DemoCourse',
course_completed=True,
completed_timestamp=1486855998,
instructor_name='Professor Professorson',
grade='Passing even more',
error_message='',
)
]
self.exporter = lambda payloads=self.payloads: mock.MagicMock(
export=mock.MagicMock(return_value=iter(payloads)))
# Mocks
get_oauth_access_token_mock = mock.patch(
'integrated_channels.sap_success_factors.client.SAPSuccessFactorsAPIClient.get_oauth_access_token'
)
self.get_oauth_access_token_mock = get_oauth_access_token_mock.start()
self.get_oauth_access_token_mock.return_value = "token", datetime.datetime.utcnow(
)
self.addCleanup(get_oauth_access_token_mock.stop)
create_course_completion_mock = mock.patch(
'integrated_channels.sap_success_factors.client.SAPSuccessFactorsAPIClient.create_course_completion'
)
self.create_course_completion_mock = create_course_completion_mock.start(
)
self.addCleanup(create_course_completion_mock.stop)
def setUp(self):
super().setUp()
enterprise_customer = factories.EnterpriseCustomerFactory(name='Starfleet Academy')
# We need some non-abstract configuration for these things to work,
# so it's okay for it to be any arbitrary channel. We randomly choose SAPSF.
self.enterprise_config = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=enterprise_customer,
key="client_id",
sapsf_base_url="http://test.successfactors.com/",
sapsf_company_id="company_id",
sapsf_user_id="user_id",
secret="client_secret",
)
self.learner_transmitter = LearnerTransmitter(self.enterprise_config)
def test_enterprise_learner_entitlements(self, enable_data_sharing_consent,
enforce_data_sharing_consent,
learner_consent_state,
entitlements, expected_json):
"""
Test that entitlement details route on enterprise learner returns correct data.
This test verifies that entitlements returned by entitlement details route on enterprise learner
has the expected behavior as listed down.
1. Empty entitlements list if enterprise customer requires data sharing consent
(this includes enforcing data sharing consent at login and at enrollment) and enterprise learner
does not consent to share data.
2. Full list of entitlements for all other cases.
Arguments:
enable_data_sharing_consent (bool): True if enterprise customer enables data sharing consent,
False it does not.
enforce_data_sharing_consent (str): string for the location at which enterprise customer enforces
data sharing consent, possible values are 'at_login', 'at_enrollment' and 'optional'.
learner_consent_state (str): string containing the state of learner consent on data sharing,
possible values are 'not_set', 'enabled' and 'disabled'.
entitlements (list): A list of integers pointing to voucher ids generated in E-Commerce CAT tool.
expected_json (dict): A dict with structure and values corresponding to
the expected json from API endpoint.
"""
user_id = 1
enterprise_customer = factories.EnterpriseCustomerFactory(
enable_data_sharing_consent=enable_data_sharing_consent,
enforce_data_sharing_consent=enforce_data_sharing_consent,
)
factories.UserDataSharingConsentAuditFactory(
user__id=user_id,
user__enterprise_customer=enterprise_customer,
state=learner_consent_state,
)
for entitlement in entitlements:
factories.EnterpriseCustomerEntitlementFactory(
enterprise_customer=enterprise_customer,
entitlement_id=entitlement,
)
url = reverse('enterprise-learner-entitlements', (user_id, ))
response = self.client.get(settings.TEST_SERVER + url)
response = self.load_json(response.content)
assert sorted(response) == sorted(expected_json)
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_validate_username(self, username, expected_status_code):
"""
Success for POSTing with users (determined by username) depends on whether the user exists.
"""
self.user.is_staff = True
self.user.save()
permission = Permission.objects.get(name='Can add Enterprise Customer Learner')
self.user.user_permissions.add(permission)
factories.EnterpriseCustomerFactory(uuid=FAKE_UUIDS[0])
data = {
'enterprise_customer': FAKE_UUIDS[0],
'username': username,
}
response = self.client.post(settings.TEST_SERVER + reverse('enterprise-learner-list'), data=data)
assert response.status_code == expected_status_code
response = self.load_json(response.content)
if expected_status_code == 201:
self.assertDictEqual(data, response)
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().setUp()
self.enterprise_customer = factories.EnterpriseCustomerFactory()
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
enterprise_customer=self.enterprise_customer, )
self.enterprise_course_enrollment = factories.EnterpriseCourseEnrollmentFactory(
id=5,
enterprise_customer_user=self.enterprise_customer_user,
)
self.enterprise_config = factories.MoodleEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
moodle_base_url='foobar',
service_short_name='shortname',
category_id=1,
username='******',
password='******',
token='token',
)
self.payload = MoodleLearnerDataTransmissionAudit(
moodle_user_email=self.enterprise_customer.contact_email,
enterprise_course_enrollment_id=self.enterprise_course_enrollment.
id,
course_id='course-v1:edX+DemoX+DemoCourse',
course_completed=True,
completed_timestamp=1486855998,
total_hours=1.0,
grade=.9,
)
self.exporter = lambda payloads=self.payload: mock.MagicMock(
export=mock.MagicMock(return_value=iter(payloads)))
# Mocks
create_course_completion_mock = mock.patch(
'integrated_channels.moodle.client.MoodleAPIClient.create_course_completion'
)
self.create_course_completion_mock = create_course_completion_mock.start(
)
self.addCleanup(create_course_completion_mock.stop)
self.create_course_completion_mock = create_course_completion_mock.start(
)
self.addCleanup(create_course_completion_mock.stop)
def setUp(self):
super(TestBlackboardLearnerDataTransmitter, self).setUp()
self.enterprise_customer = factories.EnterpriseCustomerFactory()
self.enterprise_customer_user = factories.EnterpriseCustomerUserFactory(
enterprise_customer=self.enterprise_customer, )
self.enterprise_course_enrollment = factories.EnterpriseCourseEnrollmentFactory(
id=5,
enterprise_customer_user=self.enterprise_customer_user,
)
self.enterprise_config = factories.BlackboardEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer,
blackboard_base_url='foobar',
client_id='client_id',
client_secret='client_secret',
refresh_token='token',
)
self.payload = BlackboardLearnerDataTransmissionAudit(
blackboard_user_email=self.enterprise_customer.contact_email,
enterprise_course_enrollment_id=self.enterprise_course_enrollment.
id,
course_id='course-v1:edX+DemoX+DemoCourse',
course_completed=True,
completed_timestamp=1486855998,
total_hours=1.0,
grade=.9,
)
self.exporter = lambda payloads=self.payload: mock.MagicMock(
export=mock.MagicMock(return_value=iter(payloads)))
# Mocks
create_course_completion_mock = mock.patch(
'integrated_channels.blackboard.client.BlackboardAPIClient.create_course_completion'
)
self.create_course_completion_mock = create_course_completion_mock.start(
)
self.addCleanup(create_course_completion_mock.stop)
self.create_course_completion_mock = create_course_completion_mock.start(
)
self.addCleanup(create_course_completion_mock.stop)
def setUp(self):
super(TestRouterView, self).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]))
self.request.user.id = 1
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)
tracker_mock = mock.patch('enterprise.utils.tracker')
self.tracker_mock = tracker_mock.start()
self.tracker_mock.get_tracker.return_value.resolve_context.return_value = {}
self.addCleanup(tracker_mock.stop)
analytics = mock.patch('enterprise.utils.analytics')
self.analytics = analytics.start()
self.addCleanup(analytics.stop)
def setUp(self):
super(TestContentMetadataItemTransmission, self).setUp()
self.enterprise_customer = factories.EnterpriseCustomerFactory()
def setUp(self):
super(TestEnterpriseCustomerUserFilterBackend, self).setUp()
enterprise_customer = factories.EnterpriseCustomerFactory()
factories.EnterpriseCustomerUserFactory(
enterprise_customer=enterprise_customer, user_id=self.user.id)
self.url = settings.TEST_SERVER + reverse('enterprise-learner-list')
