Get rid of object validator

openapi_core/schema/media_types/models.py

@@ -51,12 +51,6 @@ class MediaType(object):
             raise InvalidMediaTypeValue(exc)
 
         try:
-            unmarshalled = self.schema.unmarshal(value, custom_formatters=custom_formatters)
+            return self.schema.unmarshal(value, custom_formatters=custom_formatters)
-        except OpenAPISchemaError as exc:
-            raise InvalidMediaTypeValue(exc)
-
-        try:
-            return self.schema.obj_validate(
-                unmarshalled, custom_formatters=custom_formatters)
         except OpenAPISchemaError as exc:
             raise InvalidMediaTypeValue(exc)

openapi_core/schema/parameters/models.py

@@ -123,16 +123,10 @@ class Parameter(object):
             raise InvalidParameterValue(self.name, exc)
 
         try:
-            unmarshalled = self.schema.unmarshal(
+            return self.schema.unmarshal(
                 value,
                 custom_formatters=custom_formatters,
                 strict=True,
             )
         except OpenAPISchemaError as exc:
             raise InvalidParameterValue(self.name, exc)
-
-        try:
-            return self.schema.obj_validate(
-                unmarshalled, custom_formatters=custom_formatters)
-        except OpenAPISchemaError as exc:
-            raise InvalidParameterValue(self.name, exc)

openapi_core/schema/schemas/_format.py

@@ -1,9 +1,105 @@
-from jsonschema._format import FormatChecker
+from base64 import b64encode, b64decode
-from six import binary_type
+import binascii
+from datetime import datetime
+from uuid import UUID
 
-oas30_format_checker = FormatChecker()
+from jsonschema._format import FormatChecker
+from jsonschema.exceptions import FormatError
+from six import binary_type, text_type, integer_types
+
+
+class StrictFormatChecker(FormatChecker):
+
+    def check(self, instance, format):
+        if format not in self.checkers:
+            raise FormatError(
+                "Format checker for %r format not found" % (format, ))
+        return super(StrictFormatChecker, self).check(
+            instance, format)
+
+
+oas30_format_checker = StrictFormatChecker()
+
+
+@oas30_format_checker.checks('int32')
+def is_int32(instance):
+    return isinstance(instance, integer_types)
+
+
+@oas30_format_checker.checks('int64')
+def is_int64(instance):
+    return isinstance(instance, integer_types)
+
+
+@oas30_format_checker.checks('float')
+def is_float(instance):
+    return isinstance(instance, float)
+
+
+@oas30_format_checker.checks('double')
+def is_double(instance):
+    # float has double precision in Python
+    # It's double in CPython and Jython
+    return isinstance(instance, float)
 
 
 @oas30_format_checker.checks('binary')
-def binary(value):
+def is_binary(instance):
-    return isinstance(value, binary_type)
+    return isinstance(instance, binary_type)
+
+
+@oas30_format_checker.checks('byte', raises=(binascii.Error, TypeError))
+def is_byte(instance):
+    if isinstance(instance, text_type):
+        instance = instance.encode()
+
+    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
+        return strict_rfc3339.validate_rfc3339(instance)
+
+
+@oas30_format_checker.checks("date", raises=ValueError)
+def is_date(instance):
+    if isinstance(instance, binary_type):
+        return False
+    if not isinstance(instance, text_type):
+        return True
+    return datetime.strptime(instance, "%Y-%m-%d")
+
+
+@oas30_format_checker.checks("uuid", raises=AttributeError)
+def is_uuid(instance):
+    if isinstance(instance, binary_type):
+        return False
+    if not isinstance(instance, text_type):
+        return True
+    try:
+        uuid_obj = UUID(instance)
+    except ValueError:
+        return False
+
+    return text_type(uuid_obj) == instance

openapi_core/schema/schemas/_validators.py

@@ -1,4 +1,5 @@
-from jsonschema.exceptions import ValidationError
+from jsonschema._utils import find_additional_properties, extras_msg
+from jsonschema.exceptions import ValidationError, FormatError
 
 
 def type(validator, data_type, instance, schema):
@@ -9,6 +10,17 @@ def type(validator, data_type, instance, schema):
         yield ValidationError("%r is not of type %s" % (instance, data_type))
 
 
+def format(validator, format, instance, schema):
+    if instance is None:
+        return
+
+    if validator.format_checker is not None:
+        try:
+            validator.format_checker.check(instance, format)
+        except FormatError as error:
+            yield ValidationError(error.message, cause=error.cause)
+
+
 def items(validator, items, instance, schema):
     if not validator.is_type(instance, "array"):
         return
@@ -23,5 +35,24 @@ def nullable(validator, is_nullable, instance, schema):
         yield ValidationError("None for not nullable")
 
 
+def additionalProperties(validator, aP, instance, schema):
+    if not validator.is_type(instance, "object"):
+        return
+
+    extras = set(find_additional_properties(instance, schema))
+
+    if not extras:
+        return
+
+    if validator.is_type(aP, "object"):
+        for extra in extras:
+            for error in validator.descend(instance[extra], aP, path=extra):
+                yield error
+    elif validator.is_type(aP, "boolean"):
+        if not aP:
+            error = "Additional properties are not allowed (%s %s unexpected)"
+            yield ValidationError(error % extras_msg(extras))
+
+
 def not_implemented(validator, value, instance, schema):
     pass

openapi_core/schema/schemas/factories.py

@@ -1,9 +1,12 @@
 """OpenAPI core schemas factories module"""
 import logging
 
+from six import iteritems
+
 from openapi_core.compat import lru_cache
 from openapi_core.schema.properties.generators import PropertiesGenerator
 from openapi_core.schema.schemas.models import Schema
+from openapi_core.schema.schemas.types import Contribution
 
 log = logging.getLogger(__name__)
 
@@ -86,3 +89,59 @@ class SchemaFactory(object):
 
     def _create_items(self, items_spec):
         return self.create(items_spec)
+
+
+class SchemaDictFactory(object):
+
+    contributions = (
+        Contribution('type', src_prop_attr='value'),
+        Contribution('format'),
+        Contribution('properties', is_dict=True, dest_default={}),
+        Contribution('required', dest_default=[]),
+        Contribution('default'),
+        Contribution('nullable', dest_default=False),
+        Contribution('all_of', dest_prop_name='allOf', is_list=True, dest_default=[]),
+        Contribution('one_of', dest_prop_name='oneOf', is_list=True, dest_default=[]),
+        Contribution('additional_properties', dest_prop_name='additionalProperties', dest_default=True),
+        Contribution('min_items', dest_prop_name='minItems'),
+        Contribution('max_items', dest_prop_name='maxItems'),
+        Contribution('min_length', dest_prop_name='minLength'),
+        Contribution('max_length', dest_prop_name='maxLength'),
+        Contribution('pattern', src_prop_attr='pattern'),
+        Contribution('unique_items', dest_prop_name='uniqueItems', dest_default=False),
+        Contribution('minimum'),
+        Contribution('maximum'),
+        Contribution('multiple_of', dest_prop_name='multipleOf'),
+        Contribution('exclusive_minimum', dest_prop_name='exclusiveMinimum', dest_default=False),
+        Contribution('exclusive_maximum', dest_prop_name='exclusiveMaximum', dest_default=False),
+        Contribution('min_properties', dest_prop_name='minProperties'),
+        Contribution('max_properties', dest_prop_name='maxProperties'),
+    )
+
+    def create(self, schema):
+        schema_dict = {}
+        for contrib in self.contributions:
+            self._contribute(schema, schema_dict, contrib)
+        return schema_dict
+
+    def _contribute(self, schema, schema_dict, contrib):
+        def src_map(x):
+            return getattr(x, '__dict__')
+        src_val = getattr(schema, contrib.src_prop_name)
+
+        if src_val and contrib.src_prop_attr:
+            src_val = getattr(src_val, contrib.src_prop_attr)
+
+        if contrib.is_list:
+            src_val = list(map(src_map, src_val))
+        if contrib.is_dict:
+            src_val = dict(
+                (k, src_map(v))
+                for k, v in iteritems(src_val)
+            )
+
+        if src_val == contrib.dest_default:
+            return
+
+        dest_prop_name = contrib.dest_prop_name or contrib.src_prop_name
+        schema_dict[dest_prop_name] = src_val

openapi_core/schema/schemas/models.py

@@ -123,6 +123,14 @@ class Schema(object):
 
         self._source = _source
 
+    @property
+    def __dict__(self):
+        return self._source or self.to_dict()
+
+    def to_dict(self):
+        from openapi_core.schema.schemas.factories import SchemaDictFactory
+        return SchemaDictFactory().create(self)
+
     def __getitem__(self, name):
         return self.properties[name]
 
@@ -220,7 +228,7 @@ class Schema(object):
 
     def get_validator(self, resolver=None):
         return OAS30Validator(
-            self._source, resolver=resolver, format_checker=oas30_format_checker)
+            self.__dict__, resolver=resolver, format_checker=oas30_format_checker)
 
     def validate(self, value, resolver=None):
         validator = self.get_validator(resolver=resolver)
