def test_delete():
client = mock.Mock(spec=("delete_many", ))
cache = global_cache.MemcacheCache(client)
key1 = cache._key(b"one")
key2 = cache._key(b"two")
cache.delete((b"one", b"two"))
client.delete_many.assert_called_once_with([key1, key2])
def test_get():
client = mock.Mock(spec=("get_many", ))
cache = global_cache.MemcacheCache(client)
key1 = cache._key(b"one")
key2 = cache._key(b"two")
client.get_many.return_value = {key1: "bun", key2: "shoe"}
assert cache.get((b"one", b"two")) == ["bun", "shoe"]
client.get_many.assert_called_once_with([key1, key2])
def test_unwatch():
client = mock.Mock(spec=())
cache = global_cache.MemcacheCache(client)
key2 = cache._key(b"two")
cache.caskeys[key2] = b"5"
cache.caskeys["whatevs"] = b"6"
cache.unwatch([b"one", b"two"])
assert cache.caskeys == {"whatevs": b"6"}
def test_set_if_not_exists_w_expires():
client = mock.Mock(spec=("add", ))
client.add.side_effect = (True, False)
cache_items = collections.OrderedDict([(b"a", b"foo"), (b"b", b"bar")])
cache = global_cache.MemcacheCache(client)
results = cache.set_if_not_exists(cache_items, expires=123)
assert results == {b"a": True, b"b": False}
client.add.assert_has_calls([
mock.call(cache._key(b"a"), b"foo", expire=123, noreply=False),
mock.call(cache._key(b"b"), b"bar", expire=123, noreply=False),
])
def test_compare_and_swap():
client = mock.Mock(spec=("cas", ))
cache = global_cache.MemcacheCache(client)
key2 = cache._key(b"two")
cache.caskeys[key2] = b"5"
cache.caskeys["whatevs"] = b"6"
cache.compare_and_swap({
b"one": "bun",
b"two": "shoe",
})
client.cas.assert_called_once_with(key2, "shoe", b"5", expire=0)
assert cache.caskeys == {"whatevs": b"6"}
def test_watch():
client = mock.Mock(spec=("gets_many", ))
cache = global_cache.MemcacheCache(client)
key1 = cache._key(b"one")
key2 = cache._key(b"two")
client.gets_many.return_value = {
key1: ("bun", b"0"),
key2: ("shoe", b"1"),
}
cache.watch((b"one", b"two"))
client.gets_many.assert_called_once_with([key1, key2])
assert cache.caskeys == {
key1: b"0",
key2: b"1",
}
def test_set():
client = mock.Mock(spec=("set_many", ))
cache = global_cache.MemcacheCache(client)
key1 = cache._key(b"one")
key2 = cache._key(b"two")
cache.set({
b"one": "bun",
b"two": "shoe",
})
client.set_many.assert_called_once_with(
{
key1: "bun",
key2: "shoe",
},
expire=0,
)
def test_compare_and_swap_and_expires():
client = mock.Mock(spec=("cas", ))
cache = global_cache.MemcacheCache(client)
key2 = cache._key(b"two")
cache.caskeys[key2] = b"5"
cache.caskeys["whatevs"] = b"6"
result = cache.compare_and_swap(
{
b"one": "bun",
b"two": "shoe",
},
expires=5,
)
assert result == {b"two": True}
client.cas.assert_called_once_with(key2,
"shoe",
b"5",
expire=5,
noreply=False)
assert cache.caskeys == {"whatevs": b"6"}
def test_set_failed_key():
client = mock.Mock(spec=("set_many", ))
cache = global_cache.MemcacheCache(client)
key1 = cache._key(b"one")
key2 = cache._key(b"two")
client.set_many.return_value = [key2]
unset = cache.set({
b"one": "bun",
b"two": "shoe",
})
assert unset == {b"two": global_cache.MemcacheCache.KeyNotSet(b"two")}
client.set_many.assert_called_once_with(
{
key1: "bun",
key2: "shoe",
},
expire=0,
noreply=False,
)
def test_set_w_expires():
client = mock.Mock(spec=("set_many", ))
client.set_many.return_value = []
cache = global_cache.MemcacheCache(client)
key1 = cache._key(b"one")
key2 = cache._key(b"two")
cache.set(
{
b"one": "bun",
b"two": "shoe",
},
expires=5,
)
client.set_many.assert_called_once_with(
{
key1: "bun",
key2: "shoe",
},
expire=5,
noreply=False,
)
def test_clear():
client = mock.Mock(spec=("flush_all", ))
cache = global_cache.MemcacheCache(client)
cache.clear()
client.flush_all.assert_called_once_with()
