v20/3x - raise on http status 4xx and 5xx

Author: commonism

aiopenapi3/errors.py

@@ -3,7 +3,7 @@
 import dataclasses
 
 import httpx
-
+import pydantic
 
 if typing.TYPE_CHECKING:
     from ._types import (
@@ -187,3 +187,25 @@ class HeadersMissingError(ResponseError):
     def __str__(self):
         return f"""<{self.__class__.__name__} {self.response.request.method} '{self.response.request.url.path}' ({self.operation.operationId})
         {self.missing}>"""
+
+
+class HTTPStatusIndicatedError(HTTPError):
+    """The HTTP Status is 4xx or 5xx"""
+
+    pass
+
+
+@dataclasses.dataclass(repr=False)
+class HttpClientError(HTTPStatusIndicatedError):
+    """response code 4xx"""
+
+    headers: dict[str, str]
+    data: pydantic.BaseModel
+
+
+@dataclasses.dataclass(repr=False)
+class HttpServerError(HTTPStatusIndicatedError):
+    """response code 5xx"""
+
+    headers: dict[str, str]
+    data: pydantic.BaseModel

aiopenapi3/openapi.py

@@ -232,6 +232,7 @@ def __init__(
         loader: Optional[Loader] = None,
         plugins: Optional[list[Plugin]] = None,
         use_operation_tags: bool = True,
+        raise_on_error: bool = True,
     ) -> None:
         """
         Creates a new OpenAPI document from a loaded spec file.  This is
@@ -244,6 +245,7 @@ def __init__(
         :param loader: the Loader for the description document(s)
         :param plugins: list of plugins
         :param use_operation_tags: honor tags
+        :param raise_on_error: raise an exception if the http status code indicates error
         """
         self._base_url: yarl.URL = yarl.URL(url)
 
@@ -266,6 +268,11 @@ def __init__(
         Maximum Content-Length in Responses - default to 8 MBytes
         """
 
+        self._raise_on_error = raise_on_error
+        """
+        Raise for http status code 400-599
+        """
+
         self._security: dict[str, tuple[str]] = dict()
         """
         authorization informations

aiopenapi3/request.py

@@ -27,8 +27,7 @@ async def aclosing(thing):
 
 from .base import HTTP_METHODS, ReferenceBase
 from .version import __version__
-from .errors import RequestError, OperationIdDuplicationError
-
+from .errors import RequestError, OperationIdDuplicationError, HttpServerError, HttpClientError
 
 if typing.TYPE_CHECKING:
     from ._types import (
@@ -218,6 +217,14 @@ def _build_req(self, session: Union[httpx.Client, httpx.AsyncClient]) -> httpx.R
         )
         return req
 
+    def _raise_on_error(self, result: httpx.Response, headers: dict[str, str], data: Union[pydantic.BaseModel, bytes]):
+        if self.api._raise_on_error is False:
+            return
+        if 500 <= result.status_code <= 599:
+            raise HttpServerError(headers, data)
+        elif 400 <= result.status_code <= 499:
+            raise HttpClientError(headers, data)
+
     def request(
         self,
         data: Optional["RequestData"] = None,

aiopenapi3/v20/glue.py

@@ -17,6 +17,7 @@
 from ..request import RequestBase, AsyncRequestBase
 from ..errors import HTTPStatusError, ContentTypeError, ResponseSchemaError, ResponseDecodingError, HeadersMissingError
 
+
 from .parameter import Parameter
 from .root import Root
 
@@ -348,9 +349,13 @@ def _process_request(self, result: httpx.Response) -> tuple["ResponseHeadersType
             data = self.api.plugins.message.unmarshalled(
                 request=self, operationId=self.operation.operationId, unmarshalled=data
             ).unmarshalled
+
+            self._raise_on_error(result, rheaders, data)
+
             return rheaders, data
         elif self.operation.produces and content_type in self.operation.produces:
-            return rheaders, result.content
+            self._raise_on_error(result, rheaders, ctx.received)
+            return rheaders, ctx.received
         else:
             raise ContentTypeError(
                 self.operation,

aiopenapi3/v30/glue.py

@@ -576,13 +576,18 @@ def _process_request(self, result: httpx.Response) -> tuple["ResponseHeadersType
             data = self.api.plugins.message.unmarshalled(
                 request=self, operationId=self.operation.operationId, unmarshalled=data
             ).unmarshalled
+
+            self._raise_on_error(result, rheaders, data)
+
             return rheaders, data
         else:
             """
             We have received a valid (i.e. expected) content type,
             e.g. application/octet-stream
             but we can't validate it since it's not json.
             """
+            self._raise_on_error(result, rheaders, ctx.received)
+
             return rheaders, ctx.received
 
 

tests/conftest.py

@@ -518,9 +518,9 @@ def with_paths_server_variables(openapi_version):
     yield _get_parsed_yaml("paths-server-variables.yaml", openapi_version)
 
 
-@pytest.fixture
-def with_paths_response_error():
-    yield _get_parsed_yaml("paths-response-error.yaml")
+@pytest.fixture(params=["", "-v20"], ids=["v3x", "v20"])
+def with_paths_response_error_vXX(request):
+    return _get_parsed_yaml(f"paths-response-error{request.param}.yaml")
 
 
 @pytest.fixture

tests/fixtures/paths-response-error-v20.yaml

@@ -0,0 +1,46 @@
+swagger: "2.0"
+info:
+  title: with response headers
+  description: with response headers
+  version: 1.0.0
+host: api.example.com
+basePath: /v1
+schemes:
+  - https
+
+consumes:
+  - application/json
+produces:
+  - application/json
+
+definitions: {}
+
+paths:
+  /test:
+    get:
+      operationId: test
+      responses:
+        "200":
+          description: "ok"
+          schema:
+            type: string
+            enum: ["ok"]
+
+        "437":
+          description: "client error"
+          schema:
+            type: string
+            enum: ["ok"]
+
+          headers:
+            X-required:
+              type: string
+
+        "537":
+          description: "server error"
+          schema:
+            type: string
+            enum: ["ok"]
+          headers:
+            X-required:
+              type: string

tests/fixtures/paths-response-error.yaml

@@ -20,3 +20,27 @@ paths:
               schema:
                 type: string
                 const: ok
+        "437":
+          description: "client error"
+          content:
+            application/json:
+              schema:
+                type: string
+                const: ok
+          headers:
+            X-required:
+              schema:
+                type: string
+              required: true
+        "537":
+          description: "server error"
+          content:
+            application/json:
+              schema:
+                type: string
+                const: ok
+          headers:
+            X-required:
+              schema:
+                type: string
+              required: true

tests/path_test.py

@@ -12,7 +12,13 @@
 import yarl
 
 from aiopenapi3 import OpenAPI
-from aiopenapi3.errors import OperationParameterValidationError, OperationIdDuplicationError, HeadersMissingError
+from aiopenapi3.errors import (
+    OperationParameterValidationError,
+    OperationIdDuplicationError,
+    HeadersMissingError,
+    HttpClientError,
+    HttpServerError,
+)
 
 URLBASE = "/"
 
@@ -480,7 +486,7 @@ def test_paths_tags(httpx_mock, with_paths_tags):
 
 
 def test_paths_response_status_pattern_default(httpx_mock, with_paths_response_status_pattern_default):
-    api = OpenAPI("/", with_paths_response_status_pattern_default, session_factory=httpx.Client)
+    api = OpenAPI("/", with_paths_response_status_pattern_default, session_factory=httpx.Client, raise_on_error=False)
 
     httpx_mock.add_response(headers={"Content-Type": "application/json"}, status_code=201, json="created")
     r = api._.test()
@@ -505,10 +511,10 @@ def test_paths_response_status_pattern_default(httpx_mock, with_paths_response_s
         api._.test()
 
 
-def test_paths_response_error(httpx_mock, with_paths_response_error):
+def test_paths_response_error(httpx_mock, with_paths_response_error_vXX):
     from aiopenapi3 import ResponseSchemaError, ContentTypeError, HTTPStatusError, ResponseDecodingError
 
-    api = OpenAPI("/", with_paths_response_error, session_factory=httpx.Client)
+    api = OpenAPI("/", with_paths_response_error_vXX, session_factory=httpx.Client)
 
     httpx_mock.add_response(headers={"Content-Type": "application/json"}, status_code=200, json="ok")
     r = api._.test()
@@ -530,6 +536,18 @@ def test_paths_response_error(httpx_mock, with_paths_response_error):
     with pytest.raises(ResponseSchemaError):
         api._.test()
 
+    httpx_mock.add_response(headers={"Content-Type": "application/json", "X-required": "1"}, status_code=437, json="ok")
+    with pytest.raises(HttpClientError):
+        api._.test()
+
+    httpx_mock.add_response(headers={"Content-Type": "application/json", "X-required": "1"}, status_code=537, json="ok")
+    with pytest.raises(HttpServerError):
+        api._.test()
+
+    httpx_mock.add_response(headers={"Content-Type": "application/json", "X-required": "1"}, status_code=437, json="ok")
+    api._raise_on_error = False
+    api._.test()
+
 
 @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
 def test_paths_request_calling(httpx_mock, with_paths_response_status_pattern_default):