Validators refactor

Author: p1c2u

openapi_core/templating/paths/finders.py

@@ -29,15 +29,8 @@ def __init__(self, spec: Spec, base_url: Optional[str] = None):
     def find(
         self,
         method: str,
-        host_url: str,
-        path: str,
-        path_pattern: Optional[str] = None,
+        full_url: str,
     ) -> ServerOperationPath:
-        if path_pattern is not None:
-            full_url = urljoin(host_url, path_pattern)
-        else:
-            full_url = urljoin(host_url, path)
-
         paths_iter = self._get_paths_iter(full_url)
         paths_iter_peek = peekable(paths_iter)
 

openapi_core/validation/request/__init__.py

@@ -5,7 +5,7 @@
 from openapi_core.unmarshalling.schemas import (
     oas31_schema_unmarshallers_factory,
 )
-from openapi_core.validation.request.proxies import DetectRequestValidatorProxy
+from openapi_core.validation.request.proxies import RequestValidatorProxy
 from openapi_core.validation.request.validators import RequestBodyValidator
 from openapi_core.validation.request.validators import (
     RequestParametersValidator,
@@ -32,29 +32,37 @@
     "openapi_request_validator",
 ]
 
-openapi_v30_request_body_validator = RequestBodyValidator(
+openapi_v30_request_body_validator = RequestValidatorProxy(
+    RequestBodyValidator,
     schema_unmarshallers_factory=oas30_request_schema_unmarshallers_factory,
 )
-openapi_v30_request_parameters_validator = RequestParametersValidator(
+openapi_v30_request_parameters_validator = RequestValidatorProxy(
+    RequestParametersValidator,
     schema_unmarshallers_factory=oas30_request_schema_unmarshallers_factory,
 )
-openapi_v30_request_security_validator = RequestSecurityValidator(
+openapi_v30_request_security_validator = RequestValidatorProxy(
+    RequestSecurityValidator,
     schema_unmarshallers_factory=oas30_request_schema_unmarshallers_factory,
 )
-openapi_v30_request_validator = RequestValidator(
+openapi_v30_request_validator = RequestValidatorProxy(
+    RequestValidator,
     schema_unmarshallers_factory=oas30_request_schema_unmarshallers_factory,
 )
 
-openapi_v31_request_body_validator = RequestBodyValidator(
+openapi_v31_request_body_validator = RequestValidatorProxy(
+    RequestBodyValidator,
     schema_unmarshallers_factory=oas31_schema_unmarshallers_factory,
 )
-openapi_v31_request_parameters_validator = RequestParametersValidator(
+openapi_v31_request_parameters_validator = RequestValidatorProxy(
+    RequestParametersValidator,
     schema_unmarshallers_factory=oas31_schema_unmarshallers_factory,
 )
-openapi_v31_request_security_validator = RequestSecurityValidator(
+openapi_v31_request_security_validator = RequestValidatorProxy(
+    RequestSecurityValidator,
     schema_unmarshallers_factory=oas31_schema_unmarshallers_factory,
 )
-openapi_v31_request_validator = RequestValidator(
+openapi_v31_request_validator = RequestValidatorProxy(
+    RequestValidator,
     schema_unmarshallers_factory=oas31_schema_unmarshallers_factory,
 )
 
@@ -67,27 +75,15 @@
 openapi_v3_request_validator = openapi_v31_request_validator
 
 # detect version spec
-openapi_request_body_validator = DetectRequestValidatorProxy(
-    {
-        ("openapi", "3.0"): openapi_v30_request_body_validator,
-        ("openapi", "3.1"): openapi_v31_request_body_validator,
-    },
-)
-openapi_request_parameters_validator = DetectRequestValidatorProxy(
-    {
-        ("openapi", "3.0"): openapi_v30_request_parameters_validator,
-        ("openapi", "3.1"): openapi_v31_request_parameters_validator,
-    },
-)
-openapi_request_security_validator = DetectRequestValidatorProxy(
-    {
-        ("openapi", "3.0"): openapi_v30_request_security_validator,
-        ("openapi", "3.1"): openapi_v31_request_security_validator,
-    },
-)
-openapi_request_validator = DetectRequestValidatorProxy(
-    {
-        ("openapi", "3.0"): openapi_v30_request_validator,
-        ("openapi", "3.1"): openapi_v31_request_validator,
-    },
+openapi_request_body_validator = RequestValidatorProxy(
+    RequestBodyValidator,
+)
+openapi_request_parameters_validator = RequestValidatorProxy(
+    RequestParametersValidator,
+)
+openapi_request_security_validator = RequestValidatorProxy(
+    RequestSecurityValidator,
+)
+openapi_request_validator = RequestValidatorProxy(
+    RequestValidator,
 )

openapi_core/validation/request/proxies.py

@@ -1,50 +1,45 @@
 """OpenAPI spec validator validation proxies module."""
 from typing import Any
-from typing import Hashable
 from typing import Iterator
-from typing import Mapping
 from typing import Optional
-from typing import Tuple
+from typing import Type
 
-from openapi_core.exceptions import OpenAPIError
 from openapi_core.spec import Spec
-from openapi_core.validation.exceptions import ValidatorDetectError
 from openapi_core.validation.request.datatypes import RequestValidationResult
 from openapi_core.validation.request.protocols import Request
 from openapi_core.validation.request.validators import BaseRequestValidator
 
 
-class DetectRequestValidatorProxy:
+class RequestValidatorProxy:
     def __init__(
-        self, choices: Mapping[Tuple[str, str], BaseRequestValidator]
+        self,
+        validator_cls: Type[BaseRequestValidator],
+        **validator_kwargs: Any,
     ):
-        self.choices = choices
-
-    def detect(self, spec: Spec) -> BaseRequestValidator:
-        for (key, value), validator in self.choices.items():
-            if key in spec and spec[key].startswith(value):
-                return validator
-        raise ValidatorDetectError("Spec schema version not detected")
+        self.validator_cls = validator_cls
+        self.validator_kwargs = validator_kwargs
 
     def validate(
         self,
         spec: Spec,
         request: Request,
         base_url: Optional[str] = None,
     ) -> RequestValidationResult:
-        validator = self.detect(spec)
-        return validator.validate(spec, request, base_url=base_url)
+        validator = self.validator_cls(
+            spec, base_url=base_url, **self.validator_kwargs
+        )
+        return validator.validate(request)
 
     def is_valid(
         self,
         spec: Spec,
         request: Request,
         base_url: Optional[str] = None,
     ) -> bool:
-        validator = self.detect(spec)
-        error = next(
-            validator.iter_errors(spec, request, base_url=base_url), None
+        validator = self.validator_cls(
+            spec, base_url=base_url, **self.validator_kwargs
         )
+        error = next(validator.iter_errors(request), None)
         return error is None
 
     def iter_errors(
@@ -53,5 +48,7 @@ def iter_errors(
         request: Request,
         base_url: Optional[str] = None,
     ) -> Iterator[Exception]:
-        validator = self.detect(spec)
-        yield from validator.iter_errors(spec, request, base_url=base_url)
+        validator = self.validator_cls(
+            spec, base_url=base_url, **self.validator_kwargs
+        )
+        yield from validator.iter_errors(request)

openapi_core/validation/request/validators.py

@@ -28,7 +28,12 @@
 from openapi_core.spec.paths import Spec
 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 import (
+    oas30_request_schema_unmarshallers_factory,
+)
+from openapi_core.unmarshalling.schemas import (
+    oas31_schema_unmarshallers_factory,
+)
 from openapi_core.unmarshalling.schemas.exceptions import UnmarshalError
 from openapi_core.unmarshalling.schemas.exceptions import ValidateError
 from openapi_core.unmarshalling.schemas.factories import (
@@ -50,37 +55,39 @@
 
 
 class BaseRequestValidator(BaseValidator):
+
+    schema_unmarshallers_factories = {
+        ("openapi", "3.0"): oas30_request_schema_unmarshallers_factory,
+        ("openapi", "3.1"): oas31_schema_unmarshallers_factory,
+    }
+
     def __init__(
         self,
-        schema_unmarshallers_factory: SchemaUnmarshallersFactory,
+        spec: Spec,
+        base_url: Optional[str] = None,
+        schema_unmarshallers_factory: Optional[
+            SchemaUnmarshallersFactory
+        ] = None,
         schema_casters_factory: SchemaCastersFactory = schema_casters_factory,
         parameter_deserializers_factory: ParameterDeserializersFactory = parameter_deserializers_factory,
         media_type_deserializers_factory: MediaTypeDeserializersFactory = media_type_deserializers_factory,
         security_provider_factory: SecurityProviderFactory = security_provider_factory,
     ):
         super().__init__(
-            schema_unmarshallers_factory,
+            spec,
+            base_url=base_url,
+            schema_unmarshallers_factory=schema_unmarshallers_factory,
             schema_casters_factory=schema_casters_factory,
             parameter_deserializers_factory=parameter_deserializers_factory,
             media_type_deserializers_factory=media_type_deserializers_factory,
         )
         self.security_provider_factory = security_provider_factory
 
-    def iter_errors(
-        self,
-        spec: Spec,
-        request: Request,
-        base_url: Optional[str] = None,
-    ) -> Iterator[Exception]:
-        result = self.validate(spec, request, base_url=base_url)
+    def iter_errors(self, request: Request) -> Iterator[Exception]:
+        result = self.validate(request)
         yield from result.errors
 
-    def validate(
-        self,
-        spec: Spec,
-        request: Request,
-        base_url: Optional[str] = None,
-    ) -> RequestValidationResult:
+    def validate(self, request: Request) -> RequestValidationResult:
         raise NotImplementedError
 
     def _get_parameters(
@@ -143,11 +150,11 @@ def _get_parameter(self, param: Spec, request: Request) -> Any:
             raise MissingParameter(name)
 
     def _get_security(
-        self, spec: Spec, request: Request, operation: Spec
+        self, request: Request, operation: Spec
     ) -> Optional[Dict[str, str]]:
         security = None
-        if "security" in spec:
-            security = spec / "security"
+        if "security" in self.spec:
+            security = self.spec / "security"
         if "security" in operation:
             security = operation / "security"
 
@@ -157,20 +164,16 @@ def _get_security(
         for security_requirement in security:
             try:
                 return {
-                    scheme_name: self._get_security_value(
-                        spec, scheme_name, request
-                    )
+                    scheme_name: self._get_security_value(scheme_name, request)
                     for scheme_name in list(security_requirement.keys())
                 }
             except SecurityError:
                 continue
 
         raise InvalidSecurity
 
-    def _get_security_value(
-        self, spec: Spec, scheme_name: str, request: Request
-    ) -> Any:
-        security_schemes = spec / "components#securitySchemes"
+    def _get_security_value(self, scheme_name: str, request: Request) -> Any:
+        security_schemes = self.spec / "components#securitySchemes"
         if scheme_name not in security_schemes:
             return
         scheme = security_schemes[scheme_name]
@@ -207,16 +210,9 @@ def _get_body_value(self, request_body: Spec, request: Request) -> Any:
 
 
 class RequestParametersValidator(BaseRequestValidator):
-    def validate(
-        self,
-        spec: Spec,
-        request: Request,
-        base_url: Optional[str] = None,
-    ) -> RequestValidationResult:
+    def validate(self, request: Request) -> RequestValidationResult:
         try:
-            path, operation, _, path_result, _ = self._find_path(
-                spec, request, base_url=base_url
-            )
+            path, operation, _, path_result, _ = self._find_path(request)
         except PathError as exc:
             return RequestValidationResult(errors=[exc])
 
@@ -239,16 +235,9 @@ def validate(
 
 
 class RequestBodyValidator(BaseRequestValidator):
-    def validate(
-        self,
-        spec: Spec,
-        request: Request,
-        base_url: Optional[str] = None,
-    ) -> RequestValidationResult:
+    def validate(self, request: Request) -> RequestValidationResult:
         try:
-            _, operation, _, _, _ = self._find_path(
-                spec, request, base_url=base_url
-            )
+            _, operation, _, _, _ = self._find_path(request)
         except PathError as exc:
             return RequestValidationResult(errors=[exc])
 
@@ -277,21 +266,14 @@ def validate(
 
 
 class RequestSecurityValidator(BaseRequestValidator):
-    def validate(
-        self,
-        spec: Spec,
-        request: Request,
-        base_url: Optional[str] = None,
-    ) -> RequestValidationResult:
+    def validate(self, request: Request) -> RequestValidationResult:
         try:
-            _, operation, _, _, _ = self._find_path(
-                spec, request, base_url=base_url
-            )
+            _, operation, _, _, _ = self._find_path(request)
         except PathError as exc:
             return RequestValidationResult(errors=[exc])
 
         try:
-            security = self._get_security(spec, request, operation)
+            security = self._get_security(request, operation)
         except InvalidSecurity as exc:
             return RequestValidationResult(errors=[exc])
 
@@ -302,22 +284,15 @@ def validate(
 
 
 class RequestValidator(BaseRequestValidator):
-    def validate(
-        self,
-        spec: Spec,
-        request: Request,
-        base_url: Optional[str] = None,
-    ) -> RequestValidationResult:
+    def validate(self, request: Request) -> RequestValidationResult:
         try:
-            path, operation, _, path_result, _ = self._find_path(
-                spec, request, base_url=base_url
-            )
+            path, operation, _, path_result, _ = self._find_path(request)
         # don't process if operation errors
         except PathError as exc:
             return RequestValidationResult(errors=[exc])
 
         try:
-            security = self._get_security(spec, request, operation)
+            security = self._get_security(request, operation)
         except InvalidSecurity as exc:
             return RequestValidationResult(errors=[exc])