Merge pull request #26 from bunq/feature/exception-handler

Feature/exception handler

Author: dnl-blkv

EXCEPTIONS.md

@@ -0,0 +1,69 @@
+## Exceptions
+When you make a request via the SDK, there is a chance of request failing
+due to various reasons. When such a failure happens, an exception
+corresponding to the error occurred is raised.
+
+
+----
+#### Possible Exceptions
+* `BadRequestException` If the request returns with status code `400`
+* `UnauthorizedException` If the request returns with status code `401`
+* `ForbiddenException` If the request returns with status code `403`
+* `NotFoundException` If the request returns with status code `404`
+* `MethodNotAllowedException` If the request returns with status code `405`
+* `TooManyRequestsException` If the request returns with status code `429`
+* `PleaseContactBunqException` If the request returns with status code `500`.
+If you get this exception, please contact us preferably via the support chat in the bunq app.
+* `UnknownApiErrorException` If none of the above mentioned exceptions are raised,
+this exception will be raised instead.
+
+For more information regarding these errors, please take a look on the documentation
+page here: https://doc.bunq.com/api/1/page/errors
+
+---
+#### Base exception
+All the exceptions have the same base exception which looks like this:
+```python
+class ApiException(Exception):
+    def __init__(self, message, response_code):
+        pass
+        
+    @property
+    def message(self):
+        """
+        :rtype: str
+        """
+
+        return self._message
+
+    @property
+    def response_code(self):
+        """
+        :rtype: int
+        """
+
+        return self._response_code
+```
+This means that each exception will have the response code and the error message 
+related to the specific exception that has been raised.
+
+---
+#### Exception handling
+Because we raise different exceptions for each error, you can catch an error
+if you expect it to be raised.
+
+```python
+from bunq.sdk.exception import BadRequestException
+from bunq.sdk.context import ApiEnvironmentType, ApiContext
+
+API_KEY = "Some invalid API key"
+DESCRIPTION = "This wil raise a BadRequestException"
+
+try:
+    # Make a call that might raise an exception
+    ApiContext(ApiEnvironmentType.SANDBOX, API_KEY, DESCRIPTION)
+except BadRequestException as error:
+    # Do something if exception is raised
+    print(error.response_code)
+    print(error.message) # or just print(error)
+```

README.md

@@ -183,3 +183,7 @@ Please do not forget to set the `_API_KEY` constant in
 
 Information regarding the test cases can be found in the [README.md](./tests/README.md)
 located in [test](/tests)
+
+## Exceptions
+The SDK can raise multiple exceptions. For an overview of these exceptions please
+take a look at [EXCEPTIONS.md](./EXCEPTIONS.md)

bunq/sdk/client.py

@@ -6,6 +6,7 @@
 
 from bunq.sdk import exception
 from bunq.sdk import security
+from bunq.sdk.exception_factory import ExceptionFactory
 from bunq.sdk.json import converter
 
 
@@ -200,7 +201,7 @@ def _assert_response_success(self, response):
         """
 
         if response.status_code != self._STATUS_CODE_OK:
-            raise exception.ApiException(
+            raise ExceptionFactory.create_exception_for_response(
                 response.status_code,
                 self._fetch_error_messages(response)
             )

bunq/sdk/exception.py

@@ -1,44 +1,22 @@
 class ApiException(Exception):
-    """
-    :type _response_code: int
-    """
-
-    # Constants for formatting messages
-    _FORMAT_RESPONSE_CODE_LINE = 'HTTP Response Code: {}'
-    _GLUE_ERROR_MESSAGES = '\n'
-
-    def __init__(self, response_code, messages):
+    def __init__(self, message, response_code):
         """
+        :type message: str
         :type response_code: int
-        :type messages: list[str]
         """
 
-        super(ApiException, self).__init__(
-            self.generate_message_error(response_code, messages)
-        )
+        self._message = message
         self._response_code = response_code
 
-    def generate_message_error(self, response_code, messages):
-        """
-        :type response_code: int
-        :type messages: list[str]
-
-        :rtype: str
-        """
-
-        line_response_code = self._FORMAT_RESPONSE_CODE_LINE \
-            .format(response_code)
-
-        return self.glue_messages([line_response_code] + messages)
+        super(ApiException, self).__init__(message)
 
-    def glue_messages(self, messages):
+    @property
+    def message(self):
         """
