Merge pull request #9 from p1c2u/feature/request-validator

Request validator

Author: p1c2u

README.rst

@@ -51,10 +51,31 @@ Now you can use it to validate and unmarshal requests
 
 .. code-block:: python
 
-   from openapi_core import request_parameters_factory, request_body_factory
+   from openapi_core.validators import RequestValidator
 
-   parameters = request_parameters_factory.create(request, spec)
-   body = request_body_factory.create(request, spec)
+   validator = RequestValidator(spec)
+   result = validator.validate(request)
+
+   # raise errors if request invalid
+   result.validate()
+
+   # get parameters
+   path_params = result.parameters['path']
+   query_params = result.parameters['query']
+
+   # get body
+   body = result.body
+
+Request object should implement BaseOpenAPIRequest interface. You can use FlaskOpenAPIRequest a Flask/Werkzeug request wrapper implementation:
+
+.. code-block:: python
+
+   from openapi_core.validators import RequestValidator
+   from openapi_core.wrappers import FlaskOpenAPIRequest
+
+   openapi_request = FlaskOpenAPIRequest(flask_request)
+   validator = RequestValidator(spec)
+   result = validator.validate(openapi_request)
 
 Related projects
 ================

openapi_core/__init__.py

@@ -1,14 +1,12 @@
 """OpenAPI core module"""
-from openapi_core.shortcuts import create_spec
-from openapi_core.wrappers import RequestParametersFactory, RequestBodyFactory
+from openapi_core.shortcuts import (
+    create_spec, validate_parameters, validate_body,
+)
 
 __author__ = 'Artur Maciąg'
 __email__ = 'maciag.artur@gmail.com'
 __version__ = '0.2.2'
 __url__ = 'https://github.com/p1c2u/openapi-core'
 __license__ = 'BSD 3-Clause License'
 
-__all__ = ['create_spec', 'request_parameters_factory', 'request_body_factory']
-
-request_parameters_factory = RequestParametersFactory()
-request_body_factory = RequestBodyFactory()
+__all__ = ['create_spec', 'validate_parameters', 'validate_body']

openapi_core/exceptions.py

@@ -9,37 +9,65 @@ class OpenAPIMappingError(OpenAPIError):
     pass
 
 
-class MissingParameterError(OpenAPIMappingError):
+class OpenAPIServerError(OpenAPIMappingError):
     pass
 
 
-class MissingPropertyError(OpenAPIMappingError):
+class OpenAPIOperationError(OpenAPIMappingError):
     pass
 
 
-class InvalidContentTypeError(OpenAPIMappingError):
+class InvalidValueType(OpenAPIMappingError):
     pass
 
 
-class InvalidOperationError(OpenAPIMappingError):
+class OpenAPIParameterError(OpenAPIMappingError):
     pass
 
 
-class InvalidServerError(OpenAPIMappingError):
+class OpenAPIBodyError(OpenAPIMappingError):
     pass
 
 
-class InvalidValueType(OpenAPIMappingError):
+class InvalidServer(OpenAPIServerError):
     pass
 
 
-class InvalidValue(OpenAPIMappingError):
+class InvalidOperation(OpenAPIOperationError):
     pass
 
 
-class EmptyValue(OpenAPIMappingError):
+class EmptyValue(OpenAPIParameterError):
     pass
 
 
-class UndefinedSchemaProperty(OpenAPIMappingError):
+class MissingParameter(OpenAPIParameterError):
+    pass
+
+
+class InvalidParameterValue(OpenAPIParameterError):
+    pass
+
+
+class MissingBody(OpenAPIBodyError):
+    pass
+
+
+class InvalidMediaTypeValue(OpenAPIBodyError):
+    pass
+
+
+class UndefinedSchemaProperty(OpenAPIBodyError):
+    pass
+
+
+class MissingProperty(OpenAPIBodyError):
+    pass
+
+
+class InvalidContentType(OpenAPIBodyError):
+    pass
+
+
+class InvalidValue(OpenAPIMappingError):
     pass

openapi_core/media_types.py

@@ -1,6 +1,8 @@
 """OpenAPI core mediaTypes module"""
 from six import iteritems
 
+from openapi_core.exceptions import InvalidValueType, InvalidMediaTypeValue
+
 
 class MediaType(object):
     """Represents an OpenAPI MediaType."""
@@ -13,7 +15,10 @@ def unmarshal(self, value):
         if not self.schema:
             return value
 
-        return self.schema.unmarshal(value)
+        try:
+            return self.schema.unmarshal(value)
+        except InvalidValueType as exc:
+            raise InvalidMediaTypeValue(str(exc))
 
 
 class MediaTypeGenerator(object):

openapi_core/parameters.py

@@ -2,7 +2,9 @@
 import logging
 import warnings
 
-from openapi_core.exceptions import EmptyValue
+from openapi_core.exceptions import (
+    EmptyValue, InvalidValueType, InvalidParameterValue,
+)
 
 log = logging.getLogger(__name__)
 
