Fixed failing tests. (#75)

Author: Kevin Hellemun

tests/http/test_bad_request_with_response_id.py

@@ -1,6 +1,7 @@
 from bunq.sdk.exception import ApiException
-from bunq.sdk.model.generated.endpoint import UserPerson
+from bunq.sdk.model.generated.endpoint import MonetaryAccountBank
 from tests.bunq_test import BunqSdkTestCase
+from bunq.sdk.context import BunqContext
 
 
 class TestPagination(BunqSdkTestCase):
@@ -9,16 +10,13 @@ class TestPagination(BunqSdkTestCase):
     successfully.
     """
 
-    _INVALID_USER_PERSON_ID = 0
+    _INVALID_MONETARY_ACCOUNT_ID = 0
 
     def test_bad_request_with_response_id(self):
         """
         """
+        BunqContext.load_api_context(self._get_api_context())
 
         with self.assertRaises(ApiException) as caught_exception:
-            UserPerson.get(
-                self._get_api_context(),
-                self._INVALID_USER_PERSON_ID
-            )
-
+            MonetaryAccountBank.get(self._INVALID_MONETARY_ACCOUNT_ID)
         self.assertIsNotNone(caught_exception.exception.response_id)

tests/http/test_pagination_scenario.py

@@ -1,4 +1,5 @@
 from bunq.sdk import client
+from bunq.sdk.context import BunqContext
 from bunq.sdk.json import converter
 from bunq.sdk.model.generated import endpoint
 from bunq.sdk.model.generated import object_
@@ -18,14 +19,15 @@ def setUpClass(cls):
         cls._MONETARY_ACCOUNT_ID = Config.get_monetary_account_id_1()
         cls._COUNTER_PARTY_ALIAS_OTHER = \
             Config.get_pointer_counter_party_other()
-        cls._API_CONTEXT = cls._get_api_context()
         cls._PAYMENT_LISTING_PAGE_SIZE = 2
         cls._PAYMENT_REQUIRED_COUNT_MINIMUM = cls._PAYMENT_LISTING_PAGE_SIZE * 2
         cls._NUMBER_ZERO = 0
         cls._PAYMENT_AMOUNT_EUR = '0.01'
         cls._PAYMENT_CURRENCY = 'EUR'
         cls._PAYMENT_DESCRIPTION = 'Python test Payment'
 
+        BunqContext.load_api_context(cls._get_api_context())
+
     def test_api_scenario_payment_listing_with_pagination(self):
         self._ensure_enough_payments()
         payments_expected = self._payments_required()
@@ -65,7 +67,7 @@ def _payment_missing_count(self):
         """
 
         return self._PAYMENT_REQUIRED_COUNT_MINIMUM - \
-            len(self._payments_required())
+               len(self._payments_required())
 
     def _payments_required(self):
         """
@@ -84,22 +86,14 @@ def _list_payments(self, params):
         :rtype BunqResponse[list[Payment]]
         """
 
-        return endpoint.Payment.list(self._API_CONTEXT, self._USER_ID,
-                                     self._MONETARY_ACCOUNT_ID, params)
+        return endpoint.Payment.list(params=params)
 
     def _create_payment(self):
         """
         :rtype: None
         """
 
-        request_map = {
-            endpoint.Payment.FIELD_AMOUNT:
-                object_.Amount(self._PAYMENT_AMOUNT_EUR,
-                               self._PAYMENT_CURRENCY),
-            endpoint.Payment.FIELD_DESCRIPTION: self._PAYMENT_DESCRIPTION,
-            endpoint.Payment.FIELD_COUNTERPARTY_ALIAS:
-                self._COUNTER_PARTY_ALIAS_OTHER,
-        }
-
-        endpoint.Payment.create(self._API_CONTEXT, request_map,
-                                self._USER_ID, self._MONETARY_ACCOUNT_ID)
+        endpoint.Payment.create(object_.Amount(self._PAYMENT_AMOUNT_EUR,
+                                               self._PAYMENT_CURRENCY),
+                                self._COUNTER_PARTY_ALIAS_OTHER,
+                                self._PAYMENT_DESCRIPTION)

tests/model/generated/endpoint/test_attachment_public.py

@@ -1,4 +1,5 @@
 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 tests.bunq_test import BunqSdkTestCase
@@ -20,7 +21,8 @@ def setUpClass(cls):
         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()
+
+        BunqContext.load_api_context(cls._get_api_context())
 
     def test_file_upload_and_retrieval(self):
         """
@@ -35,14 +37,11 @@ def test_file_upload_and_retrieval(self):
                 self._ATTACHMENT_DESCRIPTION,
         }
 
-        attachment_uuid = AttachmentPublic.create(self._API_CONTEXT,
-                                                  self.attachment_contents,
+        attachment_uuid = AttachmentPublic.create(self.attachment_contents,
                                                   custom_headers).value
 
         contents_from_response = AttachmentPublicContent.list(
-            self._API_CONTEXT,
-            attachment_uuid
-        ).value
+            attachment_uuid).value
 
         self.assertEqual(self.attachment_contents, contents_from_response)
 

tests/model/generated/endpoint/test_avatar.py

@@ -36,21 +36,15 @@ def test_avatar_creation(self):
             ApiClient.HEADER_CONTENT_TYPE: self._CONTENT_TYPE
         }
         attachment_public_uuid = AttachmentPublic.create(
-            self._API_CONTEXT,
-            self.attachment_contents,
-            custom_header
-        ).value
+            self.attachment_contents, custom_header).value
 
-        avatar_map = {
-            Avatar.FIELD_ATTACHMENT_PUBLIC_UUID: attachment_public_uuid
-        }
-        avatar_uuid = Avatar.create(self._API_CONTEXT, avatar_map).value
-        attachment_uuid_after = Avatar.get(self._API_CONTEXT, avatar_uuid) \
+        avatar_uuid = Avatar.create(attachment_public_uuid).value
+        attachment_uuid_after = Avatar.get(avatar_uuid) \
             .value.image[self._FIRST_INDEX].attachment_public_uuid
 
         file_contents_received = AttachmentPublicContent.list(
-            self._API_CONTEXT, attachment_uuid_after
-        ).value
+            attachment_uuid_after).value
+
         self.assertEqual(self.attachment_contents, file_contents_received)
 
     @property

tests/model/generated/endpoint/test_card_debit.py

@@ -1,12 +1,13 @@
 import random
 import string
 
+from bunq.sdk.context import BunqContext
+from bunq.sdk.exception import BunqException
 from bunq.sdk.model.generated.endpoint import Card
 from bunq.sdk.model.generated.endpoint import CardDebit
 from bunq.sdk.model.generated.endpoint import CardName
-from bunq.sdk.model.generated.endpoint import User
-from bunq.sdk.model.generated.object_ import Pointer
 from bunq.sdk.model.generated.object_ import CardPinAssignment
+from bunq.sdk.model.generated.object_ import Pointer
 from tests.bunq_test import BunqSdkTestCase
 from tests.config import Config
 
@@ -26,10 +27,11 @@ def setUpClass(cls):
         cls._SECOND_LINE_LENGTH_MAXIMUM = 20
         cls._STRING_EMPTY = ''
         cls._USER_ID = Config.get_user_id()
-        cls._API_CONTEXT = cls._get_api_context()
         cls._MONETARY_ACCOUNT_ID = Config.get_monetary_account_id_1()
         cls._PIN_CODE_ASSIGNMENT_TYPE_PRIMARY = 'PRIMARY'
 
+        BunqContext.load_api_context(cls._get_api_context())
+
     def test_order_debit_card(self):
         """
         Tests ordering a new card and checks if the fields we have entered
@@ -45,15 +47,10 @@ def test_order_debit_card(self):
             self._MONETARY_ACCOUNT_ID
         )
 
