OAS 3.0 validator

Author: p1c2u

openapi_core/schema/media_types/models.py

@@ -32,17 +32,26 @@ def deserialize(self, value):
         deserializer = self.get_dererializer()
         return deserializer(value)
 
-    def unmarshal(self, value, custom_formatters=None):
+    def cast(self, value):
         if not self.schema:
             return value
 
         try:
-            deserialized = self.deserialize(value)
+            return self.deserialize(value)
         except ValueError as exc:
             raise InvalidMediaTypeValue(exc)
 
+    def unmarshal(self, value, custom_formatters=None, resolver=None):
+        if not self.schema:
+            return value
+
+        try:
+            self.schema.validate(value, resolver=resolver)
+        except OpenAPISchemaError as exc:
+            raise InvalidMediaTypeValue(exc)
+
         try:
-            unmarshalled = self.schema.unmarshal(deserialized, custom_formatters=custom_formatters)
+            unmarshalled = self.schema.unmarshal(value, custom_formatters=custom_formatters)
         except OpenAPISchemaError as exc:
             raise InvalidMediaTypeValue(exc)
 

openapi_core/schema/parameters/models.py

@@ -72,7 +72,7 @@ def deserialize(self, value):
         deserializer = self.get_dererializer()
         return deserializer(value)
 
-    def get_value(self, request):
+    def get_raw_value(self, request):
         location = request.parameters[self.location.value]
 
         if self.name not in location:
@@ -89,7 +89,7 @@ def get_value(self, request):
 
         return location[self.name]
 
-    def unmarshal(self, value, custom_formatters=None):
+    def cast(self, value):
         if self.deprecated:
             warnings.warn(
                 "{0} parameter is deprecated".format(self.name),
@@ -109,13 +109,22 @@ def unmarshal(self, value, custom_formatters=None):
             raise InvalidParameterValue(self.name, exc)
 
         try:
-            casted = self.schema.cast(deserialized)
+            return self.schema.cast(deserialized)
+        except OpenAPISchemaError as exc:
+            raise InvalidParameterValue(self.name, exc)
+
+    def unmarshal(self, value, custom_formatters=None, resolver=None):
+        if not self.schema:
+            return value
+
+        try:
+            self.schema.validate(value, resolver=resolver)
         except OpenAPISchemaError as exc:
             raise InvalidParameterValue(self.name, exc)
 
         try:
             unmarshalled = self.schema.unmarshal(
-                casted,
+                value,
                 custom_formatters=custom_formatters,
                 strict=True,
             )

openapi_core/schema/schemas/_format.py

@@ -0,0 +1,9 @@
+from jsonschema._format import FormatChecker
+from six import binary_type
+
+oas30_format_checker = FormatChecker()
+
+
+@oas30_format_checker.checks('binary')
+def binary(value):
+    return isinstance(value, binary_type)

openapi_core/schema/schemas/_types.py

@@ -0,0 +1,21 @@
+from jsonschema._types import (
+    TypeChecker, is_any, is_array, is_bool, is_integer,
+    is_object, is_number,
+)
+from six import text_type, binary_type
+
+
+def is_string(checker, instance):
+    return isinstance(instance, (text_type, binary_type))
+
+
+oas30_type_checker = TypeChecker(
+    {
+        u"string": is_string,
+        u"number": is_number,
+        u"integer": is_integer,
+        u"boolean": is_bool,
+        u"array": is_array,
+        u"object": is_object,
+    },
+)

openapi_core/schema/schemas/_validators.py

@@ -0,0 +1,27 @@
+from jsonschema.exceptions import ValidationError
+
+
+def type(validator, data_type, instance, schema):
+    if instance is None:
+        return
+
+    if not validator.is_type(instance, data_type):
+        yield ValidationError("%r is not of type %s" % (instance, data_type))
+
+
+def items(validator, items, instance, schema):
+    if not validator.is_type(instance, "array"):
+        return
+
+    for index, item in enumerate(instance):
+        for error in validator.descend(item, items, path=index):
+            yield error
+
+
+def nullable(validator, is_nullable, instance, schema):
+    if instance is None and not is_nullable:
+        yield ValidationError("None for not nullable")
+
+
+def not_implemented(validator, value, instance, schema):
+    pass

openapi_core/schema/schemas/factories.py

@@ -50,11 +50,11 @@ def create(self, schema_spec):
 
         all_of = []
         if all_of_spec:
-            all_of = map(self.create, all_of_spec)
+            all_of = list(map(self.create, all_of_spec))
 
         one_of = []
         if one_of_spec:
-            one_of = map(self.create, one_of_spec)
+            one_of = list(map(self.create, one_of_spec))
 
         items = None
         if items_spec:
@@ -76,6 +76,7 @@ def create(self, schema_spec):
             exclusive_maximum=exclusive_maximum,
             exclusive_minimum=exclusive_minimum,
             min_properties=min_properties, max_properties=max_properties,
+            _source=schema_deref,
         )
 
     @property

