feature/sdk_python#149 ApiContext is now saved and restored correctly.

angelomelonas · angelomelonas · commit d84182480581 · 2020-09-16T16:13:55.000+02:00
diff --git a/bunq/sdk/context/api_context.py b/bunq/sdk/context/api_context.py
@@ -145,9 +145,13 @@ def __register_device(self,
 
     def __initialize_session(self) -> None:
         from bunq.sdk.model.core.session_server import SessionServer
-
         session_server = SessionServer.create(self).value
-        self._session_context = SessionContext(session_server)
+
+        token = session_server.token
+        expiry_time = self._get_expiry_timestamp(session_server)
+        user = session_server.get_user_reference()
+
+        self._session_context = SessionContext(token, expiry_time, user)
 
     @classmethod
     def _get_expiry_timestamp(cls, session_server: SessionServer) -> datetime.datetime:
diff --git a/bunq/sdk/context/bunq_context.py b/bunq/sdk/context/bunq_context.py
@@ -17,7 +17,10 @@ def __init__(self) -> None:
     @classmethod
     def load_api_context(cls, api_context: ApiContext) -> None:
         cls._api_context = api_context
-        cls._user_context = UserContext(api_context.session_context.user_id, api_context.session_context.user)
+        cls._user_context = UserContext(
+            api_context.session_context.user_id,
+            api_context.session_context.get_user_reference()
+        )
         cls._user_context.init_main_monetary_account()
 
     @classmethod
diff --git a/bunq/sdk/context/session_context.py b/bunq/sdk/context/session_context.py
@@ -1,14 +1,28 @@
+from __future__ import annotations
+
 import datetime
+from typing import Optional
 
-from bunq.sdk.model.core.session_server import SessionServer
+from bunq.sdk.exception.bunq_exception import BunqException
+from bunq.sdk.model.core.bunq_model import BunqModel
+from bunq.sdk.model.core.session_token import SessionToken
+from bunq.sdk.model.generated.endpoint import UserPerson, UserCompany, UserApiKey, UserPaymentServiceProvider
 
 
 class SessionContext:
-    def __init__(self, session_server: SessionServer) -> None:
-        self._token = session_server.token.token
-        self._expiry_time = self._get_expiry_timestamp(session_server)
-        self._user_id = session_server.get_referenced_user().id_
-        self._user = session_server.get_referenced_user()
+    """
+    :type _token: str
+    :type _expiry_time: datetime.datetime
+    :type _user_id: int
+    :type _user_person: UserPerson|None
+    :type _user_company: UserCompany|None
+    :type _user_api_key: UserApiKey|None
+    :type _user_payment_service_provider: UserPaymentServiceProvider|None
+    """
+
+    # Error constants
+    _ERROR_ALL_FIELD_IS_NULL = 'All fields are null'
+    _ERROR_UNEXPECTED_USER_INSTANCE = '"{}" is unexpected user instance.'
 
     @property
     def token(self) -> str:
@@ -23,5 +37,66 @@ def user_id(self) -> int:
         return self._user_id
 
     @property
-    def user(self):
-        return self._user
+    def user_person(self) -> Optional[UserPerson]:
+        return self._user_person
+
+    @property
+    def user_company(self) -> Optional[UserCompany]:
+        return self._user_company
+
+    @property
+    def user_api_key(self) -> Optional[UserApiKey]:
+        return self._user_api_key
+
+    @property
+    def user_payment_service_provider(self) -> Optional[UserPaymentServiceProvider]:
+        return self._user_payment_service_provider
+
+    def __init__(self, token: SessionToken, expiry_time: datetime.datetime, user: BunqModel) -> None:
+        self._user_person = None
+        self._user_company = None
+        self._user_api_key = None
+        self._user_payment_service_provider = None
+        self._token = token.token
+        self._expiry_time = expiry_time
+        self._user_id = self.__get_user_id(user)
+        self.__set_user(user)
+
+    def __get_user_id(self, user: BunqModel) -> int:
+        if isinstance(user, UserPerson):
+            return user.id_
+
+        if isinstance(user, UserCompany):
+            return user.id_
+
+        if isinstance(user, UserApiKey):
+            return user.id_
+
+        if isinstance(user, UserPaymentServiceProvider):
+            return user.id_
+
+        raise BunqException(self._ERROR_UNEXPECTED_USER_INSTANCE)
+
+    def __set_user(self, user: BunqModel):
+        if isinstance(user, UserPerson):
+            self._user_person = user
+        elif isinstance(user, UserCompany):
+            self._user_company = user
+        elif isinstance(user, UserApiKey):
+            self._user_api_key = user
+        elif isinstance(user, UserPaymentServiceProvider):
+            self._user_payment_service_provider = user
+        else:
+            raise BunqException(self._ERROR_UNEXPECTED_USER_INSTANCE)
+
+    def get_user_reference(self) -> BunqModel:
+        if self.user_person is not None:
+            return self.user_person
+        elif self.user_company is not None:
+            return self.user_company
+        elif self.user_api_key is not None:
+            return self.user_api_key
+        elif self.user_payment_service_provider is not None:
+            return self.user_payment_service_provider
+        else:
+            raise BunqException(self._ERROR_ALL_FIELD_IS_NULL)
diff --git a/bunq/sdk/json/converter.py b/bunq/sdk/json/converter.py
@@ -7,7 +7,7 @@
 import typing
 import warnings
 from types import ModuleType
-from typing import Type, Optional, Callable, Generator, Dict, Match, List, Union, Generic
+from typing import Type, Optional, Callable, Generator, Dict, Match, List, Union, Generic, Any
 
 from bunq.sdk.exception.bunq_exception import BunqException
 from bunq.sdk.util.type_alias import T, JsonValue
@@ -22,6 +22,7 @@
 class JsonAdapter(Generic[T]):
     # Error constants
     _ERROR_COULD_NOT_FIND_CLASS = 'Could not find class: {}'
+    _ERROR_MISSING_DOC_COMMENT = 'A doc :type is missing for {} in class {}'
 
     # Maps to store custom serializers and deserializers
     _custom_serializers = {}
@@ -41,15 +42,14 @@ class JsonAdapter(Generic[T]):
     _PREFIX_KEY_PROTECTED = '_'
 
     # Constants to fetch param types from the docstrings
-    _TEMPLATE_PATTERN_PARAM_TYPES = ':type (_?{}):[\s\n\r]+([\w.]+)(?:\[([\w.]+)\])?'
-    _PATTERN_PARAM_NAME_TYPED_ANY = ':type (\w+):'
+    _TEMPLATE_PATTERN_PARAM_TYPES = ':type (_?{}):[\\s\\n\\r]+([\\w.]+)(?:\\[([\\w.]+)\\])?'
+    _PATTERN_PARAM_NAME_TYPED_ANY = ':type (\\w+):'
     _SUBMATCH_INDEX_NAME = 1
     _SUBMATCH_INDEX_TYPE_MAIN = 2
     _SUBMATCH_INDEX_TYPE_SUB = 3
 
     # List of builtin type names
-    _TYPE_NAMES_BUILTIN = {'int', 'bool', 'float', 'str', 'list', 'dict',
-                           'bytes', 'unicode'}
+    _TYPE_NAMES_BUILTIN = {'int', 'bool', 'float', 'str', 'list', 'dict', 'bytes', 'unicode'}
 
     # Delimiter between modules in class paths
     _DELIMITER_MODULE = '.'
@@ -187,7 +187,12 @@ def _fetch_attribute_specs_from_doc(cls,
                                         cls_in: Type[T],
                                         attribute_name: str) -> Optional[ValueSpecs]:
         pattern = cls._TEMPLATE_PATTERN_PARAM_TYPES.format(attribute_name)
-        match = re.search(pattern, cls_in.__doc__)
+        doc_type = cls_in.__doc__
+
+        if doc_type is None:
+            raise BunqException(cls._ERROR_MISSING_DOC_COMMENT.format(attribute_name, cls_in))
+
+        match = re.search(pattern, doc_type)
 
         if match is not None:
             return ValueSpecs(
diff --git a/bunq/sdk/json/installation_adapter.py b/bunq/sdk/json/installation_adapter.py
@@ -51,5 +51,5 @@ def serialize(cls, installation: Installation) -> List:
         return [
             {cls._FIELD_ID: converter.serialize(installation.id_)},
             {cls._FIELD_TOKEN: converter.serialize(installation.token)},
-            {cls._FIELD_SERVER_PUBLIC_KEY: converter.serialize(installation.server_public_key), },
+            {cls._FIELD_SERVER_PUBLIC_KEY: converter.serialize(installation.server_public_key)},
         ]
diff --git a/bunq/sdk/model/core/session_server.py b/bunq/sdk/model/core/session_server.py
@@ -20,7 +20,7 @@ class SessionServer(BunqModel):
     :type _user_person: UserPerson|None
     :type _user_company: UserCompany|None
     :type _user_api_key: UserApiKey|None
-    :type _user_payment_service_provider:UserPaymentServiceProvider|None
+    :type _user_payment_service_provider: UserPaymentServiceProvider|None
     """
 
     # Endpoint name.
@@ -32,40 +32,41 @@ class SessionServer(BunqModel):
     # Error constants
     _ERROR_ALL_FIELD_IS_NULL = 'All fields are null'
 
-    def __init__(self) -> None:
-        self._id_ = None
-        self._token = None
-        self._user_person = None
-        self._user_company = None
-        self._user_api_key = None
-        self._user_payment_service_provider = None
-
     @property
-    def id_(self) -> Id:
+    def id_(self) -> Optional[Id]:
         return self._id_
 
     @property
-    def token(self) -> SessionToken:
+    def token(self) -> Optional[SessionToken]:
         return self._token
 
     @property
-    def user_person(self) -> UserPerson:
+    def user_person(self) -> Optional[UserPerson]:
         return self._user_person
 
     @property
-    def user_company(self) -> UserCompany:
+    def user_company(self) -> Optional[UserCompany]:
         return self._user_company
 
     @property
     def user_api_key(self) -> Optional[UserApiKey]:
         return self._user_api_key
 
     @property
-    def user_payment_service_provider(self) -> UserPaymentServiceProvider:
+    def user_payment_service_provider(self) -> Optional[UserPaymentServiceProvider]:
         return self._user_payment_service_provider
 
+    def __init__(self) -> None:
+        self._user_person = None
+        self._user_company = None
+        self._user_api_key = None
+        self._user_payment_service_provider = None
+        self._token = None
+        self._id_ = None
+
     @classmethod
     def create(cls, api_context: ApiContext) -> BunqResponse[SessionServer]:
+        cls.__init__(cls)
         api_client = ApiClient(api_context)
         body_bytes = cls.generate_request_body_bytes(api_context.api_key)
         response_raw = api_client.post(cls._ENDPOINT_URL_POST, body_bytes, {})
@@ -79,35 +80,27 @@ def generate_request_body_bytes(cls, secret: str) -> bytes:
     def is_all_field_none(self) -> bool:
         if self.id_ is not None:
             return False
-
-        if self.token is not None:
+        elif self.token is not None:
             return False
-
-        if self.user_person is not None:
+        elif self.user_person is not None:
             return False
-
-        if self.user_company is not None:
+        elif self.user_company is not None:
             return False
-
-        if self.user_payment_service_provider is not None:
+        elif self.user_api_key is not None:
             return False
-
-        if self.user_api_key is not None:
+        elif self.user_payment_service_provider is not None:
             return False
+        else:
+            return True
 
-        return True
-
-    def get_referenced_user(self) -> BunqModel:
-        if self._user_person is not None:
-            return self._user_person
-
-        if self._user_company is not None:
-            return self._user_company
-
-        if self._user_payment_service_provider is not None:
-            return self._user_payment_service_provider
-
-        if self._user_api_key is not None:
-            return self._user_api_key
-
-        raise BunqException(self._ERROR_ALL_FIELD_IS_NULL)
+    def get_user_reference(self) -> BunqModel:
+        if self.user_person is not None:
+            return self.user_person
+        elif self.user_company is not None:
+            return self.user_company
+        elif self.user_api_key is not None:
+            return self.user_api_key
+        elif self.user_payment_service_provider is not None:
+            return self.user_payment_service_provider
+        else:
+            raise BunqException(self._ERROR_ALL_FIELD_IS_NULL)
diff --git a/bunq/sdk/security/security.py b/bunq/sdk/security/security.py
@@ -16,6 +16,7 @@
 from Cryptodome.PublicKey import RSA
 from Cryptodome.PublicKey.RSA import RsaKey
 from Cryptodome.Signature import PKCS1_v1_5
+from requests.structures import CaseInsensitiveDict
 
 from bunq.sdk.exception.bunq_exception import BunqException
 
@@ -58,6 +59,7 @@
 _HEADER_CLIENT_ENCRYPTION_HMAC = 'X-Bunq-Client-Encryption-Hmac'
 _HEADER_SERVER_SIGNATURE = 'X-Bunq-Server-Signature'
 
+
 def generate_rsa_private_key() -> RsaKey:
     return RSA.generate(_RSA_KEY_SIZE)
 
@@ -177,7 +179,7 @@ def _add_header_client_encryption_hmac(request_bytes: bytes,
 def validate_response(public_key_server: RsaKey,
                       status_code: int,
                       body_bytes: bytes,
-                      headers: Dict[str, str]) -> None:
+                      headers: CaseInsensitiveDict[str, str]) -> None:
     if is_valid_response_header_with_body(public_key_server, status_code, body_bytes, headers):
         return
     elif is_valid_response_body(public_key_server, body_bytes, headers):
@@ -189,7 +191,7 @@ def validate_response(public_key_server: RsaKey,
 def is_valid_response_header_with_body(public_key_server: RsaKey,
                                        status_code: int,
                                        body_bytes: bytes,
-                                       headers: Dict[str, str]) -> bool:
+                                       headers: CaseInsensitiveDict[str, str]) -> bool:
     head_bytes = _generate_response_head_bytes(status_code, headers)
     bytes_signed = head_bytes + body_bytes
     signer = PKCS1_v1_5.pkcs1_15.new(public_key_server)
@@ -205,8 +207,8 @@ def is_valid_response_header_with_body(public_key_server: RsaKey,
 
 
 def is_valid_response_body(public_key_server: RsaKey,
-                      body_bytes: bytes,
-                      headers: Dict[str, str]) -> bool:
+                           body_bytes: bytes,
+                           headers: CaseInsensitiveDict[str, str]) -> bool:
     signer = PKCS1_v1_5.pkcs1_15.new(public_key_server)
     digest = SHA256.new()
     digest.update(body_bytes)
@@ -220,7 +222,7 @@ def is_valid_response_body(public_key_server: RsaKey,
 
 
 def _generate_response_head_bytes(status_code: int,
-                                  headers: Dict[str, str]) -> bytes:
+                                  headers: CaseInsensitiveDict[str, str]) -> bytes:
     head_string = str(status_code) + _DELIMITER_NEWLINE
     header_tuples = sorted((k, headers[k]) for k in headers)
 
diff --git a/tests/context/test_user_context.py b/tests/context/test_user_context.py
@@ -14,7 +14,10 @@ def setUpClass(cls):
 
     def test_build_user_context(self):
         from bunq.sdk.context.user_context import UserContext
-        user_context = UserContext(self._API_CONTEXT.session_context.user_id, self._API_CONTEXT.session_context.user)
+        user_context = UserContext(
+            self._API_CONTEXT.session_context.user_id,
+            self._API_CONTEXT.session_context.get_user_reference()
+        )
         user_context.refresh_user_context()
 
         self.assertIsNotNone(user_context.user_id)

Original file line number	Diff line number	Diff line change
`@@ -51,5 +51,5 @@ def serialize(cls, installation: Installation) -> List:`
`51`	`51`	`return [`
`52`	`52`	`{cls._FIELD_ID: converter.serialize(installation.id_)},`
`53`	`53`	`{cls._FIELD_TOKEN: converter.serialize(installation.token)},`
`54`		`- {cls._FIELD_SERVER_PUBLIC_KEY: converter.serialize(installation.server_public_key), },`
	`54`	`+ {cls._FIELD_SERVER_PUBLIC_KEY: converter.serialize(installation.server_public_key)},`
`55`	`55`	`]`