Feature/bunq/sdk python#59 add response id to request error

bunq/sdk/client.py

@@ -15,6 +15,13 @@ class ApiClient(object):
     :type _api_context: bunq.sdk.context.ApiContext
     """
 
+    # Error constants
+    _ERROR_COULD_NOT_DETERMINE_RESPONSE_ID_HEADER = ('The response header'
+                                                     '"X-Bunq-Client-Response-'
+                                                     'Id" or "x-bunq-client-'
+                                                     'response-id" could not '
+                                                     'be found.')
+
     # Endpoints not requiring active session for the request to succeed.
     _URL_DEVICE_SERVER = 'device-server'
     _URI_INSTALLATION = 'installation'
@@ -39,6 +46,8 @@ class ApiClient(object):
     HEADER_GEOLOCATION = 'X-Bunq-Geolocation'
     HEADER_SIGNATURE = 'X-Bunq-Client-Signature'
     HEADER_AUTHENTICATION = 'X-Bunq-Client-Authentication'
+    HEADER_RESPONSE_ID_UPPER_CASED = 'X-Bunq-Client-Response-Id'
+    HEADER_RESPONSE_ID_LOWER_CASED = 'x-bunq-client-response-id'
 
     # Default header values
     _USER_AGENT_BUNQ = 'bunq-sdk-python/0.12.4'
@@ -215,7 +224,8 @@ def _assert_response_success(self, response):
         if response.status_code != self._STATUS_CODE_OK:
             raise ExceptionFactory.create_exception_for_response(
                 response.status_code,
-                self._fetch_error_messages(response)
+                self._fetch_all_error_message(response),
+                self._fetch_response_id(response)
             )
 
     @classmethod
@@ -228,7 +238,7 @@ def _create_bunq_response_raw(cls, response):
 
         return BunqResponseRaw(response.content, response.headers)
 
-    def _fetch_error_messages(self, response):
+    def _fetch_all_error_message(self, response):
         """
         :type response: requests.Response
 
@@ -259,6 +269,25 @@ def _fetch_error_descriptions(self, error_dict):
 
         return error_descriptions
 
+    def _fetch_response_id(self, response):
+        """
+        :type response: requests.Response
+
+        :rtype: str
+        """
+
+        headers = response.headers
+
+        if self.HEADER_RESPONSE_ID_UPPER_CASED in headers:
+            return headers[self.HEADER_RESPONSE_ID_UPPER_CASED]
+
+        if self.HEADER_RESPONSE_ID_LOWER_CASED in headers:
+            return headers[self.HEADER_RESPONSE_ID_LOWER_CASED]
+
+        return exception.BunqException(
+            self._ERROR_COULD_NOT_DETERMINE_RESPONSE_ID_HEADER
+        )
+
     def put(self, uri_relative, request_bytes, custom_headers):
         """
         :type uri_relative: str

bunq/sdk/exception.py

@@ -1,10 +1,12 @@
 class ApiException(Exception):
-    def __init__(self, message, response_code):
+    def __init__(self, message, response_code, response_id):
         """
+        :type response_id: str
         :type message: str
         :type response_code: int
         """
 
+        self._response_id = response_id
         self._message = message
         self._response_code = response_code
 
@@ -26,6 +28,14 @@ def response_code(self):
 
         return self._response_code
 
+    @property
+    def response_id(self):
+        """
+        :rtype: str
+        """
+
+        return self._response_id
+
 
 class BunqException(Exception):
     def __init__(self, message):

bunq/sdk/exception_factory.py

@@ -21,40 +21,86 @@ class ExceptionFactory:
 
     # Constants for formatting messages
     _FORMAT_RESPONSE_CODE_LINE = 'HTTP Response Code: {}'
-    _GLUE_ERROR_MESSAGES = '\n'
+    _FORMAT_RESPONSE_ID_LINE = 'The response id to help bunq debug: {}'
+    _FORMAT_ERROR_MESSAGE_LINE = 'Error message: {}'
+    _GLUE_ERROR_MESSAGE_NEW_LINE = '\n'
+    _GLUE_ERROR_MESSAGE_STRING_EMPTY = ''
 
     @classmethod
-    def create_exception_for_response(cls, response_code, messages):
+    def create_exception_for_response(
+            cls,
+            response_code,
+            messages,
+            response_id
+    ):
         """
