import pytest from cache.ListCache import ListCache from core.global_symbols import NotFound, Removed from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka from tests.cache import FakeSdp class TestListIfNeededCache(TestUsingMemoryBasedSheerka): 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_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 take 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 take 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 take 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"]