def test_get_enterprise_customer_for_user(self): """ Test `get_enterprise_customer_for_user` helper method. """ faker = FakerFactory.create() provider_id = faker.slug() user = UserFactory() ecu = EnterpriseCustomerUserFactory(user_id=user.id, ) EnterpriseCustomerIdentityProviderFactory( enterprise_customer=ecu.enterprise_customer, provider_id=provider_id, ) # Assert that correct enterprise customer is returned self.assertEqual( utils.get_enterprise_customer_for_user(auth_user=user), ecu.enterprise_customer, ) # Assert that None is returned if user is not associated with any enterprise customer self.assertEqual( utils.get_enterprise_customer_for_user(auth_user=UserFactory()), None, )
def setUp(self): self.api_user = UserFactory(username='******') self.user = UserFactory() self.course_id = COURSE_ID self.enterprise_customer = EnterpriseCustomerFactory() self.identity_provider = FakerFactory.create().slug() EnterpriseCustomerIdentityProviderFactory( provider_id=self.identity_provider, enterprise_customer=self.enterprise_customer) self.enterprise_customer_user = EnterpriseCustomerUserFactory( user_id=self.user.id, enterprise_customer=self.enterprise_customer, ) self.enrollment = EnterpriseCourseEnrollmentFactory( enterprise_customer_user=self.enterprise_customer_user, course_id=self.course_id, consent_granted=True, ) self.integrated_channel = SAPSuccessFactorsEnterpriseCustomerConfiguration( enterprise_customer=self.enterprise_customer, sapsf_base_url='enterprise.successfactors.com', key='key', secret='secret', ) super(TestTransmitLearnerData, self).setUp()
def test_view_post( self, create_enterprise_customer, create_enterprise_customer_idp, no_of_enterprise_customer_idp, enable_slug_login, enterprise_slug, expected_response, status_code, expected_logger_message, ): """ Test that view HTTP POST works as expected. """ enterprise_customer = None if create_enterprise_customer: enterprise_customer = EnterpriseCustomerFactory( slug=enterprise_slug, enable_slug_login=enable_slug_login) if enterprise_customer and create_enterprise_customer_idp: for _ in range(no_of_enterprise_customer_idp): EnterpriseCustomerIdentityProviderFactory( enterprise_customer=enterprise_customer) with LogCapture(LOGGER_NAME) as log: self._assert_post_request(enterprise_slug, status_code, expected_response) if expected_logger_message: log.check_present(( LOGGER_NAME, 'ERROR', expected_logger_message.format(enterprise_slug), ))
def test_handle_consent_enrollment_without_course_mode( self, registry_mock, *args ): # pylint: disable=unused-argument """ Verify that user is redirected to LMS dashboard in case there is no parameter `course_mode` in the request querystring. """ course_id = self.demo_course_id enterprise_customer = EnterpriseCustomerFactory( name='Starfleet Academy', enable_data_sharing_consent=True, enforce_data_sharing_consent='at_enrollment', enable_audit_enrollment=True, ) 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) self._login() handle_consent_enrollment_url = self._append_fresh_login_param( reverse( 'enterprise_handle_consent_enrollment', args=[enterprise_customer.uuid, course_id], ) ) response = self.client.get(handle_consent_enrollment_url) redirect_url = LMS_DASHBOARD_URL self.assertRedirects(response, redirect_url, 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 test_handle_consent_enrollment_with_professional_course_mode( self, registry_mock, enrollment_api_client_mock, track_enrollment_mock, *args ): # pylint: disable=unused-argument """ Verify that user is redirected to course in case the provided course mode is audit track. """ course_id = self.demo_course_id enterprise_customer = EnterpriseCustomerFactory( name='Starfleet Academy', enable_data_sharing_consent=True, enforce_data_sharing_consent='at_enrollment', enable_audit_enrollment=True, ) enterprise_catalog = EnterpriseCustomerCatalogFactory(enterprise_customer=enterprise_customer) 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) enterprise_customer_user = EnterpriseCustomerUserFactory( user_id=self.user.id, enterprise_customer=enterprise_customer ) enrollment_client = enrollment_api_client_mock.return_value enrollment_client.get_course_modes.return_value = self.dummy_demo_course_modes self._login() handle_consent_enrollment_url = self._append_fresh_login_param( '{consent_enrollment_url}?{params}'.format( consent_enrollment_url=reverse( 'enterprise_handle_consent_enrollment', args=[enterprise_customer.uuid, course_id] ), params=urlencode({ 'course_mode': 'professional', 'catalog': enterprise_catalog.uuid }) ) ) response = self.client.get(handle_consent_enrollment_url) redirect_url = LMS_START_PREMIUM_COURSE_FLOW_URL.format(course_id=course_id) redirect_url += '?catalog={catalog_uuid}'.format( catalog_uuid=enterprise_catalog.uuid ) self.assertRedirects(response, redirect_url, fetch_redirect_response=False) self.assertTrue(EnterpriseCourseEnrollment.objects.filter( enterprise_customer_user__enterprise_customer=enterprise_customer, enterprise_customer_user__user_id=enterprise_customer_user.user_id, course_id=course_id ).exists()) track_enrollment_mock.assert_called_once_with( 'course-landing-page-enrollment', enterprise_customer_user.user_id, course_id, handle_consent_enrollment_url, )
def test_handle_consent_enrollment_404(self, registry_mock, enrollment_api_client_mock, *args): # pylint: disable=unused-argument """ Verify that user gets HTTP 404 response if there is no enterprise in database against the provided enterprise UUID or if enrollment API client is unable to get course modes for the provided course id. """ course_id = self.demo_course_id enrollment_client = enrollment_api_client_mock.return_value enrollment_client.get_course_modes.return_value = {} enterprise_customer = EnterpriseCustomerFactory( name='Starfleet Academy', enable_data_sharing_consent=True, enforce_data_sharing_consent='at_enrollment', enable_audit_enrollment=True, ) 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) self._login() handle_consent_enrollment_url = self._append_fresh_login_param( '{consent_enrollment_url}?{params}'.format( consent_enrollment_url=reverse( 'enterprise_handle_consent_enrollment', args=[enterprise_customer.uuid, course_id]), params=urlencode({'course_mode': 'professional'}))) with mock.patch('enterprise.views.render') as mock_render: mock_render.return_value = HttpResponse( ) # Must return response to keep view happy self.client.get(handle_consent_enrollment_url) assert mock_render.call_args_list[0][1]['status'] == 404
def setUp(self): ecidp = EnterpriseCustomerIdentityProviderFactory(provider_id='provider_slug') self.customer = ecidp.enterprise_customer self.user = UserFactory(is_active=True) self.request_factory = RequestFactory() self.request = self.request_factory.get('/') self.request.session = cache.SessionStore() super().setUp()
def test_identity_provider(self): """ Test identity_provider property returns correct value without errors. """ faker = FakerFactory.create() provider_id = faker.slug() customer = EnterpriseCustomerFactory() EnterpriseCustomerIdentityProviderFactory(provider_id=provider_id, enterprise_customer=customer) assert customer.identity_provider == provider_id # pylint: disable=no-member
def test_provider_name(self, mock_method): """ Test provider_name property returns correct value without errors.. """ faker = FakerFactory.create() provider_name = faker.name() mock_method.return_value.configure_mock(name=provider_name) ec_idp = EnterpriseCustomerIdentityProviderFactory() assert ec_idp.provider_name == provider_name # pylint: disable=no-member
def setUp(self): """ Set up test environment. """ super(TestEnterpriseDecorators, self).setUp() faker = FakerFactory.create() self.provider_id = faker.slug() # pylint: disable=no-member self.uuid = faker.uuid4() # pylint: disable=no-member self.customer = EnterpriseCustomerFactory(uuid=self.uuid) EnterpriseCustomerIdentityProviderFactory(provider_id=self.provider_id, enterprise_customer=self.customer) self.session_engine = import_module(settings.SESSION_ENGINE)
def setUp(self): """ Set up test environment. """ super(TestUtils, self).setUp() faker = FakerFactory.create() self.provider_id = faker.slug() self.uuid = faker.uuid4() self.customer = EnterpriseCustomerFactory(uuid=self.uuid) EnterpriseCustomerIdentityProviderFactory( provider_id=self.provider_id, enterprise_customer=self.customer)
def test_get_remote_id(self, provider_id, expected_value, called, mock_third_party_api): user = UserFactory(username="******") enterprise_customer_user = EnterpriseCustomerUserFactory(user_id=user.id) if provider_id: EnterpriseCustomerIdentityProviderFactory(provider_id=provider_id, enterprise_customer=enterprise_customer_user.enterprise_customer) mock_third_party_api.return_value.get_remote_id.return_value = 'saml-user-id' actual_value = enterprise_customer_user.get_remote_id() assert actual_value == expected_value if called: mock_third_party_api.return_value.get_remote_id.assert_called_once_with(provider_id, "hi") else: assert mock_third_party_api.return_value.get_remote_id.call_count == 0
def test_string_conversion(self, method): """ Test ``EnterpriseCustomerIdentityProvider`` conversion to string. """ provider_id, enterprise_customer_name = "saml-test", "TestShib" enterprise_customer = EnterpriseCustomerFactory(name=enterprise_customer_name) ec_idp = EnterpriseCustomerIdentityProviderFactory( enterprise_customer=enterprise_customer, provider_id=provider_id, ) expected_to_str = "<EnterpriseCustomerIdentityProvider {provider_id}>: {enterprise_name}".format( provider_id=provider_id, enterprise_name=enterprise_customer_name, ) self.assertEqual(method(ec_idp), expected_to_str)
def test_view_post(self, create_enterprise_customer, create_enterprise_customer_idp, enable_slug_login, enterprise_slug, expected_response, status_code): """ Test that view HTTP POST works as expected. """ enterprise_customer = None if create_enterprise_customer: enterprise_customer = EnterpriseCustomerFactory( slug=enterprise_slug, enable_slug_login=enable_slug_login) if enterprise_customer and create_enterprise_customer_idp: EnterpriseCustomerIdentityProviderFactory( enterprise_customer=enterprise_customer) self._assert_post_request(enterprise_slug, status_code, expected_response)
def test_create_new_identity_provider_link(self, mock_idp_choices, mock_url, mock_saml_config, mock_method): """ Test create new identity provider link in help text. """ provider_id = FAKER.slug() # pylint: disable=no-member name = FAKER.name() # pylint: disable=invalid-name enterprise_customer_identity_provider = EnterpriseCustomerIdentityProviderFactory( enterprise_customer=EnterpriseCustomerFactory(site=SiteFactory( domain="site.localhost.com"))) mock_method.return_value = mock.Mock(pk=1, name=name, provider_id=provider_id) mock_saml_config._meta.app_label = 'test_app' mock_saml_config._meta.model_name = 'test_model' mock_url.return_value = '/test_saml_app/test_saml_model/add/' mock_idp_choices.return_value = self.idp_choices form = EnterpriseCustomerIdentityProviderAdminForm( { 'provider_id': provider_id, 'enterprise_customer': self.enterprise_customer }, instance=enterprise_customer_identity_provider) assert '/test_saml_app/test_saml_model/add/?source=1' in form.fields[ 'provider_id'].help_text assert form.fields['provider_id'].choices == list(self.idp_choices) # Without provider id information. form = EnterpriseCustomerIdentityProviderAdminForm( {'enterprise_customer': self.enterprise_customer}, instance=None) assert 'Create a new identity provider' in form.fields[ 'provider_id'].help_text assert '/test_saml_app/test_saml_model/add/?source=1' not in form.fields[ 'provider_id'].help_text assert form.fields['provider_id'].choices == list(self.idp_choices) mock_method.return_value = None # Invalid provider id. form = EnterpriseCustomerIdentityProviderAdminForm( {'enterprise_customer': self.enterprise_customer}, instance=enterprise_customer_identity_provider) assert 'Make sure you have added a valid provider_id' in form.fields[ 'provider_id'].help_text
def test_export_as_csv_actual_model(self): """ Tests export_as_csv as it is used in EnterpriseCustomer admin. """ fields = EnterpriseCustomerAdmin.EXPORT_AS_CSV_FIELDS collection = [ EnterpriseCustomerFactory(), EnterpriseCustomerFactory(), EnterpriseCustomerFactory(), ] for item in collection: EnterpriseCustomerIdentityProviderFactory(enterprise_customer=item) expected_rows = [fields] + [[getattr(customer, field) for field in fields] for customer in collection] export_as_csv = export_as_csv_action("CSV Export", fields=fields) export_as_csv(self.model_admin_mock, mock.Mock(), collection) self._assert_correct_csv(self.output_stream, expected_rows)
def test_handle_consent_enrollment_with_invalid_course_mode( self, registry_mock, enrollment_api_client_mock, get_ec_user_mock, *args ): # pylint: disable=unused-argument """ Verify that user is redirected to LMS dashboard in case the provided course mode does not exist. """ course_id = self.demo_course_id enterprise_customer = EnterpriseCustomerFactory( name='Starfleet Academy', enable_data_sharing_consent=True, enforce_data_sharing_consent='at_enrollment', enable_audit_enrollment=True, ) 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) enterprise_customer_user = EnterpriseCustomerUserFactory( user_id=self.user.id, enterprise_customer=enterprise_customer ) enrollment_client = enrollment_api_client_mock.return_value enrollment_client.get_course_modes.return_value = self.dummy_demo_course_modes mocked_enterprise_customer_user = get_ec_user_mock.return_value mocked_enterprise_customer_user.return_value = enterprise_customer_user self._login() handle_consent_enrollment_url = self._append_fresh_login_param( '{consent_enrollment_url}?{params}'.format( consent_enrollment_url=reverse( 'enterprise_handle_consent_enrollment', args=[enterprise_customer.uuid, course_id] ), params=urlencode({'course_mode': 'some-invalid-course-mode'}) ) ) response = self.client.get(handle_consent_enrollment_url) redirect_url = LMS_DASHBOARD_URL self.assertRedirects(response, redirect_url, fetch_redirect_response=False)
def setUp(self): ecidp = EnterpriseCustomerIdentityProviderFactory( provider_id='provider_slug') self.customer = ecidp.enterprise_customer self.user = UserFactory(is_active=True) super(TestTpaPipeline, self).setUp()
def setUpTestData(cls): super().setUpTestData() cls.client = Client() cls.enterprise_customer = EnterpriseCustomerFactory() cls.identity_provider = EnterpriseCustomerIdentityProviderFactory(enterprise_customer=cls.enterprise_customer)