changed signatures to match C# SDK and fixed time bug

Author: asloobq

examples/sample_bidstream_client.py

@@ -1,6 +1,6 @@
 import sys
 
-from uid2_client import BidStreamClient
+from uid2_client import BidstreamClient
 
 
 # this sample client decrypts an advertising token into a raw UID2
@@ -11,7 +11,7 @@ def _usage():
     sys.exit(1)
 
 
-if len(sys.argv) <= 4:
+if len(sys.argv) <= 6:
     _usage()
 
 base_url = sys.argv[1]
@@ -20,9 +20,9 @@ def _usage():
 domain_name = sys.argv[4]
 ad_token = sys.argv[5]
 
-client = BidStreamClient(base_url, auth_key, secret_key)
+client = BidstreamClient(base_url, auth_key, secret_key)
 client.refresh_keys()
-decrypt_result = client.decrypt_ad_token_into_raw_uid(ad_token, domain_name)
+decrypt_result = client.decrypt_token_into_raw_uid(ad_token, domain_name)
 
 print('UID2 =', decrypt_result.uid2)
 print('Established =', decrypt_result.established)

examples/sample_sharing_client.py

@@ -21,11 +21,11 @@ def _usage():
 
 client = SharingClient(base_url, auth_key, secret_key)
 client.refresh_keys()
-new_sharing_token = client.encrypt_raw_uid_into_sharing_token(raw_uid)
+new_sharing_token = client.encrypt_raw_uid_into_token(raw_uid)
 
 print('New Sharing Token =', new_sharing_token)
 
-decrypt_result = client.decrypt_sharing_token_into_raw_uid(new_sharing_token)
+decrypt_result = client.decrypt_token_into_raw_uid(new_sharing_token)
 
 print('Decrypted UID2 =', decrypt_result.uid2)
 print('Established =', decrypt_result.established)

tests/test_bidstream_client.py

@@ -2,7 +2,7 @@
 from unittest.mock import patch
 
 from test_utils import *
-from uid2_client import BidStreamClient, EncryptionError, Uid2Base64UrlCoder
+from uid2_client import BidstreamClient, EncryptionError, Uid2Base64UrlCoder
 
 
 @patch('uid2_client.bid_stream_client.refresh_bidstream_keys')
@@ -12,15 +12,15 @@ class TestBidStreamClient(unittest.TestCase):
 
     def setUp(self):
         self._key_collection = create_key_collection(IdentityScope.UID2)
-        self._client = BidStreamClient(self._CONST_BASE_URL, self._CONST_API_KEY, client_secret)
+        self._client = BidstreamClient(self._CONST_BASE_URL, self._CONST_API_KEY, client_secret)
 
     def test_smoke_test(self, mock_refresh_bidstream_keys):  # SmokeTest
         for expected_scope, expected_version in test_cases_all_scopes_all_versions:
             with self.subTest(expected_scope=expected_scope, expected_version=expected_version):
                 token = generate_uid_token(expected_scope, expected_version)
                 mock_refresh_bidstream_keys.return_value = create_key_collection(expected_scope)
                 self._client.refresh_keys()
-                decrypted = self._client.decrypt_ad_token_into_raw_uid(token, None)
+                decrypted = self._client.decrypt_token_into_raw_uid(token, None)
                 self.assertEqual(decrypted.identity_scope, expected_scope)
                 self.assertEqual(decrypted.advertising_token_version, expected_version)
 
@@ -33,7 +33,7 @@ def test_phone_uids(self, mock_refresh_bidstream_keys):  # PhoneTest
                 self._client.refresh_keys()
                 token = generate_uid_token(expected_scope, expected_version, phone_uid)
                 self.assertEqual(IdentityType.Phone, get_identity_type(token))
-                result = self._client.decrypt_ad_token_into_raw_uid(token, None)
+                result = self._client.decrypt_token_into_raw_uid(token, None)
                 self.assertIsNotNone(result)
                 self.assertEqual(result.uid2, phone_uid)
                 self.assertEqual(result.identity_scope, expected_scope)
