Merge pull request #318 from p1c2u/feature/spec-path

Spec path

Author: p1c2u

Diff for: openapi_core/casting/schemas/casters.py

@@ -1,5 +1,7 @@
+from __future__ import division
+
 from openapi_core.casting.schemas.exceptions import CastError
-from openapi_core.schema.schemas.types import NoValue
+from openapi_core.types import NoValue
 
 
 class PrimitiveCaster(object):
@@ -14,7 +16,7 @@ def __call__(self, value):
         try:
             return self.caster_callable(value)
         except (ValueError, TypeError):
-            raise CastError(value, self.schema.type.value)
+            raise CastError(value, self.schema['type'])
 
 
 class DummyCaster(object):
@@ -31,7 +33,7 @@ def __init__(self, schema, casters_factory):
 
     @property
     def items_caster(self):
-        return self.casters_factory.create(self.schema.items)
+        return self.casters_factory.create(self.schema / 'items')
 
     def __call__(self, value):
         if value in (None, NoValue):

Diff for: openapi_core/casting/schemas/factories.py

@@ -1,5 +1,3 @@
-from openapi_core.schema.schemas.enums import SchemaType
-
 from openapi_core.casting.schemas.casters import (
     PrimitiveCaster, DummyCaster, ArrayCaster
 )
@@ -9,23 +7,24 @@
 class SchemaCastersFactory(object):
 
     DUMMY_CASTERS = [
-        SchemaType.STRING, SchemaType.OBJECT, SchemaType.ANY,
+        'string', 'object', 'any',
     ]
     PRIMITIVE_CASTERS = {
-        SchemaType.INTEGER: int,
-        SchemaType.NUMBER: float,
-        SchemaType.BOOLEAN: forcebool,
+        'integer': int,
+        'number': float,
+        'boolean': forcebool,
     }
     COMPLEX_CASTERS = {
-        SchemaType.ARRAY: ArrayCaster,
+        'array': ArrayCaster,
     }
 
     def create(self, schema):
-        if schema.type in self.DUMMY_CASTERS:
+        schema_type = schema.getkey('type', 'any')
+        if schema_type in self.DUMMY_CASTERS:
             return DummyCaster()
-        elif schema.type in self.PRIMITIVE_CASTERS:
-            caster_callable = self.PRIMITIVE_CASTERS[schema.type]
+        elif schema_type in self.PRIMITIVE_CASTERS:
+            caster_callable = self.PRIMITIVE_CASTERS[schema_type]
             return PrimitiveCaster(schema, caster_callable)
-        elif schema.type in self.COMPLEX_CASTERS:
-            caster_class = self.COMPLEX_CASTERS[schema.type]
+        elif schema_type in self.COMPLEX_CASTERS:
+            caster_class = self.COMPLEX_CASTERS[schema_type]
             return caster_class(schema, self)

Diff for: openapi_core/deserializing/media_types/factories.py

@@ -20,11 +20,11 @@ def __init__(self, custom_deserializers=None):
             custom_deserializers = {}
         self.custom_deserializers = custom_deserializers
 
-    def create(self, media_type):
+    def create(self, mimetype):
         deserialize_callable = self.get_deserializer_callable(
-            media_type.mimetype)
+            mimetype)
         return PrimitiveDeserializer(
-            media_type.mimetype, deserialize_callable)
+            mimetype, deserialize_callable)
 
     def get_deserializer_callable(self, mimetype):
         if mimetype in self.custom_deserializers:

Diff for: openapi_core/deserializing/parameters/deserializers.py

@@ -2,7 +2,7 @@
 from openapi_core.deserializing.parameters.exceptions import (
     EmptyParameterValue,
 )
-from openapi_core.schema.parameters.enums import ParameterLocation
+from openapi_core.schema.parameters import get_aslist, get_explode, get_style
 
 
 class PrimitiveDeserializer(object):
@@ -11,15 +11,19 @@ def __init__(self, param, deserializer_callable):
         self.param = param
         self.deserializer_callable = deserializer_callable
 
+        self.aslist = get_aslist(self.param)
+        self.explode = get_explode(self.param)
+        self.style = get_style(self.param)
+
     def __call__(self, value):
-        if (self.param.location == ParameterLocation.QUERY and value == "" and
-                not self.param.allow_empty_value):
+        if (self.param['in'] == 'query' and value == "" and
+                not self.param.getkey('allowEmptyValue', False)):
             raise EmptyParameterValue(
-                value, self.param.style, self.param.name)
+                value, self.style, self.param['name'])
 
-        if not self.param.aslist or self.param.explode:
+        if not self.aslist or self.explode:
             return value
         try:
             return self.deserializer_callable(value)
         except (ValueError, TypeError, AttributeError):
-            raise DeserializeError(value, self.param.style)
+            raise DeserializeError(value, self.style)

Diff for: openapi_core/deserializing/parameters/factories.py

@@ -3,24 +3,26 @@
 from openapi_core.deserializing.parameters.deserializers import (
     PrimitiveDeserializer,
 )
-from openapi_core.schema.parameters.enums import ParameterStyle
+from openapi_core.schema.parameters import get_style
 
 
 class ParameterDeserializersFactory(object):
 
     PARAMETER_STYLE_DESERIALIZERS = {
-        ParameterStyle.FORM: lambda x: x.split(','),
-        ParameterStyle.SIMPLE: lambda x: x.split(','),
-        ParameterStyle.SPACE_DELIMITED: lambda x: x.split(' '),
-        ParameterStyle.PIPE_DELIMITED: lambda x: x.split('|'),
+        'form': lambda x: x.split(','),
+        'simple': lambda x: x.split(','),
+        'spaceDelimited': lambda x: x.split(' '),
+        'pipeDelimited': lambda x: x.split('|'),
     }
 
     def create(self, param):
-        if param.deprecated:
+        if param.getkey('deprecated', False):
             warnings.warn(
-                "{0} parameter is deprecated".format(param.name),
+                "{0} parameter is deprecated".format(param['name']),
                 DeprecationWarning,
             )
 
-        deserialize_callable = self.PARAMETER_STYLE_DESERIALIZERS[param.style]
+        style = get_style(param)
+
+        deserialize_callable = self.PARAMETER_STYLE_DESERIALIZERS[style]
         return PrimitiveDeserializer(param, deserialize_callable)

Diff for: openapi_core/exceptions.py

@@ -1,5 +1,56 @@
 """OpenAPI core exceptions module"""
+import attr
 
 
 class OpenAPIError(Exception):
     pass
+
+
+class OpenAPIParameterError(OpenAPIError):
+    pass
+
+
+class MissingParameterError(OpenAPIParameterError):
+    """Missing parameter error"""
+    pass
+
+
+@attr.s(hash=True)
+class MissingParameter(MissingParameterError):
+    name = attr.ib()
+
+    def __str__(self):
+        return "Missing parameter (without default value): {0}".format(
+            self.name)
+
+
+@attr.s(hash=True)
+class MissingRequiredParameter(MissingParameterError):
+    name = attr.ib()
+
+    def __str__(self):
+        return "Missing required parameter: {0}".format(self.name)
+
+
+class OpenAPIRequestBodyError(OpenAPIError):
+    pass
+
+
+@attr.s(hash=True)
+class MissingRequestBody(OpenAPIRequestBodyError):
+    request = attr.ib()
+
+    def __str__(self):
+        return "Missing required request body"
+
+
+class OpenAPIResponseError(OpenAPIError):
+    pass
+
+
+@attr.s(hash=True)
+class MissingResponseContent(OpenAPIResponseError):
+    response = attr.ib()
+
+    def __str__(self):
+        return "Missing response content"