Sheerka-Old/tests/cache/test_cache.py

import pytest

from cache.BaseCache import MAX_INITIALIZED_KEY
from cache.Cache import Cache
from cache.CacheManager import CacheManager
from cache.DictionaryCache import DictionaryCache
from cache.IncCache import IncCache
from cache.ListCache import ListCache
from cache.ListIfNeededCache import ListIfNeededCache
from cache.SetCache import SetCache
from core.concept import Concept
from core.global_symbols import NotFound, Removed
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
from tests.cache import FakeSdp


class TestCache(TestUsingMemoryBasedSheerka):
    def test_i_can_configure(self):
        cache = Cache()
        cache.configure(max_size=256,
                        default="default_delegate",
                        extend_exists="extend_exists_delegate",
                        alt_sdp_get="alt_sdp_delegate",
                        sdp=FakeSdp())

        # Caution, in this test, I initialize default, extend_exists and alt_get_delegate with string
        # to simplify the test, but it real usage, they are lambda
        # default = lambda sdp, key: sdp.get(cache_name, key) or lambda key: func(key)
        # extend_exists = lambda sdp, key: sdp.exists(cache_name, key) or lambda key: func(key)
        # alt_sdp_get = lambda sdp, key: sdp.alt_get(cache_name, key)

        assert cache._max_size == 256
        assert cache._default == "default_delegate"
        assert cache._extend_exists == "extend_exists_delegate"
        assert cache._alt_sdp_get == "alt_sdp_delegate"
        assert cache._sdp is not None

    def test_i_can_auto_configure(self):
        sdp = FakeSdp(get_value=lambda cache_name, key: key + 1 if cache_name == "cache_name" else NotFound,
                      extend_exists=lambda cache_name, key: True if cache_name == "cache_name" else False,
                      get_alt_value=lambda cache_name, key: key + 2 if cache_name == "cache_name" else NotFound)

        cache = Cache(sdp=sdp).auto_configure("cache_name")
        assert cache._default(cache._sdp, 10) == 11
        assert cache._extend_exists(cache._sdp, 10) == True
        assert cache._alt_sdp_get(cache._sdp, 10) == 12

        cache = Cache(sdp=sdp).auto_configure("another_cache")
        assert cache._default(cache._sdp, 10) == NotFound
        assert cache._extend_exists(cache._sdp, 10) == False
        assert cache._alt_sdp_get(cache._sdp, 10) == NotFound

    def test_i_can_get_an_retrieve_value_from_cache(self):
        cache = Cache()
        cache.put("key", "value")
        assert cache.get("key") == "value"
        assert len(cache) == 1

        cache.put("key", "another value")  # another value in the cache replace the previous one
        assert cache.get("key") == "another value"
        assert len(cache) == 1

        cache.put("key2", "value2")  # another key
        assert cache.get("key2") == "value2"
        assert len(cache) == 2
        assert cache.copy() == {"key": "another value", "key2": "value2"}

    def test_i_do_not_evict_when_put(self):
        maxsize = 5
        cache = Cache(max_size=5)

        for key in range(maxsize + 2):
            cache.put(key, key)

        assert len(cache) == maxsize + 2
        assert cache.copy() == {
            0: 0,
            1: 1,
            2: 2,
            3: 3,
            4: 4,
            5: 5,
            6: 6,
        }

    def test_i_can_evict_when_get(self):
        maxsize = 5
        cache = Cache(max_size=5, default=lambda k: k)

        for key in range(maxsize + 2):
            cache.get(key)

        assert len(cache) == maxsize
        assert cache.copy() == {
            2: 2,
            3: 3,
            4: 4,
            5: 5,
            6: 6,
        }

    def test_i_do_not_evict_when_items_are_not_committed(self):
        maxsize = 5
        cache = Cache(max_size=5, default=lambda k: k)

        for key in range(maxsize + 2):
            cache.put(key, key)

        assert len(cache) == maxsize + 2

        cache.get(-1)
        assert len(cache) == maxsize + 2
        assert cache.copy() == {
            0: 0,
            1: 1,
            2: 2,
            3: 3,
            4: 4,
            5: 5,
            6: 6,
        }

    def test_i_can_get_a_value_from_alt_sdp(self):
        cache = Cache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name")

        alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "value found !")
        assert cache.get("key", alt_sdp=alt_sdp) == "value found !"

        # The value is now in cache
        assert cache.copy() == {'key': 'value found !'}

    def test_i_cannot_get_a_value_from_alt_sdp_when_cache_is_cleared(self):
        cache = Cache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name")
        cache.clear()

        alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "value found !")
        assert cache.get("key", alt_sdp=alt_sdp) is NotFound
        assert cache.copy() == {}

    def test_i_can_get_default_value_from_simple_cache(self):
        cache = Cache()
        assert cache.get("key") is NotFound

        cache = Cache(default=10)
        assert cache.get("key") == 10
        assert "key" not in cache  # default value are not put in cache

        cache = Cache(default=lambda key: key + "_not_found")
        assert cache.get("key") == "key_not_found"
        assert "key" in cache  # default callable are put in cache

        cache = Cache(default=lambda sdp, key: sdp.get("cache_name", key),
                      sdp=FakeSdp(get_value=lambda entry, key: key + "_not_found"))
        assert cache.get("key") == "key_not_found"
        assert "key" in cache  # default callable are put in cache

    def test_i_do_not_ask_the_remote_repository_twice(self):
        nb_request = []

        cache = Cache(default=lambda key: nb_request.append("requested"))
        assert cache.get("key") is None
        assert cache.get("key") is None
        assert len(nb_request) == 1

    def test_i_can_update_from_simple_cache(self):
        cache = Cache()
        cache.put("key", "value")
        cache.update("key", "value", "key", "new_value")

        assert len(cache._cache) == 1
        assert len(cache) == 1
        assert cache.get("key") == "new_value"
        assert cache.to_add == {"key"}
        assert cache.to_remove == set()

        cache.reset_events()
        cache.update("key", "new_value", "another_key", "another_value")
        assert len(cache._cache) == 1
        assert len(cache) == 1
        assert cache.get("key") is NotFound
        assert cache.get("another_key") == "another_value"
        assert cache.to_add == {"another_key"}
        assert cache.to_remove == {"key"}

        with pytest.raises(KeyError):
            cache.update("wrong key", "value", "key", "value")

    def test_i_can_update_when_alt_sdp_same_keys(self):
        cache = Cache(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_different_keys(self):
        cache = Cache(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", "key2", "value2", FakeSdp(extend_exists=lambda cache_name, key: True))

        assert cache.get("key2") == "value2"
        assert cache.get("key") == Removed
        assert cache.to_add == {"key", "key2"}
        assert cache.to_remove == set()

    @pytest.mark.parametrize("cache", [
        Cache(), ListCache(), ListIfNeededCache(), SetCache(), IncCache()
    ])
    def test_i_can_manage_cache_events(self, cache):
        cache.put("key", "value")

        assert cache.to_add == {"key"}
        assert cache.to_remove == set()

        cache.update("key", "value", "key", "another value")
        assert cache.to_add == {"key"}
        assert cache.to_remove == set()

        cache.update("key", "another value", "key2", "value2")
        assert cache.to_add == {"key2"}
        assert cache.to_remove == {"key"}

        cache.update("key2", "value2", "key", "value")
        assert cache.to_add == {"key"}
        assert cache.to_remove == {"key2"}

    @pytest.mark.parametrize("cache", [
        ListCache(), SetCache(), ListIfNeededCache()
    ])
    def test_i_can_manage_list_and_set_cache_events(self, cache):
        cache.put("key", "value")
        cache.put("key", "value2")

        assert cache.to_add == {"key"}
        assert cache.to_remove == set()

        cache.update("key", "value", "key", "another value")
        assert cache.to_add == {"key"}
        assert cache.to_remove == set()

        cache.update("key", "value2", "key2", "value2")
        assert cache.to_add == {"key", "key2"}
        assert cache.to_remove == set()

        cache.update("key", "another value", "key3", "another value")
        assert cache.to_add == {"key2", "key3"}
        assert cache.to_remove == {"key"}

    @pytest.mark.parametrize("cache", [
        Cache(), ListCache(), SetCache(), ListIfNeededCache(), IncCache()
    ])
    def test_exists(self, cache):
        assert not cache.exists("key")
        cache.put("key", "value")
        assert cache.exists("key")

    def test_exists_extend(self):
        cache = Cache(extend_exists=lambda k: True if k == "special_key" else False)
        assert not cache.exists("key")
        assert cache.exists("special_key")

    def test_i_can_extend_exists_when_internal_sdp(self):
        cache = Cache(extend_exists=lambda sdp, k: True if k == "special_key" else False, sdp=FakeSdp)
        assert not cache.exists("key")
        assert cache.exists("special_key")

    def test_add_concept_fills_all_dependent_caches(self):
        sheerka, context, one, two, two_2, three = self.init_concepts("one", "two", Concept("two"), "three")
        cache_manager = CacheManager(cache_only=True, sdp=None)

        cache_manager.register_concept_cache("by_id", Cache(), lambda obj: obj.id, True)
        cache_manager.register_concept_cache("by_name", ListCache(), lambda obj: obj.name, True)
        cache_manager.register_concept_cache("by_name2", ListIfNeededCache(), lambda obj: obj.name, True)

        cache_manager.add_concept(one)
        cache_manager.add_concept(two)
        cache_manager.add_concept(two_2)
        cache_manager.add_concept(three)

        assert len(cache_manager.caches) == 3
        assert cache_manager.caches["by_id"].cache._cache == {
            "1001": one,
            "1002": two,
            "1003": two_2,
            "1004": three,
        }
        assert cache_manager.caches["by_name"].cache._cache == {
            "one": [one],
            "two": [two, two_2],
            "three": [three]
        }
        assert cache_manager.caches["by_name2"].cache._cache == {
            "one": one,
            "two": [two, two_2],
            "three": three
        }

        assert cache_manager.get("by_id", "1002") == two
        assert cache_manager.get("by_name", "two") == [two, two_2]
        assert cache_manager.get("by_name2", "two") == [two, two_2]

    @pytest.mark.parametrize("cache, default, new_value, expected", [
        (ListCache(), lambda k: NotFound, "value", ["value"]),
        (ListCache(), lambda k: ["value"], "value", ["value", "value"]),
        (ListIfNeededCache(), lambda k: NotFound, "value", "value"),
        (ListIfNeededCache(), lambda k: "value", "value1", ["value", "value1"]),
        (ListIfNeededCache(), lambda k: ["value1", "value2"], "value1", ["value1", "value2", "value1"]),
        (SetCache(), lambda k: NotFound, "value", {"value"}),
        (SetCache(), lambda k: {"value"}, "value", {"value"}),
        (SetCache(), lambda k: {"value1"}, "value2", {"value1", "value2"}),
    ])
    def test_default_is_called_before_put_to_keep_in_sync(self, cache, default, new_value, expected):
        cache.configure(default=default)
        cache.put("key", new_value)

        assert cache.get("key") == expected

    def test_default_is_called_before_updating_simple_cache(self):
        cache = Cache(default=lambda k: NotFound)
        with pytest.raises(KeyError):
            cache.update("old_key", "old_value", "new_key", "new_value")

        cache = Cache(default=lambda k: "old_value")
        cache.update("old_key", "old_value", "new_key", "new_value")
        assert cache.get("new_key") == "new_value"

    def test_i_can_delete_an_entry_from_cache(self):
        cache = Cache()
        cache.put("key", "value")

        assert cache.get("key") == "value"
        cache.delete("key")
        assert cache.get("key") is NotFound
        assert cache.to_remove == {"key"}

    def test_i_can_delete_when_entry_is_only_in_db(self):
        cache = Cache(default=lambda k: "value" if k == 'key' else NotFound)

        cache.delete("another_key")
        assert cache.copy() == {}
        assert cache.to_add == set()
        assert cache.to_remove == set()

        cache.delete("key")
        assert cache.copy() == {}
        assert cache.to_add == set()
        assert cache.to_remove == {"key"}

    def test_i_can_delete_an_entry_from_cache_when_alt_sdp_and_value_in_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 = Cache(extend_exists=lambda sdp, k: sdp.exists("cache_name", k))
        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_an_entry_from_cache_when_alt_sdp_when_in_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 = Cache(default=lambda k: "value", extend_exists=lambda sdp, k: sdp.exists("cache_name", k))

        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_an_entry_from_cache_when_alt_sdp_and_no_value_in_cache_or_remote_repository(self):
        # alt_cache_manager is used when no value found
        cache = Cache(default=lambda sdp, k: sdp.get("cache_name", k),
                      extend_exists=lambda sdp, k: sdp.exists("cache_name", k),
                      sdp=FakeSdp(get_value=lambda entry, k: NotFound))

        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_no_error_when_deleting_a_key_that_does_not_exists_when_alt_sdp(self):
        # alt_cache_manager is used when no value found
        cache = Cache(default=lambda sdp, k: sdp.get("cache_name", k),
                      extend_exists=lambda sdp, k: sdp.exists("cache_name", k),
                      sdp=FakeSdp(get_value=lambda entry, k: NotFound))

        cache.delete("key", value=None, alt_sdp=FakeSdp(extend_exists=lambda cache_name, key: False))
        assert cache.copy() == {}
        assert cache.to_add == set()
        assert cache.to_remove == set()

    def test_initialized_key_is_removed_when_the_entry_is_found(self):
        caches = [Cache(), ListCache(), ListIfNeededCache(), SetCache()]

        for cache in caches:
            cache.put("key", "value")
            cache.get("key")

            assert len(cache._initialized_keys) == 0

        cache = IncCache()
        cache.put("key", 10)
        cache.get("key")
        assert len(cache._initialized_keys) == 0

    def test_initialized_keys_are_reset_when_max_length_is_reached(self):
        cache = Cache()
        for i in range(MAX_INITIALIZED_KEY):
            cache.get(str(i))

        assert len(cache._initialized_keys) == MAX_INITIALIZED_KEY

        cache.get(str(MAX_INITIALIZED_KEY + 1))
        assert len(cache._initialized_keys) == 1

    def test_i_can_populate(self):
        items = [("1", "1"), ("2", "2"), ("3", "3")]
        cache = Cache()

        cache.populate(lambda: items, lambda item: item[0])

        assert len(cache) == 3
        assert cache.get("1") == ("1", "1")
        assert cache.get("2") == ("2", "2")
        assert cache.get("3") == ("3", "3")

        assert cache.to_add == {"1", "2", "3"}
        assert cache.to_remove == set()

    def test_i_can_populate_using_internal_sdp(self):
        items = [("1", "1"), ("2", "2"), ("3", "3")]
        cache = Cache(sdp=FakeSdp(populate=items))

        cache.populate(lambda sdp: sdp.populate(), lambda item: item[0])

        assert len(cache) == 3
        assert cache.get("1") == ("1", "1")
        assert cache.get("2") == ("2", "2")
        assert cache.get("3") == ("3", "3")

        assert cache.to_add == {"1", "2", "3"}
        assert cache.to_remove == set()

    def test_i_can_reset_the_event_after_populate(self):
        items = [("1", "1"), ("2", "2"), ("3", "3")]
        cache = Cache()
        cache.to_add = {"some_value"}
        cache.to_remove = {"some_other_value"}

        cache.populate(lambda: items, lambda item: item[0], reset_events=True)

        assert len(cache) == 3
        assert cache.copy() == {"1": ("1", "1"),
                                "2": ("2", "2"),
                                "3": ("3", "3")}
        assert cache.to_add == {"some_value"}
        assert cache.to_remove == {"some_other_value"}

    def test_i_can_get_all(self):
        items = [("1", "1"), ("2", "2"), ("3", "3")]
        cache = Cache()

        cache.populate(lambda: items, lambda item: item[0])

        res = cache.get_all()
        assert len(res) == 3
        assert list(res) == [('1', '1'), ('2', '2'), ('3', '3')]

    def test_i_can_clone_cache(self):
        cache = Cache(max_size=256,
                      default=lambda sdp, key: sdp.get("cache_name", key),
                      extend_exists=False,
                      alt_sdp_get=lambda sdp, key: sdp.alt_get("cache_name", key),
                      sdp=FakeSdp(get_value=lambda entry, key: key + "_not_found"))
        cache.put("key1", "value1")
        cache.put("key2", "value2")

        clone = cache.clone()
        assert type(cache) == type(clone)
        assert clone._max_size == cache._max_size
        assert clone._default == cache._default
        assert clone._extend_exists == cache._extend_exists
        assert clone._alt_sdp_get == cache._alt_sdp_get
        assert clone._sdp == cache._sdp
        assert clone._cache == {}  # value are not copied
        assert clone._initialized_keys == set()
        assert clone._current_size == 0
        assert clone.to_add == set()
        assert clone.to_remove == set()

        clone.configure(sdp=FakeSdp(lambda entry, key: key + " found !"))

        assert cache.get("key3") == "key3_not_found"
        assert clone.get("key3") == "key3 found !"

    @pytest.mark.parametrize("cache", [
        Cache(),
        DictionaryCache(),
        IncCache(),
        ListCache(),
        ListIfNeededCache()
    ])
    def test_i_can_clone_all_caches(self, cache):
        clone = cache.clone()
        assert type(clone) == type(cache)

    def test_sanity_check_on_list_if_needed_cache(self):
        cache = ListIfNeededCache()
        clone = cache.clone()

        clone.put("key", "value1")
        clone.put("key", "value2")

        assert clone.get("key") == ["value1", "value2"]

    def test_i_can_clear_when_alt_sdp(self):
        cache = Cache().auto_configure("cache_name")

        cache.put("key1", "value1")
        cache.put("key2", "value2")

        cache.clear()

        assert cache.copy() == {}
        assert cache._is_cleared