def test_str_response_validation_failed(self):
response = Response("1234")
with self.assertRaises(ValidationError):
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("text/plain"),
ResponseStatusParameter(200, "",
{"text/plain": fields.Email()}))
def test_register_response_serializer(self):
class MyResponseSerializer(ResponseSerializer):
def get_response_data_type(self) -> type:
return str
def get_media_type_strings(self) -> List[str]:
return ["my/type"]
def validate_and_serialize(
self, response_input: Any,
response_status_parameter: Union[None,
ResponseStatusParameter],
can_handle_result: CanHandleResultType
) -> Tuple[bytes, str]:
assert can_handle_result.mime_type.charset == "ascii"
return "".join(reversed(response_input)).encode(
encoding=can_handle_result.mime_type.charset), "my/type"
ResponseSerializerService.register_response_serializer(
MyResponseSerializer())
response = Response("Test")
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("my/type; charset=ascii"))
self.assertEqual(b'tseT', response.content)
def test_bytes_response_body_with_schema(self):
response = Response(b"1234")
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("text/plain"),
ResponseStatusParameter(200, "", {"text/plain": fields.Integer()}))
self.assertEqual(b"1234", response.content)
self.assertEqual("1234", response.text)
self.assertEqual("text/plain", response.headers["Content-Type"])
def test_string_fallback_response_serializer(self):
ResponseSerializerService.register_response_serializer(
StringFallbackResponseSerializer())
response = Response("huhu")
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("wuff/miau"))
self.assertEqual(b'huhu', response.content)
self.assertEqual("text/plain", response._headers["Content-Type"])
def test_dict_fallback_response_serializer(self):
ResponseSerializerService.register_response_serializer(
DictFallbackResponseSerializer())
response = Response({"key": "value"})
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("wuff/miau"))
self.assertEqual(b'{"key": "value"}', response.content)
self.assertEqual("application/json", response._headers["Content-Type"])
def handle_request(self, request_method: str, request: Request, path_params: Dict) -> Response:
method_object = getattr(self, request_method.lower())
request._path_params = self._collect_and_convert_path_parameters(path_params)
self._process_query_parameters(method_object, request)
request = self._validate_request_body(method_object, request)
response: Response = self._execute_request_with_exception_mapping(method_object, request)
if not isinstance(response, Response):
raise Resource.NoResponseReturnException(
f"Resource method {method_object} does not return a response object"
)
response_status_parameter = Resource._find_response_schema_by_status(response.status_code, method_object)
ResponseSerializerService.validate_and_serialize_response_body(
response, request.http_accept_object, response_status_parameter
)
return response
def create_response(self, http_accept: HttpAccept) -> Response:
supported_media_types = [
"text/html", "application/xhtml+xml", "application/json", "application/problem+json"
]
best_match = http_accept.get_best_match(supported_media_types)
if best_match is None:
response = self.create_plain_text_response()
else:
best_match = best_match[0]
if best_match in ["text/html", "application/xhtml+xml"]:
response = self.create_html_response()
else:
response = self.create_rfc7807_json_response()
ResponseSerializerService.validate_and_serialize_response_body(response, http_accept, None)
return response
def test_response_serializer_with_schema(self):
class MySchema(Schema):
field1 = fields.Integer()
field2 = fields.String()
response = Response({
"field1": 1,
"field2": "hello",
"not_expected": "wuff"
})
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("application/json"),
ResponseStatusParameter(200, "", {"application/json": MySchema()}))
self.assertIn('"field1": 1', response.text)
self.assertIn('"field2": "hello"', response.text)
self.assertNotIn("not_expected", response.text)
self.assertIn(b'"field1": 1', response.content)
self.assertIn(b'"field2": "hello"', response.content)
self.assertNotIn(b"not_expected", response.content)
self.assertEqual(200, response.status_code)
self.assertEqual("application/json", response.headers["Content-Type"])
def test_prioritize_media_type(self):
http_accept = HttpAccept(
[MIMEType("application", "json"),
MIMEType("text", "plain", 0.7)])
ResponseSerializerService.clear_all_response_serializer()
ResponseSerializerService.register_response_serializer(
DefaultDictJsonResponseSerializer())
ResponseSerializerService.register_response_serializer(
DefaultDictTextResponseSerializer())
response = Response({"key": "value"})
ResponseSerializerService.validate_and_serialize_response_body(
response, http_accept)
self.assertEqual(b'{"key": "value"}', response.content)
self.assertEqual("application/json", response._headers["Content-Type"])
def test_clear_all_default_serializer(self):
ResponseSerializerService.clear_all_response_serializer()
response = Response("Test")
with self.assertRaises(NotAcceptable):
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("text/plain"))
def test_default_str_to_text(self):
response = Response("Test")
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("text/plain"))
self.assertEqual(b'Test', response.content)
def test_default_dict_to_text(self):
response = Response({"key": "value"})
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("text/plain"))
self.assertEqual(b'{"key": "value"}', response.content)
def test_default_list_to_json(self):
response = Response(["1", 2])
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept([MIMEType("application", "json")]))
self.assertEqual(b'["1", 2]', response.content)
def test_default_dict_to_json(self):
response = Response({"key": "value"})
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept([MIMEType("application", "json")]))
self.assertEqual(b'{"key": "value"}', response.content)
def tearDown(self) -> None:
ResponseSerializerService.restore_default_response_serializer()
def test_response_body_type_not_supported(self):
response = Response(1.0)
with self.assertRaises(Response.ResponseBodyTypeNotSupportedException):
ResponseSerializerService.validate_and_serialize_response_body(
response, HttpAccept.from_accept_string("application/json"))
