Get rid of schema validation in unmarshal

Author: p1c2u

openapi_core/schema/schemas/_format.py

@@ -7,6 +7,26 @@
 from jsonschema.exceptions import FormatError
 from six import binary_type, text_type, integer_types
 
+DATETIME_HAS_STRICT_RFC3339 = False
+DATETIME_HAS_ISODATE = False
+DATETIME_RAISES = ()
+
+try:
+    import isodate
+except ImportError:
+    pass
+else:
+    DATETIME_HAS_ISODATE = True
+    DATETIME_RAISES += (ValueError, isodate.ISO8601Error)
+
+try:
+    import strict_rfc3339
+except ImportError:
+    pass
+else:
+    DATETIME_HAS_STRICT_RFC3339 = True
+    DATETIME_RAISES += (ValueError, TypeError)
+
 
 class StrictFormatChecker(FormatChecker):
 
@@ -56,30 +76,20 @@ def is_byte(instance):
     return b64encode(b64decode(instance)) == instance
 
 
-try:
-    import strict_rfc3339
-except ImportError:
-    try:
-        import isodate
-    except ImportError:
-        pass
-    else:
-        @oas30_format_checker.checks(
-            "date-time", raises=(ValueError, isodate.ISO8601Error))
-        def is_datetime(instance):
-            if isinstance(instance, binary_type):
-                return False
-            if not isinstance(instance, text_type):
-                return True
-            return isodate.parse_datetime(instance)
-else:
-    @oas30_format_checker.checks("date-time")
-    def is_datetime(instance):
-        if isinstance(instance, binary_type):
-            return False
-        if not isinstance(instance, text_type):
-            return True
+@oas30_format_checker.checks("date-time", raises=DATETIME_RAISES)
+def is_datetime(instance):
+    if isinstance(instance, binary_type):
+        return False
+    if not isinstance(instance, text_type):
+        return True
+    
+    if DATETIME_HAS_STRICT_RFC3339:
         return strict_rfc3339.validate_rfc3339(instance)
+    
+    if DATETIME_HAS_ISODATE:
+        return isodate.parse_datetime(instance)
+
+    return True
 
 
 @oas30_format_checker.checks("date", raises=ValueError)

openapi_core/schema/schemas/exceptions.py

@@ -66,22 +66,6 @@ def __str__(self):
         return "Missing schema property: {0}".format(self.property_name)
 
 
-@attr.s(hash=True)
-class NoOneOfSchema(OpenAPISchemaError):
-    type = attr.ib()
-
-    def __str__(self):
-        return "Exactly one valid schema type {0} should be valid, None found.".format(self.type)
-
-
-@attr.s(hash=True)
-class MultipleOneOfSchema(OpenAPISchemaError):
-    type = attr.ib()
-
-    def __str__(self):
-        return "Exactly one schema type {0} should be valid, more than one found".format(self.type)
-
-
 class UnmarshallerError(OpenAPIMappingError):
     pass
 

openapi_core/schema/schemas/models.py

@@ -16,17 +16,15 @@
 from openapi_core.schema.schemas.enums import SchemaFormat, SchemaType
 from openapi_core.schema.schemas.exceptions import (
     InvalidSchemaValue, UndefinedSchemaProperty, MissingSchemaProperty,
-    OpenAPISchemaError, NoOneOfSchema, MultipleOneOfSchema, NoValidSchema,
+    OpenAPISchemaError, NoValidSchema,
     UndefinedItemsSchema, InvalidCustomFormatSchemaValue, InvalidSchemaProperty,
     UnmarshallerStrictTypeError,
 )
 from openapi_core.schema.schemas.util import (
     forcebool, format_date, format_datetime, format_byte, format_uuid,
     format_number,
 )
-from openapi_core.schema.schemas.validators import (
-    TypeValidator, AttributeValidator, OAS30Validator,
-)
+from openapi_core.schema.schemas.validators import OAS30Validator
 
 log = logging.getLogger(__name__)
 
@@ -49,36 +47,6 @@ class Schema(object):
     DEFAULT_UNMARSHAL_CALLABLE_GETTER = {
     }
 
