Add additional meta data to schema and errors

openapi_core/schema/schemas/exceptions.py

@@ -3,8 +3,9 @@
 import attr
 
 
+@attr.s
 class OpenAPISchemaError(OpenAPIMappingError):
-    pass
+    schema = attr.ib()
 
 
 @attr.s
@@ -77,3 +78,19 @@ class MultipleOneOfSchema(OpenAPISchemaError):
 
     def __str__(self):
         return "Exactly one schema type {0} should be valid, more than one found".format(self.type)
+
+
+@attr.s
+class InvalidSchema(OpenAPISchemaError):
+    msg = attr.ib()
+
+    def __str__(self):
+        return self.msg
+
+
+@attr.s
+class InvalidFormat(OpenAPISchemaError):
+    msg = attr.ib()
+
+    def __str__(self):
+        return self.msg

openapi_core/schema/schemas/factories.py

@@ -13,7 +13,7 @@ class SchemaFactory(object):
     def __init__(self, dereferencer):
         self.dereferencer = dereferencer
 
-    def create(self, schema_spec):
+    def create(self, schema_spec, schema_name=''):
         schema_deref = self.dereferencer.dereference(schema_spec)
 
         schema_type = schema_deref.get('type', None)
@@ -75,6 +75,7 @@ def create(self, schema_spec):
             exclusive_maximum=exclusive_maximum,
             exclusive_minimum=exclusive_minimum,
             min_properties=min_properties, max_properties=max_properties,
+            schema_name=schema_name, schema_deref=schema_deref,
         )
 
     @property

openapi_core/schema/schemas/generators.py

@@ -16,5 +16,5 @@ def generate(self, schemas_spec):
         schemas_deref = self.dereferencer.dereference(schemas_spec)
 
         for schema_name, schema_spec in iteritems(schemas_deref):
-            schema, _ = self.schemas_registry.get_or_create(schema_spec)
+            schema, _ = self.schemas_registry.get_or_create(schema_spec, schema_name)
             yield schema_name, schema

openapi_core/schema/schemas/registries.py

@@ -15,17 +15,17 @@ def __init__(self, dereferencer):
         super(SchemaRegistry, self).__init__(dereferencer)
         self._schemas = {}
 
-    def get_or_create(self, schema_spec):
+    def get_or_create(self, schema_spec, schema_name=''):
         schema_hash = dicthash(schema_spec)
         schema_deref = self.dereferencer.dereference(schema_spec)
 
         if schema_hash in self._schemas:
             return self._schemas[schema_hash], False
 
         if '$ref' in schema_spec:
-            schema = Proxy(lambda: self.create(schema_deref))
+            schema = Proxy(lambda: self.create(schema_deref, schema_name))
         else:
-            schema = self.create(schema_deref)
+            schema = self.create(schema_deref, schema_name)
 
         self._schemas[schema_hash] = schema
 

requirements_dev.txt

@@ -2,4 +2,5 @@ mock==2.0.0
 pytest==3.5.0
 pytest-flake8
 pytest-cov==2.5.1
-flask
+flask
+ruamel.yaml==0.15.89

tests/unit/schema/test_exceptions.py

@@ -0,0 +1,27 @@
+from openapi_core.schema.schemas import exceptions
+import pytest
+import attr
+
+
+def is_open_api_exception(exception_type):
+    try:
+        return issubclass(exception_type, exceptions.OpenAPISchemaError)
+    except TypeError:
+        return False
+
+
+class TestExceptions:
+
+    @pytest.mark.parametrize(
+        "exception_type",
+        (
+            exception_type
+            for exception_type_name in dir(exceptions)
+            for exception_type in [getattr(exceptions, exception_type_name)]
+            if is_open_api_exception(exception_type)
+        )
+    )
+    def test_convert_to_string(self, exception_type):
+        # verify that we can convert to a string without error
+        args = ['x'] * len(attr.fields(exception_type))
+        str(exception_type(*args))

tests/unit/schema/test_schemas.py

@@ -6,7 +6,9 @@
 
 from openapi_core.extensions.models.models import Model
 from openapi_core.schema.schemas.exceptions import (
-    InvalidSchemaValue, MultipleOneOfSchema, NoOneOfSchema, OpenAPISchemaError,
+    InvalidSchemaValue, MultipleOneOfSchema, NoOneOfSchema,
+    OpenAPISchemaError, InvalidSchema, InvalidFormat, NoValidSchema,
+    InvalidSchemaProperty
 )
 from openapi_core.schema.schemas.models import Schema
 
