def test_ok(self):
with patch("gobstuf.rest.brp.rest_response.request", mock_request):
result = RESTResponse.ok(any_data)
response = json.loads(result['response'])
self.assertEqual(result['content_type'], 'application/hal+json')
self.assertEqual(result['status'], 200)
self.assertEqual(response, RESTResponse._hal(any_data))
def test_client_error_response(self):
with patch("gobstuf.rest.brp.rest_response.request", mock_request):
result = RESTResponse._client_error_response(data=any_data,
status=400)
response = json.loads(result['response'])
# Check if all required attributes are present in the response
for attr in [
'type', 'title', 'status', 'detail', 'instance', 'code'
]:
self.assertTrue(attr in response)
# Check if the type is correctly build
self.assertEqual(
response['type'],
"https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1 400 Bad Request"
)
self.assertEqual(response['status'], 400)
self.assertEqual(response['instance'], mock_request.url)
# Check override of default fields
result = RESTResponse._client_error_response(data=any_data,
status=400,
title='any title',
any='other')
response = json.loads(result['response'])
self.assertEqual(response['title'], 'any title')
self.assertEqual(response['any'], 'other')
def test_json_response(self):
with patch("gobstuf.rest.brp.rest_response.request", mock_request):
# Return the data as a JSON string response
result = RESTResponse._json_response(any_data)
self.assertEqual(result['response'], json.dumps(any_data))
# Include any other arguments in the Response
result = RESTResponse._json_response(any_data, aap="noot")
self.assertEqual(result['aap'], "noot")
def _build_response(self, response_obj: StufMappedResponse, **kwargs):
"""Return single object response by default
Overridden by StufRestFilterView to create a list of objects
:param response_obj:
:param kwargs:
:return:
"""
try:
data = response_obj.get_answer_object()
except NoStufAnswerException:
# Return 404, answer section is empty
return RESTResponse.not_found(detail=self.get_not_found_message(
**kwargs))
else:
return RESTResponse.ok(data)
def get(self, **kwargs):
try:
errors = self._validate(**kwargs)
except StufRestFilterView.InvalidQueryParametersException as e:
errors = e.err
assert getattr(self, '_validate_called', False), \
f"Make sure to call super()._validate() from children of {self.__class__}"
if errors:
return RESTResponse.bad_request(**errors)
try:
return self._get(**kwargs)
except Exception:
logging.error("ERROR: Request failed:")
logging.error(traceback.format_exc())
return RESTResponse.internal_server_error()
def test_hal(self):
with patch("gobstuf.rest.brp.rest_response.request", mock_request):
hal = RESTResponse._hal(any_data)
self.assertEqual(hal, {
'_links': {
'self': {
'href': 'any url'
}
},
'any': 'data'
})
def _error_response(self, response_obj: StufErrorResponse):
"""Builds the error response based on the error response received from MKS
:param response_obj:
:return:
"""
logging.error(f"MKS Error. "
f"Code {response_obj.get_error_code()}. "
f"Plek: {response_obj.get_error_plek()}. "
f"Omschrijving: {response_obj.get_error_omschrijving()} "
f"Berichtcode: {response_obj.get_berichtcode()}")
try:
return response_obj.get_http_response()
except UnknownErrorCode:
return RESTResponse.bad_request()
def _build_response(self, response_obj: StufMappedResponse, **kwargs):
"""Returns the REST response, of the format:
_embedded: {
ingeschrevenpersonen: [
{ response object 1},
{ response object 2},
{ ... },
]
}
:param response_obj:
:param kwargs:
:return:
"""
data = response_obj.get_all_answer_objects()
return RESTResponse.ok({'_embedded': {
self.name: data,
}}, {})
def test_not_found(self):
with patch("gobstuf.rest.brp.rest_response.request", mock_request):
result = RESTResponse.not_found()
self.assertEqual(result['status'], 404)
def test_forbidden(self):
with patch("gobstuf.rest.brp.rest_response.request", mock_request):
result = RESTResponse.forbidden()
self.assertEqual(result['status'], 403)
def test_bad_request(self):
with patch("gobstuf.rest.brp.rest_response.request", mock_request):
result = RESTResponse.bad_request()
self.assertEqual(result['status'], 400)
def test_internal_server_error(self):
with patch("gobstuf.rest.brp.rest_response.request", mock_request):
result = RESTResponse.internal_server_error()
self.assertEqual(result['status'], 500)
def get_http_response(self):
"""Returns HTTP response object for given MKS code.
:return:
"""
if self.get_berichtcode() != 'Fo02':
raise UnknownErrorCode()
responses = {
# De stuurgegevens zijn onjuist gevuld
'StUF001': RESTResponse.bad_request(),
# Het interactieve proces voor het afhandelen van een synchrone vraag is niet actief
'StUF002': RESTResponse.internal_server_error(),
# De gevraagde gegevens zijn niet beschikbaar
'StUF003': RESTResponse.not_found(),
# De gevraagde sortering wordt niet ondersteund
'StUF004': RESTResponse.internal_server_error(),
# Er heeft zich in de StUF-communicatie een time-out voorgedaan
'StUF005': RESTResponse.internal_server_error(),
# Het vraagbericht bevat als selectiecriterium zowel de sleutel in het vragende systeem als het ontvangende
# systeem,
'StUF006': RESTResponse.internal_server_error(),
# Het ontvangende systeem ondersteunt niet het bevraagd worden op sleutel in het vragende systeem
'StUF007': RESTResponse.internal_server_error(),
# De beantwoording van het vraagbericht vergt meer systeemresources dan het antwoordende systeem
# beschikbaar heeft
'StUF008': RESTResponse.internal_server_error(),
# Het vraagbericht is gericht aan een niet bekend systeem
'StUF009': RESTResponse.internal_server_error(),
# Het vragende systeem is niet geautoriseerd voor de gevraagde gegevens
'StUF010': RESTResponse.forbidden(),
# De syntax van het StUF-vraagbericht is onjuist
'StUF011': RESTResponse.internal_server_error(),
# Het ontvangende systeem ondersteunt niet de afhandeling van asynchrone vraagberichten
'StUF012': RESTResponse.internal_server_error(),
# Het vragende systeem is bij het ontvangende systeem niet bekend
'StUF013': RESTResponse.internal_server_error(),
# Het zendende systeem is niet geautoriseerd voor de gevraagde combinatie van berichtcode,
# entiteittype en functie
'StUF052': RESTResponse.forbidden(),
}
try:
return responses[self.get_error_code()]
except KeyError:
raise UnknownErrorCode()