-        :type messages: list[str]
-
         :rtype: str
         """
 
-        return self._GLUE_ERROR_MESSAGES.join(messages)
+        return self._message
 
     @property
     def response_code(self):
@@ -52,3 +30,35 @@ def response_code(self):
 class BunqException(Exception):
     def __init__(self, message):
         super(BunqException, self).__init__(message)
+
+
+class UnknownApiErrorException(ApiException):
+    pass
+
+
+class BadRequestException(ApiException):
+    pass
+
+
+class UnauthorizedException(ApiException):
+    pass
+
+
+class ForbiddenException(ApiException):
+    pass
+
+
+class NotFoundException(ApiException):
+    pass
+
+
+class MethodNotAllowedException(ApiException):
+    pass
+
+
+class TooManyRequestsException(ApiException):
+    pass
+
+
+class PleaseContactBunqException(ApiException):
+    pass

bunq/sdk/exception_factory.py

@@ -0,0 +1,77 @@
+from bunq.sdk.exception import BadRequestException
+from bunq.sdk.exception import UnauthorizedException
+from bunq.sdk.exception import ForbiddenException
+from bunq.sdk.exception import NotFoundException
+from bunq.sdk.exception import MethodNotAllowedException
+from bunq.sdk.exception import TooManyRequestsException
+from bunq.sdk.exception import PleaseContactBunqException
+from bunq.sdk.exception import UnknownApiErrorException
+from bunq.sdk.exception import ApiException
+
+
+class ExceptionFactory:
+    # Error response code constants
+    _HTTP_RESPONSE_CODE_BAD_REQUEST = 400
+    _HTTP_RESPONSE_CODE_UNAUTHORIZED = 401
+    _HTTP_RESPONSE_CODE_FORBIDDEN = 403
+    _HTTP_RESPONSE_CODE_NOT_FOUND = 404
+    _HTTP_RESPONSE_CODE_METHOD_NOT_ALLOWED = 405
+    _HTTP_RESPONSE_CODE_TOO_MANY_REQUESTS = 429
+    _HTTP_RESPONSE_CODE_INTERNAL_SERVER_ERROR = 500
+
+    # Constants for formatting messages
+    _FORMAT_RESPONSE_CODE_LINE = 'HTTP Response Code: {}'
+    _GLUE_ERROR_MESSAGES = '\n'
+
+    @classmethod
+    def create_exception_for_response(cls, response_code, messages):
+        """
+        :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)
+
+        if response_code == cls._HTTP_RESPONSE_CODE_BAD_REQUEST:
+            return BadRequestException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_UNAUTHORIZED:
+            return UnauthorizedException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_FORBIDDEN:
+            return ForbiddenException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_NOT_FOUND:
+            return NotFoundException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_METHOD_NOT_ALLOWED:
+            return MethodNotAllowedException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_TOO_MANY_REQUESTS:
+            return TooManyRequestsException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_INTERNAL_SERVER_ERROR:
+            return PleaseContactBunqException(error_message, response_code)
+
+        return UnknownApiErrorException(error_message, response_code)
+
+    @classmethod
+    def _generate_message_error(cls, response_code, messages):
+        """
+        :type response_code: int
+        :type messages: list[str]
+
+        :rtype: str
+        """
+
+        line_response_code = cls._FORMAT_RESPONSE_CODE_LINE \
+            .format(response_code)
+
+        return cls._glue_messages([line_response_code] + messages)
+
+    @classmethod
+    def _glue_messages(cls, messages):
+        """
+        :type messages: list[str]
+
+        :rtype: str
+        """
+
+        return cls._GLUE_ERROR_MESSAGES.join(messages)

tests/bunq_test.py

@@ -4,8 +4,6 @@
 from tests.config import Config
 from bunq.sdk.context import ApiContext
 from bunq.sdk.context import ApiEnvironmentType
-from bunq.sdk.model.generated import endpoint
-from bunq.sdk.exception import ApiException
 
 
 class BunqSdkTestCase(unittest.TestCase):
@@ -35,10 +33,11 @@ def _get_api_context(cls):
 
         try:
             api_context = ApiContext.restore(filename_bunq_config_full)
-            endpoint.User.list(api_context)
-        except (ApiException, FileNotFoundError):
+        except FileNotFoundError:
             api_context = ApiContext(ApiEnvironmentType.SANDBOX, cls._API_KEY,
                                      cls._DEVICE_DESCRIPTION, [])
+        else:
+            api_context.ensure_session_active()
 
         api_context.save(filename_bunq_config_full)