Sheerka-Old/tests/cache/test_ListCache.py

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 TestListCache(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_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 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"]