Updating unmarshal and validation methods' signatures to propagate the context until reaching the properties.

Author: phrfpeixoto

openapi_core/schema/media_types/models.py

@@ -32,7 +32,8 @@ def deserialize(self, value):
         deserializer = self.get_dererializer()
         return deserializer(value)
 
-    def unmarshal(self, value, custom_formatters=None):
+    @requires_context
+    def unmarshal(self, value, custom_formatters=None, context=None):
         if not self.schema:
             return value
 
@@ -42,12 +43,15 @@ def unmarshal(self, value, custom_formatters=None):
             raise InvalidMediaTypeValue(exc)
 
         try:
-            unmarshalled = self.schema.unmarshal(deserialized, custom_formatters=custom_formatters)
+            unmarshalled = self.schema.unmarshal(
+                deserialized, custom_formatters=custom_formatters,
+                context=context)
         except OpenAPISchemaError as exc:
             raise InvalidMediaTypeValue(exc)
 
         try:
             return self.schema.validate(
-                unmarshalled, custom_formatters=custom_formatters)
+                unmarshalled, custom_formatters=custom_formatters,
+                context=context)
         except OpenAPISchemaError as exc:
             raise InvalidMediaTypeValue(exc)

openapi_core/schema/parameters/models.py

@@ -9,12 +9,15 @@
     MissingRequiredParameter, MissingParameter, InvalidParameterValue,
     EmptyParameterValue,
 )
-from openapi_core.schema.schemas.enums import SchemaType
+from openapi_core.schema.schemas.enums import SchemaType, UnmarshalContext
 from openapi_core.schema.schemas.exceptions import OpenAPISchemaError
 
 log = logging.getLogger(__name__)
 
 
+_CONTEXT = UnmarshalContext.REQUEST
+
+
 class Parameter(object):
     """Represents an OpenAPI operation Parameter."""
 
@@ -112,13 +115,14 @@ def unmarshal(self, value, custom_formatters=None):
             unmarshalled = self.schema.unmarshal(
                 deserialized,
                 custom_formatters=custom_formatters,
-                strict=False,
+                strict=False, context=_CONTEXT
             )
         except OpenAPISchemaError as exc:
             raise InvalidParameterValue(self.name, exc)
 
         try:
             return self.schema.validate(
-                unmarshalled, custom_formatters=custom_formatters)
+                unmarshalled, custom_formatters=custom_formatters,
+                context=_CONTEXT)
         except OpenAPISchemaError as exc:
             raise InvalidParameterValue(self.name, exc)

openapi_core/schema/schemas/models.py

@@ -11,15 +11,17 @@
 from six import iteritems, integer_types, binary_type, text_type
 
 from openapi_core.extensions.models.factories import ModelFactory
-from openapi_core.schema.schemas.enums import SchemaFormat, SchemaType
+from openapi_core.schema.schemas.enums import (
+    SchemaFormat, SchemaType, UnmarshalContext
+)
 from openapi_core.schema.schemas.exceptions import (
     InvalidSchemaValue, UndefinedSchemaProperty, MissingSchemaProperty,
     OpenAPISchemaError, NoOneOfSchema, MultipleOneOfSchema, NoValidSchema,
     UndefinedItemsSchema, InvalidCustomFormatSchemaValue, InvalidSchemaProperty,
     UnmarshallerStrictTypeError,
 )
 from openapi_core.schema.schemas.util import (
-    forcebool, format_date, format_datetime, format_byte, format_uuid,
+    requires_context, format_date, format_datetime, format_byte, format_uuid,
     format_number,
 )
 from openapi_core.schema.schemas.validators import (
@@ -161,7 +163,8 @@ def get_all_required_properties_names(self):
 
         return set(required)
 
-    def get_cast_mapping(self, custom_formatters=None, strict=True):
+    def get_cast_mapping(self, custom_formatters=None, strict=True,
+                         context=None):
         primitive_unmarshallers = self.get_primitive_unmarshallers(
             custom_formatters=custom_formatters)
 
@@ -171,7 +174,7 @@ def get_cast_mapping(self, custom_formatters=None, strict=True):
         )
 
         pass_defaults = lambda f: functools.partial(
-          f, custom_formatters=custom_formatters, strict=strict)
+          f, custom_formatters=custom_formatters, strict=strict, context=context)
         mapping = self.DEFAULT_CAST_CALLABLE_GETTER.copy()
         mapping.update(primitive_unmarshallers_partial)
         mapping.update({
@@ -189,7 +192,8 @@ def are_additional_properties_allowed(self, one_of_schema=None):
                 one_of_schema.additional_properties is not False)
         )
 