@@ -35,12 +37,15 @@ def unmarshal(self, value):
         if (self.location == "query" and value == "" and
                 not self.allow_empty_value):
             raise EmptyValue(
-                "Value of {0} parameter cannot be empty.".format(self.name))
+                "Value of {0} parameter cannot be empty".format(self.name))
 
         if not self.schema:
             return value
 
-        return self.schema.unmarshal(value)
+        try:
+            return self.schema.unmarshal(value)
+        except InvalidValueType as exc:
+            raise InvalidParameterValue(str(exc))
 
 
 class ParametersGenerator(object):

openapi_core/request_bodies.py

@@ -1,6 +1,7 @@
 """OpenAPI core requestBodies module"""
 from functools import lru_cache
 
+from openapi_core.exceptions import InvalidContentType
 from openapi_core.media_types import MediaTypeGenerator
 
 
@@ -12,7 +13,11 @@ def __init__(self, content, required=False):
         self.required = required
 
     def __getitem__(self, mimetype):
-        return self.content[mimetype]
+        try:
+            return self.content[mimetype]
+        except KeyError:
+            raise InvalidContentType(
+                "Invalid mime type `{0}`".format(mimetype))
 
 
 class RequestBodyFactory(object):

openapi_core/schemas.py

@@ -10,8 +10,7 @@
 from six import iteritems
 
 from openapi_core.exceptions import (
-    InvalidValueType, UndefinedSchemaProperty, MissingPropertyError,
-    InvalidValue,
+    InvalidValueType, UndefinedSchemaProperty, MissingProperty, InvalidValue,
 )
 from openapi_core.models import ModelFactory
 
@@ -59,7 +58,8 @@ def cast(self, value):
         if value is None:
             if not self.nullable:
                 raise InvalidValueType(
-                    "Failed to cast value of %s to %s", value, self.type,
+                    "Failed to cast value of {0} to {1}".format(
+                        value, self.type)
                 )
             return self.default
 
@@ -73,7 +73,7 @@ def cast(self, value):
             return cast_callable(value)
         except ValueError:
             raise InvalidValueType(
-                "Failed to cast value of %s to %s", value, self.type,
+                "Failed to cast value of {0} to {1}".format(value, self.type)
             )
 
     def unmarshal(self, value):
@@ -88,7 +88,8 @@ def unmarshal(self, value):
 
         if self.enum and casted not in self.enum:
             raise InvalidValue(
-                "Value of %s not in enum choices: %s", value, str(self.enum),
+                "Value of {0} not in enum choices: {1}".format(
+                    value, self.enum)
             )
 
         return casted
@@ -115,7 +116,7 @@ def _unmarshal_object(self, value):
                 prop_value = value[prop_name]
             except KeyError:
                 if prop_name in self.required:
-                    raise MissingPropertyError(
+                    raise MissingProperty(
                         "Missing schema property {0}".format(prop_name))
                 if not prop.nullable and not prop.default:
                     continue

openapi_core/shortcuts.py

@@ -3,7 +3,9 @@
 from openapi_spec_validator.validators import Dereferencer
 from openapi_spec_validator import default_handlers
 
+from openapi_core.exceptions import OpenAPIParameterError, OpenAPIBodyError
 from openapi_core.specs import SpecFactory
+from openapi_core.validators import RequestValidator
 
 
 def create_spec(spec_dict, spec_url=''):
@@ -12,3 +14,25 @@ def create_spec(spec_dict, spec_url=''):
     dereferencer = Dereferencer(spec_resolver)
     spec_factory = SpecFactory(dereferencer)
     return spec_factory.create(spec_dict, spec_url=spec_url)
+
+
+def validate_parameters(spec, request):
+    validator = RequestValidator(spec)
+    result = validator.validate(request)
+    try:
+        result.validate()
+    except OpenAPIBodyError:
+        return result.parameters
+    else:
+        return result.parameters
+
+
+def validate_body(spec, request):
+    validator = RequestValidator(spec)
+    result = validator.validate(request)
+    try:
+        result.validate()
+    except OpenAPIParameterError:
+        return result.body
+    else:
+        return result.body

openapi_core/specs.py

@@ -6,7 +6,7 @@
 from openapi_spec_validator import openapi_v3_spec_validator
 
 from openapi_core.components import ComponentsFactory
-from openapi_core.exceptions import InvalidOperationError
+from openapi_core.exceptions import InvalidOperation, InvalidServer
 from openapi_core.infos import InfoFactory
 from openapi_core.paths import PathsGenerator
 from openapi_core.schemas import SchemaRegistry
@@ -32,14 +32,22 @@ def __getitem__(self, path_name):
     def default_url(self):
         return self.servers[0].default_url
 
+    def get_server(self, full_url_pattern):
+        for spec_server in self.servers:
+            if spec_server.default_url in full_url_pattern:
+                return spec_server
+
+        raise InvalidServer(
+            "Invalid request server {0}".format(full_url_pattern))
+
     def get_server_url(self, index=0):
         return self.servers[index].default_url
 
     def get_operation(self, path_pattern, http_method):
         try:
             return self.paths[path_pattern].operations[http_method]
         except KeyError:
-            raise InvalidOperationError(
+            raise InvalidOperation(
                 "Unknown operation path {0} with method {1}".format(
                     path_pattern, http_method))