WIP

Author: mdellweg

pulp-glue/pulp_glue/common/openapi.py

@@ -21,7 +21,6 @@
 from pulp_glue.common.exceptions import (
     OpenAPIError,
     PulpAuthenticationFailed,
-    PulpException,
     PulpHTTPError,
     PulpNotAutorized,
     UnsafeCallError,
@@ -41,9 +40,14 @@
 
 @dataclass
 class _Request:
+    operation_id: str
     method: str
+    url: str
     headers: MutableMultiMapping[str] | CIMultiDictProxy[str] | t.MutableMapping[str, str]
-    body: bytes | None
+    params: dict[str, str]
+    data: dict[str, t.Any] | str | None
+    files: list[tuple[str, tuple[str, UploadType, str]]] | None
+    security: list[dict[str, list[str]]] | None
 
 
 @dataclass
@@ -515,7 +519,7 @@ def _render_request_body(
 
         return content_type, data, files
 
-    async def _send_request(
+    def _render_request(
         self,
         path_spec: dict[str, t.Any],
         method: str,
@@ -524,11 +528,11 @@ async def _send_request(
         headers: dict[str, str],
         body: dict[str, t.Any] | None = None,
         validate_body: bool = True,
-    ) -> _Response:
+    ) -> _Request:
         method_spec = path_spec[method]
         _headers = CIMultiDict(self._headers)
         _headers.update(headers)
-        content_type, data, files = self._render_request_body(method_spec, body, validate_body)
+
         security: list[dict[str, list[str]]] | None
         if self._auth_provider and "Authorization" not in self._headers:
             security = method_spec.get("security", self.api_spec.get("security"))
@@ -538,34 +542,60 @@ async def _send_request(
             # Authorization header present? You wanted it that way...
             security = None
 
+        content_type, data, files = self._render_request_body(method_spec, body, validate_body)
         # For we encode the json on our side.
         # Somehow this does not work properly for multipart...
         if content_type is not None and content_type.startswith("application/json"):
             _headers["Content-Type"] = content_type
 
-        for key, value in headers.items():
-            self._debug_callback(2, f"  {key}: {value}")
-        if data is not None:
-            self._debug_callback(3, f"{data!r}")
+        return _Request(
+            operation_id=method_spec["operationId"],
+            method=method,
+            url=url,
+            headers=_headers,
+            params=params,
+            data=data,
+            files=files,
+            security=security,
+        )
 
-        if self._dry_run and method.upper() not in SAFE_METHODS:
-            raise UnsafeCallError(_("Call aborted due to safe mode"))
+    def _log_request(self, request: _Request) -> None:
+        if request.params:
+            qs = urlencode(request.params)
+            log_msg = f"{request.operation_id} : {request.method} {request.url}?{qs}"
+        else:
+            log_msg = f"{request.operation_id} : {request.method} {request.url}"
+        self._debug_callback(1, log_msg)
+        self._debug_callback(
+            2, "\n".join([f"  {key}=={value}" for key, value in request.params.items()])
+        )
+        for key, value in request.headers.items():
+            self._debug_callback(2, f"  {key}: {value}")
+        if request.data is not None:
+            self._debug_callback(3, f"{request.data!r}")
 
+    async def _send_request(
+        self,
+        request: _Request,
+    ) -> _Response:
         try:
             async with aiohttp.ClientSession() as session:
                 async with session.request(
-                    method,
-                    url,
-                    params=params,
-                    headers=_headers,
-                    data=data,
-                    # files=files,
+                    request.method,
+                    request.url,
+                    params=request.params,
+                    headers=request.headers,
+                    data=request.data,
+                    # files=request.files,
                     ssl=self.ssl_context,
                     max_redirects=0,
-                    middlewares=[_Middleware(self, security)],
-                ) as response:
+                    middlewares=[_Middleware(self, request.security)],
+                ) as r:
                     # response.raise_for_status()
-                    response_body = await response.read()
+                    response_body = await r.read()
+                    response = _Response(
+                        status_code=r.status, headers=r.headers, body=response_body
+                    )
         except aiohttp.TooManyRedirects as e:
             # We could handle that in the middleware...
             assert e.history[-1] is not None
@@ -577,25 +607,25 @@ async def _send_request(
         except aiohttp.ClientResponseError as e:
             raise OpenAPIError(str(e))
 
-        self._debug_callback(1, _("Response: {status_code}").format(status_code=response.status))
+        return response
+
+    def _log_response(self, response: _Response) -> None:
+        self._debug_callback(
+            1, _("Response: {status_code}").format(status_code=response.status_code)
+        )
         for key, value in response.headers.items():
             self._debug_callback(2, f"  {key}: {value}")
-        if response_body:
-            self._debug_callback(3, f"{response_body!r}")
+        if response.body:
+            self._debug_callback(3, f"{response.body!r}")
 
-        if response.status == 401:
+    def _parse_response(self, method_spec: dict[str, t.Any], response: _Response) -> t.Any:
+        if response.status_code == 401:
             raise PulpAuthenticationFailed(method_spec["operationId"])
-        if response.status == 403:
+        elif response.status_code == 403:
             raise PulpNotAutorized(method_spec["operationId"])
-        try:
-            response.raise_for_status()
-        except aiohttp.ClientResponseError as e:
-            raise PulpHTTPError(str(e), e.status)
-        except aiohttp.ClientError as e:
-            raise PulpException(str(e))
-        return _Response(status_code=response.status, headers=response.headers, body=response_body)
+        elif response.status_code >= 300:
+            raise PulpHTTPError(response.body.decode(), response.status_code)
 
-    def _parse_response(self, method_spec: dict[str, t.Any], response: _Response) -> t.Any:
         if response.status_code == 204:
             return {}
 
@@ -668,26 +698,21 @@ def call(
             )
         url = urljoin(self._base_url, path)
 
-        if query_params:
-            qs = urlencode(query_params)
-            log_msg = f"{operation_id} : {method} {url}?{qs}"
-        else:
-            log_msg = f"{operation_id} : {method} {url}"
-        self._debug_callback(1, log_msg)
-        self._debug_callback(
-            2, "\n".join([f"  {key}=={value}" for key, value in query_params.items()])
+        request = self._render_request(
+            path_spec,
+            method,
+            url,
+            query_params,
+            headers,
+            body,
+            validate_body=validate_body,
         )
+        self._log_request(request)
 
-        response = asyncio.run(
-            self._send_request(
-                path_spec,
-                method,
-                url,
-                query_params,
-                headers,
-                body,
-                validate_body=validate_body,
-            )
-        )
+        if self._dry_run and request.method.upper() not in SAFE_METHODS:
+            raise UnsafeCallError(_("Call aborted due to safe mode"))
+
+        response = asyncio.run(self._send_request(request))
 
+        self._log_response(response)
         return self._parse_response(method_spec, response)

pulp-glue/tests/test_openapi_logging.py

@@ -1,69 +1,102 @@
 import json
 import logging
-import typing as t
 
 import pytest
 
-from pulp_glue.common.openapi import OpenAPI
+from pulp_glue.common.openapi import OpenAPI, _Request, _Response
 
 pytestmark = pytest.mark.glue
 
 TEST_SCHEMA = json.dumps(
     {
         "openapi": "3.0.3",
-        "paths": {"test/": {"get": {"operationId": "test_id", "responses": {200: {}}}}},
-        "components": {"schemas": {}},
+        "paths": {
+            "test/": {
+                "get": {"operationId": "get_test_id", "responses": {200: {}}},
+                "post": {
+                    "operationId": "post_test_id",
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/testBody"}
+                            }
+                        },
+                    },
+                    "responses": {200: {}},
+                },
+            }
+        },
+        "components": {
+            "schemas": {
+                "testBody": {
+                    "type": "object",
+                    "properties": {"text": {"type": "string"}},
+                    "required": ["text"],
+                }
+            }
+        },
     }
 ).encode()
 
 
-class MockRequest:
-    headers: dict[str, str] = {}
-    body: dict[str, t.Any] = {}
-
-
-class MockResponse:
-    status_code = 200
-    headers: dict[str, str] = {}
-    text = "{}"
-    content: dict[str, t.Any] = {}
-
-    def raise_for_status(self) -> None:
-        pass
-
-
-class MockSession:
-    def prepare_request(self, *args: t.Any, **kwargs: t.Any) -> MockRequest:
-        return MockRequest()
-
-    def send(self, request: MockRequest) -> MockResponse:
-        return MockResponse()
+async def mock_send_request(request: _Request) -> _Response:
+    return _Response(status_code=200, headers={}, body=b"{}")
 
 
 @pytest.fixture
-def openapi(monkeypatch: pytest.MonkeyPatch) -> OpenAPI:
+def mock_openapi(monkeypatch: pytest.MonkeyPatch) -> OpenAPI:
     monkeypatch.setattr(OpenAPI, "load_api", lambda self, refresh_cache: TEST_SCHEMA)
-    openapi = OpenAPI("base_url", "doc_path")
+    openapi = OpenAPI("base_url", "doc_path", user_agent="test agent")
     openapi._parse_api(TEST_SCHEMA)
-    monkeypatch.setattr(openapi, "_session", MockSession())
+    monkeypatch.setattr(
+        openapi,
+        "_send_request",
+        mock_send_request,
+    )
     return openapi
 
 
-def test_openapi_logs_nothing_from_info(openapi: OpenAPI, caplog: pytest.LogCaptureFixture) -> None:
-    caplog.set_level(logging.INFO)
-    openapi.call("test_id")
-    assert caplog.record_tuples == []
-
-
-def test_openapi_logs_operation_info_to_debug(
-    openapi: OpenAPI, caplog: pytest.LogCaptureFixture
-) -> None:
-    caplog.set_level(logging.DEBUG)
-    openapi.call("test_id")
-    assert caplog.record_tuples == [
-        ("pulp_glue.openapi", logging.DEBUG + 3, "test_id : get test/"),
-        ("pulp_glue.openapi", logging.DEBUG + 2, ""),
-        ("pulp_glue.openapi", logging.DEBUG + 1, "{}"),
-        ("pulp_glue.openapi", logging.DEBUG + 3, "Response: 200"),
-        ("pulp_glue.openapi", logging.DEBUG + 1, "{}"),
-    ]
+class TestOpenAPILogs:
+    def test_nothing_with_level_info(
+        self,
+        mock_openapi: OpenAPI,
+        caplog: pytest.LogCaptureFixture,
+    ) -> None:
+        caplog.set_level(logging.INFO)
+        mock_openapi.call("get_test_id")
+        assert caplog.record_tuples == []
+
+    def test_get_operation_to_debug(
+        self,
+        mock_openapi: OpenAPI,
+        caplog: pytest.LogCaptureFixture,
+    ) -> None:
+        caplog.set_level(logging.DEBUG, logger="pulp_glue.openapi")
+        mock_openapi.call("get_test_id")
+        assert caplog.record_tuples == [
+            ("pulp_glue.openapi", logging.DEBUG + 3, "get_test_id : get test/"),
+            ("pulp_glue.openapi", logging.DEBUG + 2, ""),
+            ("pulp_glue.openapi", logging.DEBUG + 2, "  User-Agent: test agent"),
+            ("pulp_glue.openapi", logging.DEBUG + 2, "  Accept: application/json"),
+            ("pulp_glue.openapi", logging.DEBUG + 3, "Response: 200"),
+            ("pulp_glue.openapi", logging.DEBUG + 1, "b'{}'"),
+        ]
+
+    def test_post_operation_to_debug(
+        self,
+        mock_openapi: OpenAPI,
+        caplog: pytest.LogCaptureFixture,
+    ) -> None:
+        caplog.set_level(logging.DEBUG, logger="pulp_glue.openapi")
+        mock_openapi.call("post_test_id", body={"text": "Trace"})
+        assert caplog.record_tuples == [
+            ("pulp_glue.openapi", logging.DEBUG + 3, "post_test_id : post test/"),
+            ("pulp_glue.openapi", logging.DEBUG + 2, ""),
+            ("pulp_glue.openapi", logging.DEBUG + 2, "  User-Agent: test agent"),
+            ("pulp_glue.openapi", logging.DEBUG + 2, "  Accept: application/json"),
+            ("pulp_glue.openapi", logging.DEBUG + 2, "  Content-Type: application/json"),
+            ("pulp_glue.openapi", logging.DEBUG + 1, '\'{"text": "Trace"}\''),
+            ("pulp_glue.openapi", logging.DEBUG + 3, "Response: 200"),
+            ("pulp_glue.openapi", logging.DEBUG + 1, "b'{}'"),
+        ]