@@ -396,236 +404,4 @@ class Schema(object):
             except OpenAPISchemaError as exc:
                 raise InvalidSchemaProperty(prop_name, exc)
 
-        self._validate_properties(properties, one_of_schema=one_of_schema,
-                                  custom_formatters=custom_formatters)
-
         return properties
-
-    def get_validator_mapping(self):
-        mapping = {
-            SchemaType.ARRAY: self._validate_collection,
-            SchemaType.STRING: self._validate_string,
-            SchemaType.OBJECT: self._validate_object,
-            SchemaType.INTEGER: self._validate_number,
-            SchemaType.NUMBER: self._validate_number,
-        }
-
-        def default(x, **kw):
-            return x
-
-        return defaultdict(lambda: default, mapping)
-
-    def obj_validate(self, value, custom_formatters=None):
-        if value is None:
-            if not self.nullable:
-                raise InvalidSchemaValue("Null value for non-nullable schema of type {type}", value, self.type)
-            return
-
-        # type validation
-        type_validator_callable = self.TYPE_VALIDATOR_CALLABLE_GETTER[
-            self.type]
-        if not type_validator_callable(value):
-            raise InvalidSchemaValue(
-                "Value {value} not valid type {type}", value, self.type.value)
-
-        # structure validation
-        validator_mapping = self.get_validator_mapping()
-        validator_callable = validator_mapping[self.type]
-        validator_callable(value, custom_formatters=custom_formatters)
-
-        return value
-
-    def _validate_collection(self, value, custom_formatters=None):
-        if self.items is None:
-            raise UndefinedItemsSchema(self.type)
-
-        if self.min_items is not None:
-            if self.min_items < 0:
-                raise OpenAPISchemaError(
-                    "Schema for collection invalid:"
-                    " minItems must be non-negative"
-                )
-            if len(value) < self.min_items:
-                raise InvalidSchemaValue(
-                    "Value must contain at least {type} item(s),"
-                    " {value} found", len(value), self.min_items)
-        if self.max_items is not None:
-            if self.max_items < 0:
-                raise OpenAPISchemaError(
-                    "Schema for collection invalid:"
-                    " maxItems must be non-negative"
-                )
-            if len(value) > self.max_items:
-                raise InvalidSchemaValue(
-                    "Value must contain at most {value} item(s),"
-                    " {type} found", len(value), self.max_items)
-        if self.unique_items and len(set(value)) != len(value):
-            raise OpenAPISchemaError("Value may not contain duplicate items")
-
-        f = functools.partial(self.items.obj_validate,
-                              custom_formatters=custom_formatters)
-        return list(map(f, value))
-
-    def _validate_number(self, value, custom_formatters=None):
-        if self.minimum is not None:
-            if self.exclusive_minimum and value <= self.minimum:
-                raise InvalidSchemaValue(
-                    "Value {value} is not less than or equal to {type}", value, self.minimum)
-            elif value < self.minimum:
-                raise InvalidSchemaValue(
-                    "Value {value} is not less than {type}", value, self.minimum)
-
-        if self.maximum is not None:
-            if self.exclusive_maximum and value >= self.maximum:
-                raise InvalidSchemaValue(
-                    "Value {value} is not greater than or equal to {type}", value, self.maximum)
-            elif value > self.maximum:
-                raise InvalidSchemaValue(
-                    "Value {value} is not greater than {type}", value, self.maximum)
-
-        if self.multiple_of is not None and value % self.multiple_of:
-            raise InvalidSchemaValue(
-                "Value {value} is not a multiple of {type}",
-                    value, self.multiple_of)
-
-    def _validate_string(self, value, custom_formatters=None):
-        try:
-            schema_format = SchemaFormat(self.format)
-        except ValueError:
-            msg = "Unsupported {0} format validation".format(self.format)
-            if custom_formatters is not None:
-                formatstring = custom_formatters.get(self.format)
-                if formatstring is None:
-                    raise OpenAPISchemaError(msg)
-            else:
-                raise OpenAPISchemaError(msg)
-        else:
-            formatstring =\
-                self.STRING_FORMAT_CALLABLE_GETTER[schema_format]
-
-        if not formatstring.validate(value):
-            raise InvalidSchemaValue(
-                "Value {value} not valid format {type}", value, self.format)
-
-        if self.min_length is not None:
-            if self.min_length < 0:
-                raise OpenAPISchemaError(
-                    "Schema for string invalid:"
-                    " minLength must be non-negative"
-                )
-            if len(value) < self.min_length:
-                raise InvalidSchemaValue(
-                    "Value is shorter ({value}) than the minimum length of {type}",
-                    len(value), self.min_length
-                )
-        if self.max_length is not None:
-            if self.max_length < 0:
-                raise OpenAPISchemaError(
-                    "Schema for string invalid:"
-                    " maxLength must be non-negative"
-                )
-            if len(value) > self.max_length:
-                raise InvalidSchemaValue(
-                    "Value is longer ({value}) than the maximum length of {type}",
-                    len(value), self.max_length
-                )
-        if self.pattern is not None and not self.pattern.search(value):
-            raise InvalidSchemaValue(
-                "Value {value} does not match the pattern {type}",
-                    value, self.pattern.pattern
-            )
-
-        return True
-
-    def _validate_object(self, value, custom_formatters=None):
-        properties = value.__dict__
-
-        if self.one_of:
-            valid_one_of_schema = None
-            for one_of_schema in self.one_of:
-                try:
-                    self._validate_properties(
-                      properties, one_of_schema,
-                      custom_formatters=custom_formatters)
-                except OpenAPISchemaError:
-                    pass
-                else:
-                    if valid_one_of_schema is not None:
-                        raise MultipleOneOfSchema(self.type)
-                    valid_one_of_schema = True
-
-            if valid_one_of_schema is None:
-                raise NoOneOfSchema(self.type)
-
-        else:
-            self._validate_properties(properties,
-                                      custom_formatters=custom_formatters)
-
-        if self.min_properties is not None:
-            if self.min_properties < 0:
-                raise OpenAPISchemaError(
-                    "Schema for object invalid:"
-                    " minProperties must be non-negative"
-                )
-
-            if len(properties) < self.min_properties:
-                raise InvalidSchemaValue(
-                    "Value must contain at least {type} properties,"
-                    " {value} found", len(properties), self.min_properties
-                )
-
-        if self.max_properties is not None:
-            if self.max_properties < 0:
-                raise OpenAPISchemaError(
-                    "Schema for object invalid:"
-                    " maxProperties must be non-negative"
-                )
-            if len(properties) > self.max_properties:
-                raise InvalidSchemaValue(
-                    "Value must contain at most {type} properties,"
-                    " {value} found", len(properties), self.max_properties
-                )
-
-        return True
-
-    def _validate_properties(self, value, one_of_schema=None,
-                             custom_formatters=None):
-        all_props = self.get_all_properties()
-        all_props_names = self.get_all_properties_names()
-        all_req_props_names = self.get_all_required_properties_names()
-
-        if one_of_schema is not None:
-            all_props.update(one_of_schema.get_all_properties())
-            all_props_names |= one_of_schema.\
-                get_all_properties_names()
-            all_req_props_names |= one_of_schema.\
-                get_all_required_properties_names()
-
-        value_props_names = value.keys()
-        extra_props = set(value_props_names) - set(all_props_names)
-        extra_props_allowed = self.are_additional_properties_allowed(
-            one_of_schema)
-        if extra_props and not extra_props_allowed:
-            raise UndefinedSchemaProperty(extra_props)
-
-        if self.additional_properties is not True:
-            for prop_name in extra_props:
-                prop_value = value[prop_name]
-                self.additional_properties.obj_validate(
-                    prop_value, custom_formatters=custom_formatters)
-
-        for prop_name, prop in iteritems(all_props):
-            try:
-                prop_value = value[prop_name]
-            except KeyError:
-                if prop_name in all_req_props_names:
-                    raise MissingSchemaProperty(prop_name)
-                if not prop.nullable and not prop.default:
-                    continue
-                prop_value = prop.default
-            try:
-                prop.obj_validate(prop_value, custom_formatters=custom_formatters)
-            except OpenAPISchemaError as exc:
-                raise InvalidSchemaProperty(prop_name, original_exception=exc)
-
-        return True