-        card_debit_map = {
-            CardDebit.FIELD_NAME_ON_CARD: self.card_name_allowed,
-            CardDebit.FIELD_ALIAS: self.alias_first,
-            CardDebit.FIELD_PIN_CODE_ASSIGNMENT: [pin_code_assignment],
-            CardDebit.FIELD_SECOND_LINE: second_line
-        }
-        card_debit = CardDebit.create(self._API_CONTEXT, card_debit_map,
-                                      self._USER_ID).value
-        card = Card.get(self._API_CONTEXT, self._USER_ID, card_debit.id_).value
+        card_debit = CardDebit.create(second_line, self.card_name_allowed,
+                                      self.alias_first, 'MAESTRO',
+                                      [pin_code_assignment]).value
+        card = Card.get(card_debit.id_).value
 
         self.assertEqual(self.card_name_allowed, card.name_on_card)
         self.assertEqual(second_line, card.second_line)
@@ -65,17 +62,25 @@ def alias_first(self):
         :rtype: Pointer
         """
 
-        return User.list(self._API_CONTEXT).value[self._FIRST_INDEX] \
-            .UserCompany.alias[self._FIRST_INDEX]
+        if BunqContext.user_context().is_only_user_company_set():
+            return BunqContext.user_context().user_company.alias[
+                self._FIRST_INDEX]
+
+        if BunqContext.user_context().is_only_user_person_set():
+            return BunqContext.user_context().user_person.alias[
+                self._FIRST_INDEX]
+
+        raise BunqException('Could not determine user alias.')
 
     @property
     def card_name_allowed(self):
         """
         :rtype: str
         """
 
-        return CardName.list(self._API_CONTEXT, self._USER_ID).value[
-            self._FIRST_INDEX].possible_card_name_array[self._FIRST_INDEX]
+        return \
+            CardName.list().value[self._FIRST_INDEX].possible_card_name_array[
+                self._FIRST_INDEX]
 
     @property
     def second_line_random(self):

tests/model/generated/endpoint/test_draft_share_invite_bank.py

@@ -1,9 +1,10 @@
 from datetime import datetime
 from datetime import timedelta
 
+from bunq.sdk.context import BunqContext
 from bunq.sdk.model.generated.endpoint import DraftShareInviteBank
 from bunq.sdk.model.generated.endpoint import DraftShareInviteBankQrCodeContent
-from bunq.sdk.model.generated.object_ import DraftShareInviteBankEntry
+from bunq.sdk.model.generated.object_ import DraftShareInviteEntry
 from bunq.sdk.model.generated.object_ import ShareDetail
 from bunq.sdk.model.generated.object_ import ShareDetailReadOnly
 from tests.bunq_test import BunqSdkTestCase
@@ -23,7 +24,7 @@ def setUpClass(cls):
         cls._WRITE_BYTES = 'wb'
         cls._EXPIRATION_ADDED_TIME = 1
         cls._USER_ID = Config.get_user_id()
-        cls._API_CONTEXT = cls._get_api_context()
+        BunqContext.load_api_context(cls._get_api_context())
 
     def test_draft_share_invite_bank(self):
         """
