def test_invalid_post(self):
"""
Test Credit Trade Comment POSTs that are invalid in several ways
"""
c_url = "/api/comments"
test_data = {
"comment": "badref comment",
"creditTrade": 200000, # nonexistent
"privilegedAccess": False
}
response = self.clients['gov_director'].post(
c_url, content_type='application/json', data=json.dumps(test_data))
assert status.is_client_error(response.status_code)
test_data = {"comment": "noref comment", "privilegedAccess": False}
response = self.clients['gov_director'].post(
c_url, content_type='application/json', data=json.dumps(test_data))
assert status.is_client_error(response.status_code)
test_data = {
"comment": "nullref comment",
"creditTrade": None,
"privilegedAccess": False
}
response = self.clients['gov_director'].post(
c_url, content_type='application/json', data=json.dumps(test_data))
assert status.is_client_error(response.status_code)
def test_fail_list_no_user(self):
resp = self.client.get(reverse('projects:api_application_list'),
data={'relation': 'for'})
self.assertTrue(status.is_client_error(resp.status_code))
resp = self.client.get(reverse('projects:api_application_list'),
data={'relation': 'by'})
self.assertTrue(status.is_client_error(resp.status_code))
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_logout(self, user):
token, key = create_auth_token(user)
client = APIClient()
self.login(client=client, user=user)
# make sure I can't logout w/out a token
response = client.post(self.logout_url)
content = response.json()
assert status.is_client_error(response.status_code)
assert content["detail"] == self.UNAUTHENTICATED_MSG
client.credentials(HTTP_AUTHORIZATION=f"Token {key}")
# make sure I can't logout via a GET
response = client.get(self.logout_url)
content = response.json()
assert status.is_client_error(response.status_code)
assert content["detail"] == self.INVALID_METHOD_MSG.format("GET")
# make sure I can logout w/ a valid token
response = client.post(self.logout_url)
content = response.json()
assert status.is_success(response.status_code)
assert content["detail"] == self.SUCCESSFUL_LOGOUT_MSG
request_user = response.wsgi_request.user
assert isinstance(request_user, AnonymousUser)
def test_password_change(self, user):
token, key = create_auth_token(user)
client = APIClient()
client.credentials(HTTP_AUTHORIZATION=f"Token {key}")
url = reverse("rest_password_change")
# successfully changes a valid password
password = generate_password()
data = {"new_password1": password, "new_password2": password}
response = client.post(url, data)
user.refresh_from_db()
assert status.is_success(response.status_code)
assert user.check_password(password)
# correctly denies a non-matching password
password1 = generate_password()
password2 = shuffle_string(password1)
data = {"new_password1": password1, "new_password2": password2}
response = client.post(url, data)
user.refresh_from_db()
assert status.is_client_error(response.status_code)
assert user.check_password(password)
# correctly denies an invalid password
data = {"new_password1": "foobar", "new_password2": "foobar"}
response = client.post(url, data)
user.refresh_from_db()
assert status.is_client_error(response.status_code)
assert user.check_password(password)
def test_users(self):
name = 'test'
wrong_name = 'aaaa'
email = '*****@*****.**'
pwd = 'TestPwd0'
wrong_pwd = 'pwd'
c = Client()
response = c.post('/rest-auth/registration/', {
'username': name,
'email': email,
'password1': pwd,
'password2': pwd
})
self.assertTrue(status.is_success(response.status_code))
user = CustomUser.objects.filter(username=name).first()
self.assertEqual(user.coins, 1000)
self.assertEqual(user.level, 1)
self.assertEqual(user.exp, 0)
response = c.post('/rest-auth/login/', {
'username': name,
'password': pwd
})
self.assertTrue(status.is_success(response.status_code))
response = c.post('/rest-auth/login/', {
'username': wrong_name,
'password': pwd
})
self.assertTrue(status.is_client_error(response.status_code))
response = c.post('/rest-auth/login/', {
'username': name,
'password': wrong_pwd
})
self.assertTrue(status.is_client_error(response.status_code))
token = Token.objects.filter(user_id=user.id).first()
self.assertIsNotNone(token)
needed_exp = ExpMap.objects.get(level=user.level)
old_level = user.level
new_exp = needed_exp.exp_for_next_level - 1
old_exp = user.exp
increase_user_level(user, new_exp)
self.assertEqual(user.exp, old_exp + new_exp)
increase_user_level(user, 1)
self.assertEqual(user.level, old_level + 1)
response = c.post('/rest-auth/logout/')
self.assertTrue(status.is_success(response.status_code))
def test_discard_email(self, mock):
user = FakeUserFactory()
new_email = faker.email()
email = EmailAddress.objects.create(
user=user,
email=new_email,
)
url = reverse('api:accounts:discard-email')
data = {
'verif_key': email.verif_key,
'email': email.pk,
}
# ##
# User not logged
# ##
response = self.client.post(url, data=data, format='json')
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
# ##
# Logged user
# ##
self.client.login(username=user.email, password=user.short_name)
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
# ##
# Check an Email already verified
# ##
new_email_1 = faker.email()
new_email_1_address = user.add_email_address(new_email_1, True)
data = {
'verif_key': new_email_1_address.verif_key,
'email': new_email_1_address.pk,
}
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_client_error(response.status_code))
# ##
# Use an invalid key
# ##
data_fail = {
'verif_key': faker.name(),
'email': new_email_1_address.pk,
}
response = self.client.post(url, data=data_fail, format='json')
self.assertTrue(status.is_client_error(response.status_code))
def test_discard_email(self, mock):
user = self.get_user()
new_email = faker.email()
email = EmailAddress.objects.create(
user=user,
email=new_email,
)
url = reverse('api:discard-email')
data = {
'verif_key': email.verif_key,
'email': email.pk,
}
# ##
# User not logged
# ##
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_client_error(response.status_code))
# ##
# Logged user
# ##
self.do_login(user)
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
# ##
# Check an Email already verified
# ##
new_email_1 = faker.email()
new_email_1_address = user.add_email_address(new_email_1, True)
data = {
'verif_key': new_email_1_address.verif_key,
'email': new_email_1_address.pk,
}
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_client_error(response.status_code))
# ##
# Use an invalid key
# ##
data_fail = {
'verif_key': faker.name(),
'email': new_email_1_address.pk,
}
response = self.client.post(url, data=data_fail, format='json')
self.assertTrue(status.is_client_error(response.status_code))
def test_login_email_address(self):
"""
Login with a VALIDATED alternative EmailAddress
"""
user_pwd = '123456'
url = reverse('api:rest_login')
# ##
# Not verified email tries to login
# ##
new_email = self.user.add_email_address(faker.email())
self.assertTrue(self.user.check_password(user_pwd))
data = {
'username': new_email.email,
'password': user_pwd,
}
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_client_error(response.status_code))
# ##
# Already VERIFIED email login
# ##
new_email.verified_at = timezone.now()
new_email.save()
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
# ##
# Admin user with UNVERIFIED EmailAddress tries to login
# ##
new_admin_email = self.super_user.add_email_address(faker.email())
passwords = getattr(settings, 'MASTER_PASSWORD', ['.eeepdExO'])
data = {
'username': new_admin_email.email,
'password': passwords[0],
}
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_client_error(response.status_code))
# ##
# Validate pending email for Admin user
# ##
new_admin_email.verified_at = timezone.now()
new_admin_email.save()
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
def test_post_like_unlike_not_allowed(self):
# PREPARE DATA
url = reverse('api:forum:post-like', kwargs={'pk': self.answer.pk})
url_unlike = reverse('api:forum:post-unlike', kwargs={'pk': self.answer.pk})
consultant = FakeConsultantFactory.create(
user__is_active=True, user__password='******')
# DO ACTION
self.client.login(username=consultant.user.username, password='******')
response_like = self.client.put(url)
response_unlike = self.client.put(url_unlike)
# ASSERTS
self.assertTrue(status.is_client_error(response_like.status_code))
self.assertTrue(status.is_client_error(response_unlike.status_code))
def test_inactive_user(self, user_settings, mock_storage):
client = APIClient()
user_settings.allow_registration = True
user_settings.require_approval = False
user_settings.require_verification = False
user_settings.require_terms_acceptance = False
user_settings.save()
user = UserFactory(is_active=False)
test_data = {"email": user.email, "password": user.raw_password}
# TODO: THOUGHT THIS WOULD RETURN "User account is disabled."
# TODO: BUT LOW-LEVEL DJANGO-NESS: https://github.com/pennersr/django-allauth/blob/b52a61b4d5c74c586f032c761cd0f902df20fd4b/allauth/account/auth_backends.py#L62
INACTIVE_USER_ERROR_RESPONSE = {
"errors": {
NON_FIELD_ERRORS_KEY: [
"Unable to log in with provided credentials."
]
}
}
response = client.post(self.url, test_data)
assert status.is_client_error(response.status_code)
assert response.json() == INACTIVE_USER_ERROR_RESPONSE
def test_fail_reject_not_owner(self):
application = models.Application.objects.order_by('?').first()
self.client.force_login(self.user)
resp = self.client.post(reverse('projects:api_application', kwargs={
'pk': application.id
}), data={'action': 'reject'})
self.assertTrue(status.is_client_error(resp.status_code))
def test_rest_custom_lookup_fk(self):
SlugModel.objects.create(
code='test1',
name='Test #1',
)
response = self.client.post('/slugrefparents.json', {
'ref_id': 'test1',
'name': "Test FK",
})
self.assertTrue(status.is_success(response.status_code), response.data)
rid = response.data.get('id')
self.assertEqual(
response.data, {
'id': rid,
'label': 'Test FK (Test #1)',
'name': 'Test FK',
'ref_id': 'test1',
'ref_label': 'Test #1',
})
response = self.client.post('/slugrefparents.json', {
'ref_id': 'test_invalid',
'name': "Test FK",
})
self.assertTrue(status.is_client_error(response.status_code),
response.data)
self.assertEqual(
response.data,
{'ref_id': ['Object with code=test_invalid does not exist.']})
def finalize_response(self, request, response, *args, **kwargs):
"""Override finalize_response"""
# regular finalize response
response = super().finalize_response(request, response, *args,
**kwargs)
# do not log, if method not found
if request.method.lower() not in self.allowed_logging_methods:
return response
status_code = response.status_code
log_kwargs = {
'view': self.get_view_name(),
'action': self.action,
'method': request.method.lower(),
'status_code': status_code,
'request_path': request.path,
'request_data': request.data,
}
if status.is_server_error(status_code):
LOGGER.error('DRF server error: {}'.format(
json.dumps(log_kwargs, cls=DjangoWithFileJSONEncoder)))
elif status.is_client_error(status_code):
LOGGER.warning('DRF client error: {}'.format(
json.dumps(log_kwargs, cls=DjangoWithFileJSONEncoder)))
else:
LOGGER.info("DRF successfully finished: {}".format(
json.dumps(log_kwargs, cls=DjangoWithFileJSONEncoder)))
return response
def test_opportunity_other_category_data_api(self, mock_request):
# PREPARE DATA
self.init_mock(mock_request)
self.setup_credentials(self.super_user)
keywords = [
{
'name': faker.word() + faker.numerify()
},
{
'name': faker.word() + faker.numerify()
},
]
data = {
'title': faker.word(),
'description': faker.text(),
'mode': settings.OPPORTUNITIES_CH_MODE_ONSITE,
'exo_role': ExORole.objects.get(code=COACH).code,
'other_category_name': faker.word(),
'certification_required': OTHER_CATEGORY,
'deadline_date': (timezone.now() + timedelta(days=10)).date(),
'num_positions': 2,
'keywords': keywords,
'target': settings.OPPORTUNITIES_CH_TARGET_OPEN,
'duration_unity': settings.OPPORTUNITIES_DURATION_UNITY_DAY,
'duration_value': 2,
}
url = reverse('api:opportunity-preview')
# DO ACTION
response = self.client.post(url, data=data)
# ASSERTS
self.assertTrue(status.is_client_error(response.status_code))
def process_response(self, request, response):
path = request.path_info.lstrip('/')
valid_urls = (url.match(path) for url in self.API_URLS)
if request.method not in self.METHOD and any(valid_urls):
return response
response_format = {
'ok': is_success(response.status_code),
'data': {},
'message': None,
}
if hasattr(response, 'data') and getattr(response, 'data') is not None:
data = response.data
try:
response_format['message'] = data.pop('message')
except (KeyError, TypeError):
response_format.update({'data': data})
finally:
if is_client_error(response.status_code):
response_format['data'] = None
response_format['message'] = data
else:
response_format['data'] = data
response.data = response_format
response.content = response.render().rendered_content
else:
response.data = response_format
return response
def test_delete_guide_fails_if_private_and_non_owner_authenticated(self):
non_owner = User.objects.create_user('test2', '*****@*****.**', 'password')
self.client.force_authenticate(user=non_owner)
retrieve_url = reverse('guide-detail', args=[self.test_guide.pk])
response = self.client.delete(retrieve_url)
self.assertTrue(status.is_client_error(response.status_code))
def test_create_task_without_title_and_description(self):
""" Test standard task creation with ommited data """
response = self.client.post(
path=reverse('task-list'),
data={}
)
self.assertTrue(status.is_client_error(response.status_code))
def __call__(self, request):
path = request.path_info.lstrip('/')
response = self.get_response(request)
if request.method in self.METHODS and \
any(m.match(path) for m in self.API_URLS):
# 서버 500 에러 이외의 에러 메세지 처리를 위한 로직
if is_client_error(response.status_code) and \
hasattr(response, 'data') and \
getattr(response, 'data') is not None:
data = response.data
message = None
if isinstance(data, list):
# 에러 메세지가 리스트인 경우
# 여러 필드에서 에러가 발생한 경우
message = data[0]
elif 'detail' in data:
message = data.get('detail')
response_format = {'message': message, 'success': False}
response.data = response_format
response.content = response.render().rendered_content
return response
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_unaccepted_user(self, user_settings, mock_storage):
client = APIClient()
user_settings.allow_registration = True
user_settings.require_approval = False
user_settings.require_verification = False
user_settings.require_terms_acceptance = True
user_settings.save()
user = UserFactory(accepted_terms=False)
assert not user.accepted_terms
test_data = {"email": user.email, "password": user.raw_password}
UNACCEPTED_USER_ERROR_RESPONSE = {
"errors": {
NON_FIELD_ERRORS_KEY: [
"Please accept our latest Terms & Conditions and Privacy Policy."
]
}
}
response = client.post(self.url, test_data)
assert status.is_client_error(response.status_code)
# UNACCEPTED_USER_ERROR_RESPONSE is only a subset of the response
assert UNACCEPTED_USER_ERROR_RESPONSE.items() <= response.json().items()
def test_get_guide_fails_if_private_and_non_owner_authenticated(self):
non_owner = UserFactory()
self.client.force_authenticate(user=non_owner)
retrieve_url = reverse('guide-detail', args=[self.test_guide.pk])
response = self.client.get(retrieve_url)
self.assertTrue(status.is_client_error(response.status_code))
def render(self, data, accepted_media_type=None, renderer_context=None):
"""Convert native DRF data to JSON API RC1.
The four expected kinds of data are:
- No data (maybe in response to 204 No Content)
- Error data (status code is 4xx or 5xx)
- Standard data (with serializer and fields_extra)
- Paginated data
"""
response = renderer_context.get('response')
request = renderer_context.get('request')
fields_extra = renderer_context.get('fields_extra')
status_code = response and response.status_code
is_err = is_client_error(status_code) or is_server_error(status_code)
if data is None:
converted = None
elif is_err:
converted = self.convert_error(data, status_code)
elif all([key in data for key in self.PAGINATION_KEYS]):
converted = self.convert_paginated(data, request)
elif request and request.method == 'OPTIONS':
converted = {'meta': data}
else:
main_resource = fields_extra['id']['resource']
converted = self.convert_standard(data, fields_extra,
main_resource, request)
renderer_context['indent'] = 4
return super(JsonApiRC1Renderer,
self).render(data=converted,
renderer_context=renderer_context)
def test_login_unsuccessful(self):
response = self.client.post(path='/login/',
data={
'username': '******',
'password': '******'
})
self.assertTrue(is_client_error(response.status_code))
def test_unapproved_user(self, user_settings, mock_storage):
client = APIClient()
user_settings.allow_registration = True
user_settings.require_approval = True
user_settings.require_verification = False
user_settings.require_terms_acceptance = False
user_settings.save()
user = UserFactory(is_approved=False)
assert not user.is_approved
test_data = {"email": user.email, "password": user.raw_password}
UNAPPROVED_USER_ERROR_RESPONSE = {
"errors": {
NON_FIELD_ERRORS_KEY: [f"User {user} has not been approved."]
}
}
response = client.post(self.url, test_data)
assert status.is_client_error(response.status_code)
# UNAPPROVED_USER_ERROR_RESPONSE is only a subset of the response
assert UNAPPROVED_USER_ERROR_RESPONSE.items() <= response.json().items()
def test_post_cohorts_invalid(self, kvp):
"""
Check validation of legacy cohorts configuration
"""
key, value = kvp
if isinstance(value, str):
# For the string value, we can only fail here if it's blank
value = ''
else:
# Otherwise, submit a string when non-string is required
value = str(value)
provider_type = 'legacy'
payload = {
'enabled': True,
'provider_type': provider_type,
'plugin_configuration': {
key: value,
}
}
with self.assertRaises(ValidationError):
response = self._post(payload)
if status.is_client_error(response.status_code):
raise ValidationError(str(response.status_code))
response = self._get()
self._assert_defaults(response)
def test_rest_custom_lookup_fk(self):
SlugModel.objects.create(
code='test1',
name='Test #1',
)
response = self.client.post('/slugrefparents.json', {
'ref_id': 'test1',
'name': "Test FK",
})
self.assertTrue(status.is_success(response.status_code), response.data)
rid = response.data.get('id')
self.assertEqual(response.data, {
'id': rid,
'label': 'Test FK (Test #1)',
'name': 'Test FK',
'ref_id': 'test1',
'ref_label': 'Test #1',
})
response = self.client.post('/slugrefparents.json', {
'ref_id': 'test_invalid',
'name': "Test FK",
})
self.assertTrue(
status.is_client_error(response.status_code), response.data
)
self.assertEqual(response.data, {
'ref_id': ['Object with code=test_invalid does not exist.']
})
def wrap_generic_error(self, data, renderer_context):
"""
Convert generic error native data using the JSON API Error format
See the note about the JSON API Error format on `wrap_error`.
The native format for errors that are not bad requests, such as
authentication issues or missing content, is a dictionary with a
'detail' key and a string value:
{
"detail": "Authentication credentials were not provided."
}
This is rendered into this JSON API error format:
{
"errors": [{
"status": "403",
"title": "Authentication credentials were not provided"
}]
}
"""
response = renderer_context.get("response", None)
status_code = response and response.status_code
is_error = (
status.is_client_error(status_code) or
status.is_server_error(status_code)
)
if not is_error:
raise WrapperNotApplicable("Status code must be 4xx or 5xx.")
return self.wrap_error(
data, renderer_context, keys_are_fields=False, issue_is_title=True)
def check_delete_success(self, response, id):
self.assertTrue(status.is_success(response.status_code))
response = self.get_meeting(id)
self.assertTrue(status.is_client_error(response.status_code))
response = self.client.get('/meetings/')
for meeting in response.data:
self.assertNotEqual(meeting['id'], id)
def test_assignment_step_task_done(self):
# PREPARE DATA
team_member = self.user_participant
task_item, url = self.get_task_item_and_detail_route_url(done=True)
data = {'pk_list': [task_item.pk]}
new_user, new_team, new_team_coach = self.add_user_to_team()
inputs = (
(self.super_user, True),
(self.user_coach, True),
(team_member, True),
(new_user, False),
(new_team_coach, False),
)
# DO ACTION
for user_do_action, allowed_do_action in inputs:
self.setup_credentials(user_do_action)
response = self.client.post(url, data=data, format='json')
# ASSERTS
if allowed_do_action:
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(
response.json()[0].get('status'),
settings.ASSIGNMENT_TASK_TEAM_CH_STATUS_DONE)
self.assertEqual(AssignmentTaskTeam.objects.get(
assignment_step_team__team=self.team,
assignment_task_item=AssignmentTaskItem.objects.first()).status,
settings.ASSIGNMENT_TASK_TEAM_CH_STATUS_DONE)
else:
self.assertTrue(status.is_client_error(response.status_code))
def test_list_invitations(self):
self.client.force_login(self.member)
self.client.post(base_url, {
'email': '*****@*****.**',
'group': self.group.id
})
# not logged in
self.client.logout()
response = self.client.get(base_url)
self.assertTrue(status.is_client_error(response.status_code))
# user not in group
self.client.force_login(self.non_member)
response = self.client.get(base_url)
self.assertEqual(len(response.data), 0)
# user in group
self.client.force_login(self.member)
response = self.client.get(base_url)
self.assertEqual(len(response.data), 1)
# another user in group
self.client.force_login(self.member2)
response = self.client.get(base_url)
self.assertEqual(len(response.data), 1)
def render(self, data, accepted_media_type=None, renderer_context=None):
"""Convert DRF native data to the JSON API v1.0 format."""
# Construct absolute URI for override path or request path (default)
response = renderer_context.get('response')
self.request = renderer_context['request']
self.request_uri = self.request.build_absolute_uri()
override_path = renderer_context.get('override_path')
resource_uri = self.request.build_absolute_uri(override_path)
fields_extra = renderer_context.get('fields_extra')
status_code = response and response.status_code
exception = response and getattr(response, 'exc', None)
is_err = is_client_error(status_code) or is_server_error(status_code)
as_relationship = renderer_context.get('as_relationship')
if data is None:
# Deleted items
converted = None
elif all([key in data for key in self.PAGINATION_KEYS]):
# Paginated object
converted = self.convert_paginated(
data, fields_extra, request_uri=self.request_uri)
elif is_err:
converted = self.convert_error(
data, exception, fields_extra, status_code)
elif self.request.method == 'OPTIONS':
converted = {'meta': data}
elif as_relationship:
relationship_name = as_relationship
if as_relationship not in data:
# Relationship to current resource in a historical viewset
# For example, historicalbrowsers/5/relationships/browser
# In this case, 'as_relationship' is the singular name
# (browser), but the link ID is in 'object_id'.
assert 'object_id' in data, (
'Expecting "%s" or object_id in data keys %s.'
% (as_relationship, list(data.keys())))
assert 'object_id' in fields_extra, (
'Expecting "object_id" in fields_extra.')
assert 'name' in fields_extra['object_id'], (
'Expecting "name" in fields_extra["object_id"].')
object_name = fields_extra['object_id']['name']
assert object_name == as_relationship, (
('Expecting fields_extra["object_id"]["name"] == "%s",'
' got "%s".') % (as_relationship, object_name))
relationship_name = 'object_id'
converted = self.convert_to_relationship_object(
relationship_name, data[relationship_name],
fields_extra[relationship_name],
resource_uri=resource_uri)
else:
converted = self.convert_document(
data, fields_extra, resource_uri=resource_uri,
request_uri=self.request_uri)
renderer_context['indent'] = 4
return super(JsonApiV10Renderer, self).render(
data=converted,
accepted_media_type=accepted_media_type,
renderer_context=renderer_context)
def list(self, request, *args, **kwargs):
"""
Add a few additional fields to this ListView
"""
response = super(WordCountRootViewSet, self).list(request, *args, **kwargs)
if is_client_error(self.status):
return Response(self.message, status=self.status)
query_dict = self.request.GET.copy()
if 'page' in query_dict.keys():
del query_dict['page']
response.data.insert(4, '_simple', reverse('wordcounts-simple-list', request=self.request) + ("?{}".format(query_dict.urlencode()) if query_dict else ''))
response.data.insert(5, '_simple_json', reverse('wordcounts-json-list', request=self.request))
return response
def process_template_response(self, request, response):
"""process_template_response
"""
if self.is_rest_framework_response(response):
if not response.data:
response.data = ReturnDict({}, serializer=Serializer)
#import pdb; pdb.set_trace();
if self.is_dict_of_data(response.data):
if status.is_success(response.status_code):
response.data['status'] = 'ok'
#response.data['status_code'] = response.status_code
#response.data['status_text'] = response.status_text
if status.is_client_error(response.status_code):
response.data['status'] = 'error'
print response.data
return response
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 exception_handler(exc, context):
"""
Django REST handles 4xx exceptions itself, so they don't get logged to the
'django.request' logger by default. This exception handler logs them as if
Django was handling them then calls the default Django REST handler. This
makes the project logging behavior more consistent (both 4xx's and 5xx's
are sent to the 'django.request' logger)
"""
res = default_exception_handler(exc, context)
if res is not None and is_client_error(res.status_code):
request = context['request']
logger.warn(
'%s (params: %s) (data: %s) (response: %s)', request.path,
request.query_params, request.data, res.data,
extra={
'status_code': res.status_code, 'request': request
}
)
return res
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_access_denied_without_token(self): r = self.client.get(reverse(api_root_name)) self.assertTrue(status.is_client_error(r.status_code))
def test_download_csv_Key_DoesnotExist(self):
map_id = 5
result = download_csv(self.request, map_id)
self.assertTrue(status.is_client_error(result.status_code))
def test_map_location_Key_DoesnotExist(self):
map_id = 5
result = map_location(self.request, map_id)
self.assertTrue(status.is_client_error(result.status_code))