openapi_core/schema/schemas/types.py

@@ -0,0 +1,11 @@
+import attr
+
+
+@attr.s(hash=True)
+class Contribution(object):
+    src_prop_name = attr.ib()
+    src_prop_attr = attr.ib(default=None)
+    dest_prop_name = attr.ib(default=None)
+    is_list = attr.ib(default=False)
+    is_dict = attr.ib(default=False)
+    dest_default = attr.ib(default=None)

openapi_core/schema/schemas/validators.py

@@ -33,14 +33,14 @@ class AttributeValidator(object):
         return True
 
 
-OAS30Validator = create(
+BaseOAS30Validator = create(
     meta_schema=_utils.load_schema("draft4"),
     validators={
         u"multipleOf": _validators.multipleOf,
+        # exclusiveMaximum supported inside maximum_draft3_draft4
         u"maximum": _legacy_validators.maximum_draft3_draft4,
-        u"exclusiveMaximum": _validators.exclusiveMaximum,
+        # exclusiveMinimum supported inside minimum_draft3_draft4
         u"minimum": _legacy_validators.minimum_draft3_draft4,
-        u"exclusiveMinimum": _validators.exclusiveMinimum,
         u"maxLength": _validators.maxLength,
         u"minLength": _validators.minLength,
         u"pattern": _validators.pattern,
@@ -59,9 +59,9 @@ OAS30Validator = create(
         u"not": _validators.not_,
         u"items": oas_validators.items,
         u"properties": _validators.properties,
-        u"additionalProperties": _validators.additionalProperties,
+        u"additionalProperties": oas_validators.additionalProperties,
         # TODO: adjust description
-        u"format": _validators.format,
+        u"format": oas_validators.format,
         # TODO: adjust default
         u"$ref": _validators.ref,
         # fixed OAS fields
@@ -78,3 +78,18 @@ OAS30Validator = create(
     version="oas30",
     id_of=lambda schema: schema.get(u"id", ""),
 )
+
+
+class OAS30Validator(BaseOAS30Validator):
+
+    def iter_errors(self, instance, _schema=None):
+        if _schema is None:
+                _schema = self.schema
+
+        # append defaults to trigger validator (i.e. nullable)
+        if 'nullable' not in _schema:
+            _schema.update({
+                'nullable': False,
+            })
+
+        return super(OAS30Validator, self).iter_errors(instance, _schema)

tests/unit/schema/test_schemas.py

@@ -8,7 +8,6 @@ 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,
-    UndefinedSchemaProperty
 )
 from openapi_core.schema.schemas.models import Schema
 
@@ -347,7 +346,7 @@ class TestSchemaUnmarshal(object):
         assert schema.unmarshal('string') == 'string'
 
 
-class TestSchemaObjValidate(object):
+class TestSchemaValidate(object):
 
     @pytest.mark.parametrize('schema_type', [
         'boolean', 'array', 'integer', 'number', 'string',
@@ -357,7 +356,7 @@ class TestSchemaObjValidate(object):
         value = None
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('schema_type', [
         'boolean', 'array', 'integer', 'number', 'string',
@@ -366,219 +365,221 @@ class TestSchemaObjValidate(object):
         schema = Schema(schema_type, nullable=True)
         value = None
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
         assert result is None
 
+    @pytest.mark.xfail(
+        reason="validation does not care about custom formats atm")
     def test_string_format_custom_missing(self):
         custom_format = 'custom'
         schema = Schema('string', schema_format=custom_format)
         value = 'x'
 
         with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [False, True])
     def test_boolean(self, value):
         schema = Schema('boolean')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [1, 3.14, u('true'), [True, False]])
     def test_boolean_invalid(self, value):
         schema = Schema('boolean')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
-    @pytest.mark.parametrize('value', [[1, 2], (3, 4)])
+    @pytest.mark.parametrize('value', [(1, 2)])
     def test_array_no_schema(self, value):
         schema = Schema('array')
 
         with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
+            schema.validate(value)
 
-    @pytest.mark.parametrize('value', [[1, 2], (3, 4)])
+    @pytest.mark.parametrize('value', [[1, 2]])
     def test_array(self, value):
         schema = Schema('array', items=Schema('integer'))
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
-    @pytest.mark.parametrize('value', [False, 1, 3.14, u('true')])
+    @pytest.mark.parametrize('value', [False, 1, 3.14, u('true'), (3, 4)])
     def test_array_invalid(self, value):
         schema = Schema('array')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [1, 3])
     def test_integer(self, value):
         schema = Schema('integer')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [False, 3.14, u('true'), [1, 2]])
     def test_integer_invalid(self, value):
         schema = Schema('integer')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [0, 1, 2])
     def test_integer_minimum_invalid(self, value):
         schema = Schema('integer', minimum=3)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [4, 5, 6])
     def test_integer_minimum(self, value):
         schema = Schema('integer', minimum=3)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [4, 5, 6])
     def test_integer_maximum_invalid(self, value):
         schema = Schema('integer', maximum=3)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [0, 1, 2])
     def test_integer_maximum(self, value):
         schema = Schema('integer', maximum=3)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [1, 2, 4])
     def test_integer_multiple_of_invalid(self, value):
         schema = Schema('integer', multiple_of=3)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [3, 6, 18])
     def test_integer_multiple_of(self, value):
         schema = Schema('integer', multiple_of=3)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [1, 3.14])
     def test_number(self, value):
         schema = Schema('number')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [False, 'true', [1, 3]])
     def test_number_invalid(self, value):
         schema = Schema('number')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [0, 1, 2])
     def test_number_minimum_invalid(self, value):
         schema = Schema('number', minimum=3)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [3, 4, 5])
     def test_number_minimum(self, value):
         schema = Schema('number', minimum=3)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [1, 2, 3])
     def test_number_exclusive_minimum_invalid(self, value):
         schema = Schema('number', minimum=3, exclusive_minimum=3)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [4, 5, 6])
     def test_number_exclusive_minimum(self, value):
         schema = Schema('number', minimum=3)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [4, 5, 6])
     def test_number_maximum_invalid(self, value):
         schema = Schema('number', maximum=3)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [1, 2, 3])
     def test_number_maximum(self, value):
         schema = Schema('number', maximum=3)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [3, 4, 5])
     def test_number_exclusive_maximum_invalid(self, value):
         schema = Schema('number', maximum=3, exclusive_maximum=True)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [0, 1, 2])
     def test_number_exclusive_maximum(self, value):
         schema = Schema('number', maximum=3, exclusive_maximum=True)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [1, 2, 4])
     def test_number_multiple_of_invalid(self, value):
         schema = Schema('number', multiple_of=3)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [3, 6, 18])
     def test_number_multiple_of(self, value):
         schema = Schema('number', multiple_of=3)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
