Validation errors refactor

Author: p1c2u

openapi_core/contrib/django/handlers.py

@@ -13,16 +13,16 @@
 from openapi_core.templating.paths.exceptions import OperationNotFound
 from openapi_core.templating.paths.exceptions import PathNotFound
 from openapi_core.templating.paths.exceptions import ServerNotFound
-from openapi_core.validation.exceptions import InvalidSecurity
-from openapi_core.validation.exceptions import MissingRequiredParameter
+from openapi_core.templating.security.exceptions import SecurityNotFound
+from openapi_core.validation.exceptions import ValidationError
 
 
 class DjangoOpenAPIErrorsHandler:
 
     OPENAPI_ERROR_STATUS: Dict[Type[Exception], int] = {
-        MissingRequiredParameter: 400,
+        ValidationError: 400,
         ServerNotFound: 400,
-        InvalidSecurity: 403,
+        SecurityNotFound: 403,
         OperationNotFound: 405,
         PathNotFound: 404,
         MediaTypeNotFound: 415,

openapi_core/contrib/falcon/handlers.py

@@ -14,16 +14,16 @@
 from openapi_core.templating.paths.exceptions import OperationNotFound
 from openapi_core.templating.paths.exceptions import PathNotFound
 from openapi_core.templating.paths.exceptions import ServerNotFound
-from openapi_core.validation.exceptions import InvalidSecurity
-from openapi_core.validation.exceptions import MissingRequiredParameter
+from openapi_core.templating.security.exceptions import SecurityNotFound
+from openapi_core.validation.request.exceptions import MissingRequiredParameter
 
 
 class FalconOpenAPIErrorsHandler:
 
     OPENAPI_ERROR_STATUS: Dict[Type[Exception], int] = {
         MissingRequiredParameter: 400,
         ServerNotFound: 400,
-        InvalidSecurity: 403,
+        SecurityNotFound: 403,
         OperationNotFound: 405,
         PathNotFound: 404,
         MediaTypeNotFound: 415,

openapi_core/templating/security/__init__.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from typing import List
+
+from openapi_core.exceptions import OpenAPIError
+
+
+class SecurityFinderError(OpenAPIError):
+    """Security finder error"""
+
+
+@dataclass
+class SecurityNotFound(SecurityFinderError):
+    """Find security error"""
+
+    schemes: List[List[str]]
+
+    def __str__(self) -> str:
+        return f"Security not found. Schemes not valid for any requirement: {str(self.schemes)}"

openapi_core/templating/security/exceptions.py

@@ -10,57 +10,3 @@ class ValidatorDetectError(OpenAPIError):
 
 class ValidationError(OpenAPIError):
     pass
-
-
-@dataclass
-class InvalidSecurity(ValidationError):
-    def __str__(self) -> str:
-        return "Security not valid for any requirement"
-
-
-class OpenAPIParameterError(OpenAPIError):
-    pass
-
-
-class MissingParameterError(OpenAPIParameterError):
-    """Missing parameter error"""
-
-
-@dataclass
-class MissingParameter(MissingParameterError):
-    name: str
-
-    def __str__(self) -> str:
-        return f"Missing parameter (without default value): {self.name}"
-
-
-@dataclass
-class MissingRequiredParameter(MissingParameterError):
-    name: str
-
-    def __str__(self) -> str:
-        return f"Missing required parameter: {self.name}"
-
-
-class OpenAPIHeaderError(OpenAPIError):
-    pass
-
-
-class MissingHeaderError(OpenAPIHeaderError):
-    """Missing header error"""
-
-
-@dataclass
-class MissingHeader(MissingHeaderError):
-    name: str
-
-    def __str__(self) -> str:
-        return f"Missing header (without default value): {self.name}"
-
-
-@dataclass
-class MissingRequiredHeader(MissingHeaderError):
-    name: str
-
-    def __str__(self) -> str:
-        return f"Missing required header: {self.name}"

openapi_core/validation/exceptions.py

@@ -2,9 +2,9 @@
 from dataclasses import dataclass
 from typing import Iterable
 
-from openapi_core.exceptions import OpenAPIError
+from openapi_core.unmarshalling.schemas.exceptions import ValidateError
+from openapi_core.validation.exceptions import ValidationError
 from openapi_core.validation.request.datatypes import Parameters
-from openapi_core.validation.request.protocols import Request
 
 
 @dataclass
@@ -22,11 +22,11 @@ def context(self) -> Iterable[Exception]:
         return self.errors
 
 
-class OpenAPIRequestBodyError(OpenAPIError):
+class RequestBodyError(ValidationError):
     pass
 
 
-class MissingRequestBodyError(OpenAPIRequestBodyError):
+class MissingRequestBodyError(RequestBodyError):
     """Missing request body error"""
 
 
@@ -38,3 +38,31 @@ def __str__(self) -> str:
 class MissingRequiredRequestBody(MissingRequestBodyError):
     def __str__(self) -> str:
         return "Missing required request body"
+
+
+class RequestBodyValidateError(RequestBodyError, ValidateError):
+    pass
+
+
+@dataclass
+class ParameterError(ValidationError):
+    name: str
+    location: str
+
+
+class ParameterValidateError(ParameterError, ValidateError):
+    pass
+
+
+class MissingParameterError(ParameterError):
+    """Missing parameter error"""
+
+
+class MissingParameter(MissingParameterError):
+    def __str__(self) -> str:
+        return f"Missing parameter (without default value): {self.name}"
+
+
+class MissingRequiredParameter(MissingParameterError):
+    def __str__(self) -> str:
+        return f"Missing required parameter: {self.name}"

openapi_core/validation/request/exceptions.py

@@ -32,6 +32,7 @@
 from openapi_core.templating.paths.exceptions import PathError
 from openapi_core.templating.paths.finders import APICallPathFinder
 from openapi_core.templating.paths.finders import WebhookPathFinder
+from openapi_core.templating.security.exceptions import SecurityNotFound
 from openapi_core.unmarshalling.schemas import (
     oas30_request_schema_unmarshallers_factory,
 )
@@ -44,17 +45,18 @@
     SchemaUnmarshallersFactory,
 )
 from openapi_core.util import chainiters
-from openapi_core.validation.exceptions import InvalidSecurity
-from openapi_core.validation.exceptions import MissingParameter
-from openapi_core.validation.exceptions import MissingRequiredParameter
 from openapi_core.validation.request.datatypes import Parameters
 from openapi_core.validation.request.datatypes import RequestParameters
 from openapi_core.validation.request.datatypes import RequestValidationResult
+from openapi_core.validation.request.exceptions import MissingParameter
 from openapi_core.validation.request.exceptions import MissingRequestBody
+from openapi_core.validation.request.exceptions import MissingRequiredParameter
 from openapi_core.validation.request.exceptions import (
     MissingRequiredRequestBody,
 )
 from openapi_core.validation.request.exceptions import ParametersError
+from openapi_core.validation.request.exceptions import ParameterValidateError
+from openapi_core.validation.request.exceptions import RequestBodyValidateError
 from openapi_core.validation.request.protocols import BaseRequest
 from openapi_core.validation.request.protocols import Request
 from openapi_core.validation.request.protocols import WebhookRequest
@@ -91,7 +93,7 @@ def _validate(
     ) -> RequestValidationResult:
         try:
             security = self._get_security(request.parameters, operation)
-        except InvalidSecurity as exc:
+        except SecurityNotFound as exc:
             return RequestValidationResult(errors=[exc])
 
         try:
@@ -175,7 +177,7 @@ def _validate_security(
     ) -> RequestValidationResult:
         try:
             security = self._get_security(request.parameters, operation)
-        except InvalidSecurity as exc:
+        except SecurityNotFound as exc:
             return RequestValidationResult(errors=[exc])
 
         return RequestValidationResult(
@@ -241,11 +243,13 @@ def _get_parameter(
         location = parameters[param_location]
         try:
             return self._get_param_or_header_value(param, location)
+        except ValidateError as exc:
+            raise ParameterValidateError(name, param_location) from exc
         except KeyError:
             required = param.getkey("required", False)
             if required:
-                raise MissingRequiredParameter(name)
-            raise MissingParameter(name)
+                raise MissingRequiredParameter(name, param_location)
+            raise MissingParameter(name, param_location)
 
     def _get_security(
         self, parameters: RequestParameters, operation: Spec
@@ -259,18 +263,21 @@ def _get_security(
         if not security:
             return {}
 
+        schemes = []
         for security_requirement in security:
             try:
+                scheme_names = list(security_requirement.keys())
+                schemes.append(scheme_names)
                 return {
                     scheme_name: self._get_security_value(
                         parameters, scheme_name
                     )
-                    for scheme_name in list(security_requirement.keys())
+                    for scheme_name in scheme_names
                 }
             except SecurityError:
                 continue
 
-        raise InvalidSecurity
+        raise SecurityNotFound(schemes)
 
     def _get_security_value(
         self, parameters: RequestParameters, scheme_name: str
@@ -301,7 +308,10 @@ def _get_body(
             return casted
 
         schema = media_type / "schema"
-        unmarshalled = self._unmarshal(schema, casted)
+        try:
+            unmarshalled = self._unmarshal(schema, casted)
+        except ValidateError as exc:
+            raise RequestBodyValidateError() from exc
         return unmarshalled
 
     def _get_body_value(self, body: Optional[str], request_body: Spec) -> Any:

openapi_core/validation/request/validators.py

@@ -4,7 +4,8 @@
 from typing import Iterable
 
 from openapi_core.exceptions import OpenAPIError
-from openapi_core.validation.response.protocols import Response
+from openapi_core.unmarshalling.schemas.exceptions import ValidateError
+from openapi_core.validation.exceptions import ValidationError
 
 
 @dataclass
@@ -13,6 +14,38 @@ class HeadersError(Exception):
     context: Iterable[OpenAPIError]
 
 
+@dataclass
+class DataError(ValidationError):
+    pass
+
+
+class DataValidateError(DataError, ValidateError):
+    pass
+
+
+@dataclass
+class HeaderError(ValidationError):
+    name: str
+
+
+class MissingHeaderError(HeaderError):
+    """Missing header error"""
+
+
+class MissingHeader(MissingHeaderError):
+    def __str__(self) -> str:
+        return f"Missing header (without default value): {self.name}"
+
+
+class MissingRequiredHeader(MissingHeaderError):
+    def __str__(self) -> str:
+        return f"Missing required header: {self.name}"
+
+
+class HeaderValidateError(HeaderError, ValidateError):
+    pass
+
+
 class OpenAPIResponseError(OpenAPIError):
     pass
 

openapi_core/validation/response/exceptions.py

@@ -27,12 +27,14 @@
 from openapi_core.unmarshalling.schemas.exceptions import UnmarshalError
 from openapi_core.unmarshalling.schemas.exceptions import ValidateError
 from openapi_core.util import chainiters
-from openapi_core.validation.exceptions import MissingHeader
-from openapi_core.validation.exceptions import MissingRequiredHeader
 from openapi_core.validation.request.protocols import Request
 from openapi_core.validation.request.protocols import WebhookRequest
 from openapi_core.validation.response.datatypes import ResponseValidationResult
+from openapi_core.validation.response.exceptions import DataValidateError
 from openapi_core.validation.response.exceptions import HeadersError
+from openapi_core.validation.response.exceptions import HeaderValidateError
+from openapi_core.validation.response.exceptions import MissingHeader
+from openapi_core.validation.response.exceptions import MissingRequiredHeader
 from openapi_core.validation.response.exceptions import MissingResponseContent
 from openapi_core.validation.response.protocols import Response
 from openapi_core.validation.validators import BaseAPICallValidator
@@ -64,7 +66,6 @@ def _validate(
             MissingResponseContent,
             DeserializeError,
             CastError,
-            ValidateError,
             UnmarshalError,
         ) as exc:
             validated_data = None
@@ -169,7 +170,10 @@ def _get_data(
             return casted
 
         schema = media_type / "schema"
-        data = self._unmarshal(schema, casted)
+        try:
+            data = self._unmarshal(schema, casted)
+        except ValidateError as exc:
+            raise DataValidateError() from exc
 
         return data
 
@@ -226,6 +230,8 @@ def _get_header(
 
         try:
             return self._get_param_or_header_value(header, headers, name=name)
+        except ValidateError as exc:
+            raise HeaderValidateError(name) from exc
         except KeyError:
             required = header.getkey("required", False)
             if required: