def test_login_change_password(self, user, user_settings): user_settings.require_verification = False user_settings.require_approval = False user_settings.require_terms_acceptance = False user_settings.save() user.change_password = True user.save() assert len(mail.outbox) == 0 response = self.login(user=user) assert status.is_redirect(response.status_code) assert resolve(response.url).view_name == "account_reset_password_done" request_user = response.wsgi_request.user assert isinstance(request_user, AnonymousUser) assert len(mail.outbox) == 1 assert user.email in mail.outbox[0].to user.change_password = False user.save() response = self.login(user=user) assert status.is_redirect(response.status_code) request_user = response.wsgi_request.user assert request_user == user and user.is_authenticated assert response.url == settings.LOGIN_REDIRECT_URL
def test_status_categories(self): self.assertFalse(is_informational(99)) self.assertTrue(is_informational(100)) self.assertTrue(is_informational(199)) self.assertFalse(is_informational(200)) self.assertFalse(is_success(199)) self.assertTrue(is_success(200)) self.assertTrue(is_success(299)) self.assertFalse(is_success(300)) self.assertFalse(is_redirect(299)) self.assertTrue(is_redirect(300)) self.assertTrue(is_redirect(399)) self.assertFalse(is_redirect(400)) self.assertFalse(is_client_error(399)) self.assertTrue(is_client_error(400)) self.assertTrue(is_client_error(499)) self.assertFalse(is_client_error(500)) self.assertFalse(is_server_error(499)) self.assertTrue(is_server_error(500)) self.assertTrue(is_server_error(599)) self.assertFalse(is_server_error(600))
def test_registration(self, user_data, user_settings): """ Tests that registering a user results in an un-verified un-approved user """ client = Client() test_data = { "email": user_data["email"], "password1": user_data["password"], "password2": user_data["password"], "accepted_terms": True, } response = client.post(self.registration_url, test_data) assert status.is_redirect(response.status_code) assert resolve( response.url).view_name == "account_email_verification_sent" user = UserModel.objects.get(email=user_data["email"]) assert UserModel.objects.count() == 1 assert user.is_active == True assert user.is_verified == False assert user.is_approved == False
def test_consultant_create_waiting_list(self): # PREPARE DATA name = faker.name() email = faker.email() custom_text = faker.text() self.login(username=self.super_user.username, password='******') url = reverse('consultant:add') data = { 'name': name, 'email': email, 'custom_text': custom_text, 'waiting_list': True } # DO ACTION response = self.post(url, data) consultant = Consultant.all_objects.get(user__email=email) self.validate_consultant_process(consultant) self.enable_advising_for_consultant(consultant) # ASSERTS self.assertIsNotNone(consultant) self.assertTrue(status.is_redirect(response.status_code)) self.assertEqual(response.url, reverse('consultant:list')) self.assertTrue(consultant.is_in_waiting_list) url, zone = UserRedirectController.redirect_url(consultant.user) self.assertEqual(url, consultant.get_public_profile_v2()) self.assertFalse(zone)
def test_consultant_add_with_duplicated_email(self): # PREPARE DATA name = faker.name() email = faker.email() custom_text = faker.text() self.login(username=self.super_user.username, password='******') url = reverse('consultant:add') data = { 'name': name, 'email': email, 'custom_text': custom_text, } # DO ACTION response = self.post(url, data) # ASSERTS self.assertTrue(status.is_redirect(response.status_code)) # DO ACTION data['email'] = data['email'].upper() response = self.post(url, data) # ASSERTS self.assertFalse(response.context_data.get('form').is_valid())
def test_registration_verify_email(self, user_settings, user_data): client = Client() test_data = { "email": user_data["email"], "password1": user_data["password"], "password2": user_data["password"], } client.post(self.registration_url, test_data) user = UserModel.objects.get(email=test_data["email"]) valid_verification_url = reverse( "account_confirm_email", kwargs={"key": user.latest_confirmation_key}) invalid_verification_url = reverse( "account_confirm_email", kwargs={"key": shuffle_string(user.latest_confirmation_key)}, ) response = client.post(invalid_verification_url) assert status.is_client_error(response.status_code) assert user.is_verified is False response = client.post(valid_verification_url) assert status.is_redirect(response.status_code) assert user.is_verified is True
def test_registration_accept_terms(self, user_data, user_settings): client = Client() user_settings.require_terms_acceptance = True user_settings.save() test_data = { "email": user_data["email"], "password1": user_data["password"], "password2": user_data["password"], } response = client.post(self.registration_url, test_data) request_user = response.wsgi_request.user assert status.is_success(response.status_code) assert not request_user.is_authenticated test_data.update({"accepted_terms": True}) response = client.post(self.registration_url, test_data) request_user = response.wsgi_request.user assert status.is_redirect(response.status_code) assert not request_user.is_authenticated assert resolve( response.url).view_name == "account_email_verification_sent"
def test_login_unaccepted(self, user, user_settings): user_settings.require_verification = False user_settings.require_approval = False user_settings.require_terms_acceptance = True user_settings.save() user.accepted_terms = False user.save() # an unaccepted user can't login... response = self.login(user=user) request_user = response.wsgi_request.user assert request_user != user and not request_user.is_authenticated # an accepted user can login... user.accepted_terms = True user.save() response = self.login(user=user) assert status.is_redirect(response.status_code) request_user = response.wsgi_request.user assert request_user == user and user.is_authenticated assert response.url == settings.LOGIN_REDIRECT_URL
def assertResponseRedirect(self, response, msg=None): status_code = response.status_code if msg is not None: message = msg.format(status_code=status_code) else: message = None self.assertTrue(status.is_redirect(status_code), message)
def test_create_ko(self): url = reverse('certification:level-1', kwargs={'language': 'en'}) self.client.login(username=self.user.username, password='******') response = self.client.post(url) self.assertTrue(status.is_redirect(response.status_code)) self.assertFalse( self.project.has_perm(self.user, settings.PROJECT_PERMS_VIEW_PROJECT)) self.assertEqual(response.url, settings.DOMAIN_NAME)
def test_valid_create(self): # PREPARE DATA url = reverse('project:project:populate-media', kwargs={'project_id': self.project.pk}) for _type, _ in settings.PROJECT_CH_TYPE_PROJECT: # DO ACTION response = self.client.post(url, data={'_type': _type}) # ASSERTS self.assertTrue(status.is_redirect(response.status_code))
def test_login_inactive(self, user, user_settings): user.accepted_terms = True user.is_approved = True user.is_active = False user.verify() user.save() response = self.login(user=user) assert status.is_redirect(response.status_code) request_user = response.wsgi_request.user assert request_user != user and not request_user.is_authenticated assert resolve(response.url).view_name == "account_inactive"
def test_create_twice(self): project_id = self.project.id url = reverse('certification:level-1', kwargs={'language': 'en'}) self.client.login(username=self.user.username, password='******') with self.settings( EXO_FOUNDATIONS_EN=project_id, PROJECT_CERTIFICATION_LEVEL_1=[ project_id, ], PROJECT_CERTIFICATION_LEVEL_1_LANGUAGE={'en': project_id}): response = self.client.post(url) response_duplicated = self.client.post(url) self.assertTrue(status.is_redirect(response.status_code)) self.assertTrue(status.is_redirect( response_duplicated.status_code)) self.assertTrue( self.project.has_perm(self.user, settings.PROJECT_PERMS_VIEW_PROJECT)) self.assertEqual( response.url, settings.DOMAIN_NAME + self.project.get_frontend_index_url(self.user), )
def test_login_unverified(self, user, user_settings): assert user_settings.require_verification is True assert user.is_verified is False # an unverified user cannot login... response = self.login(user=user) assert status.is_redirect(response.status_code) request_user = response.wsgi_request.user assert request_user != user and not request_user.is_authenticated assert resolve( response.url).view_name == "account_email_verification_sent" # a verified user can login... user.verify() response = self.login(user=user) assert status.is_redirect(response.status_code) request_user = response.wsgi_request.user assert request_user == user and user.is_authenticated assert response.url == settings.LOGIN_REDIRECT_URL
def test_user_badge_job_update_item_view(self): # PREPARE DATA user_badge_item = FakeUserBadgeItemFactory.create() url = reverse('tools:badge:update-job-item', kwargs={'pk': user_badge_item.pk}) data = { 'name': faker.name(), 'date': faker.date(), } # DO ACTION response = self.client.post(url, data=data) # ASSERTS self.assertTrue(status.is_redirect(response.status_code)) user_badge_item.refresh_from_db() self.assertEqual(user_badge_item.name, data.get('name')) self.assertEqual(user_badge_item.date, parse_date(data.get('date')))
def test_get_current_user_slashless(self, mock_storage): """ Tests that using the reserved username "current" will redirect to the current user if the url has no trailing slash. """ client = APIClient() user = UserFactory() token, key = create_auth_token(user) client.credentials(HTTP_AUTHORIZATION=f"Token {key}") url = reverse("users-detail", kwargs={"id": "current"}) assert url[-1] == "/" response = client.get(url[:-1]) assert status.is_redirect(response.status_code) assert response.url == url
def to_json_response(response): status_code = response.status_code data = None if status.is_success(status_code): if hasattr(response, 'is_rendered') and not response.is_rendered: response.render() data = {'data': response.content} elif status.is_redirect(status_code): data = {'redirect': response.url} elif (status.is_client_error(status_code) or status.is_server_error(status_code)): data = {'errors': [{'status': status_code}]} return JsonResponse(data)
def test_create_fail_default_language(self): project_id = self.project.id url = reverse('certification:level-1') self.client.login(username=self.user.username, password='******') with self.settings( EXO_FOUNDATIONS_EN=project_id, PROJECT_CERTIFICATION_LEVEL_1=[ project_id, ], PROJECT_CERTIFICATION_LEVEL_1_LANGUAGE={'es': project_id}): response = self.client.post(url) self.assertTrue(status.is_redirect(response.status_code)) self.assertFalse( self.project.has_perm(self.user, settings.PROJECT_PERMS_VIEW_PROJECT)) self.assertIsNone(self.project.get_frontend_index_url(self.user))
def test_logout(self, user): client = Client() client.force_login(user) # make sure I can't logout via a GET response = client.get(self.logout_url) request_user = response.wsgi_request.user assert status.is_success(response.status_code) assert request_user == user and request_user.is_authenticated # make sure I _can_ logout w/ a token via a POST response = client.post(self.logout_url) request_user = response.wsgi_request.user assert status.is_redirect(response.status_code) assert request_user != user and not request_user.is_authenticated assert response.url == settings.LOGOUT_REDIRECT_URL
def test_create_and_download_cog(admin_api_client, geotiff_image_entry): """Test POST for ConvertedImage model.""" response = admin_api_client.post( '/rgd_imagery_test/api/image_process/imagery/cog', {'source_image': geotiff_image_entry.id}, ) assert response.status_code == 201 assert response.data # Check that a COG was generated cog = models.ConvertedImage.objects.get( source_image=geotiff_image_entry.id) # NOTE: This doesn't actually verify the file is in COG format. Assumed. assert cog.processed_image # Also test download endpoint here: pk = cog.pk response = admin_api_client.get( f'/rgd_imagery_test/api/image_process/imagery/cog/{pk}/data') assert status.is_redirect(response.status_code)
def to_json_response(response): status_code = response.status_code data = None if status.is_success(status_code): if hasattr(response, 'is_rendered') and not response.is_rendered: response.render() data = {'data': response.content} elif status.is_redirect(status_code): data = {'redirect': response.url} elif (status.is_client_error(status_code) or status.is_server_error(status_code)): data = {'errors': [{ 'status': status_code }]} return JsonResponse(data)
def test_disable_backend(self, user_settings): """ Tests that you cannot access backend views when it's disabled. """ client = Client() user_settings.enable_backend_access = True user_settings.save() response = client.get(self.registration_url) assert status.is_success(response.status_code) user_settings.enable_backend_access = False user_settings.save() response = client.get(self.registration_url) assert status.is_redirect(response.status_code) assert resolve(response.url).view_name == "disabled"
def test_view_do_payment_no_accesible_if_not_pending_or_errored(self): # PREPARE DATA client = Client() test_cases = [ settings.PAYMENTS_CH_CANCELED, settings.PAYMENTS_CH_ERASED, settings.PAYMENTS_CH_PAID, settings.PAYMENTS_CH_VALIDATED, ] for test in test_cases: self.payment.status = test self.payment.save(update_fields=['status']) # DO ACTION response = client.get(self.payment.url) # ASSERTIONS self.assertFalse(self.payment.is_pending) self.assertTrue(status.is_redirect(response.status_code))
def test_user_badge_item_delete_view(self): # PREPARE DATA user_badge_item = FakeUserBadgeItemFactory.create() url = reverse('tools:badge:delete-item', kwargs={'pk': user_badge_item.pk}) # DO ACTION response = self.client.delete(url) # ASSERTS self.assertTrue(status.is_redirect(response.status_code)) self.assertFalse(UserBadgeItem.objects.filter(pk=user_badge_item.pk).exists()) # ASSERTS LOGS self.assertTrue( self.super_user.actor_actions .filter( verb=settings.BADGE_ACTION_LOG_DELETE, description='item {}'.format(user_badge_item.pk) ) .exists() )
def test_user_badge_activity_add_view_twice_request(self): # PREPARE DATA badge = FakeBadgeFactory.create(code=settings.BADGE_CODE_CONTENT_CREATOR) url = reverse('tools:badge:add-activity-job') data = { 'email': self.user.email, 'badge': badge.pk, 'comment': faker.text(), } # DO ACTION response = self.client.post(url, data=data) # ASSERTS self.assertTrue(status.is_redirect(response.status_code)) self.assertTrue(self.user.get_badges(code=badge.code).exists()) self.assertEqual(self.user.get_badges(code=badge.code).first().num, 1) # DO ACTION AGAIN self.client.post(url, data=data) # ASSERTS self.assertEqual(self.user.get_badges(code=badge.code).first().num, 1) # ASSERTS LOGS user_badge = self.user.get_badges(code=badge.code).first() self.assertEqual( user_badge .get_logs(verb=settings.BADGE_ACTION_LOG_CREATE) .filter(description=data.get('comment')) .count(), 1 ) self.assertEqual( user_badge .get_logs(verb=settings.BADGE_ACTION_LOG_UPDATE) .filter(description=data.get('comment')) .count(), 1 )
def __init__(self, data=None, status=None, message=None): super(AppResponse, self).__init__(None, status=status) status_message = "" try: if is_informational(status): status_message = "informational" elif is_success(status): status_message = "ok" elif is_redirect(status): status_message = "redirect" elif is_client_error(status): status_message = "client_error" elif is_server_error(status): status_message = "server_error" except TypeError: status_message = "" self.data = { 'data': data, 'status_message': status_message, 'message': message }
def make_rest_call(method, url, headers, data=None): response = None try: if method == 'GET': response = requests.get(url, headers=headers) elif method == 'DELETE': response = requests.delete(url, headers=headers) elif method == 'POST': response = requests.post(url, data=data, headers=headers) except (ConnectionError, HTTPError, Timeout) as e: logger.error('REST %s Connection exception : %s', method, e) except: logger.error('Unexpected REST %s error: %s', method, sys.exc_info()[0]) if response is None or status.is_server_error(response.status_code): msg = '{0} {1}'.format('Service temporarily unavailable:', urlparse(url).netloc) raise ServiceUnavailable(detail=msg) elif status.is_client_error(response.status_code): raise BadRequest() elif status.is_redirect(response.status_code): logger.warn('Redirect %s for %s', response.status_code, url) return response
def test_consultant_create_frontend(self): # PREPARE DATA name = faker.name() email = faker.email() custom_text = faker.text() self.login(username=self.super_user.username, password='******') url = reverse('consultant:add') data = { 'name': name, 'email': email, 'custom_text': custom_text, } # DO ACTION response = self.post(url, data) # ASSERTS consultant = Consultant.all_objects.get(user__email=email) self.assertIsNotNone(consultant) self.assertEqual(consultant.user.short_name, name.split(' ')[0]) self.assertEqual(consultant.user.full_name, name) self.assertTrue(status.is_redirect(response.status_code)) self.assertEqual(response.url, reverse('consultant:list'))
def assertStatusRedirect(self, response): self.assertTrue(status.is_redirect(response.status_code))
def test_download_checksum_file_url(admin_api_client, checksum_file_url): pk = checksum_file_url.pk response = admin_api_client.get( f'/rgd_test/api/rgd/checksum_file/{pk}/data') assert status.is_redirect(response.status_code)
def test_download_image_file(admin_api_client, astro_image): pk = astro_image.pk response = admin_api_client.get( f'/rgd_imagery_test/api/rgd_imagery/{pk}/data') assert status.is_redirect(response.status_code)