paddle-python-sdk 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

paddle_billing/Client.py

@@ -9,6 +9,7 @@ from uuid               import uuid4
 from paddle_billing.FiltersUndefined import FiltersUndefined
 from paddle_billing.HasParameters    import HasParameters
 from paddle_billing.Options          import Options
+from paddle_billing.ResponseParser   import ResponseParser
 
 from paddle_billing.Logger.NullHandler import NullHandler
 
@@ -133,8 +134,17 @@ class Client:
         except RequestException as e:
             self.status_code = e.response.status_code
 
+            api_error = None
+            if e.response is not None:
+                response_parser = ResponseParser(e.response)
+                api_error = response_parser.get_error()
+
             if self.log:
-                self.log.error(f"Request failed: {e}")
+                self.log.error(f"Request failed: {e}.{' ' + api_error.detail if api_error is not None else ''}")
+
+            if api_error is not None:
+                raise api_error
+
             raise
 
 
@@ -187,7 +197,7 @@ class Client:
             'Authorization':  f"Bearer {self.__api_key}",
             'Content-Type':   'application/json',
             'Paddle-Version': str(self.use_api_version),
-            'User-Agent':     'PaddleSDK/python 0.1.2',
+            'User-Agent':     'PaddleSDK/python 0.1.3',
         })
 
         # Configure retries

paddle_billing/Exceptions/ApiError.py

@@ -1,25 +1,27 @@
 from paddle_billing.Exceptions.FieldError import FieldError
 
+from requests import HTTPError
 
-class ApiError(Exception):
-    def __init__(self, error_type, error_code, detail, docs_url, *field_errors):
+class ApiError(HTTPError):
+    def __init__(self, response, error_type, error_code, detail, docs_url, *field_errors):
+        super().__init__(detail, response=response)
         self.error_type   = error_type
         self.error_code   = error_code
         self.detail       = detail
         self.docs_url     = docs_url
         self.field_errors = field_errors
-        super().__init__(self.detail)
 
 
     def __repr__(self):