openapi_core/schema/schemas/models.py

@@ -9,8 +9,10 @@
 import warnings
 
 from six import iteritems, integer_types, binary_type, text_type
+from jsonschema.exceptions import ValidationError
 
 from openapi_core.extensions.models.factories import ModelFactory
+from openapi_core.schema.schemas._format import oas30_format_checker
 from openapi_core.schema.schemas.enums import SchemaFormat, SchemaType
 from openapi_core.schema.schemas.exceptions import (
     InvalidSchemaValue, UndefinedSchemaProperty, MissingSchemaProperty,
@@ -23,7 +25,7 @@
     format_number,
 )
 from openapi_core.schema.schemas.validators import (
-    TypeValidator, AttributeValidator,
+    TypeValidator, AttributeValidator, OAS30Validator,
 )
 
 log = logging.getLogger(__name__)
@@ -85,7 +87,7 @@ def __init__(
             min_length=None, max_length=None, pattern=None, unique_items=False,
             minimum=None, maximum=None, multiple_of=None,
             exclusive_minimum=False, exclusive_maximum=False,
-            min_properties=None, max_properties=None):
+            min_properties=None, max_properties=None, _source=None):
         self.type = SchemaType(schema_type)
         self.model = model
         self.properties = properties and dict(properties) or {}
@@ -119,6 +121,8 @@ def __init__(
         self._all_required_properties_cache = None
         self._all_optional_properties_cache = None
 
+        self._source = _source
+
     def __getitem__(self, name):
         return self.properties[name]
 
@@ -214,6 +218,18 @@ def get_unmarshal_mapping(self, custom_formatters=None, strict=True):
 
         return defaultdict(lambda: lambda x: x, mapping)
 
+    def get_validator(self, resolver=None):
+        return OAS30Validator(
+            self._source, resolver=resolver, format_checker=oas30_format_checker)
+
+    def validate(self, value, resolver=None):
+        validator = self.get_validator(resolver=resolver)
+        try:
+            return validator.validate(value)
+        except ValidationError:
+            # TODO: pass validation errors
+            raise InvalidSchemaValue("Value not valid for schema", value, self.type)
+
     def unmarshal(self, value, custom_formatters=None, strict=True):
         """Unmarshal parameter from the value."""
         if self.deprecated:
@@ -241,10 +257,7 @@ def unmarshal(self, value, custom_formatters=None, strict=True):
                 "Value {value} is not of type {type}", value, self.type)
         except ValueError:
             raise InvalidSchemaValue(
-                "Failed to cast value {value} to type {type}", value, self.type)
-
-        if unmarshalled is None and not self.required:
-            return None
+                "Failed to unmarshal value {value} to type {type}", value, self.type)
 
         return unmarshalled
 
@@ -297,8 +310,7 @@ def _unmarshal_any(self, value, custom_formatters=None, strict=True):
                     return unmarshal_callable(value)
                 except UnmarshallerStrictTypeError:
                     continue
-                # @todo: remove ValueError when validation separated
-                except (OpenAPISchemaError, TypeError, ValueError):
+                except (OpenAPISchemaError, TypeError):
                     continue
 
         raise NoValidSchema(value)
@@ -307,9 +319,6 @@ def _unmarshal_collection(self, value, custom_formatters=None, strict=True):
         if not isinstance(value, (list, tuple)):
             raise InvalidSchemaValue("Value {value} is not of type {type}", value, self.type)
 