-    @pytest.mark.parametrize('value', [u('true'), ])
+    @pytest.mark.parametrize('value', [u('true'), b('test')])
     def test_string(self, value):
         schema = Schema('string')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
-    @pytest.mark.parametrize('value', [b('test'), False, 1, 3.14, [1, 3]])
+    @pytest.mark.parametrize('value', [False, 1, 3.14, [1, 3]])
     def test_string_invalid(self, value):
         schema = Schema('string')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
         b('true'), u('test'), False, 1, 3.14, [1, 3],
@@ -588,27 +589,27 @@ class TestSchemaObjValidate(object):
         schema = Schema('string', schema_format='date')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
-        datetime.date(1989, 1, 2), datetime.date(2018, 1, 2),
+        u('1989-01-02'), u('2018-01-02'),
     ])
     def test_string_format_date(self, value):
         schema = Schema('string', schema_format='date')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [
-        uuid.UUID('{12345678-1234-5678-1234-567812345678}'),
+        u('12345678-1234-5678-1234-567812345678'),
     ])
     def test_string_format_uuid(self, value):
         schema = Schema('string', schema_format='uuid')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [
         b('true'), u('true'), False, 1, 3.14, [1, 3],
@@ -618,38 +619,38 @@ class TestSchemaObjValidate(object):
         schema = Schema('string', schema_format='uuid')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
         b('true'), u('true'), False, 1, 3.14, [1, 3],
-        datetime.date(1989, 1, 2),
+        u('1989-01-02'),
     ])
     def test_string_format_datetime_invalid(self, value):
         schema = Schema('string', schema_format='date-time')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
