Merge pull request #94 from domenkozar/structured-exceptions

Structured exceptions

Author: p1c2u

openapi_core/schema/content/exceptions.py

@@ -1,9 +1,16 @@
 from openapi_core.schema.exceptions import OpenAPIMappingError
 
+import attr
+
 
 class OpenAPIContentError(OpenAPIMappingError):
     pass
 
 
+@attr.s
 class MimeTypeNotFound(OpenAPIContentError):
-    pass
+    mimetype = attr.ib()
+    availableMimetypes = attr.ib()
+
+    def __str__(self):
+        return "Mimetype not found: {0}. Valid mimetypes: {1}".format(self.mimetype, self.availableMimetypes)

openapi_core/schema/content/models.py

@@ -18,4 +18,4 @@ def __getitem__(self, mimetype):
             if fnmatch.fnmatch(mimetype, key):
                 return value
 
-        raise MimeTypeNotFound("{0} mimetype not found")
+        raise MimeTypeNotFound(mimetype, self.keys())

openapi_core/schema/media_types/exceptions.py

@@ -1,13 +1,21 @@
 from openapi_core.schema.exceptions import OpenAPIMappingError
 
+import attr
+
 
 class OpenAPIMediaTypeError(OpenAPIMappingError):
     pass
 
-
+@attr.s
 class InvalidMediaTypeValue(OpenAPIMediaTypeError):
-    pass
+    original_exception = attr.ib()
 
+    def __str__(self):
+        return "Mimetype invalid: {0}".format(self.original_exception)
 
+@attr.s
 class InvalidContentType(OpenAPIMediaTypeError):
-    pass
+    mimetype = attr.ib()
+
+    def __str__(self):
+        return "Content for following mimetype not found: {0}".format(self.mimetype)

openapi_core/schema/media_types/models.py

@@ -4,7 +4,7 @@
 from json import loads
 
 from openapi_core.schema.media_types.exceptions import InvalidMediaTypeValue
-from openapi_core.schema.schemas.exceptions import InvalidSchemaValue
+from openapi_core.schema.schemas.exceptions import OpenAPISchemaError
 
 
 MEDIA_TYPE_DESERIALIZERS = {
@@ -32,21 +32,21 @@ def deserialize(self, value):
         deserializer = self.get_dererializer()
         return deserializer(value)
 
-    def unmarshal(self, value):
+    def unmarshal(self, value, custom_formatters=None):
         if not self.schema:
             return value
 
         try:
             deserialized = self.deserialize(value)
         except ValueError as exc:
-            raise InvalidMediaTypeValue(str(exc))
+            raise InvalidMediaTypeValue(exc)
 
         try:
-            unmarshalled = self.schema.unmarshal(deserialized)
-        except InvalidSchemaValue as exc:
-            raise InvalidMediaTypeValue(str(exc))
+            unmarshalled = self.schema.unmarshal(deserialized, custom_formatters=custom_formatters)
+        except OpenAPISchemaError as exc:
+            raise InvalidMediaTypeValue(exc)
 
         try:
-            return self.schema.validate(unmarshalled)
-        except InvalidSchemaValue as exc:
-            raise InvalidMediaTypeValue(str(exc))
+            return self.schema.validate(unmarshalled, custom_formatters=custom_formatters)
+        except OpenAPISchemaError as exc:
+            raise InvalidMediaTypeValue(exc)

openapi_core/schema/operations/exceptions.py

@@ -1,9 +1,17 @@
 from openapi_core.schema.exceptions import OpenAPIMappingError
 
+import attr
+
 
 class OpenAPIOperationError(OpenAPIMappingError):
     pass
 
 
+@attr.s
 class InvalidOperation(OpenAPIOperationError):
-    pass
+    path_pattern = attr.ib()
+    http_method = attr.ib()
+
+    def __str__(self):
+        return "Unknown operation path {0} with method {1}".format(
+            self.path_pattern, self.http_method)

openapi_core/schema/operations/models.py

@@ -32,7 +32,6 @@ def get_response(self, http_status='default'):
                 return self.responses[http_status_range]
 
             if 'default' not in self.responses:
-                raise InvalidResponse(
-                    "Unknown response http status {0}".format(http_status))
+                raise InvalidResponse(http_status, self.responses)
 
             return self.responses['default']

openapi_core/schema/parameters/exceptions.py

@@ -1,21 +1,40 @@
 from openapi_core.schema.exceptions import OpenAPIMappingError
 
+import attr
+
 
 class OpenAPIParameterError(OpenAPIMappingError):
     pass
 
 
+@attr.s
 class MissingParameter(OpenAPIParameterError):
-    pass
+    name = attr.ib()
+
+    def __str__(self):
+        return "Missing parameter (without default value): {0}".format(self.name)
 
 
+@attr.s
 class MissingRequiredParameter(OpenAPIParameterError):
-    pass
+    name = attr.ib()
+
+    def __str__(self):
+        return "Missing required parameter: {0}".format(self.name)
 
 
+@attr.s
 class EmptyParameterValue(OpenAPIParameterError):
-    pass
+    name = attr.ib()
+
+    def __str__(self):
+        return "Value of parameter cannot be empty: {0}".format(self.name)
 
 
+@attr.s
 class InvalidParameterValue(OpenAPIParameterError):
-    pass
+    name = attr.ib()
+    original_exception = attr.ib()
+
+    def __str__(self):
+        return "Invalid parameter value for `{0}`: {1}".format(self.name, self.original_exception)

openapi_core/schema/parameters/models.py

@@ -10,7 +10,7 @@
     EmptyParameterValue,
 )
 from openapi_core.schema.schemas.enums import SchemaType
