Moved encrypt decrypt methods with timestamp to internal

Author: asloobq

tests/test_bidstream_client.py

@@ -140,10 +140,10 @@ def test_token_expiry_custom_decryption_time(self, mock_refresh_bidstream_keys):
         token = generate_uid_token(IdentityScope.UID2, AdvertisingTokenVersion.ADVERTISING_TOKEN_V4,
                                    created_at=created_at, expires_at=expires_at)
         with self.assertRaises(EncryptionError) as context:
-            self._client.decrypt_token_into_raw_uid(token, None, expires_at + dt.timedelta(seconds=1))
+            self._client._decrypt_token_into_raw_uid(token, None, expires_at + dt.timedelta(seconds=1))
         self.assertEqual('token expired', str(context.exception))
 
-        result = self._client.decrypt_token_into_raw_uid(token, None, expires_at - dt.timedelta(seconds=1))
+        result = self._client._decrypt_token_into_raw_uid(token, None, expires_at - dt.timedelta(seconds=1))
         self.assertIsNotNone(result)
         self.assertEqual(result.identity_scope, IdentityScope.UID2)
         self.assertEqual(result.advertising_token_version, AdvertisingTokenVersion.ADVERTISING_TOKEN_V4)

tests/test_sharing_client.py

@@ -185,9 +185,9 @@ def test_expiry_in_token_matches_expiry_in_response(self, mock_refresh_keys_util
         mock_refresh_keys_util.return_value = create_default_key_collection([master_key, site_key])
         self._client.refresh_keys()
         token = self._client.encrypt_raw_uid_into_token(example_uid)
-        self._client.decrypt_token_into_raw_uid(token, now + dt.timedelta(seconds=1))
+        self._client._decrypt_token_into_raw_uid(token, now + dt.timedelta(seconds=1))
         with self.assertRaises(EncryptionError) as context:
-            self._client.decrypt_token_into_raw_uid(token, now + dt.timedelta(seconds=3))
+            self._client._decrypt_token_into_raw_uid(token, now + dt.timedelta(seconds=3))
         self.assertEqual('token expired', str(context.exception))
 
     def test_encrypt_key_inactive(self, mock_refresh_keys_util):  #EncryptKeyInactive

uid2_client/bid_stream_client.py

@@ -36,13 +36,15 @@ def __init__(self, base_url, auth_key, secret_key):
         self._auth_key = auth_key
         self._secret_key = base64.b64decode(secret_key)
 
-    def decrypt_token_into_raw_uid(self, token, domain_name, now=None):
+    def _decrypt_token_into_raw_uid(self, token, domain_name, now=None):
+        return decrypt_token(token, self._keys, domain_name, ClientType.Bidstream, now)
+
+    def decrypt_token_into_raw_uid(self, token, domain_name):
         """Decrypt advertising token to extract UID2 details.
 
             Args:
                 token (str): advertising token to decrypt
                 domain_name (str) : domain name from bid request
-                now (datetime): date/time to use as "now" when doing token expiration check
 
             Returns:
                 DecryptedToken: details extracted from the advertising token
@@ -51,7 +53,7 @@ def decrypt_token_into_raw_uid(self, token, domain_name, now=None):
                 EncryptionError: if token version is not supported, the token has expired,
                                  or no required decryption keys present in the keys collection
         """
-        return decrypt_token(token, self._keys, domain_name, ClientType.Bidstream, now)
+        return self._decrypt_token_into_raw_uid(token, domain_name, dt.datetime.now(tz=dt.timezone.utc))
 
     def refresh_keys(self):
         """Get the latest encryption keys for advertising tokens.

uid2_client/sharing_client.py

@@ -17,8 +17,8 @@ class SharingClient:
 
         Methods:
             refresh_keys: Refresh encryption keys from UID2 servers
-            encrypt_raw_uid_into_sharing_token: encrypt a raw UID2 into a sharing token
-            decrypt_sharing_token_into_raw_uid: decrypt a sharing token
+            encrypt_raw_uid_into_token: encrypt a raw UID2 into a sharing token
+            decrypt_token_into_raw_uid: decrypt a sharing token
         """
 
     def __init__(self, base_url, auth_key, secret_key):
@@ -37,25 +37,28 @@ def __init__(self, base_url, auth_key, secret_key):
         self._auth_key = auth_key
         self._secret_key = base64.b64decode(secret_key)
 
-    def encrypt_raw_uid_into_token(self, uid2, keyset_id=None, now=None):
+    def _encrypt_raw_uid_into_token(self, uid2, keyset_id=None, now=None):
+        return encrypt(uid2, None, self._keys, keyset_id, now=now)
+
+    def _decrypt_token_into_raw_uid(self, token, now=None):
+        return decrypt_token(token, self._keys, None, ClientType.Sharing, now)
+
+    def encrypt_raw_uid_into_token(self, uid2, keyset_id=None):
         """ Encrypt a UID2 into a sharing token
 
             Args:
                 uid2: the UID2 or EUID to be encrypted
-                keys (EncryptionKeysCollection): collection of keys to choose from for encryption
                 keyset_id (int) : An optional keyset id to use for the encryption. Will use default keyset if left blank
-                now (Datetime): the datettime to use for now. Defaults to utc now
 
             Returns (str): Sharing Token
             """
-        return encrypt(uid2, None, self._keys, keyset_id, now=now)
+        return self._encrypt_raw_uid_into_token(uid2, keyset_id, dt.datetime.now(tz=dt.timezone.utc))
 
-    def decrypt_token_into_raw_uid(self, token, now=None):
+    def decrypt_token_into_raw_uid(self, token):
         """Decrypt sharing token to extract UID2 details.
 
             Args:
                 token (str): sharing token to decrypt
-                now (datetime): date/time to use as "now" when doing token expiration check
 
             Returns:
                 DecryptedToken: details extracted from the sharing token
@@ -64,7 +67,7 @@ def decrypt_token_into_raw_uid(self, token, now=None):
                 EncryptionError: if token version is not supported, the token has expired,
                                  or no required decryption keys present in the keys collection
         """
-        return decrypt_token(token, self._keys, None, ClientType.Sharing, now)
+        return self._decrypt_token_into_raw_uid(token, dt.datetime.now(tz=dt.timezone.utc))
 
     def refresh_keys(self):
         """Get the latest encryption keys for sharing tokens.