-        datetime.datetime(1989, 1, 2, 0, 0, 0),
+        u('1989-01-02T00:00:00Z'),
-        datetime.datetime(2018, 1, 2, 23, 59, 59),
+        u('2018-01-02T23:59:59Z'),
     ])
     def test_string_format_datetime(self, value):
         schema = Schema('string', schema_format='date-time')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [
-        u('true'), False, 1, 3.14, [1, 3], datetime.date(1989, 1, 2),
+        u('true'), False, 1, 3.14, [1, 3], u('1989-01-02'),
-        datetime.datetime(1989, 1, 2, 0, 0, 0),
+        u('1989-01-02T00:00:00Z'),
     ])
     def test_string_format_binary_invalid(self, value):
         schema = Schema('string', schema_format='binary')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
         b('stream'), b('text'),
@@ -657,28 +658,28 @@ class TestSchemaObjValidate(object):
     def test_string_format_binary(self, value):
         schema = Schema('string', schema_format='binary')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [
-        b('tsssst'), b('dGVzdA=='),
+        b('dGVzdA=='), u('dGVzdA=='),
+    ])
+    def test_string_format_byte(self, value):
+        schema = Schema('string', schema_format='byte')
+
+        result = schema.validate(value)
+
+        assert result is None
+
+    @pytest.mark.parametrize('value', [
+        u('tsssst'), b('tsssst'), b('tesddddsdsdst'),
     ])
     def test_string_format_byte_invalid(self, value):
         schema = Schema('string', schema_format='byte')
 
         with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