-    STRING_FORMAT_CALLABLE_GETTER = {
-        SchemaFormat.NONE: Format(text_type, TypeValidator(text_type)),
-        SchemaFormat.PASSWORD: Format(text_type, TypeValidator(text_type)),
-        SchemaFormat.DATE: Format(
-            format_date, TypeValidator(date, exclude=datetime)),
-        SchemaFormat.DATETIME: Format(format_datetime, TypeValidator(datetime)),
-        SchemaFormat.BINARY: Format(binary_type, TypeValidator(binary_type)),
-        SchemaFormat.UUID: Format(format_uuid, TypeValidator(UUID)),
-        SchemaFormat.BYTE: Format(format_byte, TypeValidator(text_type)),
-    }
-
-    NUMBER_FORMAT_CALLABLE_GETTER = {
-        SchemaFormat.NONE: Format(format_number, TypeValidator(
-            integer_types + (float, ), exclude=bool)),
-        SchemaFormat.FLOAT: Format(float, TypeValidator(float)),
-        SchemaFormat.DOUBLE: Format(float, TypeValidator(float)),
-    }
-
-    TYPE_VALIDATOR_CALLABLE_GETTER = {
-        SchemaType.ANY: lambda x: True,
-        SchemaType.BOOLEAN: TypeValidator(bool),
-        SchemaType.INTEGER: TypeValidator(integer_types, exclude=bool),
-        SchemaType.NUMBER: TypeValidator(
-            integer_types + (float, ), exclude=bool),
-        SchemaType.STRING: TypeValidator(
-            text_type, date, datetime, binary_type, UUID),
-        SchemaType.ARRAY: TypeValidator(list, tuple),
-        SchemaType.OBJECT: AttributeValidator('__dict__'),
-    }
-
     def __init__(
             self, schema_type=None, model=None, properties=None, items=None,
             schema_format=None, required=None, default=None, nullable=False,
@@ -304,11 +272,12 @@ def _unmarshal_any(self, value, custom_formatters=None, strict=True):
                     continue
                 else:
                     if result is not None:
-                        raise MultipleOneOfSchema(self.type)
+                        log.warning("multiple valid oneOf schemas found")
+                        continue
                     result = unmarshalled
 
             if result is None:
-                raise NoOneOfSchema(self.type)
+                log.warning("valid oneOf schema not found")
 
             return result
         else:
@@ -321,7 +290,8 @@ def _unmarshal_any(self, value, custom_formatters=None, strict=True):
                 except (OpenAPISchemaError, TypeError):
                     continue
 
-        raise NoValidSchema(value)
+        log.warning("failed to unmarshal any type")
+        return value
 
     def _unmarshal_collection(self, value, custom_formatters=None, strict=True):
         if not isinstance(value, (list, tuple)):
@@ -344,17 +314,18 @@ def _unmarshal_object(self, value, model_factory=None,
             properties = None
             for one_of_schema in self.one_of:
                 try:
-                    found_props = self._unmarshal_properties(
+                    unmarshalled = self._unmarshal_properties(
                         value, one_of_schema, custom_formatters=custom_formatters)
                 except OpenAPISchemaError:
                     pass
                 else:
                     if properties is not None:
-                        raise MultipleOneOfSchema(self.type)
-                    properties = found_props
+                        log.warning("multiple valid oneOf schemas found")
+                        continue
+                    properties = unmarshalled
 
             if properties is None:
-                raise NoOneOfSchema(self.type)
+                log.warning("valid oneOf schema not found")
 
         else:
             properties = self._unmarshal_properties(
@@ -398,10 +369,8 @@ def _unmarshal_properties(self, value, one_of_schema=None,
                 if not prop.nullable and not prop.default:
                     continue
                 prop_value = prop.default
-            try:
-                properties[prop_name] = prop.unmarshal(
-                  prop_value, custom_formatters=custom_formatters)
-            except OpenAPISchemaError as exc:
-                raise InvalidSchemaProperty(prop_name, exc)
+
+            properties[prop_name] = prop.unmarshal(
+                prop_value, custom_formatters=custom_formatters)
 
         return properties

openapi_core/schema/schemas/unmarshallers.py

@@ -3,7 +3,7 @@
 from openapi_core.schema.schemas.enums import SchemaFormat, SchemaType
 from openapi_core.schema.schemas.exceptions import (
     InvalidSchemaValue, InvalidCustomFormatSchemaValue,
-    OpenAPISchemaError, MultipleOneOfSchema, NoOneOfSchema,
+    OpenAPISchemaError,
     InvalidSchemaProperty,
     UnmarshallerStrictTypeError,
 )

openapi_core/schema/schemas/validators.py

@@ -5,34 +5,6 @@
 from openapi_core.schema.schemas import _validators as oas_validators
 
 
-class TypeValidator(object):
-
-    def __init__(self, *types, **options):
-        self.types = types
-        self.exclude = options.get('exclude')
-
-    def __call__(self, value):
-        if self.exclude is not None and isinstance(value, self.exclude):
-            return False
-
-        if not isinstance(value, self.types):
-            return False
-
-        return True
-
-
-class AttributeValidator(object):
-
-    def __init__(self, attribute):
-        self.attribute = attribute
-
-    def __call__(self, value):
-        if not hasattr(value, self.attribute):
-            return False
-
-        return True
-
-
 BaseOAS30Validator = create(
     meta_schema=_utils.load_schema("draft4"),
     validators={

requirements.txt

@@ -2,4 +2,5 @@ openapi-spec-validator
 six
 lazy-object-proxy
 strict_rfc3339
+isodate
 attrs

tests/unit/schema/test_schemas.py

@@ -7,7 +7,7 @@
 from openapi_core.extensions.models.models import Model
 from openapi_core.schema.schemas.enums import SchemaFormat, SchemaType
 from openapi_core.schema.schemas.exceptions import (
-    InvalidSchemaValue, MultipleOneOfSchema, NoOneOfSchema, OpenAPISchemaError,
+    InvalidSchemaValue, OpenAPISchemaError,
 )
 from openapi_core.schema.schemas.models import Schema
 
@@ -167,10 +167,7 @@ def test_string_format_invalid_value(self):
         schema = Schema('string', schema_format=custom_format)
         value = 'x'
 
-        with mock.patch.dict(
-            Schema.STRING_FORMAT_CALLABLE_GETTER,
-            {custom_format: mock.Mock(side_effect=ValueError())},
-        ), pytest.raises(
+        with pytest.raises(
             InvalidSchemaValue, message='Failed to format value'
         ):
             schema.unmarshal(value)
@@ -325,22 +322,6 @@ def test_schema_any_one_of(self):
         ])
         assert schema.unmarshal(['hello']) == ['hello']
 
-    def test_schema_any_one_of_mutiple(self):
-        schema = Schema(one_of=[
-            Schema('array', items=Schema('string')),
-            Schema('array', items=Schema('number')),
-        ])
-        with pytest.raises(MultipleOneOfSchema):
-            schema.unmarshal([])
-
-    def test_schema_any_one_of_no_valid(self):
-        schema = Schema(one_of=[
-            Schema('array', items=Schema('string')),
-            Schema('array', items=Schema('number')),
-        ])
-        with pytest.raises(NoOneOfSchema):
-            schema.unmarshal({})
-
     def test_schema_any(self):
         schema = Schema()
         assert schema.unmarshal('string') == 'string'
@@ -635,7 +616,34 @@ def test_string_format_datetime_invalid(self, value):
         u('1989-01-02T00:00:00Z'),
         u('2018-01-02T23:59:59Z'),
     ])
-    def test_string_format_datetime(self, value):
+    @mock.patch(
+        'openapi_core.schema.schemas._format.'
+        'DATETIME_HAS_STRICT_RFC3339', True
+    )
+    @mock.patch(
+        'openapi_core.schema.schemas._format.'
+        'DATETIME_HAS_ISODATE', False
+    )
+    def test_string_format_datetime_strict_rfc3339(self, value):
+        schema = Schema('string', schema_format='date-time')
+
+        result = schema.validate(value)
+
+        assert result is None
+
+    @pytest.mark.parametrize('value', [
+        u('1989-01-02T00:00:00Z'),
+        u('2018-01-02T23:59:59Z'),
+    ])
+    @mock.patch(
+        'openapi_core.schema.schemas._format.'
+        'DATETIME_HAS_STRICT_RFC3339', False
+    )
+    @mock.patch(
+        'openapi_core.schema.schemas._format.'
+        'DATETIME_HAS_ISODATE', True
+    )
+    def test_string_format_datetime_isodate(self, value):
         schema = Schema('string', schema_format='date-time')
 
         result = schema.validate(value)