+        :type response_id: str
         :type response_code: int
         :type messages: list[str]
 
         :return: The exception according to the status code.
         :rtype:  ApiException
         """
 
-        error_message = cls._generate_message_error(response_code, messages)
+        error_message = cls._generate_message_error(
+            response_code,
+            messages,
+            response_id
+        )
 
         if response_code == cls._HTTP_RESPONSE_CODE_BAD_REQUEST:
-            return BadRequestException(error_message, response_code)
+            return BadRequestException(
+                error_message,
+                response_code,
+                response_id
+            )
         if response_code == cls._HTTP_RESPONSE_CODE_UNAUTHORIZED:
-            return UnauthorizedException(error_message, response_code)
+            return UnauthorizedException(
+                error_message,
+                response_code,
+                response_id
+            )
         if response_code == cls._HTTP_RESPONSE_CODE_FORBIDDEN:
-            return ForbiddenException(error_message, response_code)
+            return ForbiddenException(
+                error_message,
+                response_code,
+                response_id
+            )
         if response_code == cls._HTTP_RESPONSE_CODE_NOT_FOUND:
-            return NotFoundException(error_message, response_code)
+            return NotFoundException(
+                error_message,
+                response_code,
+                response_id
+            )
         if response_code == cls._HTTP_RESPONSE_CODE_METHOD_NOT_ALLOWED:
-            return MethodNotAllowedException(error_message, response_code)
+            return MethodNotAllowedException(
+                error_message,
+                response_code,
+                response_id
+            )
         if response_code == cls._HTTP_RESPONSE_CODE_TOO_MANY_REQUESTS:
-            return TooManyRequestsException(error_message, response_code)
+            return TooManyRequestsException(
+                error_message,
+                response_code,
+                response_id
+            )
         if response_code == cls._HTTP_RESPONSE_CODE_INTERNAL_SERVER_ERROR:
-            return PleaseContactBunqException(error_message, response_code)
+            return PleaseContactBunqException(
+                error_message,
+                response_code,
+                response_id
+            )
 
-        return UnknownApiErrorException(error_message, response_code)
+        return UnknownApiErrorException(
+            error_message,
+            response_code,
+            response_id
+        )
 
     @classmethod
-    def _generate_message_error(cls, response_code, messages):
+    def _generate_message_error(cls, response_code, messages, response_id):
         """
+        :type response_id: str
         :type response_code: int
         :type messages: list[str]
 
@@ -63,15 +109,21 @@ def _generate_message_error(cls, response_code, messages):
 
         line_response_code = cls._FORMAT_RESPONSE_CODE_LINE \
             .format(response_code)
+        line_response_id = cls._FORMAT_RESPONSE_ID_LINE.format(response_id)
+        line_error_message = cls._FORMAT_ERROR_MESSAGE_LINE.format(
+            cls._GLUE_ERROR_MESSAGE_STRING_EMPTY.join(messages)
+        )
 
-        return cls._glue_messages([line_response_code] + messages)
+        return cls._glue_all_error_message(
+            [line_response_code, line_response_id, line_error_message]
+        )
 
     @classmethod
-    def _glue_messages(cls, messages):
+    def _glue_all_error_message(cls, messages):
         """
         :type messages: list[str]
 
         :rtype: str
         """
 
-        return cls._GLUE_ERROR_MESSAGES.join(messages)
+        return cls._GLUE_ERROR_MESSAGE_NEW_LINE.join(messages)

tests/http/test_bad_request_with_response_id.py

@@ -0,0 +1,29 @@
+from bunq.sdk.exception import BadRequestException
+from bunq.sdk.model.generated.endpoint import UserPerson
+from tests.bunq_test import BunqSdkTestCase
+
+
+class TestPagination(BunqSdkTestCase):
+    """
+    Tests if the response id from a failed request can be retrieved
+    successfully.
+    """
+
+    _INVALID_USER_PERSON_ID = 0
+
+    def test_bad_request_with_response_id(self):
+        """
+        """
+
+        caught_exception = None
+
+        try:
+            UserPerson.get(
+                self._get_api_context(),
+                self._INVALID_USER_PERSON_ID
+            )
+        except BadRequestException as exception:
+            caught_exception = exception
+
+        self.assertIsNotNone(caught_exception)
+        self.assertIsNotNone(caught_exception.response_id)