+            schema.validate(value)
-
-    @pytest.mark.parametrize('value', [
-        u('tsssst'), u('dGVzdA=='),
-    ])
-    def test_string_format_byte(self, value):
-        schema = Schema('string', schema_format='byte')
-
-        result = schema.obj_validate(value)
-
-        assert result == value
 
     @pytest.mark.parametrize('value', [
         u('test'), b('stream'), datetime.date(1989, 1, 2),
@@ -689,73 +690,66 @@ class TestSchemaObjValidate(object):
         schema = Schema('string', schema_format=unknown_format)
 
         with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
+            schema.validate(value)
-
-    @pytest.mark.parametrize('value', [u(""), ])
-    def test_string_min_length_invalid_schema(self, value):
-        schema = Schema('string', min_length=-1)
-
-        with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
 
     @pytest.mark.parametrize('value', [u(""), u("a"), u("ab")])
     def test_string_min_length_invalid(self, value):
         schema = Schema('string', min_length=3)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [u("abc"), u("abcd")])
     def test_string_min_length(self, value):
         schema = Schema('string', min_length=3)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [u(""), ])
     def test_string_max_length_invalid_schema(self, value):
         schema = Schema('string', max_length=-1)
 
         with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [u("ab"), u("abc")])
     def test_string_max_length_invalid(self, value):
         schema = Schema('string', max_length=1)
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [u(""), u("a")])
     def test_string_max_length(self, value):
         schema = Schema('string', max_length=1)
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [u("foo"), u("bar")])
     def test_string_pattern_invalid(self, value):
         schema = Schema('string', pattern='baz')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [u("bar"), u("foobar")])
     def test_string_pattern(self, value):
         schema = Schema('string', pattern='bar')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', ['true', False, 1, 3.14, [1, 3]])
     def test_object_not_an_object(self, value):
         schema = Schema('object')
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [Model(), ])
     def test_object_multiple_one_of(self, value):