-        if self.items is None:
-            raise UndefinedItemsSchema(self.type)
-
         f = functools.partial(
             self.items.unmarshal,
             custom_formatters=custom_formatters, strict=strict,

openapi_core/schema/schemas/validators.py

@@ -1,3 +1,10 @@
+from jsonschema import _legacy_validators, _format, _types, _utils, _validators
+from jsonschema.validators import create
+
+from openapi_core.schema.schemas import _types as oas_types
+from openapi_core.schema.schemas import _validators as oas_validators
+
+
 class TypeValidator(object):
 
     def __init__(self, *types, **options):
@@ -24,3 +31,50 @@ def __call__(self, value):
             return False
 
         return True
+
+
+OAS30Validator = create(
+    meta_schema=_utils.load_schema("draft4"),
+    validators={
+        u"multipleOf": _validators.multipleOf,
+        u"maximum": _legacy_validators.maximum_draft3_draft4,
+        u"exclusiveMaximum": _validators.exclusiveMaximum,
+        u"minimum": _legacy_validators.minimum_draft3_draft4,
+        u"exclusiveMinimum": _validators.exclusiveMinimum,
+        u"maxLength": _validators.maxLength,
+        u"minLength": _validators.minLength,
+        u"pattern": _validators.pattern,
+        u"maxItems": _validators.maxItems,
+        u"minItems": _validators.minItems,
+        u"uniqueItems": _validators.uniqueItems,
+        u"maxProperties": _validators.maxProperties,
+        u"minProperties": _validators.minProperties,
+        u"required": _validators.required,
+        u"enum": _validators.enum,
+        # adjusted to OAS
+        u"type": oas_validators.type,
+        u"allOf": _validators.allOf,
+        u"oneOf": _validators.oneOf,
+        u"anyOf": _validators.anyOf,
+        u"not": _validators.not_,
+        u"items": oas_validators.items,
+        u"properties": _validators.properties,
+        u"additionalProperties": _validators.additionalProperties,
+        # TODO: adjust description
+        u"format": _validators.format,
+        # TODO: adjust default
+        u"$ref": _validators.ref,
+        # fixed OAS fields
+        u"nullable": oas_validators.nullable,
+        u"discriminator": oas_validators.not_implemented,
+        u"readOnly": oas_validators.not_implemented,
+        u"writeOnly": oas_validators.not_implemented,
+        u"xml": oas_validators.not_implemented,
+        u"externalDocs": oas_validators.not_implemented,
+        u"example": oas_validators.not_implemented,
+        u"deprecated": oas_validators.not_implemented,
+    },
+    type_checker=oas_types.oas30_type_checker,
+    version="oas30",
+    id_of=lambda schema: schema.get(u"id", ""),
+)

openapi_core/schema/specs/factories.py

@@ -2,6 +2,7 @@
 """OpenAPI core specs factories module"""
 
 from openapi_spec_validator import openapi_v3_spec_validator
+from openapi_spec_validator.validators import Dereferencer
 
 from openapi_core.compat import lru_cache
 from openapi_core.schema.components.factories import ComponentsFactory
@@ -14,8 +15,8 @@
 
 class SpecFactory(object):
 
-    def __init__(self, dereferencer, config=None):
-        self.dereferencer = dereferencer
+    def __init__(self, spec_resolver, config=None):
+        self.spec_resolver = spec_resolver
         self.config = config or {}
 
     def create(self, spec_dict, spec_url=''):
@@ -34,9 +35,16 @@ def create(self, spec_dict, spec_url=''):
         paths = self.paths_generator.generate(paths)
         components = self.components_factory.create(components_spec)
         spec = Spec(
-            info, list(paths), servers=list(servers), components=components)
+            info, list(paths), servers=list(servers), components=components,
+            _resolver=self.spec_resolver,
+        )
         return spec
 
+    @property
+    @lru_cache()
+    def dereferencer(self):
+        return Dereferencer(self.spec_resolver)
+
     @property
     @lru_cache()
     def schemas_registry(self):

openapi_core/schema/specs/models.py

@@ -14,12 +14,14 @@
 class Spec(object):
     """Represents an OpenAPI Specification for a service."""
 
-    def __init__(self, info, paths, servers=None, components=None):
+    def __init__(self, info, paths, servers=None, components=None, _resolver=None):
         self.info = info
         self.paths = paths and dict(paths)
         self.servers = servers or []
         self.components = components
 
+        self._resolver = _resolver
+
     def __getitem__(self, path_pattern):
         return self.get_path(path_pattern)