Implemented SheerkaOntology

tests/cache/test_CacheManager.py

@@ -0,0 +1,224 @@
+import pytest
+from cache.Cache import Cache
+from cache.CacheManager import CacheManager, ConceptNotFound
+from cache.DictionaryCache import DictionaryCache
+from cache.ListCache import ListCache
+from cache.ListIfNeededCache import ListIfNeededCache
+from core.concept import Concept
+from core.global_symbols import NotFound
+
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+from tests.cache import FakeSdp
+
+
+class TestCacheManager(TestUsingMemoryBasedSheerka):
+    def test_i_do_not_push_into_sdp_when_cache_only_is_true(self):
+        sheerka, context = self.init_test().unpack()
+
+        cache_manager = CacheManager(True)
+        cache_manager.register_cache("test", Cache(), persist=True)
+        cache_manager.put("test", "key", "value")
+
+        cache_manager.commit(context)
+        assert not sheerka.om.current_cache_manager().sdp.exists("test", "key")
+
+    def test_i_do_not_get_value_from_sdp_when_cache_only_is_true(self):
+        sheerka, context = self.init_test().unpack()
+
+        sdp = sheerka.om.get_sdp()
+        with sdp.get_transaction(context.event) as transaction:
+            transaction.add("test", "key", "value")
+
+        cache = Cache(default=lambda k: sdp.get("test", k))
+
+        cache_manager = CacheManager(True)
+        cache_manager.register_cache("test", cache, persist=True)
+
+        assert cache_manager.get("test", "key") is NotFound
+
+    def test_i_do_not_get_value_from_inner_sdp_when_cache_only_is_true(self):
+        sheerka, context = self.init_test().unpack()
+
+        cache_manager = CacheManager(True, sdp=sheerka.om.get_sdp("test"))
+        cache = Cache(default=lambda _sdp, k: _sdp.get("test", k))
+        cache_manager.register_cache("test", cache, persist=True)
+
+        with cache_manager.sdp.get_transaction(context.event) as transaction:
+            transaction.add("test", "key", "value")
+
+        assert cache_manager.get("test", "key") is NotFound
+
+    def test_i_can_get_value_from_sdp_when_cache_only_is_false(self):
+        sheerka, context = self.init_test().unpack()
+
+        sdp = sheerka.om.get_sdp()
+        with sdp.get_transaction(context.event) as transaction:
+            transaction.add("test", "key", "value")
+
+        cache_manager = CacheManager(False)
+        cache = Cache(default=lambda k: sdp.get("test", k))
+        cache_manager.register_cache("test", cache, persist=True)
+
+        assert cache_manager.get("test", "key") == "value"
+
+    def test_i_can_get_value_from_inner_sdp_when_cache_only_is_false(self):
+        sheerka, context = self.init_test().unpack()
+
+        cache_manager = CacheManager(False, sdp=sheerka.om.get_sdp("test"))
+        cache = Cache(default=lambda _sdp, k: _sdp.get("test", k))
+        cache_manager.register_cache("test", cache, persist=True)
+
+        with cache_manager.sdp.get_transaction(context.event) as transaction:
+            transaction.add("test", "key", "value")
+
+        assert cache_manager.get("test", "key") == "value"
+
+    def test_i_can_get_value_from_alt_sdp_when_cache_only_is_true(self):
+        sheerka, context = self.init_test().unpack()
+
+        cache_manager = CacheManager(cache_only=True, sdp=sheerka.om.get_sdp("test"))
+        cache_manager.register_cache("test", Cache().auto_configure("test"), persist=True)
+
+        alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "value found !")
+        assert cache_manager.get("test", "key", alt_sdp=alt_sdp) is "value found !"
+
+    def test_i_can_commit_simple_cache(self):
+        sheerka, context = self.init_test().unpack()
+
+        cache_manager = CacheManager(False, sheerka.om.get_sdp("test"))
+        cache_manager.register_cache("test", Cache(), persist=True)
+        cache = cache_manager.caches["test"].cache
+
+        cache_manager.put("test", "key", "value")
+
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test", "key") == "value"
+
+        cache.update("key", "value", "key", "another_value")
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test", "key") == "another_value"
+
+        cache.update("key", "another_value", "key2", "another_value")
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test", "key") is NotFound
+        assert cache_manager.sdp.get("test", "key2") == "another_value"
+
+        # sanity check
+        # sdp 'test' has value, but sdp '__default__' does not
+        assert cache_manager.sdp.name == "test"
+        assert cache_manager.sdp.state.data == {'test': {'key2': 'another_value'}}
+
+        default_sdp = sheerka.om.ontologies[-1].cache_manager.sdp
+        assert default_sdp.name == "__default__"
+        assert "test" not in default_sdp.state.data
+
+    def test_i_can_commit_list_cache(self):
+        sheerka, context = self.init_test().unpack()
+
+        cache_manager = CacheManager(False, sheerka.om.get_sdp("test"))
+        cache_manager.register_cache("test", ListCache(), persist=True)
+        cache = cache_manager.caches["test"].cache
+
+        cache.put("key", "value")
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test", "key") == ["value"]
+
+        cache.put("key", "value2")
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test", "key") == ["value", "value2"]
+
+        cache.update("key", "value2", "key2", "value2")
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test", "key") == ["value"]
+        assert cache_manager.sdp.get("test", "key2") == ["value2"]
+
+        cache.update("key2", "value2", "key3", "value2")
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test", "key") == ["value"]
+        assert cache_manager.sdp.get("test", "key2") is NotFound
+        assert cache_manager.sdp.get("test", "key3") == ["value2"]
+
+    def test_i_can_commit_dictionary_cache(self):
+        sheerka, context = self.init_test().unpack()
+
+        cache_manager = CacheManager(False, sheerka.om.get_sdp("test"))
+        cache_manager.register_cache("test", DictionaryCache(), persist=True)
+        cache = cache_manager.caches["test"].cache
+
+        cache.put(False, {"key": "value", "key2": "value2"})
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test") == {"key": "value", "key2": "value2"}
+        assert cache_manager.sdp.get("test", "key") == "value"
+
+        cache.put(False, {"key": "value", "key2": "value2", "key3": "value3"})
+        cache_manager.commit(context)
+        assert cache_manager.sdp.get("test") == {"key": "value", "key2": "value2", "key3": "value3"}
+
+    def test_i_can_get_value_from_sdp_when_dictionary_cache(self):
+        sheerka, context = self.init_test().unpack()
+
+        cache_manager = CacheManager(False, sheerka.om.get_sdp("cache_name"))
+        cache_manager.register_cache("cache_name", DictionaryCache().auto_configure("cache_name"), persist=True)
+
+        with cache_manager.sdp.get_transaction(context.event) as transaction:
+            transaction.add("cache_name", None, {"key1": "value1", "key2": "value2"})
+
+        assert cache_manager.get("cache_name", "key3") is NotFound
+
+        # make sure that the first call retrieves the whole remote repository
+        assert cache_manager.caches["cache_name"].cache.copy() == {"key1": "value1", "key2": "value2"}
+
+        assert cache_manager.get("cache_name", "key1") == "value1"
+        assert cache_manager.get("cache_name", "key2") == "value2"
+
+    def test_i_can_remove_a_concept_from_concepts_caches(self):
+        cache_manager = CacheManager(True)
+        cache_manager.register_concept_cache("id", Cache(), lambda c: c.id, True)
+        cache_manager.register_concept_cache("key", ListIfNeededCache(), lambda c: c.key, True)
+
+        sheerka, context, one, two, three, two_bis = self.init_concepts("one", "two", "three", Concept("two", body="2"))
+
+        for concept in [one, two, three, two_bis]:
+            cache_manager.add_concept(concept)
+
+        # sanity check before removing
+        cache_def = cache_manager.caches["id"]
+        assert cache_def.cache.copy() == {one.id: one, two.id: two, three.id: three, two_bis.id: two_bis}
+        cache_def = cache_manager.caches["key"]
+        assert cache_def.cache.copy() == {one.key: one, two.key: [two, two_bis], three.key: three}
+
+        for cache_name in cache_manager.concept_caches:
+            cache_manager.caches[cache_name].cache.reset_events()
+
+        cache_manager.remove_concept(sheerka.new(("two", two_bis.id)))
+
+        cache_def = cache_manager.caches["id"]
+        assert cache_def.cache.copy() == {one.id: one, two.id: two, three.id: three}
+        assert cache_def.cache.to_remove == {two_bis.id}
+        assert cache_def.cache.to_add == set()
+        assert len(cache_def.cache) == 3
+
+        cache_def = cache_manager.caches["key"]
+        assert cache_def.cache.copy() == {one.key: one, two.key: two, three.key: three}
+        assert cache_def.cache.to_remove == set()
+        assert cache_def.cache.to_add == {"two"}
+        assert len(cache_def.cache) == 3
+
+    def test_i_cannot_remove_a_concept_that_does_not_exists(self):
+        cache_manager = CacheManager(True)
+        cache_manager.register_concept_cache("id", Cache(), lambda c: c.id, True)
+        cache_manager.register_concept_cache("key", ListIfNeededCache(), lambda c: c.key, True)
+
+        with pytest.raises(ConceptNotFound) as ex:
+            cache_manager.remove_concept(Concept("foo", id="1001"))
+
+        assert ex.value.concept == Concept("foo", id="1001")
+
+    def test_i_can_configure_a_cache_with_internal_sdp(self):
+        cache_manager = CacheManager(cache_only=False,
+                                     sdp=FakeSdp(get_value=lambda cache_name, key: key + "_not_found"))
+        cache = Cache(default=lambda sdp, key: sdp.get("cache_name", key))
+        cache_manager.register_cache("test", cache)
+
+        assert cache.get("key") == "key_not_found"
+        assert cache_manager.get("test", "key") == "key_not_found"