Add internal refreshJson method to Bidstream client

Author: asloobq

tests/test_bidstream_client.py

@@ -85,7 +85,9 @@ def test_parse_keys_json_identity(self):
         response_body['max_bidstream_lifetime_seconds'] = '100'
         response_body['max_sharing_lifetime_seconds'] = '200'
         response_body['allow_clock_skew_seconds'] = '300'
-        keys = refresh_keys_util.parse_keys_json(response_body)
+        refresh_response = refresh_keys_util.parse_keys_json(response_body)
+        self.assertTrue(refresh_response.success)
+        keys = refresh_response.keys
         self.assertIsNotNone(keys)
         self.assertEqual(IdentityScope.EUID, keys.get_identity_scope())
         self.assertEqual('1', keys.get_caller_site_id())

tests/test_refresh_keys_util.py

@@ -16,16 +16,38 @@ def setUp(self):
         self._key_collection = create_key_collection(IdentityScope.UID2)
         self._client = SharingClient(self._CONST_BASE_URL, self._CONST_API_KEY, client_secret)
 
+    def _assert_success(self, decryption_response, token_version, scope):
+        self.assertTrue(decryption_response.success)
+        self.assertEqual(decryption_response.uid, example_uid)
+        self.assertEqual(decryption_response.advertising_token_version, token_version)
+        if (token_version == AdvertisingTokenVersion.ADVERTISING_TOKEN_V3
+                or token_version == AdvertisingTokenVersion.ADVERTISING_TOKEN_V4):
+            self.assertEqual(decryption_response.identity_type, IdentityType.Email)
+        else:
+            self.assertEqual(decryption_response.identity_type, None)
+        self.assertEqual(decryption_response.identity_scope, scope)
+        self.assertEqual(decryption_response.is_client_side_generated, False)
+
+    def _assert_fails(self, decryption_response, token_version, scope):
+        self.assertFalse(decryption_response.success)
+        self.assertEqual(decryption_response.status, DecryptionStatus.INVALID_TOKEN_LIFETIME)
+        self.assertEqual(decryption_response.advertising_token_version, token_version)
+        self.assertEqual(decryption_response.identity_scope, scope)
+        if (token_version == AdvertisingTokenVersion.ADVERTISING_TOKEN_V3
+                or token_version == AdvertisingTokenVersion.ADVERTISING_TOKEN_V4):
+            self.assertEqual(decryption_response.identity_type, IdentityType.Email)
+
+    def decrypt_and_assert_success(self, token, token_version, scope):
+        decrypted = self._client.decrypt_token_into_raw_uid(token)
+        self._assert_success(decrypted, token_version, scope)
+
     def test_smoke_test(self, mock_refresh_sharing_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_sharing_keys.return_value = RefreshResponse.make_success(create_key_collection(expected_scope))
                 self._client.refresh()
-                decrypted = self._client.decrypt_token_into_raw_uid(token)
-                self.assertEqual(decrypted.identity_scope, expected_scope)
-                self.assertEqual(decrypted.advertising_token_version, expected_version)
-                self.assertEqual((now - decrypted.established).total_seconds(), 0)
+                self.decrypt_and_assert_success(token, expected_version, expected_scope)
 
     def test_token_lifetime_too_long_for_sharing(self, mock_refresh_sharing_keys):  # TokenLifetimeTooLongForSharing
         expires_in_sec = dt.datetime.now(tz=timezone.utc) + dt.timedelta(days=31)
@@ -38,8 +60,7 @@ def test_token_lifetime_too_long_for_sharing(self, mock_refresh_sharing_keys):
                                                 99999, 86400, max_sharing_lifetime))
                 self._client.refresh()
                 result = self._client.decrypt_token_into_raw_uid(token)
-                self.assertFalse(result.success)
-                self.assertEqual(DecryptionStatus.INVALID_TOKEN_LIFETIME, result.status)
+                self._assert_fails(result, expected_version, expected_scope)
 
     def test_token_generated_in_the_future_to_simulate_clock_skew(self, mock_refresh_sharing_keys):  # TokenGeneratedInTheFutureToSimulateClockSkew
         created_at_future = dt.datetime.now(tz=timezone.utc) + dt.timedelta(minutes=31)  #max allowed clock skew is 30m
