Merge branch 'develop' into fix_import_error_json_decode_bunq/sdk_python#72

Author: OGKevin

bunq/sdk/context.py

@@ -7,7 +7,6 @@
 from bunq.sdk.exception import BunqException
 from bunq.sdk.json import converter
 from bunq.sdk.model import core
-from bunq.sdk.model.device_server_internal import DeviceServerInternal
 from bunq.sdk.model.generated import endpoint
 
 
@@ -121,6 +120,8 @@ def _register_device(self, device_description,
         :rtype: None
         """
 
+        from bunq.sdk.model.device_server_internal import DeviceServerInternal
+
         DeviceServerInternal.create(
             device_description,
             self.api_key,
@@ -222,7 +223,7 @@ def _delete_session(self):
         :rtype: None
         """
 
-        endpoint.Session.delete(self, self._SESSION_ID_DUMMY)
+        endpoint.Session.delete(self._SESSION_ID_DUMMY)
 
     @property
     def environment_type(self):

bunq/sdk/util.py

@@ -0,0 +1,58 @@
+import json
+import socket
+
+import requests
+
+from bunq.sdk.client import ApiClient
+from bunq.sdk.context import ApiContext, ApiEnvironmentType
+from bunq.sdk.exception import BunqException
+from bunq.sdk.model.generated import endpoint
+
+__UNIQUE_REQUEST_ID = "uniqueness-is-required"
+__FIELD_API_KEY = "ApiKey"
+__INDEX_FIRST = 0
+__FIELD_RESPONSE = "Response"
+__ENDPOINT_SANDBOX_USER = "sandbox-user"
+
+_ERROR_COULD_NOT_CREATE_NEW_SANDBOX_USER = "Could not create new sandbox" \
+                                           " user."
+
+
+def automatic_sandbox_install():
+    """
+    :rtype: ApiContext
+    """
+
+    sandbox_user = __generate_new_sandbox_user()
+
+    return ApiContext(
+        ApiEnvironmentType.SANDBOX,
+        sandbox_user.api_key,
+        socket.gethostname()
+    )
+
+
+def __generate_new_sandbox_user():
+    """
+    :rtype: endpoint.SandboxUser
+    """
+
+    url = ApiEnvironmentType.SANDBOX.uri_base + __ENDPOINT_SANDBOX_USER
+
+    headers = {
+        ApiClient.HEADER_REQUEST_ID: __UNIQUE_REQUEST_ID,
+        ApiClient.HEADER_CACHE_CONTROL: ApiClient._CACHE_CONTROL_NONE,
+        ApiClient.HEADER_GEOLOCATION: ApiClient._GEOLOCATION_ZERO,
+        ApiClient.HEADER_LANGUAGE: ApiClient._LANGUAGE_EN_US,
+        ApiClient.HEADER_REGION: ApiClient._REGION_NL_NL,
+    }
+
+    response = requests.request(ApiClient._METHOD_POST, url, headers=headers)
+
+    if response.status_code is ApiClient._STATUS_CODE_OK:
+        response_json = json.loads(response.text)
+        return endpoint.SandboxUser.from_json(
+            json.dumps(response_json[__FIELD_RESPONSE][__INDEX_FIRST][
+                           __FIELD_API_KEY]))
+
+    raise BunqException(_ERROR_COULD_NOT_CREATE_NEW_SANDBOX_USER)

tests/bunq_test.py

@@ -1,11 +1,24 @@
 import os
+import time
 import unittest
 
-from tests import config
 from bunq.sdk import context
+from bunq.sdk import util
+from bunq.sdk.client import ApiClient
+from bunq.sdk.exception import BunqException
+from bunq.sdk.model.generated import endpoint
+from bunq.sdk.model.generated import object_
+from tests import config
 
 
 class BunqSdkTestCase(unittest.TestCase):
+    """
+    :type _second_monetary_account: endpoint.MonetaryAccountBank
+    :type _cash_register: endpoint.CashRegister
+    """
+
+    __ERROR_COULD_NOT_DETERMINE_USER = 'Could not determine user alias.'
+
     # Config values
     _API_KEY = config.Config.get_api_key()
 
@@ -15,33 +28,148 @@ class BunqSdkTestCase(unittest.TestCase):
     # Device description used for python tests
     _DEVICE_DESCRIPTION = 'Python test device'
 
+    _PATH_ATTACHMENT = 'tests/assets/'
+    _READ_BYTES = "rb"
+    _ATTACHMENT_PATH_IN = '[email protected]'
+    _CONTENT_TYPE = 'image/png'
+    _ATTACHMENT_DESCRIPTION = 'SDK python test'
+    _FIRST_INDEX = 0
+
+    __SPENDING_MONEY_AMOUNT = '500'
+    __CURRENCY_EUR = 'EUR'
+    __POINTER_EMAIL = 'EMAIL'
+    __SPENDING_MONEY_RECIPIENT = '[email protected]'
+    __REQUEST_SPENDING_DESCRIPTION = 'sdk  python test, thanks daddy <3'
+
+    __CASH_REGISTER_STATUS = 'PENDING_APPROVAL'
+    __CASH_REGISTER_DESCRIPTION = 'python test cash register'
+
+    __SECOND_MONETARY_ACCOUNT_DESCRIPTION = 'test account python'
+
+    __EMAIL_BRAVO = '[email protected]'
+
+    __TIME_OUT_AUTO_ACCEPT_SPENDING_MONEY = 0.5
+
+    _second_monetary_account = None
+    _cash_register = None
+
     @classmethod
-    def _get_api_context(cls):
-        """
-        Calls IsSessionActive to check if the session token is still active
-        and returns the context.ApiContext.
+    def setUpClass(cls):
+        context.BunqContext.load_api_context(cls._get_api_context())
+
+    def setUp(self):
+        self.__set_second_monetary_account()
+        self.__request_spending_money()
+        time.sleep(self.__TIME_OUT_AUTO_ACCEPT_SPENDING_MONEY)
+        context.BunqContext.user_context().refresh_user_context()
+
+    def __set_second_monetary_account(self):
+        response = endpoint.MonetaryAccountBank.create(
+            self.__CURRENCY_EUR,
+            self.__SECOND_MONETARY_ACCOUNT_DESCRIPTION
+        )
 
-        Catches ApiException if the session is inactive.
-        Catches BunqException if the conf file does not exist.
+        self._second_monetary_account = endpoint.MonetaryAccountBank.get(
+            response.value
+        ).value
 
+    def __request_spending_money(self):
+        endpoint.RequestInquiry.create(
+            object_.Amount(self.__SPENDING_MONEY_AMOUNT, self.__CURRENCY_EUR),
+            object_.Pointer(
+                self.__POINTER_EMAIL,
+                self.__SPENDING_MONEY_RECIPIENT
+            ),
+            self.__REQUEST_SPENDING_DESCRIPTION,
+            False
+        )
+        endpoint.RequestInquiry.create(
+            object_.Amount(self.__SPENDING_MONEY_AMOUNT, self.__CURRENCY_EUR),
+            object_.Pointer(
+                self.__POINTER_EMAIL,
+                self.__SPENDING_MONEY_RECIPIENT
+            ),
+            self.__REQUEST_SPENDING_DESCRIPTION,
+            False,
+            self._second_monetary_account.id_
+        )
+
+    def _get_cash_register_id(self):
+        if self._cash_register is None:
+            self._set_cash_register()
+
+        return self._cash_register.id_
+
+    @classmethod
+    def _get_api_context(cls):
+        """
         :rtype: context.ApiContext
         """
 
-        filename_bunq_config_full = (cls._get_directory_test_root() +
-                                     cls._FILENAME_BUNQ_CONFIG)
+        return util.automatic_sandbox_install()
+
+    def _get_pointer_bravo(self):
+        """
+        :rtype: object_.Pointer
+        """
 
-        try:
-            api_context = context.ApiContext.restore(filename_bunq_config_full)
-        except FileNotFoundError:
-            api_context = context.ApiContext(context.ApiEnvironmentType.SANDBOX, cls._API_KEY,
-                                     cls._DEVICE_DESCRIPTION, [])
-        else:
-            api_context.ensure_session_active()
+        return object_.Pointer(self.__POINTER_EMAIL, self.__EMAIL_BRAVO)
 
-        api_context.save(filename_bunq_config_full)
+    def _get_alias_second_account(self):
+        """
+        :rtype: object_.Pointer
+        """
 
-        return api_context
+        return self._second_monetary_account.alias[self._FIRST_INDEX]
 
     @staticmethod
     def _get_directory_test_root():
         return os.path.dirname(os.path.abspath(__file__))
+
+    def _set_cash_register(self):
+        attachment_uuid = endpoint.AttachmentPublic.create(
+            self._attachment_contents,
+            {
+                ApiClient.HEADER_CONTENT_TYPE: self._CONTENT_TYPE,
+                ApiClient.HEADER_ATTACHMENT_DESCRIPTION:
+                    self._ATTACHMENT_DESCRIPTION,
+            }
+        )
+        avatar_uuid = endpoint.Avatar.create(attachment_uuid.value)
+        cash_register_id = endpoint.CashRegister.create(
+            self.__CASH_REGISTER_DESCRIPTION,
+            self.__CASH_REGISTER_STATUS,
+            avatar_uuid.value
+        )
+
+        self._cash_register = endpoint.CashRegister.get(cash_register_id.value)
+
+    @property
+    def _attachment_contents(self):
+        """
+        :rtype: bytes
+        """
+
+        with open(
+                self._get_directory_test_root() +
+                self._PATH_ATTACHMENT +
+                self._ATTACHMENT_PATH_IN,
+                self._READ_BYTES
+        ) as file:
+            return file.read()
+
+    @property
+    def alias_first(self):
+        """
+        :rtype: Pointer
+        """
+
+        if context.BunqContext.user_context().is_only_user_company_set():
+            return context.BunqContext.user_context().user_company.alias[
+                self._FIRST_INDEX]
+
+        if context.BunqContext.user_context().is_only_user_person_set():
+            return context.BunqContext.user_context().user_person.alias[
+                self._FIRST_INDEX]
+
+        raise BunqException(self.__ERROR_COULD_NOT_DETERMINE_USER)

tests/http/test_api_context.py

@@ -15,6 +15,7 @@ class TestApiContext(BunqSdkTestCase):
 
     @classmethod
     def setUpClass(cls):
+        super().setUpClass()
         cls._FILE_MODE_READ = ApiContext._FILE_MODE_READ
         cls._API_CONTEXT = cls._get_api_context()
         cls._TMP_FILE_PATH_FULL = (cls._get_directory_test_root() +

tests/model/generated/endpoint/test_attachment_public.py

@@ -1,9 +1,8 @@
+import os
+
 from bunq.sdk.client import ApiClient
-from bunq.sdk.context import BunqContext
-from bunq.sdk.model.generated.endpoint import AttachmentPublic
-from bunq.sdk.model.generated.endpoint import AttachmentPublicContent
+from bunq.sdk.model.generated import endpoint
 from tests.bunq_test import BunqSdkTestCase
-from tests.config import Config
 
 
 class TestAttachmentPublic(BunqSdkTestCase):
@@ -13,17 +12,6 @@ class TestAttachmentPublic(BunqSdkTestCase):
         AttachmentPublicContent
     """
 
-    @classmethod
-    def setUpClass(cls):
-        # config values
-        cls._PATH_ATTACHMENT = cls._get_directory_test_root() + '/assets/'
-        cls._READ_BYTES = "rb"
-        cls._CONTENT_TYPE = Config.get_attachment_content_type()
-        cls._ATTACHMENT_DESCRIPTION = Config.get_attachment_description()
-        cls._ATTACHMENT_PATH_IN = Config.get_attachment_path_in()
-
-        BunqContext.load_api_context(cls._get_api_context())
-
     def test_file_upload_and_retrieval(self):
         """
         Tests uploading an attachment, retrieves it and compare them to see
@@ -37,10 +25,10 @@ def test_file_upload_and_retrieval(self):
                 self._ATTACHMENT_DESCRIPTION,
         }
 
-        attachment_uuid = AttachmentPublic.create(self.attachment_contents,
+        attachment_uuid = endpoint.AttachmentPublic.create(self.attachment_contents,
                                                   custom_headers).value
 
-        contents_from_response = AttachmentPublicContent.list(
+        contents_from_response = endpoint.AttachmentPublicContent.list(
             attachment_uuid).value
 
         self.assertEqual(self.attachment_contents, contents_from_response)

tests/model/generated/endpoint/test_avatar.py

@@ -3,7 +3,6 @@
 from bunq.sdk.model.generated.endpoint import AttachmentPublicContent
 from bunq.sdk.model.generated.endpoint import Avatar
 from tests.bunq_test import BunqSdkTestCase
-from tests.config import Config
 
 
 class TestAvatar(BunqSdkTestCase):
@@ -14,16 +13,6 @@ class TestAvatar(BunqSdkTestCase):
         AttachmentPublicContent
     """
 
-    @classmethod
-    def setUpClass(cls):
-        cls._FIRST_INDEX = 0
-        cls._PATH_ATTACHMENT = cls._get_directory_test_root() + '/assets/'
-        cls._READ_FILE_BYTES = 'rb'
-        cls._CONTENT_TYPE = Config.get_attachment_content_type()
-        cls._ATTACHMENT_DESCRIPTION = Config.get_attachment_description()
-        cls._ATTACHMENT_PATH_IN = Config.get_attachment_path_in()
-        cls._API_CONTEXT = cls._get_api_context()
-
     def test_avatar_creation(self):
         """
         Tests the creation of an avatar by uploading a picture via
@@ -53,6 +42,8 @@ def attachment_contents(self):
         :rtype: bytes
         """
 
-        with open(self._PATH_ATTACHMENT + self._ATTACHMENT_PATH_IN,
-                  self._READ_FILE_BYTES) as f:
-            return f.read()
+        with open(
+                self._PATH_ATTACHMENT + self._ATTACHMENT_PATH_IN,
+                self._READ_BYTES
+        ) as file:
+            return file.read()