Validation factories refactor

openapi_core/validation/request/validators.py

@@ -4,18 +4,25 @@
 
 from openapi_core.casting.schemas.exceptions import CastError
 from openapi_core.deserializing.exceptions import DeserializeError
+from openapi_core.deserializing.parameters.factories import (
+    ParameterDeserializersFactory,
+)
 from openapi_core.exceptions import (
     MissingRequiredParameter, MissingParameter,
     MissingRequiredRequestBody, MissingRequestBody,
 )
 from openapi_core.security.exceptions import SecurityError
+from openapi_core.security.factories import SecurityProviderFactory
 from openapi_core.schema.parameters import get_aslist, get_explode
 from openapi_core.templating.media_types.exceptions import MediaTypeFinderError
 from openapi_core.templating.paths.exceptions import PathError
 from openapi_core.unmarshalling.schemas.enums import UnmarshalContext
 from openapi_core.unmarshalling.schemas.exceptions import (
     UnmarshalError, ValidateError,
 )
+from openapi_core.unmarshalling.schemas.factories import (
+    SchemaUnmarshallersFactory,
+)
 from openapi_core.validation.exceptions import InvalidSecurity
 from openapi_core.validation.request.datatypes import (
     RequestParameters, RequestValidationResult,
@@ -25,6 +32,23 @@
 
 class RequestValidator(BaseValidator):
 
+    @property
+    def schema_unmarshallers_factory(self):
+        spec_resolver = self.spec.accessor.dereferencer.resolver_manager.\
+            resolver
+        return SchemaUnmarshallersFactory(
+            spec_resolver, self.format_checker,
+            self.custom_formatters, context=UnmarshalContext.REQUEST,
+        )
+
+    @property
+    def security_provider_factory(self):
+        return SecurityProviderFactory()
+
+    @property
+    def parameter_deserializers_factory(self):
+        return ParameterDeserializersFactory()
+
     def validate(self, request):
         try:
             path, operation, _, path_result, _ = self._find_path(request)
@@ -212,9 +236,7 @@ def _get_security_value(self, scheme_name, request):
         if scheme_name not in security_schemes:
             return
         scheme = security_schemes[scheme_name]
-        from openapi_core.security.factories import SecurityProviderFactory
-        security_provider_factory = SecurityProviderFactory()
-        security_provider = security_provider_factory.create(scheme)
+        security_provider = self.security_provider_factory.create(scheme)
         return security_provider(request)
 
     def _get_parameter_value(self, param, request):
@@ -244,14 +266,5 @@ def _get_body_value(self, request_body, request):
         return request.body
 
     def _deserialise_parameter(self, param, value):
-        from openapi_core.deserializing.parameters.factories import (
-            ParameterDeserializersFactory,
-        )
-        deserializers_factory = ParameterDeserializersFactory()
-        deserializer = deserializers_factory.create(param)
+        deserializer = self.parameter_deserializers_factory.create(param)
         return deserializer(value)
-
-    def _unmarshal(self, param_or_media_type, value):
-        return super(RequestValidator, self)._unmarshal(
-            param_or_media_type, value, context=UnmarshalContext.REQUEST,
-        )

openapi_core/validation/response/validators.py

@@ -11,12 +11,24 @@
 from openapi_core.unmarshalling.schemas.exceptions import (
     UnmarshalError, ValidateError,
 )
+from openapi_core.unmarshalling.schemas.factories import (
+    SchemaUnmarshallersFactory,
+)
 from openapi_core.validation.response.datatypes import ResponseValidationResult
 from openapi_core.validation.validators import BaseValidator
 
 
 class ResponseValidator(BaseValidator):
 
+    @property
+    def schema_unmarshallers_factory(self):
+        spec_resolver = self.spec.accessor.dereferencer.resolver_manager.\
+            resolver
+        return SchemaUnmarshallersFactory(
+            spec_resolver, self.format_checker,
+            self.custom_formatters, context=UnmarshalContext.RESPONSE,
+        )
+
     def validate(self, request, response):
         try:
             _, operation, _, _, _ = self._find_path(request)
@@ -113,8 +125,3 @@ def _get_data_value(self, response):
             raise MissingResponseContent(response)
 
         return response.data
-
-    def _unmarshal(self, param_or_media_type, value):
-        return super(ResponseValidator, self)._unmarshal(
-            param_or_media_type, value, context=UnmarshalContext.RESPONSE,
-        )

openapi_core/validation/validators.py

@@ -1,6 +1,11 @@
 """OpenAPI core validation validators module"""
 from __future__ import division
 
+from openapi_core.casting.schemas.factories import SchemaCastersFactory
+from openapi_core.deserializing.media_types.factories import (
+    MediaTypeDeserializersFactory,
+)
+from openapi_core.templating.paths.finders import PathFinder
 from openapi_core.unmarshalling.schemas.util import build_format_checker
 
 
@@ -18,49 +23,48 @@ def __init__(
 
         self.format_checker = build_format_checker(**self.custom_formatters)
 
+    @property
+    def path_finder(self):
+        return PathFinder(self.spec, base_url=self.base_url)
+
+    @property
+    def schema_casters_factory(self):
+        return SchemaCastersFactory()
+
+    @property
+    def media_type_deserializers_factory(self):
+        return MediaTypeDeserializersFactory(
+            self.custom_media_type_deserializers)
+
+    @property
+    def schema_unmarshallers_factory(self):
+        raise NotImplementedError
+
     def _find_path(self, request):
-        from openapi_core.templating.paths.finders import PathFinder
-        finder = PathFinder(self.spec, base_url=self.base_url)
-        return finder.find(request)
+        return self.path_finder.find(request)
 
     def _get_media_type(self, content, request_or_response):
         from openapi_core.templating.media_types.finders import MediaTypeFinder
         finder = MediaTypeFinder(content)
         return finder.find(request_or_response)
 
     def _deserialise_data(self, mimetype, value):
-        from openapi_core.deserializing.media_types.factories import (
-            MediaTypeDeserializersFactory,
-        )
-        deserializers_factory = MediaTypeDeserializersFactory(
-            self.custom_media_type_deserializers)
-        deserializer = deserializers_factory.create(mimetype)
+        deserializer = self.media_type_deserializers_factory.create(mimetype)
         return deserializer(value)
 
     def _cast(self, param_or_media_type, value):
         # return param_or_media_type.cast(value)
         if 'schema' not in param_or_media_type:
             return value
 
-        from openapi_core.casting.schemas.factories import SchemaCastersFactory
-        casters_factory = SchemaCastersFactory()
         schema = param_or_media_type / 'schema'
-        caster = casters_factory.create(schema)
+        caster = self.schema_casters_factory.create(schema)
         return caster(value)
 
-    def _unmarshal(self, param_or_media_type, value, context):
+    def _unmarshal(self, param_or_media_type, value):
         if 'schema' not in param_or_media_type:
             return value
 
-        from openapi_core.unmarshalling.schemas.factories import (
-            SchemaUnmarshallersFactory,
-        )
-        spec_resolver = self.spec.accessor.dereferencer.resolver_manager.\
-            resolver
-        unmarshallers_factory = SchemaUnmarshallersFactory(
-            spec_resolver, self.format_checker,
-            self.custom_formatters, context=context,
-        )
         schema = param_or_media_type / 'schema'
-        unmarshaller = unmarshallers_factory.create(schema)
+        unmarshaller = self.schema_unmarshallers_factory.create(schema)
         return unmarshaller(value)