From 7370ebfa0051da33254458fe1d8e53f79368bdb1 Mon Sep 17 00:00:00 2001 From: Ray Luo Date: Fri, 17 May 2019 15:43:57 -0700 Subject: [PATCH 1/2] Update token_cache.py --- msal/token_cache.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/msal/token_cache.py b/msal/token_cache.py index e802eddd..1fbbe3f2 100644 --- a/msal/token_cache.py +++ b/msal/token_cache.py @@ -259,7 +259,7 @@ class SerializableTokenCache(TokenCache): """This serialization can be a starting point to implement your own persistence. This class does NOT actually persist the cache on disk/db/etc.. - Depending on your need, + If your app would not share token cache file with other apps during runtime, the following simple recipe for file-based persistence may be sufficient:: import os, atexit, msal @@ -269,37 +269,38 @@ class SerializableTokenCache(TokenCache): atexit.register(lambda: open("my_cache.bin", "w").write(cache.serialize()) # Hint: The following optional line persists only when state changed - if cache.has_state_changed else None + if cache.has_memory_state_changed else None ) app = msal.ClientApplication(..., token_cache=cache) ... - :var bool has_state_changed: + :var bool has_memory_state_changed: Indicates whether the cache state in the memory has changed since last :func:`~serialize` or :func:`~deserialize` call. """ - has_state_changed = False + has_state_changed = False # Obsolete. For backward compatibility only. + has_memory_state_changed = False def add(self, event, **kwargs): super(SerializableTokenCache, self).add(event, **kwargs) - self.has_state_changed = True + self.has_state_changed = self.has_memory_state_changed = True def modify(self, credential_type, old_entry, new_key_value_pairs=None): super(SerializableTokenCache, self).modify( credential_type, old_entry, new_key_value_pairs) - self.has_state_changed = True + self.has_state_changed = self.has_memory_state_changed = True def deserialize(self, state): # type: (Optional[str]) -> None """Deserialize the cache from a state previously obtained by serialize()""" with self._lock: self._cache = json.loads(state) if state else {} - self.has_state_changed = False # reset + self.has_state_changed = self.has_memory_state_changed = False # reset def serialize(self): # type: () -> str """Serialize the current cache state into a string.""" with self._lock: - self.has_state_changed = False + self.has_state_changed = self.has_memory_state_changed = False return json.dumps(self._cache, indent=4) From 7dcddec0a54f022d5d29465575278823d2399dfe Mon Sep 17 00:00:00 2001 From: Ray Luo Date: Fri, 17 May 2019 16:36:31 -0700 Subject: [PATCH 2/2] Update test case too --- tests/test_token_cache.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tests/test_token_cache.py b/tests/test_token_cache.py index f3771c38..e520495a 100644 --- a/tests/test_token_cache.py +++ b/tests/test_token_cache.py @@ -142,11 +142,13 @@ def setUp(self): } """) - def test_has_state_changed(self): + def test_has_memory_state_changed(self): cache = SerializableTokenCache() - self.assertFalse(cache.has_state_changed) + self.assertFalse(cache.has_memory_state_changed) + self.assertFalse(cache.has_state_changed) # For backward compatibility cache.add({}) # An NO-OP add() still counts as a state change. Good enough. - self.assertTrue(cache.has_state_changed) + self.assertTrue(cache.has_memory_state_changed) + self.assertTrue(cache.has_state_changed) # For backward compatibility def tearDown(self): state = self.cache.serialize()