Request binary format support

Author: p1c2u

Diff for: openapi_core/contrib/aiohttp/requests.py

@@ -19,7 +19,7 @@ class Empty:
 class AIOHTTPOpenAPIWebRequest:
     __slots__ = ("request", "parameters", "_get_body", "_body")
 
-    def __init__(self, request: web.Request, *, body: str | None):
+    def __init__(self, request: web.Request, *, body: bytes | None):
         if not isinstance(request, web.Request):
             raise TypeError(
                 f"'request' argument is not type of {web.Request.__qualname__!r}"
@@ -45,7 +45,7 @@ def method(self) -> str:
         return self.request.method.lower()
 
     @property
-    def body(self) -> str | None:
+    def body(self) -> bytes | None:
         return self._body
 
     @property

Diff for: openapi_core/contrib/django/requests.py

@@ -76,9 +76,9 @@ def method(self) -> str:
         return self.request.method.lower()
 
     @property
-    def body(self) -> str:
+    def body(self) -> bytes:
         assert isinstance(self.request.body, bytes)
-        return self.request.body.decode("utf-8")
+        return self.request.body
 
     @property
     def content_type(self) -> str:

Diff for: openapi_core/contrib/falcon/requests.py

@@ -49,13 +49,14 @@ def method(self) -> str:
         return self.request.method.lower()
 
     @property
-    def body(self) -> Optional[str]:
+    def body(self) -> Optional[bytes]:
+        # Falcon doesn't store raw request stream.
+        # That's why we need to revert deserialized data
+
         # Support falcon-jsonify.
         if hasattr(self.request, "json"):
-            return dumps(self.request.json)
+            return dumps(self.request.json).encode("utf-8")
 
-        # Falcon doesn't store raw request stream.
-        # That's why we need to revert serialized data
         media = self.request.get_media(
             default_when_empty=self.default_when_empty,
         )
@@ -74,7 +75,7 @@ def body(self) -> Optional[str]:
             return None
         else:
             assert isinstance(body, bytes)
-            return body.decode("utf-8")
+            return body
 
     @property
     def content_type(self) -> str:

Diff for: openapi_core/contrib/requests/requests.py

@@ -64,14 +64,14 @@ def method(self) -> str:
         return method and method.lower() or ""
 
     @property
-    def body(self) -> Optional[str]:
+    def body(self) -> Optional[bytes]:
         if self.request.body is None:
             return None
         if isinstance(self.request.body, bytes):
-            return self.request.body.decode("utf-8")
+            return self.request.body
         assert isinstance(self.request.body, str)
         # TODO: figure out if request._body_position is relevant
-        return self.request.body
+        return self.request.body.encode("utf-8")
 
     @property
     def content_type(self) -> str:

Diff for: openapi_core/contrib/starlette/requests.py

@@ -34,14 +34,14 @@ def method(self) -> str:
         return self.request.method.lower()
 
     @property
-    def body(self) -> Optional[str]:
+    def body(self) -> Optional[bytes]:
         body = self._get_body()
         if body is None:
             return None
         if isinstance(body, bytes):
-            return body.decode("utf-8")
+            return body
         assert isinstance(body, str)
-        return body
+        return body.encode("utf-8")
 
     @property
     def content_type(self) -> str:

Diff for: openapi_core/contrib/werkzeug/requests.py

@@ -39,8 +39,8 @@ def method(self) -> str:
         return self.request.method.lower()
 
     @property
-    def body(self) -> Optional[str]:
-        return self.request.get_data(as_text=True)
+    def body(self) -> Optional[bytes]:
+        return self.request.get_data(as_text=False)
 
     @property
     def content_type(self) -> str:

Diff for: openapi_core/deserializing/media_types/datatypes.py

@@ -2,5 +2,5 @@
 from typing import Callable
 from typing import Dict
 
-DeserializerCallable = Callable[[Any], Any]
+DeserializerCallable = Callable[[bytes], Any]
 MediaTypeDeserializersDict = Dict[str, DeserializerCallable]

Diff for: openapi_core/deserializing/media_types/deserializers.py

@@ -41,7 +41,9 @@ def __init__(
             extra_media_type_deserializers = {}
         self.extra_media_type_deserializers = extra_media_type_deserializers
 
-    def deserialize(self, mimetype: str, value: Any, **parameters: str) -> Any:
+    def deserialize(
+        self, mimetype: str, value: bytes, **parameters: str
+    ) -> Any:
         deserializer_callable = self.get_deserializer_callable(mimetype)
 
         try:
@@ -75,7 +77,7 @@ def __init__(
         self.encoding = encoding
         self.parameters = parameters
 
-    def deserialize(self, value: Any) -> Any:
+    def deserialize(self, value: bytes) -> Any:
         deserialized = self.media_types_deserializer.deserialize(
             self.mimetype, value, **self.parameters
         )
@@ -192,5 +194,4 @@ def decode_property_content_type(
                 value = location.getlist(prop_name)
                 return list(map(prop_deserializer.deserialize, value))
 
-        value = location[prop_name]
-        return prop_deserializer.deserialize(value)
+        return prop_deserializer.deserialize(location[prop_name])

Diff for: openapi_core/deserializing/media_types/exceptions.py

@@ -8,9 +8,9 @@ class MediaTypeDeserializeError(DeserializeError):
     """Media type deserialize operation error"""
 
     mimetype: str
-    value: str
+    value: bytes
 
     def __str__(self) -> str:
         return (
             "Failed to deserialize value with {mimetype} mimetype: {value}"
-        ).format(value=self.value, mimetype=self.mimetype)
+        ).format(value=self.value.decode("utf-8"), mimetype=self.mimetype)

Diff for: openapi_core/deserializing/media_types/util.py

@@ -10,16 +10,11 @@
 from werkzeug.datastructures import ImmutableMultiDict
 
 
-def binary_loads(value: Union[str, bytes], **parameters: str) -> bytes:
-    charset = "utf-8"
-    if "charset" in parameters:
-        charset = parameters["charset"]
-    if isinstance(value, str):
-        return value.encode(charset)
+def binary_loads(value: bytes, **parameters: str) -> bytes:
     return value
 
 
-def plain_loads(value: Union[str, bytes], **parameters: str) -> str:
+def plain_loads(value: bytes, **parameters: str) -> str:
     charset = "utf-8"
     if "charset" in parameters:
         charset = parameters["charset"]
@@ -32,30 +27,36 @@ def plain_loads(value: Union[str, bytes], **parameters: str) -> str:
     return value
 
 
-def json_loads(value: Union[str, bytes], **parameters: str) -> Any:
+def json_loads(value: bytes, **parameters: str) -> Any:
     return loads(value)
 
 
-def xml_loads(value: Union[str, bytes], **parameters: str) -> Element:
-    return fromstring(value)
+def xml_loads(value: bytes, **parameters: str) -> Element:
+    charset = "utf-8"
+    if "charset" in parameters:
+        charset = parameters["charset"]
+    return fromstring(value.decode(charset))
 
 
-def urlencoded_form_loads(value: Any, **parameters: str) -> Mapping[str, Any]:
-    return ImmutableMultiDict(parse_qsl(value))
+def urlencoded_form_loads(
+    value: bytes, **parameters: str
+) -> Mapping[str, Any]:
+    # only UTF-8 is conforming
+    return ImmutableMultiDict(parse_qsl(value.decode("utf-8")))
 
 
-def data_form_loads(
-    value: Union[str, bytes], **parameters: str
-) -> Mapping[str, Any]:
-    if isinstance(value, bytes):
-        value = value.decode("ASCII", errors="surrogateescape")
+def data_form_loads(value: bytes, **parameters: str) -> Mapping[str, Any]:
+    charset = "ASCII"
+    if "charset" in parameters:
+        charset = parameters["charset"]
+    decoded = value.decode(charset, errors="surrogateescape")
     boundary = ""
     if "boundary" in parameters:
         boundary = parameters["boundary"]
     parser = Parser()
     mimetype = "multipart/form-data"
     header = f'Content-Type: {mimetype}; boundary="{boundary}"'
-    text = "\n\n".join([header, value])
+    text = "\n\n".join([header, decoded])
     parts = parser.parsestr(text, headersonly=False)
     return ImmutableMultiDict(
         [

Diff for: openapi_core/protocols.py

@@ -17,7 +17,7 @@ def method(self) -> str:
         ...
 
     @property
-    def body(self) -> Optional[str]:
+    def body(self) -> Optional[bytes]:
         ...
 
     @property

Diff for: openapi_core/testing/requests.py

@@ -20,7 +20,7 @@ def __init__(
         view_args: Optional[Dict[str, Any]] = None,
         headers: Optional[Dict[str, Any]] = None,
         cookies: Optional[Dict[str, Any]] = None,
-        data: Optional[str] = None,
+        data: Optional[bytes] = None,
         content_type: str = "application/json",
     ):
         self.host_url = host_url

Diff for: openapi_core/validation/request/validators.py

@@ -248,7 +248,7 @@ def _get_security_value(
 
     @ValidationErrorWrapper(RequestBodyValidationError, InvalidRequestBody)
     def _get_body(
-        self, body: Optional[str], mimetype: str, operation: SchemaPath
+        self, body: Optional[bytes], mimetype: str, operation: SchemaPath
     ) -> Any:
         if "requestBody" not in operation:
             return None
@@ -262,8 +262,8 @@ def _get_body(
         return value
 
     def _get_body_value(
-        self, body: Optional[str], request_body: SchemaPath
-    ) -> Any:
+        self, body: Optional[bytes], request_body: SchemaPath
+    ) -> bytes:
         if not body:
             if request_body.getkey("required", False):
                 raise MissingRequiredRequestBody

Diff for: openapi_core/validation/validators.py

@@ -106,7 +106,7 @@ def _deserialise_media_type(
         media_type: SchemaPath,
         mimetype: str,
         parameters: Mapping[str, str],
-        value: Any,
+        value: bytes,
     ) -> Any:
         schema = media_type.get("schema")
         encoding = None
@@ -222,7 +222,7 @@ def _get_complex_param_or_header(
 
     def _get_content_schema_value_and_schema(
         self,
-        raw: Any,
+        raw: bytes,
         content: SchemaPath,
         mimetype: Optional[str] = None,
     ) -> Tuple[Any, Optional[SchemaPath]]:
@@ -246,7 +246,7 @@ def _get_content_schema_value_and_schema(
         return casted, schema
 
     def _get_content_and_schema(
-        self, raw: Any, content: SchemaPath, mimetype: Optional[str] = None
+        self, raw: bytes, content: SchemaPath, mimetype: Optional[str] = None
     ) -> Tuple[Any, Optional[SchemaPath]]:
         casted, schema = self._get_content_schema_value_and_schema(
             raw, content, mimetype

Diff for: tests/integration/contrib/django/data/v3.0/djangoproject/pets/views.py

@@ -110,7 +110,7 @@ def get(self, request, petId):
         )
         return django_response
 
-    def post(self, request):
+    def post(self, request, petId):
         assert request.openapi
         assert not request.openapi.errors
 

Diff for: tests/integration/contrib/django/test_django_project.py

@@ -412,10 +412,6 @@ def test_get_valid(self, client, data_gif):
         assert response.status_code == 200
         assert b"".join(list(response.streaming_content)) == data_gif
 
-    @pytest.mark.xfail(
-        reason="request binary format not supported",
-        strict=True,
-    )
     def test_post_valid(self, client, data_gif):
         client.cookies.load({"user": 1})
         content_type = "image/gif"
@@ -425,7 +421,7 @@ def test_post_valid(self, client, data_gif):
             "HTTP_API_KEY": self.api_key_encoded,
         }
         response = client.post(
-            "/v1/pets/12/photo", data_gif, content_type, secure=True, **headers
+            "/v1/pets/12/photo", data_gif, content_type, **headers
         )
 
         assert response.status_code == 201

Diff for: tests/integration/contrib/falcon/test_falcon_project.py

@@ -393,24 +393,23 @@ def test_get_valid(self, client, data_gif):
         assert response.status_code == 200
 
     @pytest.mark.xfail(
-        reason="request binary format not supported",
+        reason="falcon request binary handler not implemented",
         strict=True,
     )
-    def test_post_valid(self, client, data_json):
+    def test_post_valid(self, client, data_gif):
         cookies = {"user": 1}
-        content_type = "image/gif"
+        content_type = "image/jpeg"
         headers = {
             "Authorization": "Basic testuser",
             "Api-Key": self.api_key_encoded,
             "Content-Type": content_type,
         }
-        body = dumps(data_json)
 
         response = client.simulate_post(
             "/v1/pets/1/photo",
             host="petstore.swagger.io",
             headers=headers,
-            body=body,
+            body=data_gif,
             cookies=cookies,
         )
 

Diff for: tests/integration/contrib/flask/data/v3.0/flaskproject/pets/views.py

@@ -1,6 +1,8 @@
 from base64 import b64decode
 from io import BytesIO
 
+from flask import Response
+from flask import request
 from flask.helpers import send_file
 
 from openapi_core.contrib.flask.views import FlaskOpenAPIView
@@ -23,4 +25,4 @@ def get(self, petId):
 
     def post(self, petId):
         data = request.stream.read()
-        response.status = HTTP_201
+        return Response(status=201)

Diff for: tests/integration/contrib/flask/test_flask_project.py

@@ -51,7 +51,7 @@ def test_get_valid(self, client, data_gif):
             "Api-Key": self.api_key_encoded,
         }
 
-        client.set_cookie("petstore.swagger.io", "user", "1")
+        client.set_cookie("user", "1", domain="petstore.swagger.io")
         response = client.get(
             "/v1/pets/1/photo",
             headers=headers,
@@ -60,26 +60,19 @@ def test_get_valid(self, client, data_gif):
         assert response.get_data() == data_gif
         assert response.status_code == 200
 
-    @pytest.mark.xfail(
-        reason="request binary format not supported",
-        strict=True,
-    )
     def test_post_valid(self, client, data_gif):
         content_type = "image/gif"
         headers = {
             "Authorization": "Basic testuser",
             "Api-Key": self.api_key_encoded,
             "Content-Type": content_type,
         }
-        data = {
-            "file": data_gif,
-        }
 
-        client.set_cookie("petstore.swagger.io", "user", "1")
+        client.set_cookie("user", "1", domain="petstore.swagger.io")
         response = client.post(
             "/v1/pets/1/photo",
             headers=headers,
-            data=data,
+            data=data_gif,
         )
 
         assert not response.text