@@ -51,7 +51,7 @@ def test_token_lifetime_too_long_for_bidstream(self, mock_refresh_bidstream_keys
                                                                                   max_bidstream_lifetime_seconds=max_bidstream_lifetime)
                 self._client.refresh_keys()
                 with self.assertRaises(EncryptionError) as context:
-                    self._client.decrypt_ad_token_into_raw_uid(token, None)
+                    self._client.decrypt_token_into_raw_uid(token, None)
                 self.assertEqual('invalid token lifetime', str(context.exception))
 
     def test_token_generated_in_the_future_to_simulate_clock_skew(self, mock_refresh_bidstream_keys):  # TokenGeneratedInTheFutureToSimulateClockSkew
@@ -64,7 +64,7 @@ def test_token_generated_in_the_future_to_simulate_clock_skew(self, mock_refresh
                                                 99999, 86400)
                 self._client.refresh_keys()
                 with self.assertRaises(EncryptionError) as context:
-                    self._client.decrypt_ad_token_into_raw_uid(token, None)
+                    self._client.decrypt_token_into_raw_uid(token, None)
                 self.assertEqual('invalid token lifetime', str(context.exception))
 
     def test_token_generated_in_the_future_within_allowed_clock_skew(self, mock_refresh_bidstream_keys):  # TokenGeneratedInTheFutureWithinAllowedClockSkew
@@ -76,7 +76,7 @@ def test_token_generated_in_the_future_within_allowed_clock_skew(self, mock_refr
                                                                                   expected_scope, site_id, 1,
                                                 99999, 86400)
                 self._client.refresh_keys()
-                result = self._client.decrypt_ad_token_into_raw_uid(token, None)
+                result = self._client.decrypt_token_into_raw_uid(token, None)
                 self.assertIsNotNone(result)
                 self.assertEqual(result.identity_scope, expected_scope)
                 self.assertEqual(result.advertising_token_version, expected_version)
@@ -86,7 +86,7 @@ def test_empty_keys(self, mock_refresh_bidstream_keys):  # EmptyKeyContainer
         mock_refresh_bidstream_keys.return_value = None
         self._client.refresh_keys()
         with self.assertRaises(EncryptionError) as context:
-            self._client.decrypt_ad_token_into_raw_uid(token, None)
+            self._client.decrypt_token_into_raw_uid(token, None)
         self.assertEqual('keys not initialized', str(context.exception))
 
     def test_master_key_expired(self, mock_refresh_bidstream_keys):  #ExpiredKeyContainer
@@ -101,7 +101,7 @@ def get_post_refresh_keys_response_with_key_expired():
         self._client.refresh_keys()
 
         with self.assertRaises(EncryptionError) as context:
-            self._client.decrypt_ad_token_into_raw_uid(example_uid, None)
+            self._client.decrypt_token_into_raw_uid(example_uid, None)
 
         self.assertEqual('no keys available or all keys have expired; refresh the latest keys from UID2 service', str(context.exception))
 
@@ -116,7 +116,7 @@ def get_post_refresh_keys_response_with_key_expired():
         token = generate_uid_token(IdentityScope.UID2, AdvertisingTokenVersion.ADVERTISING_TOKEN_V4)
 
         with self.assertRaises(EncryptionError) as context:
-            self._client.decrypt_ad_token_into_raw_uid(token, None)
+            self._client.decrypt_token_into_raw_uid(token, None)
 
         self.assertEqual('not authorized for master key', str(context.exception))
 
@@ -128,7 +128,7 @@ def test_invalid_payload(self, mock_refresh_bidstream_keys):  #InvalidPayload
         bad_token = base64.urlsafe_b64encode(payload[:0])
 
         with self.assertRaises(EncryptionError) as context:
-            self._client.decrypt_ad_token_into_raw_uid(bad_token, None)
+            self._client.decrypt_token_into_raw_uid(bad_token, None)
         self.assertEqual('invalid payload', str(context.exception))
 
     def test_token_expiry_custom_decryption_time(self, mock_refresh_bidstream_keys):