@@ -764,20 +758,20 @@ class TestSchemaObjValidate(object):
         ]
         schema = Schema('object', one_of=one_of)
 
-        with pytest.raises(MultipleOneOfSchema):
+        with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
-    @pytest.mark.parametrize('value', [Model(), ])
+    @pytest.mark.parametrize('value', [{}, ])
     def test_object_defferent_type_one_of(self, value):
         one_of = [
             Schema('integer'), Schema('string'),
         ]
         schema = Schema('object', one_of=one_of)
 
-        with pytest.raises(MultipleOneOfSchema):
+        with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
-    @pytest.mark.parametrize('value', [Model(), ])
+    @pytest.mark.parametrize('value', [{}, ])
     def test_object_no_one_of(self, value):
         one_of = [
             Schema(
@@ -793,17 +787,17 @@ class TestSchemaObjValidate(object):
         ]
         schema = Schema('object', one_of=one_of)
 
-        with pytest.raises(NoOneOfSchema):
+        with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
-        Model({
+        {
             'foo': u("FOO"),
-        }),
+        },
-        Model({
+        {
             'foo': u("FOO"),
             'bar': u("BAR"),
-        }),
+        },
     ])
     def test_unambiguous_one_of(self, value):
         one_of = [
@@ -827,27 +821,30 @@ class TestSchemaObjValidate(object):
         ]
         schema = Schema('object', one_of=one_of)
 
-        schema.obj_validate(value)
+        result = schema.validate(value)
 
-    @pytest.mark.parametrize('value', [Model(), ])
+        assert result is None
+
+    @pytest.mark.parametrize('value', [{}, ])
     def test_object_default_property(self, value):
         schema = Schema('object', default='value1')
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [Model(), ])
     def test_object_min_properties_invalid_schema(self, value):
         schema = Schema('object', min_properties=-1)
 
         with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
-        Model({'a': 1}),
+        {'a': 1},
-        Model({'a': 1, 'b': 2}),
+        {'a': 1, 'b': 2},
-        Model({'a': 1, 'b': 2, 'c': 3})])
+        {'a': 1, 'b': 2, 'c': 3},
+    ])
     def test_object_min_properties_invalid(self, value):
         schema = Schema(
             'object',
@@ -857,12 +854,13 @@ class TestSchemaObjValidate(object):
         )
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
-        Model({'a': 1}),
+        {'a': 1},
-        Model({'a': 1, 'b': 2}),
+        {'a': 1, 'b': 2},
-        Model({'a': 1, 'b': 2, 'c': 3})])
+        {'a': 1, 'b': 2, 'c': 3},
+    ])
     def test_object_min_properties(self, value):
         schema = Schema(
             'object',
@@ -871,21 +869,22 @@ class TestSchemaObjValidate(object):
             min_properties=1,
         )
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [Model(), ])
     def test_object_max_properties_invalid_schema(self, value):
         schema = Schema('object', max_properties=-1)
 
         with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
-        Model({'a': 1}),
+        {'a': 1},
-        Model({'a': 1, 'b': 2}),
+        {'a': 1, 'b': 2},
-        Model({'a': 1, 'b': 2, 'c': 3})])
+        {'a': 1, 'b': 2, 'c': 3},
+    ])
     def test_object_max_properties_invalid(self, value):
         schema = Schema(
             'object',
@@ -895,12 +894,13 @@ class TestSchemaObjValidate(object):
         )
 
         with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
