Split cast and deserialise processes

Author: p1c2u

openapi_core/schema/media_types/models.py

@@ -31,16 +31,17 @@ def deserialize(self, value):
         deserializer = self.get_dererializer()
         return deserializer(value)
 
-    def cast(self, value):
+    def deserialise(self, value):
         try:
-            deserialized = self.deserialize(value)
+            return self.deserialize(value)
         except ValueError as exc:
             raise InvalidMediaTypeValue(exc)
 
+    def cast(self, value):
         if not self.schema:
-            return deserialized
+            return value
 
         try:
-            return self.schema.cast(deserialized)
+            return self.schema.cast(value)
         except CastError as exc:
             raise InvalidMediaTypeValue(exc)

openapi_core/schema/parameters/models.py

@@ -88,7 +88,7 @@ def get_raw_value(self, request):
 
         return location[self.name]
 
-    def cast(self, value):
+    def deserialise(self, value):
         if self.deprecated:
             warnings.warn(
                 "{0} parameter is deprecated".format(self.name),
@@ -100,14 +100,15 @@ def cast(self, value):
             raise EmptyParameterValue(self.name)
 
         try:
-            deserialized = self.deserialize(value)
+            return self.deserialize(value)
         except (ValueError, AttributeError) as exc:
             raise InvalidParameterValue(self.name, exc)
 
+    def cast(self, value):
         if not self.schema:
-            return deserialized
+            return value
 
         try:
-            return self.schema.cast(deserialized)
+            return self.schema.cast(value)
         except CastError as exc:
             raise InvalidParameterValue(self.name, exc)

openapi_core/validation/request/validators.py

@@ -109,10 +109,15 @@ def _get_parameters(self, request, params):
                 casted = param.schema.default
             else:
                 try:
-                    casted = param.cast(raw_value)
+                    deserialised = self._deserialise(param, raw_value)
                 except OpenAPIParameterError as exc:
                     errors.append(exc)
-                    continue
+                else:
+                    try:
+                        casted = self._cast(param, deserialised)
+                    except OpenAPIParameterError as exc:
+                        errors.append(exc)
+                        continue
 
             try:
                 unmarshalled = self._unmarshal(param, casted)
@@ -142,17 +147,28 @@ def _get_body(self, request, operation):
                 errors.append(exc)
             else:
                 try:
-                    casted = media_type.cast(raw_body)
+                    deserialised = self._deserialise(media_type, raw_body)
                 except InvalidMediaTypeValue as exc:
                     errors.append(exc)
                 else:
                     try:
-                        body = self._unmarshal(media_type, casted)
-                    except (ValidateError, UnmarshalError) as exc:
+                        casted = self._cast(media_type, deserialised)
+                    except InvalidMediaTypeValue as exc:
                         errors.append(exc)
+                    else:
+                        try:
+                            body = self._unmarshal(media_type, casted)
+                        except (ValidateError, UnmarshalError) as exc:
+                            errors.append(exc)
 
         return body, errors
 
+    def _deserialise(self, param_or_media_type, value):
+        return param_or_media_type.deserialise(value)
+
+    def _cast(self, param_or_media_type, value):
+        return param_or_media_type.cast(value)
+
     def _unmarshal(self, param_or_media_type, value):
         if not param_or_media_type.schema:
             return value

openapi_core/validation/response/validators.py

@@ -81,14 +81,19 @@ def _get_data(self, response, operation_response):
                 errors.append(exc)
             else:
                 try:
-                    casted = media_type.cast(raw_data)
+                    deserialised = self._deserialise(media_type, raw_data)
                 except InvalidMediaTypeValue as exc:
                     errors.append(exc)
                 else:
                     try:
-                        data = self._unmarshal(media_type, casted)
-                    except (ValidateError, UnmarshalError) as exc:
+                        casted = self._cast(media_type, deserialised)
+                    except InvalidMediaTypeValue as exc:
                         errors.append(exc)
+                    else:
+                        try:
+                            data = self._unmarshal(media_type, casted)
+                        except (ValidateError, UnmarshalError) as exc:
+                            errors.append(exc)
 
         return data, errors
 
@@ -100,6 +105,12 @@ def _get_headers(self, response, operation_response):
 
         return headers, errors
 
+    def _deserialise(self, param_or_media_type, value):
+        return param_or_media_type.deserialise(value)
+
+    def _cast(self, param_or_media_type, value):
+        return param_or_media_type.cast(value)
+
     def _unmarshal(self, param_or_media_type, value):
         if not param_or_media_type.schema:
             return value

tests/unit/schema/test_media_types.py

@@ -4,19 +4,19 @@
 from openapi_core.schema.media_types.models import MediaType
 
 
-class TestMediaTypeCast(object):
+class TestMediaTypeDeserialise(object):
 
     def test_empty(self):
         media_type = MediaType('application/json')
         value = ''
 
         with pytest.raises(InvalidMediaTypeValue):
-            media_type.cast(value)
+            media_type.deserialise(value)
 
     def test_no_schema_deserialised(self):
         media_type = MediaType('application/json')
         value = "{}"
 
-        result = media_type.cast(value)
+        result = media_type.deserialise(value)
 
         assert result == {}

tests/unit/schema/test_parameters.py

@@ -38,14 +38,14 @@ def test_cookie(self):
         assert param.explode is True
 
 
-class TestParameterCast(object):
+class TestParameterDeserialise(object):
 
     def test_deprecated(self):
         param = Parameter('param', 'query', deprecated=True)
         value = 'test'
 
         with pytest.warns(DeprecationWarning):
-            result = param.cast(value)
+            result = param.deserialise(value)
 
         assert result == value
 
@@ -54,12 +54,12 @@ def test_query_empty(self):
         value = ''
 
         with pytest.raises(EmptyParameterValue):
-            param.cast(value)
+            param.deserialise(value)
 
     def test_query_valid(self):
         param = Parameter('param', 'query')
         value = 'test'
 
-        result = param.cast(value)
+        result = param.deserialise(value)
 
         assert result == value