-        return (f"ApiError(type='{self.error_type}', error_code='{self.error_code}', detail='{self.detail}', "
+        return (f"ApiError(error_type='{self.error_type}', error_code='{self.error_code}', detail='{self.detail}', "
                 f"docs_url='{self.docs_url}', field_errors={self.field_errors})")
 
 
     @classmethod
-    def from_error_data(cls, error):
+    def from_error_data(cls, response, error):
         field_errors = [FieldError(fe['field'], fe['message']) for fe in error.get('errors', [])]
         return cls(
+            response,
             error['type'],
             error['code'],
             error['detail'],

paddle_billing/ResponseParser.py

@@ -9,6 +9,8 @@ from paddle_billing.Exceptions.ApiError import ApiError
 class ResponseParser:
     def __init__(self, response: Response):
         self.body = None
+        self.error = None
+        self.response = response
 
         if not hasattr(response, 'text'):
             return
@@ -19,13 +21,17 @@ class ResponseParser:
             self.body = None
 
         if self.body and 'error' in self.body:
-            self.parse_errors()
+            self.error = self.parse_errors()
 
 
     def get_data(self) -> list | dict:
         return self.body.get('data', []) if self.body else []
 
 
+    def get_error(self) -> ApiError | None:
+        return self.error
+
+
     def get_pagination(self) -> Pagination:
         meta       = self.body.get('meta',  {}) if self.body  else {}
         pagination = meta.get('pagination', {}) if meta       else {}
@@ -38,15 +44,15 @@ class ResponseParser:
         )
 
 
-    def parse_errors(self):
+    def parse_errors(self) -> ApiError | None:
         if not self.body or 'error' not in self.body:
-            return
+            return None
 
         error           = self.body['error']
         code            = error.get('code', 'shared_error')
         exception_class = self.find_exception_class_from_code(code)
 
-        raise exception_class(error)
+        return exception_class.from_error_data(self.response, error)
 
 
     @staticmethod
@@ -57,7 +63,7 @@ class ResponseParser:
         if not resource:
             return ApiError
 
-        class_name = f"api_error.{resource}ApiError"
+        class_name = f"paddle_billing.Exceptions.ApiErrors.{resource}ApiError"
         try:
             module = __import__(class_name, fromlist=[''])
             return getattr(module, f'{resource}ApiError')

{paddle_python_sdk-0.1.2.dist-info → paddle_python_sdk-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: paddle-python-sdk
-Version: 0.1.2
+Version: 0.1.3
 Summary: Paddle's Python SDK for Paddle Billing
 Home-page: https://developer.paddle.com/api-reference/overview
 Author: Paddle and contributors

{paddle_python_sdk-0.1.2.dist-info → paddle_python_sdk-0.1.3.dist-info}/RECORD

@@ -3,7 +3,7 @@ examples/catalog_management.py,sha256=3osNPpYD5Dh3uq3Uf7Be9li806IkLbr8W7iRJMHMJJ
 examples/event_polling.py,sha256=XIpNzSfFIF_V72a-Fujal7y43PV4K28CCt0K29goz_Y,2407
 examples/get_products.py,sha256=LqA92ykNCJJmkTQIpnqrun7HaXozh3h0BpQ4S2JnsR0,1858
 examples/logger.py,sha256=mZuSjhKSqUYpAGtvcqmazkU8Eb7jzl_MS2zNUPFNvY0,1065
-paddle_billing/Client.py,sha256=faWJ9xEnZEhJjr3_lhoDIHzKooMMi92U2_1MAloX-yg,8317
+paddle_billing/Client.py,sha256=emyh0fXgRezMTAeRQ2hrQuxI7ApPfDKDXpFl_wKEaGY,8692
 paddle_billing/ConditionallyRemoveImportMeta.py,sha256=tyCEj29dCDO3s_28NwBITRzU0ms2o9x0uToDpsufaEo,652
 paddle_billing/EnumStringify.py,sha256=iDvKULZat3jx9A-_PhvoN6CbFGf2pyxrQeYZxqX9n8M,48
 paddle_billing/Environment.py,sha256=IV5eVH131bhNkM9mAGpkziERsSsWPu-xWxGkdCQEb5c,346
@@ -13,7 +13,7 @@ paddle_billing/HasParameters.py,sha256=EOJNJLI6Yg7PZtyjr4ioEJidOZYOTumeoQcdCxjap
 paddle_billing/Options.py,sha256=Lpaw_VaKjMrxCFM7Sf5KnkLVVr_WjREiEmMZKMPKEZ8,237
 paddle_billing/PaddleStrEnum.py,sha256=SSpayqkGn_ZbB1wAiN2Qdqo17GBgTFxB5GbfLiwJuwI,1139
 paddle_billing/RecursivelyRemoveKey.py,sha256=_y1NIa9yC0jaDgzv-rfoCQ4Z4-KvorlurAh4eUp3i6s,474
-paddle_billing/ResponseParser.py,sha256=NEuuF5FAPJ_L87nTbM1pq2IEtjAe2cudUlGrdbqq18o,1871
+paddle_billing/ResponseParser.py,sha256=V0_hkWUjisMa6EQQ0p489ggSFxk-hgCREWVKdqQqtTM,2097
 paddle_billing/Undefined.py,sha256=NJKVAEGbTBDfnfaAS6Vn_pSHmHDGbIS277gVScuB2A8,26
 paddle_billing/__init__.py,sha256=IZyNx_kWTth8sU76pk34esblJFfzr_DWla_mlv4q9VA,187
 paddle_billing/Entities/Address.py,sha256=MEFULxsE86lTUruNhX5NWM0Mw4gD3r7b2128QdFNWKI,1631
@@ -194,7 +194,7 @@ paddle_billing/Entities/Transactions/TransactionProration.py,sha256=DQTbnO8R9tVN
 paddle_billing/Entities/Transactions/TransactionTimePeriod.py,sha256=wBnOcZ9zRwkIly5WrdvuSo729WJ5zWAOirP8uEeyLpU,449
 paddle_billing/Entities/Transactions/TransactionUpdateTransactionItem.py,sha256=GwfqJUcfoi3auMndxT63uRnm_qE__LWmXH0IgeECnIo,159
 paddle_billing/Entities/Transactions/__init__.py,sha256=EuAhpqyHrcGbVnzbSOMK43L3VNy6cqGK_zTsgz7YvYY,2044
-paddle_billing/Exceptions/ApiError.py,sha256=pCtnJRNPNybprR-qumCrkEszV1b7y0RUc8wH64kTdQU,951
+paddle_billing/Exceptions/ApiError.py,sha256=qT4TFN8oi-xWV10qIwQS0a-2avcnJ0x9rmk-uuw_Amk,1044
 paddle_billing/Exceptions/FieldError.py,sha256=ucSg3nDZ2bJCbuOU51ivqGRaRIS07CR_G--iTs3lgBQ,209
 paddle_billing/Exceptions/SdkException.py,sha256=JKKNX6OUCoxwzz1XLV7qGP3ih9f4Nj2mHZOws6IRy7o,40
 paddle_billing/Exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -465,10 +465,13 @@ paddle_billing/Resources/Transactions/Operations/List/Includes.py,sha256=mOSfkRx
 paddle_billing/Resources/Transactions/Operations/List/Origin.py,sha256=FedgNN1r7gDHUmqgdzOa3T1MYlWfmMC7bgmHqLkSles,432
 paddle_billing/Resources/Transactions/Operations/List/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=K_rWFm4jOBGVpoQP9llOwQwyYrXThbF3CBvood_hNRU,127
 tests/Functional/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/Functional/Client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/Functional/Client/test_Client.py,sha256=e4b7wt2hpAVxE4s0gR1qeETYoYvBPakkIiVRmG4jllk,5645
 tests/Functional/Resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/Functional/Resources/Addresses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/Functional/Resources/Addresses/test_AddressesClient.py,sha256=UimpNZ4A7Y8FR96g1FF4tUDloKM528njNrsiKOngwOg,12380
+tests/Functional/Resources/Addresses/test_AddressesClient.py,sha256=hnSEvZS6mbkFQkFr52w2OfTWVl6uP5LnAFC0jiXf0bY,16313
 tests/Functional/Resources/Adjustments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/Functional/Resources/Adjustments/test_AdjustmentsClient.py,sha256=TQIT6t5fwxeDziCNPHHA_deb14ws1y6DVeXOlJk_eR0,8869
 tests/Functional/Resources/Businesses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -508,10 +511,11 @@ tests/Unit/PaddleStrEnum/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/Unit/PaddleStrEnum/test_PaddleStrEnum.py,sha256=OUMMRhyQdMwJQ4xNKZEshvh08USOlCIjkngJylY5JdQ,1879
 tests/Utils/FakeResponse.py,sha256=naT8IgXDtbAxAAj-T3FoJl9Ze4kXb-O-Mf6BarWU6oM,305
 tests/Utils/ReadsFixture.py,sha256=VEIEST29lorMZHA11XYn7aqtEYry2TDUqeWd63IRLbM,1153
-tests/Utils/TestClient.py,sha256=Y13roXRdkDp7r73O1p030deWZNeDhDxHtkvKxNG935M,1158
+tests/Utils/TestClient.py,sha256=fZb0yzgw9Wnn0JGTw8bJyaUnpR3lRz-AL3N_7O42O7k,1381
+tests/Utils/TestLogger.py,sha256=h6PJbVrgxyi_H0FlSoSKwONOqBC35Hdmqp8_TZ5qt_w,557
 tests/Utils/__init__.py,sha256=fkxfGYArVZPD7GQlBEwT6FY052mTD83VnDerzsTK7hA,39
-paddle_python_sdk-0.1.2.dist-info/LICENSE,sha256=e5Sn9mzCdpjnqCLxXpGHNKdYB6JlRSTLhN_CD4WSO6w,10770
-paddle_python_sdk-0.1.2.dist-info/METADATA,sha256=aq5Uof1fMhvGWGF78S7agNTcpPf513VDdDe3LEnZCds,7247
-paddle_python_sdk-0.1.2.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-paddle_python_sdk-0.1.2.dist-info/top_level.txt,sha256=9a07VPng7o5wK8VAXkl6NC30xrNbW9zff_02jHyHi4c,30
-paddle_python_sdk-0.1.2.dist-info/RECORD,,
+paddle_python_sdk-0.1.3.dist-info/LICENSE,sha256=e5Sn9mzCdpjnqCLxXpGHNKdYB6JlRSTLhN_CD4WSO6w,10770
+paddle_python_sdk-0.1.3.dist-info/METADATA,sha256=nf_AUi0MjFRCT40bYveCrUXDm5Sb1l4SXbqQMsZ3ipg,7247
+paddle_python_sdk-0.1.3.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+paddle_python_sdk-0.1.3.dist-info/top_level.txt,sha256=9a07VPng7o5wK8VAXkl6NC30xrNbW9zff_02jHyHi4c,30
+paddle_python_sdk-0.1.3.dist-info/RECORD,,

tests/Functional/Client/test_Client.py

@@ -0,0 +1,138 @@
+from json         import loads, dumps
+from pytest       import mark, raises
+from urllib.parse import unquote
+
+from paddle_billing.Exceptions.ApiError                  import ApiError
+from paddle_billing.Exceptions.ApiErrors.AddressApiError import AddressApiError
+
+from requests.exceptions import RequestException, HTTPError
+
+from tests.Utils.TestLogger import test_log_handler, LogHandler
+
+
+class TestClient:
+    @mark.parametrize(
+        [
+            'expected_response_status',
+            'expected_reason',
+            'expected_response_body',
+            'expected_exception',
+        ],
+        [
+            (
+                400,
+                'Bad Request',
+                {
+                    "error": {
+                        "type": "request_error",
+                        "code": "bad_request",
+                        "detail": "Invalid request",
+                        "documentation_url": "https://developer.paddle.com/v1/errors/shared/bad_request",
+                        "errors": [
+                            {
+                                "field": "some_field",
+                                "message": "Some error message"
+                            }
+                        ]
+                    },
+                    "meta": {
+                        "request_id": "f00bb3ca-399d-4686-889c-50b028f4c912"
+                    }
+                },
+                ApiError
+            ),
+            (
+                404,
+                'Not Found',
+                {
+                    "error": {
+                        "type": "request_error",
+                        "code": "not_found",
+                        "detail": "Entity not found",
+                        "documentation_url": "https://developer.paddle.com/v1/errors/shared/not_found"
+                    },
+                    "meta": {
+                        "request_id": "f00bb3ca-399d-4686-889c-50b028f4c912"
+                    }
+                },
+                ApiError
+            ),
+            (
+                400,
+                'Bad Request',
+                {
+                    "error": {
+                        "type": "request_error",
+                        "code": "address_location_not_allowed",
+                        "detail": "Cannot create address with an unsupported location",
+                        "documentation_url": "https://developer.paddle.com/errors/addresses/address_location_not_allowed"
+                    },
+                    "meta": {
+                        "request_id": "f00bb3ca-399d-4686-889c-50b028f4c912"
+                    }
+                },
+                AddressApiError
+            ),
+        ],
+        ids=[
+            "Returns bad_request response",
+            "Returns not_found response",
+            "Returns address_location_not_allowed response",
+        ],
+    )
+    def test_post_raw_returns_error_response(
+        self,
+        test_client,
+        test_log_handler: LogHandler,
+        mock_requests,
+        expected_response_status,
+        expected_reason,
+        expected_response_body,
+        expected_exception
+    ):
+        expected_request_url = f"{test_client.base_url}/some/url"
+        expected_request_body = { "some_property": "some value" }
+        mock_requests.post(expected_request_url, status_code=expected_response_status, text=dumps(expected_response_body), reason=expected_reason)
+
+        with raises(expected_exception) as exception_info:
+            test_client.client.post_raw(expected_request_url, expected_request_body)
+
+        request_json = test_client.client.payload
+        last_request = mock_requests.last_request
+        api_error    = exception_info.value
+
+        assert unquote(last_request.url) == expected_request_url, \
+            "The URL does not match the expected URL, verify the query string is correct"
+
+        assert loads(request_json) == expected_request_body, \
+            "The request JSON doesn't match the expected fixture JSON"
+
+        assert isinstance(api_error, ApiError)
+        assert isinstance(api_error, HTTPError)
+        assert isinstance(api_error, RequestException)
+        assert api_error.response.status_code == expected_response_status, 'Unexpected status code'
+        assert api_error.error_type == expected_response_body['error']['type']
+        assert api_error.error_code == expected_response_body['error']['code']
+        assert api_error.detail == expected_response_body['error']['detail']
+        assert api_error.docs_url == expected_response_body['error']['documentation_url']
+
+        if 'errors' in expected_response_body['error']:
+            assert len(api_error.field_errors) == len(expected_response_body['error']['errors'])
+
+            for i, expected_field_error in enumerate(expected_response_body['error']['errors']):
+                assert api_error.field_errors[i].field == expected_field_error['field']
+                assert api_error.field_errors[i].error == expected_field_error['message']
+        else:
+            assert len(api_error.field_errors) == 0
+
+        assert str(api_error) == expected_response_body['error']['detail']
+        assert repr(api_error) == ("ApiError("
+            f"error_type='{api_error.error_type}', "
+            f"error_code='{api_error.error_code}', "
+            f"detail='{api_error.detail}', "
+            f"docs_url='{api_error.docs_url}', "
+            f"field_errors={api_error.field_errors}"
+            ")")
+
+        assert test_log_handler.get_logs()[0].message == \
+            f"Request failed: {expected_response_status} Client Error: {expected_reason} for url: {expected_request_url}. {api_error.detail}"

tests/Functional/Resources/Addresses/test_AddressesClient.py

@@ -1,14 +1,17 @@
-from json         import loads
-from pytest       import mark
+from json         import loads, dumps
+from pytest       import mark, raises
 from urllib.parse import unquote
 
 from paddle_billing.Entities.Address     import Address
 from paddle_billing.Entities.Collections import AddressCollection
 from paddle_billing.Entities.Shared      import CountryCode, CustomData, Status
+from paddle_billing.Exceptions.ApiError  import ApiError
 
 from paddle_billing.Resources.Addresses.Operations import CreateAddress, ListAddresses, UpdateAddress
 from paddle_billing.Resources.Shared.Operations    import Pager
 
+from requests.exceptions import RequestException, HTTPError
+
 from tests.Utils.TestClient   import mock_requests, test_client
 from tests.Utils.ReadsFixture import ReadsFixtures
 
@@ -78,6 +81,100 @@ class TestAddressesClient:
             "The response JSON doesn't match the expected fixture JSON"
 
 
+    @mark.parametrize(
+        [
+            'customer_id',
+            'operation',
+            'expected_request_body',
+            'expected_response_status',
+            'expected_reason',
+            'expected_response_body',
+            'expected_url_path',
+        ],
+        [
+            (
+                'ctm_01h844p3h41s12zs5mn4axja51',
+                CreateAddress(CountryCode.AG),
+                ReadsFixtures.read_raw_json_fixture('request/create_basic'),
+                400,
+                'Bad Request',
+                {
+                    "error": {
+                        "type": "request_error",
+                        "code": "bad_request",
+                        "detail": "Invalid request",
+                        "documentation_url": "https://developer.paddle.com/v1/errors/shared/bad_request",
+                        "errors": [
+                        {
+                            "field": "postal_code",
+                            "message": "US postal_code must be 5 digits only"
+                        }
+                        ]
+                    },
+                    "meta": {
+                        "request_id": "f00bb3ca-399d-4686-889c-50b028f4c911"
+                    }
+                },
+                '/customers/ctm_01h844p3h41s12zs5mn4axja51/addresses'
+            ),
+        ],
+        ids=[
+            "Returns 400 response for postal code",
+        ],
+    )
+    def test_create_address_returns_error_response(
+        self,
+        test_client,
+        mock_requests,
+        customer_id,
+        operation,
+        expected_request_body,
+        expected_response_status,
+        expected_reason,
+        expected_response_body,
+        expected_url_path,
+    ):
+        expected_url = f"{test_client.base_url}{expected_url_path}"
+        mock_requests.post(expected_url, status_code=expected_response_status, text=dumps(expected_response_body), reason=expected_reason)
+
+        with raises(ApiError) as exception_info:
+            test_client.client.addresses.create(customer_id, operation)
+
+        request_json = test_client.client.payload
+        last_request = mock_requests.last_request
+        api_error    = exception_info.value
+
+        assert unquote(last_request.url) == expected_url, \
+            "The URL does not match the expected URL, verify the query string is correct"
+
+        assert loads(request_json) == loads(expected_request_body), \
+            "The request JSON doesn't match the expected fixture JSON"
+
+        assert isinstance(api_error, ApiError)
+        assert isinstance(api_error, HTTPError)
+        assert isinstance(api_error, RequestException)
+        assert api_error.response.status_code == expected_response_status, 'Unexpected status code'
+        assert api_error.error_type == expected_response_body['error']['type']
+        assert api_error.error_code == expected_response_body['error']['code']
+        assert api_error.detail == expected_response_body['error']['detail']
+        assert api_error.docs_url == expected_response_body['error']['documentation_url']
+
+        assert len(api_error.field_errors) == len(expected_response_body['error']['errors'])
+
+        for i, expected_field_error in enumerate(expected_response_body['error']['errors']):
+            assert api_error.field_errors[i].field == expected_field_error['field']
+            assert api_error.field_errors[i].error == expected_field_error['message']
+
+        assert str(api_error) == api_error.detail
+        assert repr(api_error) == ("ApiError("
+            f"error_type='{api_error.error_type}', "
+            f"error_code='{api_error.error_code}', "
+            f"detail='{api_error.detail}', "
+            f"docs_url='{api_error.docs_url}', "
+            f"field_errors={api_error.field_errors}"
+            ")")
+
+
     @mark.parametrize(
         'customer_id, address_id, operation, expected_request_body, expected_response_status, expected_response_body, expected_url',
         [

tests/Utils/TestClient.py

@@ -1,20 +1,24 @@
 from os            import getenv
 from pytest        import fixture
 from requests_mock import Mocker
+from logging       import Logger
 
 from paddle_billing import Client, Environment, Options
 
+from tests.Utils.TestLogger import test_logger
+
 
 class TestClient:
     def __init__(
         self,
         client:         Client | None = None,
         api_secret_key: str    | None = None,
-        environment:    Environment   = Environment.SANDBOX
+        environment:    Environment   = Environment.SANDBOX,
+        logger:         Logger | None = None,
      ):
         self._environment = environment
         self._base_url    = self._environment.base_url
-        self._client      = client or self.create_client(api_secret_key)
+        self._client      = client or self.create_client(api_secret_key, logger)
 
 
     @property
@@ -30,16 +34,17 @@ class TestClient:
         return self._environment
 
 
-    def create_client(self, api_secret_key: str | None = None):
+    def create_client(self, api_secret_key: str | None = None, logger: Logger | None = None):
         return Client(
             getenv('PADDLE_API_SECRET_KEY') if api_secret_key is None else api_secret_key,
             options = Options(self._environment),
+            logger=logger
         )
 
 
 @fixture(autouse=True)
-def test_client():
-    return TestClient(environment=Environment.SANDBOX)
+def test_client(test_logger):
+    return TestClient(environment=Environment.SANDBOX, logger=test_logger)
 
 
 @fixture

tests/Utils/TestLogger.py

@@ -0,0 +1,28 @@
+from pytest  import fixture
+from logging import getLogger, Logger, Handler, LogRecord
+
+
+class LogHandler(Handler):
+    def __init__(self):
+        super().__init__()
+        self._logs = []
+
+
+    def emit(self, record):
+        self._logs.append(record)
+
+
+    def get_logs(self) -> list[LogRecord]:
+        return self._logs
+
+
+@fixture
+def test_log_handler() -> LogHandler:
+    return LogHandler()
+
+
+@fixture
+def test_logger(test_log_handler) -> Logger:
+    logger = getLogger('paddle_test_logger')
+    logger.addHandler(test_log_handler)
+    return logger

tests/conftest.py

@@ -0,0 +1,2 @@
+from tests.Utils.TestClient import mock_requests, test_client
+from tests.Utils.TestLogger import test_log_handler, test_logger