-from openapi_core.schema.schemas.exceptions import InvalidSchemaValue
+from openapi_core.schema.schemas.exceptions import OpenAPISchemaError
 
 log = logging.getLogger(__name__)
 
@@ -77,12 +77,10 @@ def get_value(self, request):
 
         if self.name not in location:
             if self.required:
-                raise MissingRequiredParameter(
-                    "Missing required `{0}` parameter".format(self.name))
+                raise MissingRequiredParameter(self.name)
 
             if not self.schema or self.schema.default is None:
-                raise MissingParameter(
-                    "Missing `{0}` parameter".format(self.name))
+                raise MissingParameter(self.name)
 
             return self.schema.default
 
@@ -91,7 +89,7 @@ def get_value(self, request):
 
         return location[self.name]
 
-    def unmarshal(self, value):
+    def unmarshal(self, value, custom_formatters=None):
         if self.deprecated:
             warnings.warn(
                 "{0} parameter is deprecated".format(self.name),
@@ -100,23 +98,22 @@ def unmarshal(self, value):
 
         if (self.location == ParameterLocation.QUERY and value == "" and
                 not self.allow_empty_value):
-            raise EmptyParameterValue(
-                "Value of {0} parameter cannot be empty".format(self.name))
+            raise EmptyParameterValue(self.name)
 
         if not self.schema:
             return value
 
         try:
             deserialized = self.deserialize(value)
         except (ValueError, AttributeError) as exc:
-            raise InvalidParameterValue(str(exc))
+            raise InvalidParameterValue(self.name, exc)
 
         try:
-            unmarshalled = self.schema.unmarshal(deserialized)
-        except InvalidSchemaValue as exc:
-            raise InvalidParameterValue(str(exc))
+            unmarshalled = self.schema.unmarshal(deserialized, custom_formatters=custom_formatters)
+        except OpenAPISchemaError as exc:
+            raise InvalidParameterValue(self.name, exc)
 
         try:
-            return self.schema.validate(unmarshalled)
-        except InvalidSchemaValue as exc:
-            raise InvalidParameterValue(str(exc))
+            return self.schema.validate(unmarshalled, custom_formatters=custom_formatters)
+        except OpenAPISchemaError as exc:
+            raise InvalidParameterValue(self.name, exc)

openapi_core/schema/request_bodies/exceptions.py

@@ -1,9 +1,15 @@
 from openapi_core.schema.exceptions import OpenAPIMappingError
 
+import attr
+
 
 class OpenAPIRequestBodyError(OpenAPIMappingError):
     pass
 
 
+@attr.s
 class MissingRequestBody(OpenAPIRequestBodyError):
-    pass
+    request = attr.ib()
+
+    def __str__(self):
+        return "Missing required request body"

openapi_core/schema/request_bodies/models.py

@@ -16,11 +16,9 @@ def __getitem__(self, mimetype):
         try:
             return self.content[mimetype]
         except MimeTypeNotFound:
-            raise InvalidContentType(
-                "Invalid mime type `{0}`".format(mimetype))
+            raise InvalidContentType(mimetype)
 
     def get_value(self, request):
         if not request.body and self.required:
-            raise MissingRequestBody("Missing required request body")
-
+            raise MissingRequestBody(request)
         return request.body