@@ -102,27 +104,31 @@ def test_string_format_custom(self):
 
         assert result == 'x-custom'
 
-    def test_string_format_unknown(self):
+    @pytest.mark.parametrize("custom_formatters", (None, {}))
+    def test_string_format_unknown(self, custom_formatters):
         unknown_format = 'unknown'
         schema = Schema('string', schema_format=unknown_format)
         value = 'x'
 
         with pytest.raises(OpenAPISchemaError):
-            schema.unmarshal(value)
+            schema.unmarshal(value, custom_formatters)
 
-    @pytest.mark.xfail(reason="No custom formats support atm")
     def test_string_format_invalid_value(self):
         custom_format = 'custom'
         schema = Schema('string', schema_format=custom_format)
         value = 'x'
 
-        with mock.patch.dict(
-            Schema.STRING_FORMAT_CAST_CALLABLE_GETTER,
-            {custom_format: mock.Mock(side_effect=ValueError())},
-        ), pytest.raises(
-            InvalidSchemaValue, message='Failed to format value'
+        def _raise(e): raise e()
+
+        custom_formatters = {
+            custom_format: mock.Mock(unmarshal=lambda x: _raise(ValueError))
+        }
+
+        with pytest.raises(
+            InvalidSchemaValue,
+            message='Failed to format value'
         ):
-            schema.unmarshal(value)
+            schema.unmarshal(value, custom_formatters)
 
     def test_integer_valid(self):
         schema = Schema('integer')
@@ -171,6 +177,38 @@ def test_integer_invalid(self):
         with pytest.raises(InvalidSchemaValue):
             schema.unmarshal(value)
 
+    def test_any_no_valid_schema(self):
+        schema = Schema()
+
+        class Uncastable:
+            def _raise(self):
+                raise ValueError()
+            __nonzero__ = __bool__ = __trunc__ = __float__ = __str__ = _raise
+
+        value = Uncastable()
+
+        with pytest.raises(NoValidSchema):
+            schema.unmarshal(value)
+
+    def test_multiple_one_of(self):
+        schema = Schema('object', one_of=[
+            Schema('object', properties={
+                'one': Schema('string')
+            }),
+            Schema('object', properties={
+                'one': Schema('string')
+            }),
+        ])
+        with pytest.raises(MultipleOneOfSchema):
+            schema.unmarshal({'one': 'one'})
+
+    def test_invalid_schema_property(self):
+        schema = Schema('object', properties={
+            'one': Schema('integer')
+        })
+        with pytest.raises(InvalidSchemaProperty):
+            schema.unmarshal({'one': 'one'})
+
 
 class TestSchemaValidate(object):
 
@@ -763,3 +801,34 @@ def test_list_unique_items_invalid(self, value):
 
         with pytest.raises(Exception):
             schema.validate(value)
+
+    @pytest.mark.parametrize('schema,value', [
+        (Schema('array', items=Schema('number'), min_items=-1), []),
+        (Schema('array', items=Schema('number'), max_items=-1), []),
+        (Schema('string', min_length=-1), u('')),
+        (Schema('string', max_length=-1), u('')),
+        (Schema('object', min_properties=-1), Model()),
+        (Schema('object', max_properties=-1), Model()),
+    ])
+    def test_validate_invalid_schema(self, schema, value):
+        with pytest.raises(InvalidSchema):
+            schema.validate(value)
+
+    @pytest.mark.parametrize('custom_formatters', [
+        {},
+        None,
+    ])
+    def test_validate_string_format_unknown(self, custom_formatters):
+        unknown_format = 'unknown'
+        schema = Schema('string', schema_format=unknown_format)
+        value = 'x'
+
+        with pytest.raises(InvalidFormat):
+            schema.validate(value, custom_formatters)
+
+    def test_invalid_schema_property(self):
+        schema = Schema('object', properties={
+            'one': Schema('integer')
+        })
+        with pytest.raises(InvalidSchemaProperty):
+            schema.validate(Model({'one': 'one'}))