-    def cast(self, value, custom_formatters=None, strict=True):
+    @requires_context
+    def cast(self, value, custom_formatters=None, strict=True, context=None):
         """Cast value to schema type"""
         if value is None:
             if not self.nullable:
@@ -201,7 +205,7 @@ def cast(self, value, custom_formatters=None, strict=True):
                 "Value {value} not in enum choices: {type}", value, self.enum)
 
         cast_mapping = self.get_cast_mapping(
-            custom_formatters=custom_formatters, strict=strict)
+            custom_formatters=custom_formatters, strict=strict, context=context)
 
         if self.type is not SchemaType.STRING and value == '':
             return None
@@ -216,12 +220,14 @@ def cast(self, value, custom_formatters=None, strict=True):
             raise InvalidSchemaValue(
                 "Failed to cast value {value} to type {type}", value, self.type)
 
-    def unmarshal(self, value, custom_formatters=None, strict=True):
+    @requires_context
+    def unmarshal(self, value, custom_formatters=None, strict=True,
+                  context=None):
         """Unmarshal parameter from the value."""
         if self.deprecated:
             warnings.warn("The schema is deprecated", DeprecationWarning)
 
-        casted = self.cast(value, custom_formatters=custom_formatters, strict=strict)
+        casted = self.cast(value, custom_formatters=custom_formatters, strict=strict, context=context)
 
         if casted is None and not self.required:
             return None
@@ -248,17 +254,20 @@ def get_primitive_unmarshallers(self, **options):
 
         return unmarshallers
 
-    def _unmarshal_any(self, value, custom_formatters=None, strict=True):
+    @requires_context
+    def _unmarshal_any(self, value, custom_formatters=None, strict=True,
+                       context=None):
         types_resolve_order = [
             SchemaType.OBJECT, SchemaType.ARRAY, SchemaType.BOOLEAN,
             SchemaType.INTEGER, SchemaType.NUMBER, SchemaType.STRING,
         ]
-        cast_mapping = self.get_cast_mapping()
+        cast_mapping = self.get_cast_mapping(custom_formatters, strict, context)
         if self.one_of:
             result = None
             for subschema in self.one_of:
                 try:
-                    casted = subschema.cast(value, custom_formatters)
+                    casted = subschema.cast(value, custom_formatters,
+                                            strict, context)
                 except (OpenAPISchemaError, TypeError, ValueError):
                     continue
                 else:
@@ -283,7 +292,9 @@ def _unmarshal_any(self, value, custom_formatters=None, strict=True):
 
         raise NoValidSchema(value)
 
-    def _unmarshal_collection(self, value, custom_formatters=None, strict=True):
+    @requires_context
+    def _unmarshal_collection(self, value, custom_formatters=None, strict=True,
+                              context=None):
         if not isinstance(value, (list, tuple)):
             raise InvalidSchemaValue("Value {value} is not of type {type}", value, self.type)
 
@@ -292,12 +303,13 @@ def _unmarshal_collection(self, value, custom_formatters=None, strict=True):
 
         f = functools.partial(
             self.items.unmarshal,
-            custom_formatters=custom_formatters, strict=strict,
+            custom_formatters=custom_formatters, strict=strict, context=context
         )
         return list(map(f, value))
 
+    @requires_context
     def _unmarshal_object(self, value, model_factory=None,
-                          custom_formatters=None, strict=True):
+                          custom_formatters=None, strict=True, context=None):
         if not isinstance(value, (dict, )):
             raise InvalidSchemaValue("Value {value} is not of type {type}", value, self.type)
 