@@ -51,8 +72,7 @@ def test_token_generated_in_the_future_to_simulate_clock_skew(self, mock_refresh
                                                 99999, 86400))
                 self._client.refresh()
                 result = self._client.decrypt_token_into_raw_uid(token)
-                self.assertFalse(result.success)
-                self.assertEqual(DecryptionStatus.INVALID_TOKEN_LIFETIME, result.status)
+                self._assert_fails(result, expected_version, expected_scope)
 
     def test_token_generated_in_the_future_within_allowed_clock_skew(self, mock_refresh_sharing_keys):  # TokenGeneratedInTheFutureWithinAllowedClockSkew
         created_at_future = dt.datetime.now(tz=timezone.utc) + dt.timedelta(minutes=29)  #max allowed clock skew is 30m

tests/test_sharing_client.py

@@ -60,11 +60,12 @@
 IN_2_DAYS = now + dt.timedelta(days=2)
 IN_3_DAYS = now + dt.timedelta(days=3)
 
+
 def get_identity_type(token):
     first_char = token[0]
-    if ('A' == first_char or 'E' == first_char):
+    if 'A' == first_char or 'E' == first_char:
         return IdentityType.Email
-    if ('F' == first_char or 'B' == first_char):
+    if 'F' == first_char or 'B' == first_char:
         return IdentityType.Phone
 
     raise Exception("unknown IdentityType")
@@ -110,6 +111,7 @@ def format_key(key: EncryptionKey):
                                          base64.b64encode(key.secret).decode("utf-8"))
 
 
+
 def create_default_key_collection(key_set):
     return EncryptionKeysCollection(key_set, IdentityScope.UID2, 9000, 1,
                                     99999, 2)

tests/test_utils.py

@@ -3,10 +3,11 @@
 """
 import base64
 import datetime as dt
+import json
 
 from .client_type import ClientType
 from .encryption import decrypt_token
-from .refresh_keys_util import refresh_bidstream_keys
+from .refresh_keys_util import refresh_bidstream_keys, parse_keys_json
 
 
 class BidstreamClient:
@@ -70,3 +71,11 @@ def refresh(self):
             self._keys = refresh_response.keys
 
         return refresh_response
+
+    def _refresh_json(self, json_str):
+        body = json.loads(json_str)
+        refresh_response = parse_keys_json(body['body'])
+        if refresh_response.success:
+            self._keys = refresh_response.keys
+
+        return refresh_response

uid2_client/bid_stream_client.py

@@ -86,7 +86,12 @@ def refresh_keys(self):
 
     def refresh_json(self, json_str):
         body = json.loads(json_str)
-        return parse_keys_json(body['body'])
+        refresh_response = parse_keys_json(body['body'])
+        if refresh_response.success:
+            self._keys = refresh_response.keys
+            return refresh_response.keys
+        else:
+            raise Exception(refresh_response.reason)
 
     def encrypt(self, uid2, keyset_id=None):
         """ Encrypt an UID2 into a sharing token
@@ -118,5 +123,6 @@ def decrypt(self, token):
         """
         return decrypt(token, self._keys)
 
+
 class Uid2ClientError(Exception):
     """Raised for problems encountered while interacting with UID2 services."""

uid2_client/client.py

@@ -12,7 +12,7 @@ def _make_dt(timestamp):
     return dt.datetime.fromtimestamp(timestamp, tz=timezone.utc)
 
 
-def parse_keys_json(resp_body):
+def _parse_keys_json(resp_body):
     keys = []
     identity_scope = IdentityScope.UID2
     if resp_body["identity_scope"] == "EUID":
@@ -39,7 +39,15 @@ def _fetch_keys(base_url, path, auth_key, secret_key):
         req, nonce = make_v2_request(secret_key, dt.datetime.now(tz=timezone.utc))
         resp = post(base_url, path, headers=auth_headers(auth_key), data=req)
         resp_body = json.loads(parse_v2_response(secret_key, resp.read(), nonce)).get('body')
-        keys = parse_keys_json(resp_body)
+        keys = _parse_keys_json(resp_body)
+        return RefreshResponse.make_success(keys)
+    except Exception as exc:
+        return RefreshResponse.make_error(exc.args)
+
+
+def parse_keys_json(resp_body):
+    try:
+        keys = _parse_keys_json(resp_body)
         return RefreshResponse.make_success(keys)
     except Exception as exc:
         return RefreshResponse.make_error(exc.args)