import pytest from base import BaseTest from caching.ListCache import ListCache from common.global_symbols import NotFound, Removed from tests.caching import FakeSdp class TestListCache(BaseTest): def test_i_can_put_and_retrieve_value_from_list_cache(self): cache = ListCache() cache.put("key", "value") assert cache.get("key") == ["value"] assert len(cache) == 1 cache.put("key", "value2") # we can append to this list assert cache.get("key") == ["value", "value2"] assert len(cache) == 2 cache.put("key2", "value") assert cache.get("key2") == ["value"] assert len(cache) == 3 # duplicates are allowed cache.put("key", "value") assert cache.get("key") == ["value", "value2", "value"] assert len(cache) == 4 assert cache.copy() == {'key': ['value', 'value2', 'value'], 'key2': ['value']} def test_i_can_put_in_list_cache_when_alt_sdp_returns_values(self): cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") cache.put("key", "value2", alt_sdp=FakeSdp(get_alt_value=lambda cache_name, key: ["value1"])) assert cache.get("key") == ["value1", "value2"] cache.put("key3", "value1", alt_sdp=FakeSdp(get_alt_value=lambda cache_name, key: Removed)) assert cache.get("key3") == ["value1"] def test_i_can_put_in_list_cache_when_alt_sdp_returns_values_and_cache_is_cleared(self): cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") cache.clear() cache.put("key", "value2", alt_sdp=FakeSdp(get_alt_value=lambda cache_name, key: ["value1"])) assert cache.get("key") == ["value2"] cache.put("key3", "value1", alt_sdp=FakeSdp(get_alt_value=lambda cache_name, key: Removed)) assert cache.get("key3") == ["value1"] def test_current_cache_take_precedence_over_alt_sdp_when_i_put_data_in_list_cache(self): cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") cache.put("key", "value1") cache.put("key", "value2", alt_sdp=FakeSdp(get_alt_value=lambda cache_name, key: "xxx")) assert cache.get("key") == ["value1", "value2"] def test_current_sdp_take_precedence_over_alt_sdp_when_i_put_data_in_list_cache(self): cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: ["value1"])).auto_configure("cache_name") cache.put("key", "value2", alt_sdp=FakeSdp(get_alt_value=lambda cache_name, key: "xxx")) assert cache.get("key") == ["value1", "value2"] def test_i_can_get_when_alt_sdp(self): cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") cache.get("key", alt_sdp=FakeSdp(get_alt_value=lambda cache_name, key: ["value1"])) assert cache.get("key") == ["value1"] def test_i_can_update_from_list_cache(self): cache = ListCache() cache.put("key", "value") cache.put("key", "value2") cache.put("key", "value") cache.update("key", "value", "key", "another value") assert len(cache._cache) == 1 assert len(cache) == 3 assert cache.get("key") == ["another value", "value2", "value"] # only the first one is affected cache.update("key", "value2", "key2", "value2") assert len(cache._cache) == 2 assert len(cache) == 3 assert cache.get("key") == ["another value", "value"] assert cache.get("key2") == ["value2"] cache.update("key2", "value2", "key3", "value2") assert len(cache._cache) == 2 assert len(cache) == 3 assert cache.get("key") == ["another value", "value"] assert cache.get("key3") == ["value2"] assert cache.get("key2") is NotFound with pytest.raises(KeyError): cache.update("wrong key", "value", "key", "value") def test_i_can_update_when_alt_sdp_from_cache_keys_are_the_same(self): cache = ListCache(default=lambda sdp, key: sdp.get("cache_name", key), extend_exists=lambda sdp, key: sdp.exists("cache_name", key), sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)) cache.put("key", "value") cache.update("key", "value", "key", "new_value", FakeSdp(extend_exists=lambda cache_name, key: True)) assert cache.get("key") == ["new_value"] def test_i_can_update_when_alt_sdp_from_cache_keys_are_the_same_but_nothing_in_cache(self): # There is nothing in cache or remote repository. # We must ust the value from alt_sdp cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") previous_value = ["old_1", "old_2", "value"] alt_sdp = FakeSdp(extend_exists=lambda cache_name, key: True, get_alt_value=lambda cache_name, key: previous_value) cache.update("key", "value", "key", "new_value", alt_sdp=alt_sdp) assert cache.get("key") == ["old_1", "old_2", "new_value"] assert previous_value == ["old_1", "old_2", "value"] def test_i_can_update_when_alt_sdp_from_cache_keys_are_different(self): # keys are different # make sure that current cache take precedence over alt_sdp # In this test, the values from alt_sdp are never used cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(extend_exists=lambda cache_name, key: key == "key1", get_alt_value=lambda cache_name, key: ["xxx1"] if key == "key1" else NotFound) # one values in 'key1' cache.put("key1", "old_1") cache.update("key1", "old_1", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == Removed assert cache.get("key2") == ["new_value"] assert cache.to_add == {"key2", "key1"} assert cache.to_remove == set() # Multiple values in 'key1' cache.clear() cache.put("key1", "old_1") cache.put("key1", "old_2") cache.update("key1", "old_1", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == ["old_2"] assert cache.get("key2") == ["new_value"] assert cache.to_add == {"key2", "key1"} assert cache.to_remove == set() def test_i_can_update_when_alt_sdp_from_repository_keys_are_different(self): # keys are different # make sure that current repo take precedence over alt_sdp remote = FakeSdp(get_value=lambda cache_name, key: ["old_1"] if key == "key1" else NotFound) cache = ListCache(sdp=remote).auto_configure("cache_name") alt_sdp = FakeSdp(extend_exists=lambda cache_name, key: key == "key1", get_alt_value=lambda cache_name, key: ["xxx1"] if key == "key1" else NotFound) cache.update("key1", "old_1", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == Removed assert cache.get("key2") == ["new_value"] assert cache.to_add == {"key2", "key1"} assert cache.to_remove == set() # Multiple values in 'key1' remote = FakeSdp(get_value=lambda cache_name, key: ["old_1", "old_2"] if key == "key1" else NotFound) cache = ListCache(sdp=remote).auto_configure("cache_name") cache.update("key1", "old_1", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == ["old_2"] assert cache.get("key2") == ["new_value"] assert cache.to_add == {"key2", "key1"} assert cache.to_remove == set() def test_i_can_update_when_alt_sdp_from_alt_sdp_keys_are_different_one_value(self): # keys are different # No value found in cache or remote repository, # Will use values from alt_sdp # The old key is the same, so it has to be marked as Removed cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") # one values in 'key1' alt_sdp = FakeSdp(extend_exists=lambda cache_name, key: key == "key1", get_alt_value=lambda cache_name, key: ["old_1"] if key == "key1" else NotFound) cache.update("key1", "old_1", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == Removed assert cache.get("key2") == ["new_value"] assert cache.to_add == {"key2", "key1"} assert cache.to_remove == set() # Multiple values in 'key1' cache.test_only_reset() old_values = ["old_1", "old_2"] alt_sdp = FakeSdp(extend_exists=lambda cache_name, key: key == "key1", get_alt_value=lambda cache_name, key: old_values if key == "key1" else NotFound) cache.update("key1", "old_1", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == ["old_2"] assert cache.get("key2") == ["new_value"] assert cache.to_add == {"key2", "key1"} assert cache.to_remove == set() assert old_values == ["old_1", "old_2"] # not modified def test_i_can_update_when_alt_sdp_cache_take_precedence_for_destination_key(self): # If a value exists in destination key, either in local cache or remote repository # It takes precedence # If no value is found, we must use the value from alt_sdp cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(extend_exists=lambda cache_name, key: key == "key2", get_alt_value=lambda cache_name, key: ["xxx2"] if key == "key2" else NotFound) cache.put("key1", "source_value") cache.put("key2", "old_value") cache.update("key1", "source_value", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == NotFound assert cache.get("key2") == ['old_value', 'new_value'] assert cache.to_add == {"key2"} assert cache.to_remove == {"key1"} def test_i_can_update_when_alt_sdp_repository_take_precedence_for_destination_key(self): # If a value exists in destination key, either in local cache or remote repository # It takes precedence # If no value is found, we must use the value from alt_sdp remote_repo = FakeSdp(get_value=lambda cache_name, key: ["old_value"] if key == "key2" else NotFound) cache = ListCache(sdp=remote_repo).auto_configure("cache_name") alt_sdp = FakeSdp(extend_exists=lambda cache_name, key: key == "key2", get_alt_value=lambda cache_name, key: ["xxx2"] if key == "key2" else NotFound) cache.put("key1", "source_value") cache.update("key1", "source_value", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == NotFound assert cache.get("key2") == ['old_value', 'new_value'] assert cache.to_add == {"key2"} assert cache.to_remove == {"key1"} def test_i_can_update_when_alt_sdp_use_alt_sdp_when_no_destination_value_found(self): # If a value exists in destination key, either in local cache or remote repository # It takes precedence # If no value is found, we must use the value from alt_sdp cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") cache.put("key1", "source_value") previous_values = ["old_1", "old_2"] alt_sdp = FakeSdp(extend_exists=lambda cache_name, key: key == "key2", get_alt_value=lambda cache_name, key: previous_values if key == "key2" else NotFound) cache.update("key1", "source_value", "key2", "new_value", alt_sdp=alt_sdp) assert cache.get("key1") == NotFound assert cache.get("key2") == ["old_1", "old_2", 'new_value'] assert cache.to_add == {"key2"} assert cache.to_remove == {"key1"} assert previous_values == ["old_1", "old_2"] # not modified def test_i_can_update_when_alt_sdp_and_cache_is_cleared(self): cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: ["value1"]) cache.clear() with pytest.raises(KeyError): cache.update("key", "value1", "key", "value2", alt_sdp=alt_sdp) with pytest.raises(KeyError): cache.update("key", "value1", "key2", "value2", alt_sdp=alt_sdp) def test_default_is_called_before_updating_list_cache(self): cache = ListCache(default=lambda k: NotFound) with pytest.raises(KeyError): cache.update("old_key", "old_value", "new_key", "new_value") cache = ListCache(default=lambda k: ["old_value", "other old value"]) cache.update("old_key", "old_value", "old_key", "new_value") assert cache.get("old_key") == ["new_value", "other old value"] cache = ListCache(default=lambda k: ["old_value", "other old value"] if k == "old_key" else NotFound) cache.update("old_key", "old_value", "new_key", "new_value") assert cache.get("old_key") == ["other old value"] assert cache.get("new_key") == ["new_value"] cache = ListCache(default=lambda k: ["old_value", "other old value"] if k == "old_key" else ["other new"]) cache.update("old_key", "old_value", "new_key", "new_value") assert cache.get("old_key") == ["other old value"] assert cache.get("new_key") == ["other new", "new_value"] def test_i_can_delete_from_list_cache(self): cache = ListCache() cache.put("key", "value") cache.put("key", "value2") # we can append to this list cache.delete("key", "value2") assert len(cache) == 1 assert cache.get("key") == ["value"] cache.delete("key", "value") assert len(cache) == 0 assert cache.get("key") is NotFound def test_delete_an_entry_that_does_not_exist_has_no_effect(self): cache = ListCache() cache.put("key", "value") cache.delete("key", "value2") assert len(cache) == 1 assert cache.get("key") == ["value"] def test_i_can_delete_when_alt_sdp_a_key_from_cache(self): # There is a value in alt_cache_manager, # No remaining value in current cache after deletion # The key must be flagged as Removed cache = ListCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name") cache.put("key", "value") cache.delete("key", value=None, alt_sdp=FakeSdp(extend_exists=lambda cache_name, key: True)) assert cache.copy() == {"key": Removed} assert cache.to_add == {"key"} assert cache.to_remove == set() def test_i_can_delete_when_alt_sdp_a_value_from_cache(self): # There is a value in alt_cache_manager, # No remaining value in current cache after deletion # The key must be flagged as Removed cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") cache.put("key", "value") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True) cache.delete("key", value="value", alt_sdp=alt_sdp) assert cache.copy() == {"key": Removed} assert cache.to_remove == set() assert cache.to_add == {"key"} def test_i_can_delete_when_alt_sdp_a_value_from_cache_and_then_put_back(self): # There is a value in alt_cache_manager, # No remaining value in current cache after deletion # The key must be flagged as Removed cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") cache.put("key", "value") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True) cache.delete("key", value="value", alt_sdp=alt_sdp) # remove all values cache.put("key", "value") assert cache.copy() == {"key": ["value"]} assert cache.to_remove == set() assert cache.to_add == {"key"} def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_one_value(self): # There is a value in alt_cache_manager, # But this, there are remaining values in current cache after deletion cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") cache.put("key", "value") cache.put("key", "value2") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True) cache.delete("key", value="value", alt_sdp=alt_sdp) assert cache.copy() == {"key": ["value2"]} assert cache.to_remove == set() assert cache.to_add == {"key"} def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_values(self): # There is a value in alt_cache_manager, # But this, there are remaining values in current cache after deletion cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") cache.put("key", "value") cache.put("key", "value2") cache.put("key", "value3") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True) cache.delete("key", value="value", alt_sdp=alt_sdp) assert cache.copy() == {"key": ['value2', 'value3']} assert cache.to_remove == set() assert cache.to_add == {"key"} def test_i_can_delete_when_alt_sdp_a_key_from_remote_repository(self): # There is a value in alt_cache_manager, # No remaining value in current cache after deletion # The key must be flagged as Removed cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure( "cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True) cache.delete("key", value=None, alt_sdp=alt_sdp) assert cache.copy() == {"key": Removed} assert cache.to_remove == set() assert cache.to_add == {"key"} def test_i_can_delete_when_alt_sdp_a_value_from_remote_repository(self): # There is a value in alt_cache_manager, # No remaining value in current cache after deletion # The key must be flagged as Removed cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: ["value"])).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True) cache.delete("key", value="value", alt_sdp=alt_sdp) assert cache.copy() == {"key": Removed} assert cache.to_remove == set() assert cache.to_add == {"key"} def test_i_can_delete_when_alt_sdp_a_key_from_remote_repository_and_then_put_back(self): cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure( "cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: ["xxx"], extend_exists=lambda cache_name, key: True) cache.delete("key", value=None, alt_sdp=alt_sdp) # remove all values cache.put("key", "value") assert cache.copy() == {"key": ["value"]} assert cache.to_remove == set() assert cache.to_add == {"key"} def test_i_can_delete_when_alt_sdp_a_value_from_remote_repository_remaining_one_value(self): # There is a value in alt_cache_manager, # But this time, there are remaining values in current cache after deletion cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure( "cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True) cache.delete("key", value="value1", alt_sdp=alt_sdp) assert cache.copy() == {"key": ["value2"]} assert cache.to_remove == set() assert cache.to_add == {"key"} def test_i_can_delete_when_alt_sdp_a_key_from_alt_sdp(self): # alt_cache_manager is used because no value in cache or in remote repository # After value deletion, the key is empty cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: ["value1, value2"], extend_exists=lambda cache_name, key: True) cache.delete("key", value=None, alt_sdp=alt_sdp) assert cache.copy() == {"key": Removed} assert cache.to_add == {"key"} assert cache.to_remove == set() def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp(self): # alt_cache_manager is used because no value in cache or in remote repository # After value deletion, the key is empty cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: ["value1"], extend_exists=lambda cache_name, key: True) cache.delete("key", value="value1", alt_sdp=alt_sdp) assert cache.copy() == {"key": Removed} assert cache.to_add == {"key"} assert cache.to_remove == set() def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_and_then_put_back(self): # alt_cache_manager is used because no value in cache or in remote repository # After value deletion, the key is empty cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: ["value1"], extend_exists=lambda cache_name, key: True) cache.delete("key", value="value1", alt_sdp=alt_sdp) cache.put("key", "value") assert cache.copy() == {"key": ["value"]} assert cache.to_add == {"key"} assert cache.to_remove == set() def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_one_value_remaining(self): # alt_cache_manager is used because no value in cache or in remote repository # After value deletion, one value remains in the cache cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: ["value1", "value2"], extend_exists=lambda cache_name, key: True) cache.delete("key", value="value1", alt_sdp=alt_sdp) assert cache.copy() == {"key": ["value2"]} assert cache.to_add == {"key"} assert cache.to_remove == set() def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_multiple_values_remaining(self): # alt_cache_manager is used because no value in cache or in remote repository # After value deletion, one value remains in the cache cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: ["value1", "value2", "value3"], extend_exists=lambda cache_name, key: True) cache.delete("key", value="value1", alt_sdp=alt_sdp) assert cache.copy() == {"key": ["value2", "value3"]} assert cache.to_add == {"key"} assert cache.to_remove == set() def test_i_can_delete_when_alt_sdp_an_already_removed_value_from_alt_sdp(self): # alt_cache_manager is used because no value in cache or in remote repository # But the alternate sdp returns Removed, which means that previous value was deleted # It's like there is nothing to delete cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: Removed, extend_exists=lambda cache_name, key: False) cache.delete("key", value="value1", alt_sdp=alt_sdp) assert cache.copy() == {} assert cache.to_add == set() assert cache.to_remove == set() def test_deleting_an_entry_that_does_not_exist_is_not_an_error(self): cache = ListCache() cache.put("key", "value1") cache.reset_events() cache.delete("key3") assert len(cache) == 1 assert cache.to_add == set() assert cache.to_remove == set() cache.delete("key3", "value") assert len(cache) == 1 assert cache.to_add == set() assert cache.to_remove == set() cache.delete("key", "value2") assert len(cache) == 1 assert cache.to_add == set() assert cache.to_remove == set() def test_i_can_delete_when_alt_sdp_and_cache_is_cleared(self): cache = ListCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name") alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "value", extend_exists=lambda cache_name, key: True) cache.clear() cache.delete("key", value=None, alt_sdp=alt_sdp) assert cache.copy() == {} assert cache.to_add == set() assert cache.to_remove == set() cache.delete("key", value="value", alt_sdp=alt_sdp) assert cache.copy() == {} assert cache.to_add == set() assert cache.to_remove == set()