Merge branch 'develop' into #54-fix-missing-mastercard-action-id

Author: OGKevin

.github/ISSUE_TEMPLATE.md

@@ -7,8 +7,17 @@
 ## What happens:
 1.
 
-## Logs
-- Logs
+## Traceback
+[//]: # (If there is a traceback please share it in a quote! You can do this by pasting the traceback text, highlighting it and pressing the quote button.)
+
+## SDK version and environment
+- Tested on [0.12.4](https://github.com/bunq/sdk_python/releases/tag/0.12.4)
+- [ ] Sandbox
+- [ ] Production
+
+## Response id
+[//]: # (If this error has something to do with a request that fails, please provide the response id of the request.)
+- Response id:
 
 ## Extra info:
-- Tested on
+[//]: # (Please provide any other relevant information here)

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,8 @@
+[//]: # (Thanks for opening this pull request! Before you proceed please make sure that you have an issue that explains what this pull request will do.
+         Make sure that all your commits link to this issue e.g. "My commit. \(bunq/sdk_python#<issue nr>\)".
+         If this pull request is changing files that are located in "bunq/sdk/model/generated" then this pull request will be closed as these files must/can only be changed on bunq's side.)
+         
+## This PR closes/fixes the following issues:
+[//]: # (If for some reason your pull request does not require a test case you can just mark this box as checked and explain why it does not require a test case.)
+ - Closes bunq/sdk_php#
+    - [ ] Tested

.zappr.yaml

@@ -22,5 +22,4 @@ pull-request:
   labels:
     additional: true
     required:
-      - Reviewed by André
       - Can be merged

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,57 +21,109 @@ 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_code: int
         :type messages: list[str]
+        :type response_id: 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_code: int
         :type messages: list[str]
+        :type response_id: str
 
         :rtype: str
         """
 
         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/__init__.py

@@ -0,0 +1,24 @@
+from bunq.sdk.exception import ApiException
+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):
+        """
+        """
+
+        with self.assertRaises(ApiException) as caught_exception:
+            UserPerson.get(
+                self._get_api_context(),
+                self._INVALID_USER_PERSON_ID
+            )
+
+        self.assertIsNotNone(caught_exception.exception.response_id)