@@ -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_ad_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_ad_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

@@ -20,7 +20,7 @@ def test_smoke_test(self, mock_refresh_sharing_keys):  # SmokeTest
                 token = generate_uid_token(expected_scope, expected_version)
                 mock_refresh_sharing_keys.return_value = create_key_collection(expected_scope)
                 self._client.refresh_keys()
-                decrypted = self._client.decrypt_sharing_token_into_raw_uid(token)
+                decrypted = self._client.decrypt_token_into_raw_uid(token)
                 self.assertEqual(decrypted.identity_scope, expected_scope)
                 self.assertEqual(decrypted.advertising_token_version, expected_version)
 
@@ -35,7 +35,7 @@ def test_token_lifetime_too_long_for_sharing(self, mock_refresh_sharing_keys):
                                                 99999, 86400, max_sharing_lifetime)
                 self._client.refresh_keys()
                 with self.assertRaises(EncryptionError) as context:
-                    self._client.decrypt_sharing_token_into_raw_uid(token)
+                    self._client.decrypt_token_into_raw_uid(token)
                 self.assertEqual('invalid token lifetime', str(context.exception))
 
     def test_token_generated_in_the_future_to_simulate_clock_skew(self, mock_refresh_sharing_keys):  # TokenGeneratedInTheFutureToSimulateClockSkew
@@ -48,7 +48,7 @@ def test_token_generated_in_the_future_to_simulate_clock_skew(self, mock_refresh
                                                 99999, 86400)
                 self._client.refresh_keys()
                 with self.assertRaises(EncryptionError) as context:
-                    self._client.decrypt_sharing_token_into_raw_uid(token)
+                    self._client.decrypt_token_into_raw_uid(token)
                 self.assertEqual('invalid token lifetime', str(context.exception))
 
     def test_token_generated_in_the_future_within_allowed_clock_skew(self, mock_refresh_sharing_keys):  # TokenGeneratedInTheFutureWithinAllowedClockSkew
@@ -60,7 +60,7 @@ def test_token_generated_in_the_future_within_allowed_clock_skew(self, mock_refr
                                                                                   expected_scope, site_id, 1,
                                                 99999, 86400)
                 self._client.refresh_keys()
-                result = self._client.decrypt_sharing_token_into_raw_uid(token)
+                result = self._client.decrypt_token_into_raw_uid(token)
                 self.assertIsNotNone(result)
                 self.assertEqual(result.identity_scope, expected_scope)
                 self.assertEqual(result.advertising_token_version, expected_version)
@@ -74,7 +74,7 @@ def test_phone_uids(self, mock_refresh_sharing_keys):  # PhoneTest
                 self._client.refresh_keys()
                 token = generate_uid_token(expected_scope, expected_version, phone_uid)
                 self.assertEqual(IdentityType.Phone, get_identity_type(token))
-                result = self._client.decrypt_sharing_token_into_raw_uid(token)
+                result = self._client.decrypt_token_into_raw_uid(token)
                 self.assertIsNotNone(result)
                 self.assertEqual(result.uid2, phone_uid)
                 self.assertEqual(result.identity_scope, expected_scope)
@@ -86,25 +86,25 @@ def test_sharing_client_produces_uid2_token(self, mock_refresh_keys_util):  #Cli
         mock_refresh_keys_util.return_value = self._key_collection
         self._client.refresh_keys()
 
-        token = self._client.encrypt_raw_uid_into_sharing_token(example_uid)
+        token = self._client.encrypt_raw_uid_into_token(example_uid)
         self.assertEqual("A", token[0])
 
     def test_sharing_client_produces_euid_token(self, mock_refresh_keys_util):  #ClientProducesTokenWithCorrectPrefix
         mock_refresh_keys_util.return_value = create_key_collection(IdentityScope.EUID)
         self._client.refresh_keys()
 
