def test_decorators(app, client):
content_type = 'application/json'
invalid_content_type = 'text/javascript'
@app.route('/include')
@routing.mimetype(['application/json'])
def mimetype_include_test():
return 'Hello', StatusCode.OK
@app.route('/exclude')
@routing.mimetype([], [invalid_content_type])
def mimetype_exclude_test():
return 'Hello', StatusCode.OK
resp = client.get('/include', content_type=content_type)
assert resp.status_code == StatusCode.OK, resp.data
resp = client.get('/include', content_type=invalid_content_type)
assert resp.status_code == StatusCode.UNSUPPORTED_MEDIA_TYPE, resp.data
assert resp.get_json() == handlers.error_response_json_template(
routing.UnsupportedMediaTypeError(invalid_content_type, [content_type],
[]))
resp = client.get('/exclude', content_type=content_type)
assert resp.status_code == StatusCode.OK, resp.data
resp = client.get('/exclude', content_type=invalid_content_type)
assert resp.status_code == StatusCode.UNSUPPORTED_MEDIA_TYPE, resp.data
assert resp.get_json() == handlers.error_response_json_template(
routing.UnsupportedMediaTypeError(invalid_content_type, [],
[invalid_content_type]))
def test_request_with_all_missing_required_attribute__should_return_error(
self):
data = remove_params(VALID_SUBSCRIBE_DATA, REQUIRED_ATTRS)
resp = self.client.post(POST_URL,
data=data,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
errors.MissingAttributesError(REQUIRED_ATTRS))
resp = self.client.post(POST_URL,
data=INVALID_TOPIC_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
TopicValidationError(
'Predicates shorter than 4 elements must include wildcard as the last element'
))
resp = self.client.post(POST_URL,
data=INVALID_CALLBACK_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
CallbackURLValidationError('URL must contain scheme'))
def test_patch_error(NotificationsRepoMock, MessageLakeRepoMock, client):
invalid_mimetype = "application/x-www-form-urlencoded"
resp = client.patch(PATCH_URL.format(MESSAGE_REFERENCE),
data={},
mimetype=invalid_mimetype)
assert resp.status_code == HTTPStatus.UNSUPPORTED_MEDIA_TYPE
assert resp.content_type == VALID_RESPONSE_MIMETYPE
assert resp.get_json() == error_response_json_template(
UnsupportedMediaTypeError(invalid_mimetype, ['application/json'], []))
resp = client.patch(PATCH_URL.format(MESSAGE_REFERENCE), json={})
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.content_type == VALID_RESPONSE_MIMETYPE
assert resp.get_json() == error_response_json_template(
MessageDataEmptyError())
invalid_status = "Clearly some invalid status"
resp = client.patch(PATCH_URL.format(MESSAGE_REFERENCE),
json={"status": invalid_status})
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.content_type == VALID_RESPONSE_MIMETYPE
assert resp.get_json() == error_response_json_template(
UnexpectedMessageStatusError(invalid_status,
VALID_PATCH_STATUSES + [None]))
message_lake_repo = MessageLakeRepoMock.return_value
message_lake_repo.get.side_effect = NoSuchKey()
resp = client.patch(PATCH_URL.format(MESSAGE_REFERENCE),
json={"status": VALID_PATCH_STATUSES[0]})
message_lake_repo.get.assert_called_once()
assert resp.status_code == HTTPStatus.NOT_FOUND
assert resp.content_type == VALID_RESPONSE_MIMETYPE
assert resp.get_json() == error_response_json_template(
MessageNotFoundError(MESSAGE_REFERENCE))
# testing random exception from use case
message_lake_repo.reset_mock()
message_lake_repo.get.side_effect = None
with mock.patch(PATCH_MESSAGE_METADATA_USE_CASE) as UseCase:
uc = UseCase.return_value
uc.execute.side_effect = RandomException()
resp = client.patch(PATCH_URL.format(MESSAGE_REFERENCE),
json={"status": VALID_PATCH_STATUSES[0]})
assert resp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert resp.content_type == VALID_RESPONSE_MIMETYPE
assert resp.get_json() == error_response_json_template(
InternalServerError(uc.execute.side_effect))
uc.execute.assert_called_once()
def _test_post_message_received_empty_body(client, url=POST_URL):
resp = client.post(url, mimetype=VALID_REQUEST_MIMETYPE)
assert resp.mimetype == VALID_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.get_json() == error_response_json_template(
MessageDataEmptyError())
resp = client.post(url, json={})
assert resp.mimetype == VALID_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.get_json() == error_response_json_template(
MessageDataEmptyError())
def test_post_error(client):
# just to prevent creation of the actual repo
with mock.patch(BC_INBOX_REPO) as RepoMock:
_test_post_message_received_unsupported_mimetype(client, url=POST_URL)
_test_post_message_received_empty_body(client, url=POST_URL)
_test_post_message_missing_required_attr(client, VALID_MESSAGE_DATA_DICT, url=POST_URL)
_test_post_message_validation_failed(
Message,
MESSAGE_CLASS,
client,
VALID_MESSAGE_DATA_DICT,
url=POST_URL
)
with mock.patch(BC_INBOX_REPO) as RepoMock:
# Repo exceptions may contain sensitive info.
# Maybe their str should not be passed as message
# and logged internally instead
# testing random repo specific exception response
post = RepoMock.return_value.post
post.side_effect = Exception('Repo Specific Exception')
resp = client.post(POST_URL, json=VALID_MESSAGE_DATA_DICT)
post.assert_called_once()
assert resp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert resp.content_type == VALID_RESPONSE_MIMETYPE
assert resp.get_json() == error_response_json_template(
InternalServerError(post.side_effect)
)
# testing expected repo inablity to post message
# when post returns None
post.reset_mock()
post.return_value = None
post.side_effect = None
resp = client.post(POST_URL, json=VALID_MESSAGE_DATA_DICT)
post.assert_called_once()
assert resp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert resp.content_type == VALID_RESPONSE_MIMETYPE
assert resp.get_json() == error_response_json_template(
UnableWriteToInboxError()
)
def _test_post_message_received_unsupported_mimetype(client, url=POST_URL):
resp = client.post(url, mimetype=INVALID_REQUEST_MIMETYPE, data={})
assert resp.mimetype == VALID_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.UNSUPPORTED_MEDIA_TYPE
assert resp.get_json() == error_response_json_template(
UnsupportedMediaTypeError(INVALID_REQUEST_MIMETYPE,
[VALID_REQUEST_MIMETYPE], []))
def _test_post_message_validation_failed(
message_class,
message_class_path,
client,
valid_data,
url=POST_URL,
api=""
):
# it's pretty much impossible yet to get around from_dict validation without mocking
require_allowed = ["sender_ref"] if api == "rx" else []
message = message_class.from_dict(valid_data, require_allowed=require_allowed)
message.kwargs['spurious_attr'] = 'Something suspicious'
remove_message_params(message.kwargs, keys=message_class.required_attrs, copy_data=False, set_none=True)
with mock.patch(message_class_path + '.from_dict') as from_dict:
from_dict.return_value = message
resp = client.post(url, json=valid_data)
from_dict.assert_called_once()
assert resp.mimetype == VALID_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.get_json() == error_response_json_template(
MessageValidationError(
source=[
'spurious attr: spurious_attr',
'sender is not a jurisdiction: None',
'receiver is not a jurisdiction: None',
'subject is empty',
'obj is not a URI: None',
'predicate is not a URI: None'
]
)
)
def test_request__with_unknown_mode_error__should_return_error(self):
resp = self.client.post(POST_URL,
data=INVALID_MODE_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
UnknownModeError(INVALID_MODE_DATA[MODE_ATTR_KEY]))
def test_request__when_subscription_not_found__should_return_error(self):
resp = self.client.post(POST_URL,
data=VALID_UNSUBSCRIBE_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.NOT_FOUND, resp.data
assert resp.get_json() == error_response_json_template(
SubscriptionNotFoundError())
def test_request_with_one_missing_required_attribute__should_return_error(
self):
for key in REQUIRED_ATTRS:
data = remove_params(VALID_SUBSCRIBE_DATA, keys=[key])
resp = self.client.post(POST_URL,
data=data,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
errors.MissingAttributesError([key]))
def _test_post_message_missing_required_attr(client, valid_data, url=POST_URL):
for key in Message.required_attrs:
data = remove_message_params(valid_data, keys=[key])
resp = client.post(url, json=data)
assert resp.mimetype == VALID_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.get_json() == error_response_json_template(
MessageDeserializationError(source=['\'{}\''.format(key)]))
def test_request_with_wrong_mime_type__should_return_error(self):
# forcing correct mimetype
for content_type in INVALID_CONTENT_TYPES:
resp = self.client.post(POST_URL,
data=VALID_SUBSCRIBE_DATA,
content_type=content_type)
assert resp.status_code == StatusCode.UNSUPPORTED_MEDIA_TYPE, resp.data
assert resp.get_json() == error_response_json_template(
routing.UnsupportedMediaTypeError(content_type,
[VALID_REQUEST_CONTENT_TYPE],
[]))
def test_get_error(RepoMock, client):
instance = RepoMock.return_value
instance.get.side_effect = NoSuchKey()
resp = client.get(GET_URL.format(MESSAGE_REFERENCE))
instance.get.assert_called_once()
assert resp.mimetype == VALID_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.NOT_FOUND
assert resp.get_json() == error_response_json_template(
MessageNotFoundError(MESSAGE_REFERENCE))
instance.get.reset_mock()
instance.get.side_effect = RandomException()
resp = client.get(GET_URL.format(MESSAGE_REFERENCE))
instance.get.assert_called_once()
assert resp.mimetype == VALID_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert resp.get_json() == error_response_json_template(
InternalServerError(instance.get.side_effect))
def test_post_error(RepoMock, client):
repo = RepoMock.return_value
post = repo.post
delete = repo.delete
# forcing correct mimetype
for content_type in INVALID_CONTENT_TYPES:
resp = client.post(POST_URL,
data=VALID_SUBSCRIBE_DATA,
content_type=content_type)
assert resp.status_code == StatusCode.UNSUPPORTED_MEDIA_TYPE, resp.data
assert resp.get_json() == error_response_json_template(
routing.UnsupportedMediaTypeError(content_type,
[VALID_REQUEST_CONTENT_TYPE],
[]))
# checks missing single required attr
for key in REQUIRED_ATTRS:
data = remove_params(VALID_SUBSCRIBE_DATA, keys=[key])
resp = client.post(POST_URL,
data=data,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
errors.MissingAttributesError([key]))
# checks missing multiply required attrs, must return all missing
data = remove_params(VALID_SUBSCRIBE_DATA, REQUIRED_ATTRS)
resp = client.post(POST_URL,
data=data,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
errors.MissingAttributesError(REQUIRED_ATTRS))
resp = client.post(POST_URL,
data=INVALID_TOPIC_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
TopicValidationError(
'Predicates shorter than 4 elements must include wildcard as the last element'
))
resp = client.post(POST_URL,
data=INVALID_CALLBACK_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
CallbackURLValidationError('URL must contain scheme'))
# checks unknown mode error, if mode is not in [subscribe, unsubscribe]
resp = client.post(POST_URL,
data=INVALID_MODE_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
UnknownModeError(INVALID_MODE_DATA[MODE_ATTR_KEY]))
# checks subscription exists error
resp = client.post(POST_URL,
data=VALID_SUBSCRIBE_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
# let's support both conflict and fine, need to think about it more
assert resp.status_code in (StatusCode.CONFLICT,
StatusCode.ACCEPTED), resp.data
# assert resp.get_json() == error_response_json_template(
# SubscriptionExistsError()
# )
# checks unable to post error
repo.reset_mock()
post.return_value = None
resp = client.post(POST_URL,
data=VALID_SUBSCRIBE_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
post.assert_called_once()
assert resp.status_code == StatusCode.INTERNAL_SERVER_ERROR, resp.data
assert resp.get_json() == error_response_json_template(
UnableToPostSubscriptionError())
# checks subscription not found error
repo.reset_mock()
delete.return_value = False
resp = client.post(POST_URL,
data=VALID_UNSUBSCRIBE_DATA,
content_type=VALID_REQUEST_CONTENT_TYPE)
delete.assert_called_once()
assert resp.status_code == StatusCode.NOT_FOUND, resp.data
assert resp.get_json() == error_response_json_template(
SubscriptionNotFoundError())
def test_post_document_errors(ObjectLakeRepoMock, ObjectACLRepoMock, client):
resp = client.post(
INVALID_POST_REQUEST_COUNTRY_URL,
mimetype=INVALID_POST_REQUEST_MIMETYPE,
data={}
)
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.UNSUPPORTED_MEDIA_TYPE
assert resp.get_json() == error_response_json_template(
UnsupportedMediaTypeError(
INVALID_POST_REQUEST_MIMETYPE,
[VALID_POST_REQUEST_MIMETYPE],
[]
)
)
try:
Country(INVALID_COUNTRY_NAME)
except Exception as e:
country_exception = e
resp = client.post(
INVALID_POST_REQUEST_COUNTRY_URL,
mimetype=VALID_POST_REQUEST_MIMETYPE,
data={}
)
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.get_json() == error_response_json_template(
BadCountryNameError(country_exception)
)
resp = client.post(
VALID_POST_REQUEST_COUNTRY_URL,
mimetype=VALID_POST_REQUEST_MIMETYPE,
data={}
)
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.get_json() == error_response_json_template(
NoInputFileError()
)
resp = client.post(
VALID_POST_REQUEST_COUNTRY_URL,
mimetype=VALID_POST_REQUEST_MIMETYPE,
data=get_too_many_post_request_files()
)
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.BAD_REQUEST
assert resp.get_json() == error_response_json_template(
TooManyFilesError(2)
)
allow_access_to = ObjectACLRepoMock.return_value.allow_access_to
post_from_file_obj = ObjectLakeRepoMock.return_value.post_from_file_obj
allow_access_to.side_effect = Exception('Very bad thing: ACL')
post_from_file_obj.side_effect = Exception('Very bad thing: Lake')
resp = client.post(
VALID_POST_REQUEST_COUNTRY_URL,
mimetype=VALID_POST_REQUEST_MIMETYPE,
data=get_valid_post_request_files()
)
allow_access_to.assert_called_once()
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert resp.get_json() == error_response_json_template(
InternalServerError(allow_access_to.side_effect)
)
allow_access_to.reset_mock()
allow_access_to.side_effect = None
resp = client.post(
VALID_POST_REQUEST_COUNTRY_URL,
mimetype=VALID_POST_REQUEST_MIMETYPE,
data=get_valid_post_request_files()
)
allow_access_to.assert_called_once()
post_from_file_obj.assert_called_once()
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE
assert resp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert resp.get_json() == error_response_json_template(
InternalServerError(post_from_file_obj.side_effect)
)
def test_get_document_errors(ObjectLakeRepoMock, ObjectACLRepoMock, client):
# # testing unauthorized
# resp = client.get(DOCUMENT_GET_URL.format(VALID_DOCUMENT_URI))
# assert resp.status_code == HTTPStatus.UNAUTHORIZED
# testing invalid URI error
resp = client.get(
DOCUMENT_GET_URL.format(INVALID_DOCUMENT_URI),
headers=VALID_AUTH_HEADERS
)
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE, resp.data
assert resp.status_code == HTTPStatus.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
InvalidURIError()
)
# testing invalid country auth headers
try:
Country(INVALID_COUNTRY_NAME)
except Exception as e:
country_exception = e
resp = client.get(
DOCUMENT_GET_URL.format(VALID_DOCUMENT_URI),
headers=INVALID_AUTH_HEADERS
)
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE, resp.data
assert resp.status_code == HTTPStatus.BAD_REQUEST, resp.data
assert resp.get_json() == error_response_json_template(
BadCountryNameError(country_exception)
)
search = ObjectACLRepoMock.return_value.search
get_body = ObjectLakeRepoMock.return_value.get_body
# testing not authenticated user
search.return_value = []
resp = client.get(
DOCUMENT_GET_URL.format(VALID_DOCUMENT_URI),
headers=VALID_AUTH_HEADERS
)
search.assert_called_once()
get_body.assert_not_called()
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE, resp.data
assert resp.status_code == HTTPStatus.NOT_FOUND, resp.data
assert resp.get_json() == error_response_json_template(
DocumentNotFoundError(
VALID_DOCUMENT_URI,
Country(VALID_COUNTRY_NAME)
)
)
# testing unexpected acl repo error
search.reset_mock()
get_body.reset_mock()
search.side_effect = Exception('Very bad times indeed')
resp = client.get(
DOCUMENT_GET_URL.format(VALID_DOCUMENT_URI),
headers=VALID_AUTH_HEADERS
)
search.assert_called_once()
get_body.assert_not_called()
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE, resp.data
assert resp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR, resp.data
assert resp.get_json() == error_response_json_template(
InternalServerError(search.side_effect)
)
# testing expected lake repo error
class NoSuchKey(Exception):
pass
search.reset_mock()
get_body.reset_mock()
search.side_effect = None
search.return_value = [Country(VALID_COUNTRY_NAME)]
get_body.side_effect = NoSuchKey
resp = client.get(
DOCUMENT_GET_URL.format(VALID_DOCUMENT_URI),
headers=VALID_AUTH_HEADERS
)
search.assert_called_once()
get_body.assert_called_once()
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE, resp.data
assert resp.status_code == HTTPStatus.NOT_FOUND, resp.data
assert resp.get_json() == error_response_json_template(
DocumentNotFoundError(
VALID_DOCUMENT_URI,
Country(VALID_COUNTRY_NAME)
)
)
# testing get_body return None
# Can it even happen? Or we should consider NoSuchKey
# error to be only way to get None as a result
# of the use case?
search.reset_mock()
get_body.reset_mock()
search.return_value = [Country(VALID_COUNTRY_NAME)]
get_body.side_effect = None
get_body.return_value = None
resp = client.get(
DOCUMENT_GET_URL.format(VALID_DOCUMENT_URI),
headers=VALID_AUTH_HEADERS
)
search.assert_called_once()
get_body.assert_called_once()
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE, resp.data
assert resp.status_code == HTTPStatus.NOT_FOUND, resp.data
assert resp.get_json() == error_response_json_template(
DocumentNotFoundError(
VALID_DOCUMENT_URI,
Country(VALID_COUNTRY_NAME)
)
)
# testing unexpected lake repo error
search.reset_mock()
get_body.reset_mock()
search.return_value = [Country(VALID_COUNTRY_NAME)]
get_body.side_effect = Exception('Bad times came')
resp = client.get(
DOCUMENT_GET_URL.format(VALID_DOCUMENT_URI),
headers=VALID_AUTH_HEADERS
)
search.assert_called_once()
get_body.assert_called_once()
assert resp.mimetype == VALID_ERROR_RESPONSE_MIMETYPE, resp.data
assert resp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR, resp.data
assert resp.get_json() == error_response_json_template(
InternalServerError(get_body.side_effect)
)
def test_error_handlers(app, client):
generic_http_use_case_error_instance = CustomUseCaseError(
generic_http_error=True)
use_case_error_instance = CustomUseCaseError()
custom_error_instance = ValidationError()
generic_http_error_instance = exceptions.NotFound()
internal_server_error_exception_instance = Exception('Error')
errors_list_instance = ErrorsList(custom_error_instance,
custom_error_instance)
@app.route('/post-method', methods=['POST'])
def post_method():
return 'Hello'
@app.route('/errors-list')
def errors_list():
raise errors_list_instance
@app.route('/generic-http-error')
def generic_http_error():
raise generic_http_error_instance
@app.route('/internal-server-error')
def internal_server_error():
raise internal_server_error_exception_instance
@app.route('/custom-error')
def custom_error():
raise custom_error_instance
@app.route('/use-case-error')
def use_case_error():
raise use_case_error_instance
@app.route('/generic-http-use-case-error')
def generic_http_use_case_error():
raise generic_http_use_case_error_instance
# testing flask defaul error wrapping
resp = client.get('/post-method')
assert resp.status_code == StatusCode.METHOD_NOT_ALLOWED, resp.data
assert resp.get_json() == handlers.error_response_json_template(
GenericHTTPError(StatusCode.METHOD_NOT_ALLOWED))
# testing werkzeug error thrown manually
resp = client.get('/generic-http-error')
assert resp.status_code == StatusCode.NOT_FOUND, resp.data
assert resp.get_json() == handlers.error_response_json_template(
GenericHTTPError(generic_http_error_instance))
# testing internal exception error
resp = client.get('/internal-server-error')
assert resp.status_code == StatusCode.INTERNAL_SERVER_ERROR, resp.data
assert resp.get_json() == handlers.error_response_json_template(
InternalServerError(internal_server_error_exception_instance))
# testing custom error
resp = client.get('/custom-error')
assert resp.status_code == custom_error_instance.status_code, resp.data
assert resp.get_json() == handlers.error_response_json_template(
custom_error_instance)
# testing several errors response
resp = client.get('/errors-list')
assert resp.status_code == StatusCode.BAD_REQUEST, resp.data
assert resp.get_json() == handlers.error_response_json_template(
*errors_list_instance.errors)
# testing use case error
resp = client.get('/use-case-error')
assert resp.status_code == use_case_error_instance.status, resp.data
assert resp.get_json() == handlers.error_response_json_template(
UseCaseError(use_case_error_instance))
# testing use case
resp = client.get('/generic-http-use-case-error')
assert resp.status_code == generic_http_use_case_error_instance.status, resp.data
assert resp.get_json() == handlers.error_response_json_template(
GenericHTTPError(generic_http_use_case_error_instance.status,
detail=generic_http_use_case_error_instance.detail,
source=generic_http_use_case_error_instance.source))