@@ -34,20 +35,15 @@ def test_draft_share_invite_bank(self):
         without errors
         """
 
-        read_only = ShareDetailReadOnly(True, True, True)
-        share_detail = ShareDetail()
-        share_detail.read_only = read_only
-        share_settings = DraftShareInviteBankEntry(share_detail)
-        draft_map = {
-            DraftShareInviteBank.FIELD_DRAFT_SHARE_SETTINGS: share_settings,
-            DraftShareInviteBank.FIELD_EXPIRATION: self.expiration_date
-        }
-        draft_id = DraftShareInviteBank.create(self._API_CONTEXT, draft_map,
-                                               self._USER_ID).value
-
-        connect_qr = DraftShareInviteBankQrCodeContent.list(self._API_CONTEXT,
-                                                            self._USER_ID,
-                                                            draft_id).value
+        share_detail = ShareDetail(
+            read_only=ShareDetailReadOnly(True, True, True)
+        )
+        share_settings = DraftShareInviteEntry(share_detail)
+
+        draft_id = DraftShareInviteBank.create(self.expiration_date,
+                                               share_settings).value
+
+        connect_qr = DraftShareInviteBankQrCodeContent.list(draft_id).value
 
         with open(self._OUT_PUT_FILE_PATH, self._WRITE_BYTES) as f:
             f.write(connect_qr)

tests/model/generated/endpoint/test_monetary_account_bank.py

@@ -1,5 +1,6 @@
 from secrets import token_hex
 
+from bunq.sdk.context import BunqContext
 from bunq.sdk.model.generated.endpoint import MonetaryAccountBank
 from tests.bunq_test import BunqSdkTestCase
 from tests.config import Config
@@ -13,14 +14,14 @@ class TestMonetaryAccount(BunqSdkTestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls._FIELD_STATUS = 'CANCELLED'
-        cls._FIELD_SUB_STATUS = 'REDEMPTION_VOLUNTARY'
-        cls._FIELD_REASON = 'OTHER'
-        cls._FIELD_REASON_DESCRIPTION = 'Because this is a test'
-        cls._FIELD_CURRENCY = 'EUR'
+        cls._STATUS = 'CANCELLED'
+        cls._SUB_STATUS = 'REDEMPTION_VOLUNTARY'
+        cls._REASON = 'OTHER'
+        cls._REASON_DESCRIPTION = 'Because this is a test'
+        cls._CURRENCY = 'EUR'
         cls._MONETARY_ACCOUNT_PREFIX = 'Python_test'
         cls._USER_ID = Config.get_user_id()
-        cls._API_CONTEXT = cls._get_api_context()
+        BunqContext.load_api_context(cls._get_api_context())
 
     def test_create_new_monetary_account(self):
         """
@@ -31,21 +32,12 @@ def test_create_new_monetary_account(self):
         without errors
         """
 
-        create_map = {
-            MonetaryAccountBank.FIELD_CURRENCY: self._FIELD_CURRENCY,
-            MonetaryAccountBank.FIELD_DESCRIPTION:
-                self._MONETARY_ACCOUNT_PREFIX + token_hex()
-        }
-        monetary_account_id = MonetaryAccountBank.create(self._API_CONTEXT,
-                                                         create_map,
-                                                         self._USER_ID).value
-
-        update_map = {
-            MonetaryAccountBank.FIELD_STATUS: self._FIELD_STATUS,
-            MonetaryAccountBank.FIELD_SUB_STATUS: self._FIELD_SUB_STATUS,
-            MonetaryAccountBank.FIELD_REASON: self._FIELD_REASON,
-            MonetaryAccountBank.FIELD_REASON_DESCRIPTION:
-                self._FIELD_REASON_DESCRIPTION,
-        }
-        MonetaryAccountBank.update(self._API_CONTEXT, update_map, self._USER_ID,
-                                   monetary_account_id)
+        monetary_account_id = MonetaryAccountBank.create(self._CURRENCY,
+                                                         self._MONETARY_ACCOUNT_PREFIX + token_hex()).value
+
+        MonetaryAccountBank.update(monetary_account_id,
+                                   status=self._STATUS,
+                                   sub_status=self._SUB_STATUS,
+                                   reason=self._REASON,
+                                   reason_description=self._REASON_DESCRIPTION
+                                   )