-        token = self._client.encrypt_raw_uid_into_sharing_token(example_uid)
+        token = self._client.encrypt_raw_uid_into_token(example_uid)
         self.assertEqual("E", token[0])
 
     def test_encrypt_decrypt(self, mock_refresh_sharing_keys):  #CanEncryptAndDecryptForSharing
         key_collection = self._key_collection
         mock_refresh_sharing_keys.return_value = key_collection
 
         self._client.refresh_keys()
-        sharing_token = self._client.encrypt_raw_uid_into_sharing_token(example_uid, key_collection.get_default_keyset_id())
+        sharing_token = self._client.encrypt_raw_uid_into_token(example_uid, key_collection.get_default_keyset_id())
         self.assertIsNotNone(sharing_token)
         self.assertIsInstance(sharing_token, str)
-        result = self._client.decrypt_sharing_token_into_raw_uid(sharing_token)
+        result = self._client.decrypt_token_into_raw_uid(sharing_token)
         self.assertEqual(example_uid, result.uid2)
         mock_refresh_sharing_keys.assert_called_once()
 
@@ -113,35 +113,35 @@ def test_can_decrypt_another_clients_encrypted_token(self, mock_refresh_keys_uti
         sending_client = SharingClient(self._CONST_BASE_URL, self._CONST_API_KEY, client_secret)
         sending_client.refresh_keys()
 
-        token = sending_client.encrypt_raw_uid_into_sharing_token(example_uid)
+        token = sending_client.encrypt_raw_uid_into_token(example_uid)
 
         receiving_client = SharingClient(self._CONST_BASE_URL, self._CONST_API_KEY, client_secret)
         receiving_client.refresh_keys()
 
-        result = receiving_client.decrypt_sharing_token_into_raw_uid(token)
+        result = receiving_client.decrypt_token_into_raw_uid(token)
         self.assertEqual(example_uid, result.uid2)
 
     def test_sharing_token_is_v4(self, mock_refresh_keys_util):
         mock_refresh_keys_util.return_value = self._key_collection
         self._client.refresh_keys()
 
-        token = self._client.encrypt_raw_uid_into_sharing_token(example_uid)
+        token = self._client.encrypt_raw_uid_into_token(example_uid)
         contains_base_64_special_chars = "+" in token or "/" in token or "=" in token
         self.assertFalse(contains_base_64_special_chars)
 
     def test_raw_uid_produces_correct_identity_type_in_token(self, mock_refresh_keys_util):  #RawUidProducesCorrectIdentityTypeInToken
         mock_refresh_keys_util.return_value = self._key_collection
         self._client.refresh_keys()
 
-        self.assertEqual(IdentityType.Email, get_identity_type(self._client.encrypt_raw_uid_into_sharing_token(
+        self.assertEqual(IdentityType.Email, get_identity_type(self._client.encrypt_raw_uid_into_token(
             "Q4bGug8t1xjsutKLCNjnb5fTlXSvIQukmahYDJeLBtk=")))
-        self.assertEqual(IdentityType.Phone, get_identity_type(self._client.encrypt_raw_uid_into_sharing_token(
+        self.assertEqual(IdentityType.Phone, get_identity_type(self._client.encrypt_raw_uid_into_token(
             "BEOGxroPLdcY7LrSiwjY52+X05V0ryELpJmoWAyXiwbZ")))
-        self.assertEqual(IdentityType.Email, get_identity_type(self._client.encrypt_raw_uid_into_sharing_token(
+        self.assertEqual(IdentityType.Email, get_identity_type(self._client.encrypt_raw_uid_into_token(
             "oKg0ZY9ieD/CGMEjAA0kcq+8aUbLMBG0MgCT3kWUnJs=")))
-        self.assertEqual(IdentityType.Email, get_identity_type(self._client.encrypt_raw_uid_into_sharing_token(
+        self.assertEqual(IdentityType.Email, get_identity_type(self._client.encrypt_raw_uid_into_token(
             "AKCoNGWPYng/whjBIwANJHKvvGlGyzARtDIAk95FlJyb")))
-        self.assertEqual(IdentityType.Email, get_identity_type(self._client.encrypt_raw_uid_into_sharing_token(
+        self.assertEqual(IdentityType.Email, get_identity_type(self._client.encrypt_raw_uid_into_token(
             "EKCoNGWPYng/whjBIwANJHKvvGlGyzARtDIAk95FlJyb")))
 
     def test_multiple_keys_per_keyset(self, mock_refresh_keys_util):  # MultipleKeysPerKeyset
@@ -151,9 +151,9 @@ def get_post_refresh_keys_response_with_multiple_keys():
         mock_refresh_keys_util.return_value = get_post_refresh_keys_response_with_multiple_keys()
         self._client.refresh_keys()
 
-        sharing_token = self._client.encrypt_raw_uid_into_sharing_token(example_uid)
+        sharing_token = self._client.encrypt_raw_uid_into_token(example_uid)
 
-        result = self._client.decrypt_sharing_token_into_raw_uid(sharing_token)
+        result = self._client.decrypt_token_into_raw_uid(sharing_token)
         self.assertEqual(example_uid, result.uid2)
 
     def test_cannot_encrypt_if_no_key_from_default_keyset(self, mock_refresh_keys_util):  #CannotEncryptIfNoKeyFromTheDefaultKeyset
@@ -164,7 +164,7 @@ def get_post_refresh_keys_response_with_no_default_keyset_key():
         self._client.refresh_keys()
 
         with self.assertRaises(EncryptionError) as context:
-            self._client.encrypt_raw_uid_into_sharing_token(example_uid)
+            self._client.encrypt_raw_uid_into_token(example_uid)
         self.assertEqual('No Keyset Key Found', str(context.exception))
 
     def test_cannot_encrypt_if_theres_no_default_keyset_header(self, mock_refresh_keys_util):  #CannotEncryptIfTheresNoDefaultKeysetHeader
@@ -177,17 +177,17 @@ def get_post_refresh_keys_response_with_no_default_keyset_header():
         self._client.refresh_keys()
 
         with self.assertRaises(EncryptionError) as context:
-            self._client.encrypt_raw_uid_into_sharing_token(example_uid)
+            self._client.encrypt_raw_uid_into_token(example_uid)
         self.assertEqual('No Keyset Key Found', str(context.exception))
 
     def test_expiry_in_token_matches_expiry_in_response(self, mock_refresh_keys_util):  # ExpiryInTokenMatchesExpiryInResponse
 
         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_sharing_token(example_uid)
-        self._client.decrypt_sharing_token_into_raw_uid(token, now + dt.timedelta(seconds=1))
+        token = self._client.encrypt_raw_uid_into_token(example_uid)
+        self._client.decrypt_token_into_raw_uid(token, now + dt.timedelta(seconds=1))
         with self.assertRaises(EncryptionError) as context:
-            self._client.decrypt_sharing_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
@@ -200,7 +200,7 @@ def get_post_refresh_keys_response_with_key_inactive():
         self._client.refresh_keys()
 
         with self.assertRaises(EncryptionError) as context:
-            self._client.encrypt_raw_uid_into_sharing_token(example_uid)
+            self._client.encrypt_raw_uid_into_token(example_uid)
         self.assertEqual('No Keyset Key Found', str(context.exception))
 
     def test_encrypt_key_expired(self, mock_refresh_keys_util):  #EncryptKeyExpired
@@ -213,7 +213,7 @@ def get_post_refresh_keys_response_with_key_expired():
         self._client.refresh_keys()
 
         with self.assertRaises(EncryptionError) as context:
-            self._client.encrypt_raw_uid_into_sharing_token(example_uid)
+            self._client.encrypt_raw_uid_into_token(example_uid)
         self.assertEqual('No Keyset Key Found', str(context.exception))
 
     def test_refresh_keys(self, mock_refresh_sharing_keys):