Fixed #8

Fixed #12
Fixed #13
Fixed #14

tests/caching/test_SetCache.py

@@ -0,0 +1,540 @@
+import pytest
+
+from base import BaseTest
+from caching.SetCache import SetCache
+from common.global_symbols import NotFound, Removed
+from tests.caching import FakeSdp
+
+
+class TestSetCache(BaseTest):
+
+    def test_i_can_put_and_retrieve_values_from_set_cache(self):
+        cache = SetCache()
+
+        cache.put("key", "value")
+        assert cache.get("key") == {"value"}
+        assert len(cache) == 1
+
+        # we can add to this set
+        cache.put("key", "value2")
+        assert cache.get("key") == {"value", "value2"}
+        assert len(cache) == 2
+
+        # other keys are not affected
+        cache.put("key2", "value")
+        assert cache.get("key2") == {"value"}
+        assert len(cache) == 3
+
+        # duplicates are removed
+        cache.put("key", "value")
+        assert cache.get("key") == {"value", "value2"}
+        assert len(cache) == 3
+
+        assert cache.copy() == {'key': {'value', 'value2'}, 'key2': {'value'}}
+
+    def test_i_can_put_in_set_cache_when_alt_sdp_returns_values(self):
+        cache = SetCache(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_set_cache_when_alt_sdp_returns_values_and_cache_is_cleared(self):
+        cache = SetCache(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_set_cache(self):
+        cache = SetCache(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_set_cache(self):
+        cache = SetCache(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_set_cache(self):
+        cache = SetCache()
+
+        cache.put("key", "value")
+        cache.put("key", "value2")
+        cache.update("key", "value", "key", "another value")
+
+        assert len(cache._cache) == 1
+        assert len(cache) == 2
+        assert cache.get("key") == {"another value", "value2"}
+
+        cache.update("key", "value2", "key2", "value2")
+        assert len(cache._cache) == 2
+        assert len(cache) == 2
+        assert cache.get("key") == {"another value"}
+        assert cache.get("key2") == {"value2"}
+
+        cache.update("key", "another value", "key3", "another value")
+        assert len(cache._cache) == 2
+        assert len(cache) == 2
+        assert cache.get("key") is NotFound
+        assert cache.get("key2") == {"value2"}
+        assert cache.get("key3") == {"another value"}
+
+        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 = SetCache(sdp=FakeSdp(get_value=lambda cache_name, key: NotFound)).auto_configure("cache_name")
+
+        cache.put("key", "value")
+        cache.update("key", "value", "key", "new_value", alt_sdp=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 = SetCache(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 = SetCache(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 = SetCache(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 = SetCache(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 = SetCache(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 = SetCache(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 = SetCache(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 = SetCache(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 = SetCache(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_set_cache(self):
+        cache = SetCache(default=lambda k: NotFound)
+        with pytest.raises(KeyError):
+            cache.update("old_key", "old_value", "new_key", "new_value")
+
+        cache = SetCache(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 = SetCache(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 = SetCache(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_values_from_set_cache(self):
+        cache = SetCache()
+        cache.put("key", "value1")
+        cache.put("key", "value2")
+        cache.reset_events()
+
+        cache.delete("key", "fake_value")
+        assert cache.get("key") == {"value1", "value2"}
+        assert len(cache) == 2
+        assert cache.to_add == set()
+        assert cache.to_remove == set()
+
+        cache.delete("key", "value1")
+        assert cache.get("key") == {"value2"}
+        assert cache.to_add == {"key"}
+        assert len(cache) == 1
+
+        cache.delete("key", "value2")
+        assert cache.get("key") is NotFound
+        assert cache.to_remove == {"key"}
+        assert len(cache) == 0
+
+    def test_i_can_delete_key_from_set_cache(self):
+        cache = SetCache()
+        cache.put("key", "value1")
+        cache.put("key", "value2")
+
+        cache.delete("key")
+        assert cache.get("key") is NotFound
+        assert cache.to_remove == {"key"}
+        assert len(cache) == 0
+
+    def test_i_can_delete_a_key_that_does_not_exists(self):
+        cache = SetCache()
+        cache.delete("key")
+
+        assert cache.to_add == set()
+        assert cache.to_remove == set()
+
+    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 = SetCache(sdp=FakeSdp(get_value=lambda entry, k: 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_remove == set()
+        assert cache.to_add == {"key"}
+
+    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 = SetCache(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
+        cache = SetCache(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)
+        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_values(self):
+        # There is a value in alt_cache_manager,
+        # But there is a value in the current cache after deletion
+        cache = SetCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
+        cache.put("key", "value1")
+        cache.put("key", "value2")
+
+        cache.delete("key", value="value1", alt_sdp=FakeSdp(extend_exists=lambda cache_name, key: True))
+        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_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 = SetCache(sdp=FakeSdp(get_value=lambda entry, k: {"value1", "value2"})).auto_configure("cache_name")
+
+        cache.delete("key", value=None, alt_sdp=FakeSdp(extend_exists=lambda cache_name, key: True))
+        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 = SetCache(sdp=FakeSdp(get_value=lambda entry, k: {"value"})).auto_configure("cache_name")
+
+        cache.delete("key", value="value", alt_sdp=FakeSdp(extend_exists=lambda cache_name, key: True))
+        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_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 = SetCache(sdp=FakeSdp(get_value=lambda entry, k: {"value1", "value2"})).auto_configure("cache_name")
+
+        cache.delete("key", value=None, alt_sdp=FakeSdp(extend_exists=lambda cache_name, key: True))
+        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_values(self):
+        # There is a value in alt_cache_manager,
+        # But there is a value in the current cache after deletion
+        cache = SetCache(sdp=FakeSdp(get_value=lambda entry, k: {"value1", "value2"})).auto_configure("cache_name")
+
+        cache.delete("key", value="value1", alt_sdp=FakeSdp(extend_exists=lambda cache_name, key: True))
+        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 = SetCache(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 = SetCache(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 = SetCache(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_remove == set()
+        assert cache.to_add == {"key"}
+
+    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, the key is empty
+        cache = SetCache(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_key_that_does_not_exist_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 = SetCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
+
+        alt_sdp = FakeSdp(get_alt_value=(lambda cache_name, key: {"value1", "value2"} if key == "key" else NotFound),
+                          extend_exists=lambda cache_name, key: key == "key")
+
+        cache.delete("key2", value=None, alt_sdp=alt_sdp)
+        assert cache.copy() == {}
+        assert cache.to_add == set()
+        assert cache.to_remove == set()
+
+    def test_i_can_delete_when_alt_sdp_a_value_that_does_not_exist_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 = SetCache(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="value4", alt_sdp=alt_sdp)
+        assert cache.copy() == {}
+        assert cache.to_add == set()
+        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 = SetCache(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_i_can_delete_when_alt_sdp_and_cache_is_cleared(self):
+        cache = SetCache(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()
+
+    def test_i_can_add_when_alt_sdp_from_a_removed_remote_repository(self):
+        cache = SetCache(sdp=FakeSdp(get_value=lambda entry, k: Removed)).auto_configure("cache_name")
+        cache.put("key", "value")
+
+        assert cache.copy() == {"key": {"value"}}
+        assert cache.to_remove == set()
+        assert cache.to_add == {"key"}
+
+    def test_i_can_add_when_alt_sdp_from_a_removed_remote_repository_from_alt_sdp(self):
+        # The key is removed in the sub layers
+        # We can put it back
+        cache = SetCache(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.put("key", "value", alt_sdp=alt_sdp)
+
+        assert cache.copy() == {"key": {"value"}}
+        assert cache.to_remove == set()
+        assert cache.to_add == {"key"}