def test_compare_and_swap_w_expires():
redis = mock.Mock(spec=())
cache = global_cache.RedisCache(redis)
pipe1 = mock.Mock(spec=("multi", "setex", "execute", "reset"))
pipe2 = mock.Mock(spec=("multi", "setex", "execute", "reset"))
pipe2.execute.side_effect = redis_module.exceptions.WatchError
cache._pipes.pipes = {
"foo": pipe1,
"bar": pipe2,
}
result = cache.compare_and_swap(
{
"foo": "moo",
"bar": "car",
"baz": "maz",
},
expires=5,
)
assert result == {"foo": True, "bar": False, "baz": False}
pipe1.multi.assert_called_once_with()
pipe1.setex.assert_called_once_with("foo", 5, "moo")
pipe1.execute.assert_called_once_with()
pipe1.reset.assert_called_once_with()
pipe2.multi.assert_called_once_with()
pipe2.setex.assert_called_once_with("bar", 5, "car")
pipe2.execute.assert_called_once_with()
pipe2.reset.assert_called_once_with()
def test_compare_and_swap():
redis = mock.Mock(spec=())
cache = global_cache.RedisCache(redis)
pipe1 = mock.Mock(spec=("multi", "mset", "execute", "reset"))
pipe2 = mock.Mock(spec=("multi", "mset", "execute", "reset"))
cache.pipes = {
"ay": global_cache._Pipeline(pipe1, "abc123"),
"be": global_cache._Pipeline(pipe1, "abc123"),
"see": global_cache._Pipeline(pipe2, "def456"),
"dee": global_cache._Pipeline(pipe2, "def456"),
"whatevs": global_cache._Pipeline(None, "himom!"),
}
pipe2.execute.side_effect = redis_module.exceptions.WatchError
items = {"ay": "foo", "be": "bar", "see": "baz", "wut": "huh?"}
cache.compare_and_swap(items)
pipe1.multi.assert_called_once_with()
pipe2.multi.assert_called_once_with()
pipe1.mset.assert_called_once_with({"ay": "foo", "be": "bar"})
pipe2.mset.assert_called_once_with({"see": "baz"})
pipe1.execute.assert_called_once_with()
pipe2.execute.assert_called_once_with()
pipe1.reset.assert_called_once_with()
pipe2.reset.assert_called_once_with()
assert cache.pipes == {
"whatevs": global_cache._Pipeline(None, "himom!")
}
def test_get():
redis = mock.Mock(spec=("mget", ))
cache_keys = [object(), object()]
cache_value = redis.mget.return_value
cache = global_cache.RedisCache(redis)
assert cache.get(cache_keys) is cache_value
redis.mget.assert_called_once_with(cache_keys)
def test_watch():
def mock_redis_get(key):
if key == "foo":
return "moo"
return "nope"
redis = mock.Mock(pipeline=mock.Mock(spec=("watch", "get", "reset")),
spec=("pipeline", ))
pipe = redis.pipeline.return_value
pipe.get.side_effect = mock_redis_get
items = {"foo": "moo", "bar": "car"}
cache = global_cache.RedisCache(redis)
cache.watch(items)
pipe.watch.assert_has_calls(
[
mock.call("foo"),
mock.call("bar"),
],
any_order=True,
)
pipe.get.assert_has_calls(
[
mock.call("foo"),
mock.call("bar"),
],
any_order=True,
)
assert cache.pipes == {"foo": pipe}
def test_set_if_not_exists():
redis = mock.Mock(spec=("setnx", ))
redis.setnx.side_effect = (True, False)
cache_items = collections.OrderedDict([("a", "foo"), ("b", "bar")])
cache = global_cache.RedisCache(redis)
results = cache.set_if_not_exists(cache_items)
assert results == {"a": True, "b": False}
redis.setnx.assert_has_calls([
mock.call("a", "foo"),
mock.call("b", "bar"),
])
def test_set_w_expires():
expired = {}
def mock_expire(key, expires):
expired[key] = expires
redis = mock.Mock(expire=mock_expire, spec=("mset", "expire"))
cache_items = {"a": "foo", "b": "bar"}
cache = global_cache.RedisCache(redis)
cache.set(cache_items, expires=32)
redis.mset.assert_called_once_with(cache_items)
assert expired == {"a": 32, "b": 32}
def test_watch(uuid):
uuid.uuid4.return_value = "abc123"
redis = mock.Mock(pipeline=mock.Mock(spec=("watch",)), spec=("pipeline",))
pipe = redis.pipeline.return_value
keys = ["foo", "bar"]
cache = global_cache.RedisCache(redis)
cache.watch(keys)
pipe.watch.assert_called_once_with("foo", "bar")
assert cache.pipes == {
"foo": global_cache._Pipeline(pipe, "abc123"),
"bar": global_cache._Pipeline(pipe, "abc123"),
}
def test_unwatch():
redis = mock.Mock(spec=())
cache = global_cache.RedisCache(redis)
pipe = mock.Mock(spec=("reset", ))
cache._pipes.pipes = {
"ay": pipe,
"be": pipe,
"see": pipe,
"dee": pipe,
"whatevs": "himom!",
}
cache.unwatch(["ay", "be", "see", "dee", "nuffin"])
assert cache.pipes == {"whatevs": "himom!"}
pipe.reset.assert_has_calls([mock.call()] * 4)
def test_unwatch():
redis = mock.Mock(spec=())
cache = global_cache.RedisCache(redis)
pipe1 = mock.Mock(spec=("reset", ))
pipe2 = mock.Mock(spec=("reset", ))
cache._pipes.pipes = {
"ay": global_cache._Pipeline(pipe1, "abc123"),
"be": global_cache._Pipeline(pipe1, "abc123"),
"see": global_cache._Pipeline(pipe2, "def456"),
"dee": global_cache._Pipeline(pipe2, "def456"),
"whatevs": global_cache._Pipeline(None, "himom!"),
}
cache.unwatch(["ay", "be", "see", "dee", "nuffin"])
assert cache.pipes == {
"whatevs": global_cache._Pipeline(None, "himom!")
}
def test_delete():
redis = mock.Mock(spec=("delete", ))
cache_keys = [object(), object()]
cache = global_cache.RedisCache(redis)
cache.delete(cache_keys)
redis.delete.assert_called_once_with(*cache_keys)
def test_set():
redis = mock.Mock(spec=("mset", ))
cache_items = {"a": "foo", "b": "bar"}
cache = global_cache.RedisCache(redis)
cache.set(cache_items)
redis.mset.assert_called_once_with(cache_items)
def test_constructor():
redis = object()
cache = global_cache.RedisCache(redis)
assert cache.redis is redis
def test_clear():
redis = mock.Mock(spec=("flushdb", ))
cache = global_cache.RedisCache(redis)
cache.clear()
redis.flushdb.assert_called_once_with()