-        Model({'a': 1}),
+        {'a': 1},
-        Model({'a': 1, 'b': 2}),
+        {'a': 1, 'b': 2},
-        Model({'a': 1, 'b': 2, 'c': 3})])
+        {'a': 1, 'b': 2, 'c': 3},
+    ])
     def test_object_max_properties(self, value):
         schema = Schema(
             'object',
@@ -909,40 +909,33 @@ class TestSchemaObjValidate(object):
             max_properties=3,
         )
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
-    @pytest.mark.parametrize('value', [Model({'additional': 1}), ])
+    @pytest.mark.parametrize('value', [{'additional': 1}, ])
     def test_object_additional_propetries(self, value):
         schema = Schema('object')
 
-        schema.obj_validate(value)
+        result = schema.validate(value)
 
-    @pytest.mark.parametrize('value', [Model({'additional': 1}), ])
+        assert result is None
+
+    @pytest.mark.parametrize('value', [{'additional': 1}, ])
     def test_object_additional_propetries_false(self, value):
         schema = Schema('object', additional_properties=False)
 
-        with pytest.raises(UndefinedSchemaProperty):
+        with pytest.raises(InvalidSchemaValue):
-            schema.obj_validate(value)
+            schema.validate(value)
 
-    @pytest.mark.parametrize('value', [Model({'additional': 1}), ])
+    @pytest.mark.parametrize('value', [{'additional': 1}, ])
     def test_object_additional_propetries_object(self, value):
         additional_properties = Schema('integer')
         schema = Schema('object', additional_properties=additional_properties)
 
-        schema.obj_validate(value)
+        result = schema.validate(value)
 
-    @pytest.mark.parametrize('value', [[], ])
+        assert result is None
-    def test_list_min_items_invalid_schema(self, value):
-        schema = Schema(
-            'array',
-            items=Schema('number'),
-            min_items=-1,
-        )
-
-        with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
 
     @pytest.mark.parametrize('value', [[], [1], [1, 2]])
     def test_list_min_items_invalid(self, value):
@@ -953,7 +946,7 @@ class TestSchemaObjValidate(object):
         )
 
         with pytest.raises(Exception):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [[], [1], [1, 2]])
     def test_list_min_items(self, value):
@@ -963,9 +956,9 @@ class TestSchemaObjValidate(object):
             min_items=0,
         )
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [[], ])
     def test_list_max_items_invalid_schema(self, value):
@@ -976,7 +969,7 @@ class TestSchemaObjValidate(object):
         )
 
         with pytest.raises(OpenAPISchemaError):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [[1, 2], [2, 3, 4]])
     def test_list_max_items_invalid(self, value):
@@ -987,7 +980,7 @@ class TestSchemaObjValidate(object):
         )
 
         with pytest.raises(Exception):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [[1, 2, 1], [2, 2]])
     def test_list_unique_items_invalid(self, value):
@@ -998,19 +991,19 @@ class TestSchemaObjValidate(object):
         )
 
         with pytest.raises(Exception):
-            schema.obj_validate(value)
+            schema.validate(value)
 
     @pytest.mark.parametrize('value', [
-        Model({
+        {
             'someint': 123,
-        }),
+        },
-        Model({
+        {
             'somestr': u('content'),
-        }),
+        },
-        Model({
+        {
             'somestr': u('content'),
             'someint': 123,
-        }),
+        },
     ])
     def test_object_with_properties(self, value):
         schema = Schema(
@@ -1021,34 +1014,30 @@ class TestSchemaObjValidate(object):
             },
         )
 
-        result = schema.obj_validate(value)
+        result = schema.validate(value)
 
-        assert result == value
+        assert result is None
 
     @pytest.mark.parametrize('value', [
-        Model({
+        {
-            'somestr': Model(),
-            'someint': 123,
-        }),
-        Model({
             'somestr': {},
             'someint': 123,
-        }),
+        },
-        Model({
+        {
             'somestr': [
                 'content1', 'content2'
             ],
             'someint': 123,
-        }),
+        },
-        Model({
+        {
             'somestr': 123,
             'someint': 123,
-        }),
+        },
-        Model({
+        {
             'somestr': 'content',
             'someint': 123,
             'not_in_scheme_prop': 123,
-        }),
+        },
     ])
     def test_object_with_invalid_properties(self, value):
         schema = Schema(
@@ -1061,4 +1050,4 @@ class TestSchemaObjValidate(object):
         )
 
         with pytest.raises(Exception):
-            schema.obj_validate(value)
+            schema.validate(value)