def test_fetch_organization(self): """ Unit Test: test_fetch_organization""" organization1 = OrganizationFactory.create() organization2 = OrganizationFactory.create() with self.assertNumQueries(2): self.assertEqual(data.fetch_organization(organization1.id)['id'], organization1.id) self.assertEqual(data.fetch_organization(organization2.id)['id'], organization2.id)
def test_filter_courses_based_on_org(self): """ Test course are filtered properly on current site organization. """ edx_org_1 = OrganizationFactory() edx_org_2 = OrganizationFactory() courses_of_org_1 = CourseFactory.create_batch(2, org=edx_org_1.short_name) CourseFactory.create(org=edx_org_2.short_name) assert len(modulestore().get_courses()) == 3 EdlySubOrganizationFactory(edx_organization=edx_org_1, lms_site=self.request.site, studio_site=self.request.site) create_user_link_with_edly_sub_organization(self.request, self.request.user) response = cookies_api.set_logged_in_edly_cookies( self.request, HttpResponse(), self.user, cookie_settings(self.request)) self._copy_cookies_to_request(response, self.request) filtered_courses = filter_courses_based_on_org(self.request, courses_of_org_1) assert len(filtered_courses) == 2 edx_orgs_of_filterd_courses = [ course.org for course in filtered_courses ] for org in edx_orgs_of_filterd_courses: assert org == edx_org_1.short_name
def test_saml_provider_not_found(self): """ Test an exception is thrown if no SAML provider exists for this program's organization """ OrganizationFactory.create(short_name=self.organization_key) with pytest.raises(ProviderDoesNotExistException): get_user_by_program_id(self.external_user_id, self.program_uuid)
def test_saml_provider_not_found(self): """ Test that Prov exception is thrown if no SAML provider exists for this program's organization. """ OrganizationFactory.create(short_name=self.organization_key) with self.assertRaises(ProviderDoesNotExistException): get_users_by_external_keys(self.program_uuid, [])
def test_fetch_organization(self): """ Unit Test: test_fetch_organization""" organization1 = OrganizationFactory.create() organization2 = OrganizationFactory.create() with self.assertNumQueries(2): self.assertEqual( data.fetch_organization(organization1.id)['id'], organization1.id) self.assertEqual( data.fetch_organization(organization2.id)['id'], organization2.id)
def setUp(self): super(_DispatchingViewTestCase, self).setUp() self.dop_adapter = adapters.DOPAdapter() self.dot_adapter = adapters.DOTAdapter() self.user = UserFactory() self.dot_app = self.dot_adapter.create_public_client( name='test dot application', user=self.user, redirect_uri=DUMMY_REDIRECT_URL, client_id='dot-app-client-id', ) self.dop_app = self.dop_adapter.create_public_client( name='test dop client', user=self.user, redirect_uri=DUMMY_REDIRECT_URL, client_id='dop-app-client-id', ) self.dot_app_access = models.ApplicationAccess.objects.create( application=self.dot_app, scopes=['grades:read'], ) self.dot_app_org = models.ApplicationOrganization.objects.create( application=self.dot_app, organization=OrganizationFactory()) # Create a "restricted" DOT Application which means any AccessToken/JWT # generated for this application will be immediately expired self.restricted_dot_app = self.dot_adapter.create_public_client( name='test restricted dot application', user=self.user, redirect_uri=DUMMY_REDIRECT_URL, client_id='dot-restricted-app-client-id', ) models.RestrictedApplication.objects.create( application=self.restricted_dot_app)
def setup(): user = UserFactory.create() organization = OrganizationFactory.create() project = ProjectFactory.create(organization=organization) document = DocumentFactory.create(project=project) return user, organization, project, document, Client()
def test_same_user_key_in_multiple_organizations(self): uox_program_enrollment = self._create_waiting_program_enrollment() second_organization = OrganizationFactory.create() SAMLProviderConfigFactory.create(organization=second_organization, slug='aiu') catalog_org = CatalogOrganizationFactory.create( key=second_organization.short_name) program_uuid = self._create_catalog_program(catalog_org)['uuid'] # aiu enrollment with the same student key as our uox user aiu_program_enrollment = ProgramEnrollmentFactory.create( user=None, external_user_key=self.external_id, program_uuid=program_uuid) UserSocialAuth.objects.create( user=UserFactory.create(), uid='{0}:{1}'.format('not_used', self.external_id), ) UserSocialAuth.objects.create( user=self.user, uid='{0}:{1}'.format(self.provider_slug, self.external_id), ) self._assert_program_enrollment_user(uox_program_enrollment, self.user) aiu_user = UserFactory.create() UserSocialAuth.objects.create( user=aiu_user, uid='{0}:{1}'.format('aiu', self.external_id), ) self._assert_program_enrollment_user(aiu_program_enrollment, aiu_user)
def test_user_has_document_permissions(): user = UserFactory.create() organization = OrganizationFactory.create() project = ProjectFactory.create(organization=organization) document = DocumentFactory.create(project=project) document.add_create(user) assert len(user.get_organizations()) == 1 assert len(user.get_projects()) == 1 assert len(user.get_documents()) == 1 assert organization.can_manage(user) == False assert organization.can_invite(user) == False assert organization.can_create(user) == False assert project.can_invite(user) == False assert project.can_create(user) == False assert project.can_manage(user) == False assert document.can_create(user) == True assert document.can_invite(user) == False assert document.can_manage(user) == False document.delete_create(user) document.add_invite(user) assert document.can_create(user) == True assert document.can_invite(user) == True assert document.can_manage(user) == False document.delete_invite(user) document.add_manage(user) assert document.can_create(user) == True assert document.can_invite(user) == True assert document.can_manage(user) == True
def test_course_org_db_logo_association(self): """ Suppose we created a course and incorrectly called it `MITX/Demo/2017` while we want Hsoub logo on it? This ensures that we can override it using the `OrganizationCourse` model. """ org_id = 'PSUT' course_key = 'PSUT/Demo/Fall2018' with utils.OrganizationLogo(org_id, course_key) as prev_logo: self.assertEquals('psut.png', os.path.basename( prev_logo.name)) # Should use the PSUT legacy logo moe_logo = 'moe.png' with open(os.path.join(STATIC_DIR, moe_logo), 'rb') as updated_logo: wanted_org = OrganizationFactory.create( name='Ministry of Education', short_name='MoE', logo=SimpleUploadedFile(moe_logo, content=updated_logo.read()), ) # Associate the course with a different organization OrganizationCourse.objects.create(organization=wanted_org, course_id=course_key) with utils.OrganizationLogo(org_id, course_key) as overridden_logo: self.assertRegexpMatches( os.path.basename(overridden_logo.name), r'.*moe.*.\.png*') # Now it's an MoE course!
def test_multiple_saml_providers(self): """ Test that get_users_by_external_keys returns the expected mapping of external keys to users when multiple saml providers are configured. """ organization = OrganizationFactory.create( short_name=self.organization_key) provider_1 = SAMLProviderConfigFactory.create( organization=organization) provider_2 = SAMLProviderConfigFactory.create( organization=organization, slug='test-shib-2', enabled=True) self.create_social_auth_entry(self.user_0, provider_1, 'ext-user-0') self.create_social_auth_entry(self.user_1, provider_1, 'ext-user-1') self.create_social_auth_entry(self.user_1, provider_2, 'ext-user-1') self.create_social_auth_entry(self.user_2, provider_2, 'ext-user-2') requested_keys = {'ext-user-1', 'ext-user-2', 'ext-user-3'} actual = get_users_by_external_keys(self.program_uuid, requested_keys) # ext-user-0 not requested, ext-user-3 doesn't exist, # ext-user-2 is authorized with secondary provider # ext-user-1 has an entry in both providers expected = { 'ext-user-1': self.user_1, 'ext-user-2': self.user_2, 'ext-user-3': None, } assert actual == expected
def test_same_user_key_in_multiple_organizations(self): uox_program_enrollment = self._create_waiting_program_enrollment() second_organization = OrganizationFactory.create() SAMLProviderConfigFactory.create(organization=second_organization, slug='aiu') catalog_org = CatalogOrganizationFactory.create(key=second_organization.short_name) program_uuid = self._create_catalog_program(catalog_org)['uuid'] # aiu enrollment with the same student key as our uox user aiu_program_enrollment = ProgramEnrollmentFactory.create( user=None, external_user_key=self.external_id, program_uuid=program_uuid ) UserSocialAuth.objects.create( user=UserFactory.create(), uid='{0}:{1}'.format('not_used', self.external_id), ) UserSocialAuth.objects.create( user=self.user, uid='{0}:{1}'.format(self.provider_slug, self.external_id), ) self._assert_program_enrollment_user(uox_program_enrollment, self.user) aiu_user = UserFactory.create() UserSocialAuth.objects.create( user=aiu_user, uid='{0}:{1}'.format('aiu', self.external_id), ) self._assert_program_enrollment_user(aiu_program_enrollment, aiu_user)
def test_multiple_saml_providers(self, second_config_enabled): """ If multiple samlprovider records exist with the same organization an exception is raised """ organization = OrganizationFactory.create( short_name=self.organization_key) provider = SAMLProviderConfigFactory.create(organization=organization) self.create_social_auth_entry(self.user, provider, self.external_user_id) # create a second active config for the same organization SAMLProviderConfigFactory.create(organization=organization, slug='foox', enabled=second_config_enabled) try: get_user_by_program_id(self.external_user_id, self.program_uuid) except ProviderConfigurationException: self.assertTrue(second_config_enabled, 'Unexpected error when second config is disabled') else: self.assertFalse( second_config_enabled, 'Expected error was not raised when second config is enabled')
def test_jwt_access_token_scopes_and_filters(self, grant_type): """ Verify the JWT contains the expected scopes and filters. """ dot_app = self.dot_adapter.create_public_client( name='test dot application', user=self.user, redirect_uri=DUMMY_REDIRECT_URL, client_id='dot-app-client-id-{grant_type}'.format( grant_type=grant_type), grant_type=grant_type, ) dot_app_access = models.ApplicationAccess.objects.create( application=dot_app, scopes=['grades:read'], ) models.ApplicationOrganization.objects.create( application=dot_app, organization=OrganizationFactory()) scopes = dot_app_access.scopes filters = self.dot_adapter.get_authorization_filters(dot_app) response = self._post_request(self.user, dot_app, token_type='jwt', scope=scopes) self.assertEqual(response.status_code, 200) data = json.loads(response.content.decode('utf-8')) self.assert_valid_jwt_access_token( data['access_token'], self.user, scopes, filters=filters, )
def test_create_organization_already_exists(self): organization = OrganizationFactory(name='GITRello') payload = { 'name': organization.name, } user = UserFactory() api_client = APIClient() api_client.force_authenticate(user=user) with patch.object( OrganizationService, 'create_organization', side_effect=OrganizationAlreadyExistsException) as mocked_create_organization: response = api_client.post('/api/v1/organizations', data=payload, format='json') self.assertEqual(response.status_code, 400) mocked_create_organization.assert_called_with( owner_id=user.id, name=payload['name'], ) expected_response = { 'error_code': OrganizationAlreadyExistsException.code, 'error_message': OrganizationAlreadyExistsException.message, } self.assertDictEqual(response.data, expected_response)
def test_course_org_db_logo_override_legacy(self): """ Want to re-upload an organization logo? You can do it! Just create an organization with and upload the logo. """ org_id = 'MITX' course_key = 'MITX/Demo/2017' with utils.OrganizationLogo(org_id, course_key) as prev_logo: # Should provide the legacy logo self.assertEquals('edx.png', os.path.basename(prev_logo.name)) hsoub_logo = 'hsoub.png' # Sorry we're using this all over the place! with open(os.path.join(STATIC_DIR, hsoub_logo), 'rb') as updated_logo: org = OrganizationFactory.create( short_name='MITX', logo=SimpleUploadedFile(hsoub_logo, content=updated_logo.read()), ) with utils.OrganizationLogo(org_id, course_key) as updated_logo: # Should use the database logo self.assertRegexpMatches(os.path.basename(updated_logo.name), r'.*hsoub.*\.png.*')
def test_add_member_board_not_found(self): organization = OrganizationFactory() with self.assertRaises(BoardNotFoundException): _ = BoardMembershipService.create_board_membership( board_id=-1, organization_membership_id=organization.id, )
def test_send_invite_user_not_found(self): organization = OrganizationFactory() with self.assertRaises(UserNotFoundException): _ = OrganizationInviteService.create_organization_invite( organization_id=organization.id, email='*****@*****.**', message='message', )
def setUp(self): super(TestOrganizationsView, self).setUp() self.user_password = '******' self.user = UserFactory(password=self.user_password, is_superuser=True) self.organization = OrganizationFactory.create() self.organization_list_url = reverse('v0:organization-list') self.client.login(username=self.user.username, password=self.user_password)
def setUp(self): super(TestOrganizationsView, self).setUp() self.user_password = '******' self.user = UserFactory(password=self.user_password) self.organization = OrganizationFactory.create() self.organization_list_url = reverse('v0:organization-list') self.client.login(username=self.user.username, password=self.user_password)
def test_empty_request(self): """ Test that requesting no external keys does not cause an exception. """ organization = OrganizationFactory.create(short_name=self.organization_key) SAMLProviderConfigFactory.create(organization=organization) actual = get_users_by_external_keys(self.program_uuid, set()) assert actual == {}
def setUp(self): super(AMCAdminPermissionsTestCase, self).setUp() self.user = UserFactory.create() self.site = SiteFactory.create(domain='foo.dev', name='foo.dev') factory = APIRequestFactory() self.request = factory.get('/test/') self.request.user = self.user self.organization = OrganizationFactory()
def test_lms_organization_not_found(self): """ Test an OrganizationDoesNotExistException is thrown if the LMS has no organization matching the catalog program's authoring_organization """ organization = OrganizationFactory.create(short_name='some_other_org') SAMLProviderConfigFactory.create(organization=organization) with self.assertRaises(OrganizationDoesNotExistException): get_users_by_external_keys(self.program_uuid, [])
def setUp(self): super(ProgramEnrollmentsInspectorViewTests, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments self.url = reverse("support:program_enrollments_inspector") SupportStaffRole().add_users(self.user) self.program_uuid = str(uuid4()) self.external_user_key = 'abcaaa' # Setup three orgs and their SAML providers self.org_key_list = ['test_org', 'donut_org', 'tri_org'] for org_key in self.org_key_list: lms_org = OrganizationFactory(short_name=org_key) SAMLProviderConfigFactory( organization=lms_org, slug=org_key, enabled=True, ) self.no_saml_org_key = 'no_saml_org' self.no_saml_lms_org = OrganizationFactory( short_name=self.no_saml_org_key)
def test_social_auth_user_not_created(self): """ None should be returned if no lms user exists for an external id """ organization = OrganizationFactory.create(short_name=self.organization_key) SAMLProviderConfigFactory.create(organization=organization) user = get_user_by_program_id(self.external_user_id, self.program_uuid) self.assertIsNone(user)
def test_no_double_organization_course(self): """ Apparently edX allows multiple organizations per course, but my limited imagination wouldn't grok it! """ org_id = 'PSUT' course_key = 'PSUT/Demo/Fall2018' wanted_org = OrganizationFactory.create(short_name='MITX') OrganizationCourse.objects.create(organization=wanted_org, course_id=course_key) unwanted_org = OrganizationFactory.create(short_name='AnythingX') OrganizationCourse.objects.create(organization=unwanted_org, course_id=course_key) with self.assertRaisesRegexp(Exception, '.*multiple organizations.*'): with utils.OrganizationLogo(org_id, course_key): self.fail('Should fail when having multiple organizations')
def test_create_organization_name_not_unique(self): organization = OrganizationFactory() user = UserFactory() with self.assertRaises(OrganizationAlreadyExistsException): _ = OrganizationService().create_organization( owner_id=user.id, name=organization.name, )
def test_get_user_success(self): """ Test lms user is successfully found """ organization = OrganizationFactory.create(short_name=self.organization_key) provider = SAMLProviderConfigFactory.create(organization=organization) self.create_social_auth_entry(self.user, provider, self.external_user_id) user = get_user_by_program_id(self.external_user_id, self.program_uuid) self.assertEquals(user, self.user)
def setUp(self): self.owner = UserFactory() self.organization = OrganizationFactory(owner=self.owner) self.discipline = DisciplineFactory() self.team = TeamFactory( organization=self.organization, discipline=self.discipline, ) self.tournament = TournamentWithTeamsFactory() self.stage = StageFactory(tournament=self.tournament)
def test_lms_organization_not_found(self): """ Test an OrganizationDoesNotExistException is thrown if the LMS has no organization matching the catalog program's authoring_organization """ organization = OrganizationFactory.create(short_name='some_other_org') provider = SAMLProviderConfigFactory.create(organization=organization) self.create_social_auth_entry(self.user, provider, self.external_user_id) with pytest.raises(OrganizationDoesNotExistException): get_user_by_program_id(self.external_user_id, self.program_uuid)
def create_course(self): # Make the `may_certify()` true! past_week = datetime.now(pytz.UTC) - timedelta(days=7) course = CourseFactory.create( start=past_week, end=past_week, ) from edraak_certificates.utils import STATIC_DIR from django.core.files.uploadedfile import SimpleUploadedFile # Enforce a DB logo logo_file_name = 'moe.png' with open(os.path.join(STATIC_DIR, logo_file_name), 'rb') as logo: OrganizationFactory.create( short_name=course.org, logo=SimpleUploadedFile(logo_file_name, content=logo.read()), ) return course
def test_user_has_superuser(): user = UserFactory.create(is_superuser=True) organization = OrganizationFactory.create() project = ProjectFactory.create(organization=organization) DocumentFactory.create(project=project) UserFactory.create() assert len(user.get_organizations()) == 1 assert len(user.get_projects()) == 1 assert len(user.get_documents()) == 1 assert len(user.get_users()) == 2
def test_extra_saml_provider_disabled(self): """ If multiple samlprovider records exist with the same organization, but the extra record is disabled, no exception is raised. """ organization = OrganizationFactory.create(short_name=self.organization_key) SAMLProviderConfigFactory.create(organization=organization) # create a second active config for the same organization, NOT enabled SAMLProviderConfigFactory.create( organization=organization, slug='foox', enabled=False ) get_users_by_external_keys(self.program_uuid, [])
def test_user_has_no_permissions(): user = UserFactory.create() # Create some objects that the user should not be able to see organization = OrganizationFactory.create() project = ProjectFactory.create(organization=organization) DocumentFactory.create(project=project) UserFactory.create() assert len(user.get_organizations()) == 0 assert len(user.get_projects()) == 0 assert len(user.get_documents()) == 0 assert len(user.get_users()) == 0
def test_multiple_active_saml_providers(self): """ If multiple samlprovider records exist with the same organization an exception is raised """ organization = OrganizationFactory.create(short_name=self.organization_key) provider = SAMLProviderConfigFactory.create(organization=organization) self.create_social_auth_entry(self.user, provider, self.external_user_id) # create a second active config for the same organization SAMLProviderConfigFactory.create(organization=organization, slug='foox') with pytest.raises(UserLookupException): get_user_by_program_id(self.external_user_id, self.program_uuid)
def setUpClass(cls): super(SocialAuthEnrollmentCompletionSignalTest, cls).setUpClass() cls.external_id = '0000' cls.provider_slug = 'uox' cls.course_keys = [ CourseKey.from_string('course-v1:edX+DemoX+Test_Course'), CourseKey.from_string('course-v1:edX+DemoX+Another_Test_Course'), ] cls.organization = OrganizationFactory.create( short_name='UoX' ) cls.user = UserFactory.create() for course_key in cls.course_keys: CourseOverviewFactory(id=course_key) cls.provider_config = SAMLProviderConfigFactory.create(organization=cls.organization, slug=cls.provider_slug)
def test_catalog_program_missing_org(self): """ Test OrganizationDoesNotExistException is thrown if the cached program does not have an authoring organization. """ program = ProgramFactory.create( uuid=self.program_uuid, authoring_organizations=[] ) cache.set(PROGRAM_CACHE_KEY_TPL.format(uuid=self.program_uuid), program, None) organization = OrganizationFactory.create(short_name=self.organization_key) provider = SAMLProviderConfigFactory.create(organization=organization) self.create_social_auth_entry(self.user, provider, self.external_user_id) with pytest.raises(OrganizationDoesNotExistException): get_user_by_program_id(self.external_user_id, self.program_uuid)
def setup(): user = UserFactory.create() organization = OrganizationFactory.create() return user, organization, Client()
def setUp(self): super(TestOrganizationSerializer, self).setUp() self.organization = OrganizationFactory.create()
def test_transfer_ownership(): user, organization, project, client = setup() project.add_manage(user) assert login(client, user) # Test that the user does not have permissions yet. new_organization = OrganizationFactory() # Valid case assert project.organization.pk == organization.pk response = client.post( path=reverse('projects:transfer_ownership', args=[project.pk]), data={ 'organization': new_organization.pk, }, follow=True ) assert response.status_code == HTTP_200_OK project.refresh_from_db() assert project.organization.pk != new_organization.pk # Test that if the user does not have enough permissions, that things do not work. new_organization.add_create(user) # Valid case assert project.organization.pk == organization.pk response = client.post( path=reverse('projects:transfer_ownership', args=[project.pk]), data={ 'organization': new_organization.pk, }, follow=True ) assert response.status_code == HTTP_200_OK project.refresh_from_db() assert project.organization.pk == organization.pk new_organization.delete_create(user) # Test that if the user does not have enough permissions, that things do not work. new_organization.add_invite(user) # Valid case assert project.organization.pk == organization.pk response = client.post( path=reverse('projects:transfer_ownership', args=[project.pk]), data={ 'organization': new_organization.pk, }, follow=True ) assert response.status_code == HTTP_200_OK project.refresh_from_db() assert project.organization.pk == organization.pk new_organization.delete_invite(user) # Now test that they do. new_organization.add_manage(user) # Valid case assert project.organization.pk == organization.pk response = client.post( path=reverse('projects:transfer_ownership', args=[project.pk]), data={ 'organization': new_organization.pk, }, follow=True ) assert response.redirect_chain[0][0] == reverse('projects:transfer_ownership', args=[project.pk]) assert response.redirect_chain[0][1] == HTTP_302_FOUND project.refresh_from_db() assert project.organization.pk == new_organization.pk
def test_authenticated_user(self): """ Verify that the authenticated user gets data.""" OrganizationFactory.create() response = self.client.get(self.organization_list_url) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data['results']), 2)
def setUp(self): super(TestOrganizationModel, self).setUp() self.organization = OrganizationFactory.create()