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)