@@ -308,8 +320,9 @@ def _unmarshal_object(self, value, model_factory=None,
             for one_of_schema in self.one_of:
                 try:
                     found_props = self._unmarshal_properties(
-                        value, one_of_schema, custom_formatters=custom_formatters)
-                except OpenAPISchemaError:
+                        value, one_of_schema,
+                        custom_formatters=custom_formatters, context=context)
+                except OpenAPISchemaError as ex:
                     pass
                 else:
                     if properties is not None:
@@ -321,7 +334,7 @@ def _unmarshal_object(self, value, model_factory=None,
 
         else:
             properties = self._unmarshal_properties(
-              value, custom_formatters=custom_formatters)
+              value, custom_formatters=custom_formatters, context=context)
 
         return model_factory.create(properties, name=self.model)
 
@@ -407,7 +420,8 @@ def default(x, **kw):
 
         return defaultdict(lambda: default, mapping)
 
-    def validate(self, value, custom_formatters=None):
+    @requires_context
+    def validate(self, value, custom_formatters=None, context=None):
         if value is None:
             if not self.nullable:
                 raise InvalidSchemaValue("Null value for non-nullable schema of type {type}", value, self.type)
@@ -423,11 +437,13 @@ def validate(self, value, custom_formatters=None):
         # structure validation
         validator_mapping = self.get_validator_mapping()
         validator_callable = validator_mapping[self.type]
-        validator_callable(value, custom_formatters=custom_formatters)
+        validator_callable(value, custom_formatters=custom_formatters,
+                           context=context)
 
         return value
 
-    def _validate_collection(self, value, custom_formatters=None):
+    @requires_context
+    def _validate_collection(self, value, custom_formatters=None, context=None):
         if self.items is None:
             raise UndefinedItemsSchema(self.type)
 
@@ -455,10 +471,11 @@ def _validate_collection(self, value, custom_formatters=None):
             raise OpenAPISchemaError("Value may not contain duplicate items")
 
         f = functools.partial(self.items.validate,
-                              custom_formatters=custom_formatters)
+                              custom_formatters=custom_formatters,
+                              context=context)
         return list(map(f, value))
 
-    def _validate_number(self, value, custom_formatters=None):
+    def _validate_number(self, value, custom_formatters=None, context=None):
         if self.minimum is not None:
             if self.exclusive_minimum and value <= self.minimum:
                 raise InvalidSchemaValue(
@@ -480,7 +497,7 @@ def _validate_number(self, value, custom_formatters=None):
                 "Value {value} is not a multiple of {type}",
                     value, self.multiple_of)
 
-    def _validate_string(self, value, custom_formatters=None):
+    def _validate_string(self, value, custom_formatters=None, context=None):
         try:
             schema_format = SchemaFormat(self.format)
         except ValueError:
@@ -529,7 +546,8 @@ def _validate_string(self, value, custom_formatters=None):
 
         return True
 
-    def _validate_object(self, value, custom_formatters=None):
+    @requires_context
+    def _validate_object(self, value, custom_formatters=None, context=None):
         properties = value.__dict__
 
         if self.one_of:
@@ -538,9 +556,10 @@ def _validate_object(self, value, custom_formatters=None):
                 try:
                     self._validate_properties(
                       properties, one_of_schema,
-                      custom_formatters=custom_formatters)
-                except OpenAPISchemaError:
-                    pass
+                      custom_formatters=custom_formatters, context=context)
+                except OpenAPISchemaError as exc:
+                    log.debug("Failed to validate oneOf schema: {}"
+                              .format(str(exc)))
                 else:
                     if valid_one_of_schema is not None:
                         raise MultipleOneOfSchema(self.type)
@@ -551,7 +570,8 @@ def _validate_object(self, value, custom_formatters=None):
 
         else:
             self._validate_properties(properties,
-                                      custom_formatters=custom_formatters)
+                                      custom_formatters=custom_formatters,
+                                      context=context)
 
         if self.min_properties is not None:
             if self.min_properties < 0: