Shortcuts cleanup

openapi_core/schema/shortcuts.py

@@ -0,0 +1,12 @@
+"""OpenAPI core schema shortcuts module"""
+from jsonschema.validators import RefResolver
+from openapi_spec_validator import default_handlers
+
+from openapi_core.schema.specs.factories import SpecFactory
+
+
+def create_spec(spec_dict, spec_url='', handlers=default_handlers):
+    spec_resolver = RefResolver(
+        spec_url, spec_dict, handlers=handlers)
+    spec_factory = SpecFactory(spec_resolver)
+    return spec_factory.create(spec_dict, spec_url=spec_url)

openapi_core/shortcuts.py

@@ -1,71 +1,14 @@
 """OpenAPI core shortcuts module"""
-from jsonschema.validators import RefResolver
-from openapi_spec_validator import default_handlers
-
-from openapi_core.schema.media_types.exceptions import OpenAPIMediaTypeError
-from openapi_core.schema.parameters.exceptions import OpenAPIParameterError
-from openapi_core.schema.request_bodies.exceptions import (
-    OpenAPIRequestBodyError,
+# backward compatibility
+from openapi_core.schema.shortcuts import create_spec
+from openapi_core.validation.request.shortcuts import (
+    spec_validate_body as validate_body,
+    spec_validate_parameters as validate_parameters,
+)
+from openapi_core.validation.response.shortcuts import (
+    spec_validate_data as validate_data
 )
-from openapi_core.schema.schemas.exceptions import OpenAPISchemaError
-from openapi_core.schema.specs.factories import SpecFactory
-from openapi_core.validation.request.validators import RequestValidator
-from openapi_core.validation.response.validators import ResponseValidator
-
-
-def create_spec(spec_dict, spec_url=''):
-    spec_resolver = RefResolver(
-        spec_url, spec_dict, handlers=default_handlers)
-    spec_factory = SpecFactory(spec_resolver)
-    return spec_factory.create(spec_dict, spec_url=spec_url)
-
-
-def validate_parameters(spec, request, request_factory=None):
-    if request_factory is not None:
-        request = request_factory(request)
-
-    validator = RequestValidator(spec)
-    result = validator.validate(request)
-
-    try:
-        result.raise_for_errors()
-    except (
-            OpenAPIRequestBodyError, OpenAPIMediaTypeError,
-            OpenAPISchemaError,
-    ):
-        return result.parameters
-    else:
-        return result.parameters
-
-
-def validate_body(spec, request, request_factory=None):
-    if request_factory is not None:
-        request = request_factory(request)
-
-    validator = RequestValidator(spec)
-    result = validator.validate(request)
-
-    try:
-        result.raise_for_errors()
-    except OpenAPIParameterError:
-        return result.body
-    else:
-        return result.body
-
-
-def validate_data(
-        spec, request, response,
-        request_factory=None,
-        response_factory=None):
-    if request_factory is not None:
-        request = request_factory(request)
-
-    if response_factory is not None:
-        response = response_factory(response)
-
-    validator = ResponseValidator(spec)
-    result = validator.validate(request, response)
-
-    result.raise_for_errors()
 
-    return result.data
+__all__ = [
+    'create_spec', 'validate_body', 'validate_parameters', 'validate_data',
+]

openapi_core/testing/datatypes.py

@@ -0,0 +1,18 @@
+class ResultMock(object):
+
+    def __init__(
+            self, body=None, parameters=None, data=None, error_to_raise=None):
+        self.body = body
+        self.parameters = parameters
+        self.data = data
+        self.error_to_raise = error_to_raise
+
+    def raise_for_errors(self):
+        if self.error_to_raise is not None:
+            raise self.error_to_raise
+
+        if self.parameters is not None:
+            return self.parameters
+
+        if self.data is not None:
+            return self.data

openapi_core/testing/factories.py

@@ -0,0 +1,11 @@
+class FactoryClassMock(object):
+
+    _instances = {}
+
+    def __new__(cls, obj):
+        if obj not in cls._instances:
+            cls._instances[obj] = object.__new__(cls)
+        return cls._instances[obj]
+
+    def __init__(self, obj):
+        self.obj = obj

openapi_core/testing/mock.py

@@ -1,45 +1,6 @@
 """OpenAPI core testing mock module"""
-from werkzeug.datastructures import ImmutableMultiDict
+# backward compatibility
+from openapi_core.testing.requests import MockRequestFactory
+from openapi_core.testing.responses import MockResponseFactory
 
-from openapi_core.validation.request.datatypes import (
-    RequestParameters, OpenAPIRequest,
-)
-from openapi_core.validation.response.datatypes import OpenAPIResponse
-
-
-class MockRequestFactory(object):
-
-    @classmethod
-    def create(
-            cls, host_url, method, path, path_pattern=None, args=None,
-            view_args=None, headers=None, cookies=None, data=None,
-            mimetype='application/json'):
-        parameters = RequestParameters(
-            path=view_args or {},
-            query=ImmutableMultiDict(args or []),
-            header=headers or {},
-            cookie=cookies or {},
-        )
-        path_pattern = path_pattern or path
-        method = method.lower()
-        body = data or ''
-        return OpenAPIRequest(
-            host_url=host_url,
-            path=path,
-            path_pattern=path_pattern,
-            method=method,
-            parameters=parameters,
-            body=body,
-            mimetype=mimetype,
-        )
-
-
-class MockResponseFactory(object):
-
-    @classmethod
-    def create(cls, data, status_code=200, mimetype='application/json'):
-        return OpenAPIResponse(
-            data=data,
-            status_code=status_code,
-            mimetype=mimetype,
-        )
+__all__ = ['MockRequestFactory', 'MockResponseFactory']

openapi_core/testing/requests.py

@@ -0,0 +1,33 @@
+"""OpenAPI core testing requests module"""
+from werkzeug.datastructures import ImmutableMultiDict
+
+from openapi_core.validation.request.datatypes import (
+    RequestParameters, OpenAPIRequest,
+)
+
+
+class MockRequestFactory(object):
+
+    @classmethod
+    def create(
+            cls, host_url, method, path, path_pattern=None, args=None,
+            view_args=None, headers=None, cookies=None, data=None,
+            mimetype='application/json'):
+        parameters = RequestParameters(
+            path=view_args or {},
+            query=ImmutableMultiDict(args or []),
+            header=headers or {},
+            cookie=cookies or {},
+        )
+        path_pattern = path_pattern or path
+        method = method.lower()
+        body = data or ''
+        return OpenAPIRequest(
+            host_url=host_url,
+            path=path,
+            path_pattern=path_pattern,
+            method=method,
+            parameters=parameters,
+            body=body,
+            mimetype=mimetype,
+        )

openapi_core/testing/responses.py

@@ -0,0 +1,13 @@
+"""OpenAPI core testing responses module"""
+from openapi_core.validation.response.datatypes import OpenAPIResponse
+
+
+class MockResponseFactory(object):
+
+    @classmethod
+    def create(cls, data, status_code=200, mimetype='application/json'):
+        return OpenAPIResponse(
+            data=data,
+            status_code=status_code,
+            mimetype=mimetype,
+        )

openapi_core/validation/request/shortcuts.py

@@ -0,0 +1,52 @@
+"""OpenAPI core validation request shortcuts module"""
+from functools import partial
+
+from openapi_core.schema.media_types.exceptions import OpenAPIMediaTypeError
+from openapi_core.schema.parameters.exceptions import OpenAPIParameterError
+from openapi_core.schema.request_bodies.exceptions import (
+    OpenAPIRequestBodyError,
+)
+from openapi_core.schema.schemas.exceptions import OpenAPISchemaError
+from openapi_core.validation.request.validators import RequestValidator
+
+ERRORS_BODY = (
+    OpenAPIRequestBodyError, OpenAPIMediaTypeError, OpenAPISchemaError,
+)
+ERRORS_PARAMETERS = (
+    OpenAPIParameterError,
+)
+
+
+def validate_request(validator, request, failsafe=None):
+    if failsafe is None:
+        failsafe = ()
+    result = validator.validate(request)
+    try:
+        result.raise_for_errors()
+    except failsafe:
+        pass
+    return result
+
+
+validate_parameters = partial(validate_request, failsafe=ERRORS_BODY)
+validate_body = partial(validate_request, failsafe=ERRORS_PARAMETERS)
+
+
+def spec_validate_parameters(spec, request, request_factory=None):
+    if request_factory is not None:
+        request = request_factory(request)
+
+    validator = RequestValidator(spec)
+    result = validate_parameters(validator, request)
+
+    return result.parameters
+
+
+def spec_validate_body(spec, request, request_factory=None):
+    if request_factory is not None:
+        request = request_factory(request)
+
+    validator = RequestValidator(spec)
+    result = validate_body(validator, request)
+
+    return result.body

openapi_core/validation/response/shortcuts.py

@@ -0,0 +1,23 @@
+"""OpenAPI core validation response shortcuts module"""
+from openapi_core.validation.response.validators import ResponseValidator
+
+
+def validate_response(validator, request, response):
+    result = validator.validate(request, response)
+    result.raise_for_errors()
+    return result
+
+
+def spec_validate_data(
+        spec, request, response,
+        request_factory=None,
+        response_factory=None):
+    if request_factory is not None:
+        request = request_factory(request)
+    if response_factory is not None:
+        response = response_factory(response)
+
+    validator = ResponseValidator(spec)
+    result = validate_response(validator, request, response)
+
+    return result.data