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(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):
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):
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):
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 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):
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.sap_config = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=self.enterprise_customer)
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_transmit_content_metadata_task_with_error(
self,
sapsf_update_content_metadata_mock,
sapsf_get_oauth_access_token_mock,
degreed_create_content_metadata_mock,
): # pylint: disable=invalid-name
"""
Verify the data transmission task for integrated channels with error.
Test that the management command `transmit_content_metadata` transmits
courses metadata related to other integrated channels even if an
integrated channel fails to transmit due to some error.
"""
sapsf_get_oauth_access_token_mock.return_value = "token", datetime.utcnow(
)
sapsf_update_content_metadata_mock.return_value = 200, '{}'
degreed_create_content_metadata_mock.return_value = 200, '{}'
# Mock first integrated channel with failure
enterprise_uuid_for_failure = str(self.enterprise_customer.uuid)
self.mock_ent_courses_api_with_error(
enterprise_uuid=enterprise_uuid_for_failure)
# Now create a new integrated channel with a new enterprise and mock
# enterprise courses API to send failure response
course_run_id_for_success = 'course-v1:edX+DemoX+Demo_Course_1'
dummy_enterprise_customer = factories.EnterpriseCustomerFactory(
catalog=1,
name='Dummy Enterprise',
)
dummy_degreed = factories.DegreedEnterpriseCustomerConfigurationFactory(
enterprise_customer=dummy_enterprise_customer,
key='key',
secret='secret',
degreed_company_id='Degreed Company',
degreed_base_url='https://www.degreed.com/',
active=True,
)
dummy_sapsf = factories.SAPSuccessFactorsEnterpriseCustomerConfigurationFactory(
enterprise_customer=dummy_enterprise_customer,
sapsf_base_url='http://enterprise.successfactors.com/',
key='key',
secret='secret',
active=True,
)
enterprise_uuid_for_success = str(dummy_enterprise_customer.uuid)
self.mock_ent_courses_api_with_pagination(
enterprise_uuid=enterprise_uuid_for_success,
course_run_ids=[course_run_id_for_success])
# Verify that first integrated channel logs failure but the second
# integrated channel still successfully transmits courseware data.
expected_messages = [
# SAPSF
'Transmitting content metadata to integrated channel using configuration: '
'[<SAPSuccessFactorsEnterpriseCustomerConfiguration for Enterprise Veridian Dynamics>]',
'Transmission of content metadata failed for user [C-3PO] and for integrated channel with '
'code [SAP] and id [1].',
'Content metadata transmission task for integrated channel configuration [{}] took [0.0] seconds'
.format(self.sapsf),
'Transmitting content metadata to integrated channel using configuration: '
'[<SAPSuccessFactorsEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Retrieved content metadata for enterprise [{}]'.format(
dummy_enterprise_customer.name),
'Exporting content metadata item with plugin configuration '
'[<SAPSuccessFactorsEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Preparing to transmit creation of [1] content metadata items with plugin configuration '
'[<SAPSuccessFactorsEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Preparing to transmit update of [0] content metadata items with plugin configuration '
'[<SAPSuccessFactorsEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Preparing to transmit deletion of [0] content metadata items with plugin configuration '
'[<SAPSuccessFactorsEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Content metadata transmission task for integrated channel configuration [{}] took [0.0] seconds'
.format(dummy_sapsf),
# Degreed
'Transmitting content metadata to integrated channel using configuration: '
'[<DegreedEnterpriseCustomerConfiguration for Enterprise Veridian Dynamics>]',
'Transmission of content metadata failed for user [C-3PO] and for integrated channel with '
'code [DEGREED] and id [1].',
'Content metadata transmission task for integrated channel configuration [{}] took [0.0] seconds'
.format(self.degreed),
'Transmitting content metadata to integrated channel using configuration: '
'[<DegreedEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Retrieved content metadata for enterprise [{}]'.format(
dummy_enterprise_customer.name),
'Exporting content metadata item with plugin configuration '
'[<DegreedEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Preparing to transmit creation of [1] content metadata items with plugin configuration '
'[<DegreedEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Preparing to transmit update of [0] content metadata items with plugin configuration '
'[<DegreedEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Preparing to transmit deletion of [0] content metadata items with plugin configuration '
'[<DegreedEnterpriseCustomerConfiguration for Enterprise Dummy Enterprise>]',
'Content metadata transmission task for integrated channel configuration [{}] took [0.0] seconds'
.format(dummy_degreed)
]
with LogCapture(level=logging.INFO) as log_capture:
call_command('transmit_content_metadata', '--catalog_user',
'C-3PO')
for index, message in enumerate(expected_messages):
assert message in log_capture.records[index].getMessage()
