class TestRedisPubSub(object):
def setup(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_publish(self):
channel = 'ch#1'
msg = 'test message'
self.redis.publish(channel, msg)
eq_(self.redis.pubsub()[channel], [msg])
class TestRedisPubSub(object):
def setup(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_publish(self):
channel = 'ch#1'
msg = 'test message'
self.redis.publish(channel, msg)
eq_(self.redis.pubsub[channel], [msg])
class TestRedisPubSub(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_publish(self):
channel = 'ch#1'
msg = 'test message'
self.redis.publish(channel, msg)
self.assertListEqual(self.redis.pubsub[channel], [msg])
class TestRedis(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_get(self):
self.assertEqual('', self.redis.get('key'))
self.redis.redis['key'] = 'value'
self.assertEqual('value', self.redis.get('key'))
def test_set(self):
self.assertEqual(None, self.redis.redis.get('key'))
self.redis.set('key', 'value')
self.assertEqual('value', self.redis.redis.get('key'))
class TestPipeline(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_pipeline(self):
"""
Pipeline execution returns all of the saved up values.
"""
with self.redis.pipeline() as pipeline:
pipeline.echo("foo")
pipeline.echo("bar")
eq_(["foo", "bar"], pipeline.execute())
def test_set_and_get(self):
"""
Pipeline execution returns the pipeline, not the intermediate value.
"""
with self.redis.pipeline() as pipeline:
eq_(pipeline, pipeline.set("foo", "bar"))
eq_(pipeline, pipeline.get("foo"))
eq_([True, "bar"], pipeline.execute())
def test_scripts(self):
"""
Verify that script calls work across pipelines.
This test basically ensures that the pipeline shares
state with the mock redis instance.
"""
script_content = "redis.call('PING')"
sha = sha1(script_content).hexdigest()
self.redis.register_script(script_content)
# Script exists in mock redis
eq_([True], self.redis.script_exists(sha))
# Script exists in pipeline
eq_([True], self.redis.pipeline().script_exists(sha).execute()[0])
class TestPipeline(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_pipeline(self):
"""
Pipeline execution returns all of the saved up values.
"""
with self.redis.pipeline() as pipeline:
pipeline.echo("foo")
pipeline.echo("bar")
eq_(["foo", "bar"], pipeline.execute())
def test_set_and_get(self):
"""
Pipeline execution returns the pipeline, not the intermediate value.
"""
with self.redis.pipeline() as pipeline:
eq_(pipeline, pipeline.set("foo", "bar"))
eq_(pipeline, pipeline.get("foo"))
eq_([True, "bar"], pipeline.execute())
def test_scripts(self):
"""
Verify that script calls work across pipelines.
This test basically ensures that the pipeline shares
state with the mock redis instance.
"""
script_content = "redis.call('PING')"
sha = sha1(script_content).hexdigest()
self.redis.register_script(script_content)
# Script exists in mock redis
eq_([True], self.redis.script_exists(sha))
# Script exists in pipeline
eq_([True], self.redis.pipeline().script_exists(sha).execute()[0])
class TestReads(TestCase):
def setUp(self):
from redis import StrictRedis as Redis
self.redis = Redis(db=15)
self.mockredis = MockRedis()
self.logger = logging.getLogger("mockredis.TestReads")
def tearDown(self):
test_keys = self.redis.keys("MOCKREDIS*")
if len(test_keys) > 0:
self.redis.delete(*test_keys)
self.mockredis.flushdb()
def connections(self):
self.assertEqual("testing_redis",
self.redis.echo("testing_redis"))
self.assertEqual("testing_redis",
self.mockredis.echo("testing_redis"))
def execute(self, method, params):
'''
Execute command on redis and mockredis
'''
getattr(self.redis, method)(*params)
getattr(self.mockredis, method)(*params)
def assert_execute(self, method, params):
'''
Assert that method response is the same
for redis and mockredis
'''
self.logger.debug("method={method},params={params}"
.format(method=method, params=params))
self.assertEqual(
getattr(self.redis, method)(*params),
getattr(self.mockredis, method)(*params),
"testing {method}".format(method=method)
)
def write(self):
'''
successful writes for redis/mockredis (responses NOT compared)
'''
for method, details in redis_writes.items():
for m, params in self.gather_params(method, details):
self.execute(method, params)
def test_reads(self):
'''
equality of responses for redis/mockredis
'''
self.write()
for method, details in redis_reads.items():
for m, params in self.gather_params(method, details):
self.assert_execute(method, params)
def gather_params(self, method, details):
for param in details["params"]:
for use_key in details["keys"]:
if "values" in details:
values = details["values"]
else:
values = [""]
for i in range(len(values)):
param = [p.format(key=key.format(test=use_key),
attr=attr.format(test=use_key),
value=values[i],
index=i)
for p in param]
yield method, param
def test_reads_clean(self):
'''
equality of responses on clean db for redis/mockredis
'''
for method, details in redis_reads.items():
for m, params in self.gather_params(method, details):
self.assert_execute(method, params)
class TestRedis(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_get(self):
self.assertEqual(None, self.redis.get('key'))
self.redis.redis['key'] = 'value'
self.assertEqual('value', self.redis.get('key'))
def test_set(self):
self.assertEqual(None, self.redis.redis.get('key'))
self.redis.set('key', 'value')
self.assertEqual('value', self.redis.redis.get('key'))
def test_get_types(self):
'''
testing type coversions for set/get, hset/hget, sadd/smembers
Python bools, lists, dicts are returned as strings by
redis-py/redis.
'''
values = list([
True,
False,
[1, '2'],
{
'a': 1,
'b': 'c'
},
])
self.assertEqual(None, self.redis.get('key'))
for value in values:
self.redis.set('key', value)
self.assertEqual(str(value), self.redis.get('key'), "redis.get")
self.redis.hset('hkey', 'item', value)
self.assertEqual(str(value), self.redis.hget('hkey', 'item'))
self.redis.sadd('skey', value)
self.assertEqual(set([str(value)]), self.redis.smembers('skey'))
self.redis.flushdb()
def test_incr(self):
'''
incr, hincr when keys exist
'''
values = list([
(1, '2'),
('1', '2'),
])
for value in values:
self.redis.set('key', value[0])
self.redis.incr('key')
self.assertEqual(value[1], self.redis.get('key'), "redis.incr")
self.redis.hset('hkey', 'attr', value[0])
self.redis.hincrby('hkey', 'attr')
self.assertEqual(value[1], self.redis.hget('hkey', 'attr'),
"redis.hincrby")
self.redis.flushdb()
def test_incr_init(self):
'''
incr, hincr, decr when keys do NOT exist
'''
self.redis.incr('key')
self.assertEqual('1', self.redis.get('key'))
self.redis.hincrby('hkey', 'attr')
self.assertEqual('1', self.redis.hget('hkey', 'attr'))
self.redis.decr('dkey')
self.assertEqual('-1', self.redis.get('dkey'))
def test_ttl(self):
self.redis.set('key', 'key')
self.redis.expire('key', 30)
assert self.redis.ttl('key') <= 30
self.assertEqual(self.redis.ttl('invalid_key'), -1)
def test_push_pop_returns_str(self):
key = 'l'
values = ['5', 5, [], {}]
for v in values:
self.redis.rpush(key, v)
self.assertEquals(self.redis.lpop(key), str(v))
#### SET TESTS ####
def test_sadd(self):
key = "set"
values = ["one", "uno", "two", "three"]
for value in values:
self.assertEquals(1, self.redis.sadd(key, value))
def test_sadd_multiple(self):
key = "set"
values = ["one", "uno", "two", "three"]
self.assertEquals(4, self.redis.sadd(key, *values))
def test_sadd_duplicate_key(self):
key = "set"
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(0, self.redis.sadd(key, "one"))
def test_scard(self):
key = "set"
self.assertEquals(0, self.redis.scard(key))
self.assertFalse(key in self.redis.redis)
values = ["one", "uno", "two", "three"]
self.assertEquals(4, self.redis.sadd(key, *values))
self.assertEquals(4, self.redis.scard(key))
def test_sdiff(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sdiff([])
self.assertEquals(set(), self.redis.sdiff("w"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sdiff("x"))
self.assertEquals(set(["two", "three"]), self.redis.sdiff("x", "y"))
self.assertEquals(set(["two", "three"]), self.redis.sdiff(["x", "y"]))
self.assertEquals(set(["three"]), self.redis.sdiff("x", "y", "z"))
self.assertEquals(set(["three"]), self.redis.sdiff(["x", "y"], "z"))
def test_sdiffstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sdiffstore("w", [])
self.assertEquals(3, self.redis.sdiffstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
self.assertEquals(2, self.redis.sdiffstore("w", "x", "y"))
self.assertEquals(set(["two", "three"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sdiffstore("w", ["x", "y"]))
self.assertEquals(set(["two", "three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sdiffstore("w", "x", "y", "z"))
self.assertEquals(set(["three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sdiffstore("w", ["x", "y"], "z"))
self.assertEquals(set(["three"]), self.redis.smembers("w"))
def test_sinter(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sinter([])
self.assertEquals(set(), self.redis.sinter("w"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sinter("x"))
self.assertEquals(set(["one"]), self.redis.sinter("x", "y"))
self.assertEquals(set(["two"]), self.redis.sinter(["x", "z"]))
self.assertEquals(set(), self.redis.sinter("x", "y", "z"))
self.assertEquals(set(), self.redis.sinter(["x", "y"], "z"))
def test_sinterstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sinterstore("w", [])
self.assertEquals(3, self.redis.sinterstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
self.assertEquals(1, self.redis.sinterstore("w", "x", "y"))
self.assertEquals(set(["one"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sinterstore("w", ["x", "z"]))
self.assertEquals(set(["two"]), self.redis.smembers("w"))
self.assertEquals(0, self.redis.sinterstore("w", "x", "y", "z"))
self.assertEquals(set(), self.redis.smembers("w"))
self.assertEquals(0, self.redis.sinterstore("w", ["x", "y"], "z"))
self.assertEquals(set(), self.redis.smembers("w"))
def test_sismember(self):
key = "set"
self.assertEquals(0, self.redis.sismember(key, "one"))
self.assertFalse(key in self.redis.redis)
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(1, self.redis.sismember(key, "one"))
self.assertEquals(0, self.redis.sismember(key, "two"))
def test_smembers(self):
key = "set"
self.assertEquals(set(), self.redis.smembers(key))
self.assertFalse(key in self.redis.redis)
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(set(["one"]), self.redis.smembers(key))
self.assertEquals(1, self.redis.sadd(key, "two"))
self.assertEquals(set(["one", "two"]), self.redis.smembers(key))
def test_smove(self):
self.assertEquals(0, self.redis.smove("x", "y", "one"))
self.assertEquals(2, self.redis.sadd("x", "one", "two"))
self.assertEquals(set(["one", "two"]), self.redis.smembers("x"))
self.assertEquals(set(), self.redis.smembers("y"))
self.assertEquals(0, self.redis.smove("x", "y", "three"))
self.assertEquals(set(["one", "two"]), self.redis.smembers("x"))
self.assertEquals(set(), self.redis.smembers("y"))
self.assertEquals(1, self.redis.smove("x", "y", "one"))
self.assertEquals(set(["two"]), self.redis.smembers("x"))
self.assertEquals(set(["one"]), self.redis.smembers("y"))
def test_spop(self):
key = "set"
self.assertEquals(None, self.redis.spop(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals("one", self.redis.spop(key))
self.assertEquals(0, self.redis.scard(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(1, self.redis.sadd(key, "two"))
first = self.redis.spop(key)
self.assertTrue(first in ["one", "two"])
self.assertEquals(1, self.redis.scard(key))
second = self.redis.spop(key)
self.assertEquals("one" if first == "two" else "two", second)
self.assertEquals(0, self.redis.scard(key))
def test_srandmember(self):
key = "set"
# count is None
self.assertEquals(None, self.redis.srandmember(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals("one", self.redis.srandmember(key))
self.assertEquals(1, self.redis.scard(key))
self.assertEquals(1, self.redis.sadd(key, "two"))
self.assertTrue(self.redis.srandmember(key) in ["one", "two"])
self.assertEquals(2, self.redis.scard(key))
# count > 0
self.assertEquals([], self.redis.srandmember("empty", 1))
self.assertTrue(self.redis.srandmember(key, 1)[0] in ["one", "two"])
self.assertEquals(set(["one", "two"]),
set(self.redis.srandmember(key, 2)))
# count < 0
self.assertEquals([], self.redis.srandmember("empty", -1))
self.assertTrue(self.redis.srandmember(key, -1)[0] in ["one", "two"])
members = self.redis.srandmember(key, -2)
self.assertEquals(2, len(members))
for member in members:
self.assertTrue(member in ["one", "two"])
def test_srem(self):
key = "set"
self.assertEquals(0, self.redis.srem(key, "one"))
self.assertEquals(3, self.redis.sadd(key, "one", "two", "three"))
self.assertEquals(0, self.redis.srem(key, "four"))
self.assertEquals(2, self.redis.srem(key, "one", "three"))
self.assertEquals(1, self.redis.srem(key, "two", "four"))
def test_sunion(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sunion([])
self.assertEquals(set(), self.redis.sunion("v"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sunion("x"))
self.assertEquals(set(["one"]), self.redis.sunion("v", "y"))
self.assertEquals(set(["one", "two"]), self.redis.sunion(["y", "z"]))
self.assertEquals(set(["one", "two", "three"]),
self.redis.sunion("x", "y", "z"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.sunion(["x", "y"], "z"))
def test_sunionstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sunionstore("w", [])
self.assertEquals(0, self.redis.sunionstore("w", "v"))
self.assertEquals(set(), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
self.assertEquals(1, self.redis.sunionstore("w", "v", "y"))
self.assertEquals(set(["one"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sunionstore("w", ["y", "z"]))
self.assertEquals(set(["one", "two"]), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", "x", "y", "z"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", ["x", "y"], "z"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
#### SORTED SET TESTS ####
def test_zadd(self):
key = "zset"
values = [("one", 1), ("uno", 1), ("two", 2), ("three", 3)]
for member, score in values:
self.assertEquals(1, self.redis.zadd(key, member, score))
def test_zadd_strict(self):
"""Argument order for zadd depends on strictness"""
self.redis.strict = True
key = "zset"
values = [("one", 1), ("uno", 1), ("two", 2), ("three", 3)]
for member, score in values:
self.assertEquals(1, self.redis.zadd(key, score, member))
def test_zadd_duplicate_key(self):
key = "zset"
self.assertEquals(1, self.redis.zadd(key, "one", 1.0))
self.assertEquals(0, self.redis.zadd(key, "one", 2.0))
def test_zadd_wrong_type(self):
key = "zset"
self.redis.set(key, "value")
with self.assertRaises(Exception):
self.redis.zadd(key, "one", 2.0)
def test_zadd_multiple_bad_args(self):
key = "zset"
args = ["one", 1, "two"]
with self.assertRaises(Exception):
self.redis.zadd(key, *args)
def test_zadd_multiple_bad_score(self):
key = "zset"
with self.assertRaises(Exception):
self.redis.zadd(key, "one", "two")
def test_zadd_multiple_args(self):
key = "zset"
args = ["one", 1, "uno", 1, "two", 2, "three", 3]
self.assertEquals(4, self.redis.zadd(key, *args))
def test_zadd_multiple_kwargs(self):
key = "zset"
kwargs = {"one": 1, "uno": 1, "two": 2, "three": 3}
self.assertEquals(4, self.redis.zadd(key, **kwargs))
def test_zcard(self):
key = "zset"
self.assertEquals(0, self.redis.zcard(key))
self.redis.zadd(key, "one", 1)
self.assertEquals(1, self.redis.zcard(key))
self.redis.zadd(key, "one", 2)
self.assertEquals(1, self.redis.zcard(key))
self.redis.zadd(key, "two", 2)
self.assertEquals(2, self.redis.zcard(key))
def test_zincrby(self):
key = "zset"
self.assertEquals(1.0, self.redis.zincrby(key, "member1"))
self.assertEquals(2.0, self.redis.zincrby(key, "member2", 2))
self.assertEquals(-1.0, self.redis.zincrby(key, "member1", -2))
def test_zrange(self):
key = "zset"
self.assertEquals([], self.redis.zrange(key, 0, -1))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
# full range
self.assertEquals(["one", "two", "three"],
self.redis.zrange(key, 0, -1))
# withscores
self.assertEquals([("one", 1.5), ("two", 2.5), ("three", 3.5)],
self.redis.zrange(key, 0, -1, withscores=True))
# score_cast_func
self.assertEquals([("one", 1), ("two", 2), ("three", 3)],
self.redis.zrange(key,
0,
-1,
withscores=True,
score_cast_func=int))
# positive ranges
self.assertEquals(["one"], self.redis.zrange(key, 0, 0))
self.assertEquals(["one", "two"], self.redis.zrange(key, 0, 1))
self.assertEquals(["one", "two", "three"],
self.redis.zrange(key, 0, 2))
self.assertEquals(["one", "two", "three"],
self.redis.zrange(key, 0, 3))
self.assertEquals(["two", "three"], self.redis.zrange(key, 1, 2))
self.assertEquals(["three"], self.redis.zrange(key, 2, 3))
# negative ends
self.assertEquals(["one", "two", "three"],
self.redis.zrange(key, 0, -1))
self.assertEquals(["one", "two"], self.redis.zrange(key, 0, -2))
self.assertEquals(["one"], self.redis.zrange(key, 0, -3))
self.assertEquals([], self.redis.zrange(key, 0, -4))
# negative starts
self.assertEquals([], self.redis.zrange(key, -1, 0))
self.assertEquals(["three"], self.redis.zrange(key, -1, -1))
self.assertEquals(["two", "three"], self.redis.zrange(key, -2, -1))
self.assertEquals(["one", "two", "three"],
self.redis.zrange(key, -3, -1))
self.assertEquals(["one", "two", "three"],
self.redis.zrange(key, -4, -1))
# desc
self.assertEquals(["three", "two", "one"],
self.redis.zrange(key, 0, 2, desc=True))
self.assertEquals(["two", "one"],
self.redis.zrange(key, 1, 2, desc=True))
self.assertEquals(["three", "two"],
self.redis.zrange(key, 0, 1, desc=True))
def test_zrem(self):
key = "zset"
self.assertFalse(self.redis.zrem(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.assertEquals(1, self.redis.zcard(key))
self.assertTrue(self.redis.zrem(key, "one"))
self.assertEquals(0, self.redis.zcard(key))
def test_zscore(self):
key = "zset"
self.assertEquals(None, self.redis.zscore(key, "one"))
self.redis.zadd(key, "one", 1.0)
self.assertEquals(1.0, self.redis.zscore(key, "one"))
def test_zrank(self):
key = "zset"
self.assertEquals(None, self.redis.zrank(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(0, self.redis.zrank(key, "one"))
self.assertEquals(1, self.redis.zrank(key, "two"))
def test_zcount(self):
key = "zset"
self.assertEquals(0, self.redis.zcount(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(2, self.redis.zcount(key, "-inf", "inf"))
self.assertEquals(1, self.redis.zcount(key, "-inf", 1.0))
self.assertEquals(1, self.redis.zcount(key, "-inf", 1.5))
self.assertEquals(2, self.redis.zcount(key, "-inf", 2.0))
self.assertEquals(2, self.redis.zcount(key, "-inf", 2.5))
self.assertEquals(1, self.redis.zcount(key, 0.5, 1.0))
self.assertEquals(1, self.redis.zcount(key, 0.5, 1.5))
self.assertEquals(2, self.redis.zcount(key, 0.5, 2.0))
self.assertEquals(2, self.redis.zcount(key, 0.5, 2.5))
self.assertEquals(2, self.redis.zcount(key, 0.5, "inf"))
self.assertEquals(0, self.redis.zcount(key, "inf", "-inf"))
self.assertEquals(0, self.redis.zcount(key, 2.0, 0.5))
def test_zrangebyscore(self):
key = "zset"
self.assertEquals([], self.redis.zrangebyscore(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
self.assertEquals(["one", "two", "three"],
self.redis.zrangebyscore(key, "-inf", "inf"))
self.assertEquals([("one", 1.5), ("two", 2.5), ("three", 3.5)],
self.redis.zrangebyscore(key,
"-inf",
"inf",
withscores=True))
self.assertEquals([("one", 1), ("two", 2), ("three", 3)],
self.redis.zrangebyscore(key,
"-inf",
"inf",
withscores=True,
score_cast_func=int))
self.assertEquals(["one"], self.redis.zrangebyscore(key, 1.0, 2.0))
self.assertEquals(["one", "two"],
self.redis.zrangebyscore(key, 1.0, 3.0))
self.assertEquals(["one"],
self.redis.zrangebyscore(key,
1.0,
3.0,
start=0,
num=1))
self.assertEquals(["two"],
self.redis.zrangebyscore(key,
1.0,
3.0,
start=1,
num=1))
self.assertEquals(["two", "three"],
self.redis.zrangebyscore(key,
1.0,
3.5,
start=1,
num=4))
self.assertEquals([],
self.redis.zrangebyscore(key,
1.0,
3.5,
start=3,
num=4))
def test_zremrank(self):
key = "zset"
self.assertEquals(None, self.redis.zrevrank(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(1, self.redis.zrevrank(key, "one"))
self.assertEquals(0, self.redis.zrevrank(key, "two"))
def test_zrevrangebyscore(self):
key = "zset"
self.assertEquals([], self.redis.zrevrangebyscore(key, "inf", "-inf"))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
self.assertEquals(["three", "two", "one"],
self.redis.zrevrangebyscore(key, "inf", "-inf"))
self.assertEquals([("three", 3.5), ("two", 2.5), ("one", 1.5)],
self.redis.zrevrangebyscore(key,
"inf",
"-inf",
withscores=True))
self.assertEquals([("three", 3), ("two", 2), ("one", 1)],
self.redis.zrevrangebyscore(key,
"inf",
"-inf",
withscores=True,
score_cast_func=int))
self.assertEquals(["one"], self.redis.zrevrangebyscore(key, 2.0, 1.0))
self.assertEquals(["two", "one"],
self.redis.zrevrangebyscore(key, 3.0, 1.0))
self.assertEquals(["two"],
self.redis.zrevrangebyscore(key,
3.0,
1.0,
start=0,
num=1))
self.assertEquals(["one"],
self.redis.zrevrangebyscore(key,
3.0,
1.0,
start=1,
num=1))
self.assertEquals(["two", "one"],
self.redis.zrevrangebyscore(key,
3.5,
1.0,
start=1,
num=4))
self.assertEquals([],
self.redis.zrevrangebyscore(key,
3.5,
1.0,
start=3,
num=4))
def test_zremrangebyrank(self):
key = "zset"
self.assertEquals(0, self.redis.zremrangebyrank(key, 0, -1))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.redis.zadd(key, "three", 3.0)
self.assertEquals(2, self.redis.zremrangebyrank(key, 0, 1))
self.assertEquals(["three"], self.redis.zrange(key, 0, -1))
self.assertEquals(1, self.redis.zremrangebyrank(key, 0, -1))
self.assertEquals([], self.redis.zrange(key, 0, -1))
def test_zremrangebyscore(self):
key = "zset"
self.assertEquals(0, self.redis.zremrangebyscore(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.redis.zadd(key, "three", 3.0)
self.assertEquals(1, self.redis.zremrangebyscore(key, 0, 1))
self.assertEquals(["two", "three"], self.redis.zrange(key, 0, -1))
self.assertEquals(2, self.redis.zremrangebyscore(key, 2.0, "inf"))
self.assertEquals([], self.redis.zrange(key, 0, -1))
def test_zunionstore(self):
key = "zset"
# no keys
self.assertEquals(0, self.redis.zunionstore(key, ["zset1", "zset2"]))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# sum (default)
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"]))
self.assertEquals([("one", 1.0), ("three", 3.0), ("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# sum (explicit)
self.assertEquals(
3, self.redis.zunionstore(key, ["zset1", "zset2"],
aggregate="sum"))
self.assertEquals([("one", 1.0), ("three", 3.0), ("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# min
self.assertEquals(
3, self.redis.zunionstore(key, ["zset1", "zset2"],
aggregate="min"))
self.assertEquals([("one", 1.0), ("two", 2.0), ("three", 3.0)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# max
self.assertEquals(
3, self.redis.zunionstore(key, ["zset1", "zset2"],
aggregate="max"))
self.assertEquals([("one", 1.0), ("two", 2.5), ("three", 3.0)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore(self):
key = "zset"
# no keys
self.assertEquals(0, self.redis.zinterstore(key, ["zset1", "zset2"]))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# sum (default)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"]))
self.assertEquals([("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# sum (explicit)
self.assertEquals(
1, self.redis.zinterstore(key, ["zset1", "zset2"],
aggregate="sum"))
self.assertEquals([("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# min
self.assertEquals(
1, self.redis.zinterstore(key, ["zset1", "zset2"],
aggregate="min"))
self.assertEquals([("two", 2.0)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# max
self.assertEquals(
1, self.redis.zinterstore(key, ["zset1", "zset2"],
aggregate="max"))
self.assertEquals([("two", 2.5)],
self.redis.zrange(key, 0, -1, withscores=True))
class TestRedisZset(TestCase):
"""zset tests"""
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_zadd(self):
key = "zset"
values = [("one", 1), ("uno", 1), ("two", 2), ("three", 3)]
for member, score in values:
self.assertEquals(1, self.redis.zadd(key, member, score))
def test_zadd_strict(self):
"""Argument order for zadd depends on strictness"""
self.redis.strict = True
key = "zset"
values = [("one", 1), ("uno", 1), ("two", 2), ("three", 3)]
for member, score in values:
self.assertEquals(1, self.redis.zadd(key, score, member))
def test_zadd_duplicate_key(self):
key = "zset"
self.assertEquals(1, self.redis.zadd(key, "one", 1.0))
self.assertEquals(0, self.redis.zadd(key, "one", 2.0))
def test_zadd_wrong_type(self):
key = "zset"
self.redis.set(key, "value")
with self.assertRaises(Exception):
self.redis.zadd(key, "one", 2.0)
def test_zadd_multiple_bad_args(self):
key = "zset"
args = ["one", 1, "two"]
with self.assertRaises(Exception):
self.redis.zadd(key, *args)
def test_zadd_multiple_bad_score(self):
key = "zset"
with self.assertRaises(Exception):
self.redis.zadd(key, "one", "two")
def test_zadd_multiple_args(self):
key = "zset"
args = ["one", 1, "uno", 1, "two", 2, "three", 3]
self.assertEquals(4, self.redis.zadd(key, *args))
def test_zadd_multiple_kwargs(self):
key = "zset"
kwargs = {"one": 1, "uno": 1, "two": 2, "three": 3}
self.assertEquals(4, self.redis.zadd(key, **kwargs))
def test_zcard(self):
key = "zset"
self.assertEquals(0, self.redis.zcard(key))
self.redis.zadd(key, "one", 1)
self.assertEquals(1, self.redis.zcard(key))
self.redis.zadd(key, "one", 2)
self.assertEquals(1, self.redis.zcard(key))
self.redis.zadd(key, "two", 2)
self.assertEquals(2, self.redis.zcard(key))
def test_zincrby(self):
key = "zset"
self.assertEquals(1.0, self.redis.zincrby(key, "member1"))
self.assertEquals(2.0, self.redis.zincrby(key, "member2", 2))
self.assertEquals(-1.0, self.redis.zincrby(key, "member1", -2))
def test_zrange(self):
key = "zset"
self.assertEquals([], self.redis.zrange(key, 0, -1))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
# full range
self.assertEquals(["one", "two", "three"],
self.redis.zrange(key, 0, -1))
# withscores
self.assertEquals([("one", 1.5), ("two", 2.5), ("three", 3.5)],
self.redis.zrange(key, 0, -1, withscores=True))
# score_cast_func
self.assertEquals([("one", 1), ("two", 2), ("three", 3)],
self.redis.zrange(key, 0, -1, withscores=True, score_cast_func=int))
# positive ranges
self.assertEquals(["one"], self.redis.zrange(key, 0, 0))
self.assertEquals(["one", "two"], self.redis.zrange(key, 0, 1))
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, 0, 2))
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, 0, 3))
self.assertEquals(["two", "three"], self.redis.zrange(key, 1, 2))
self.assertEquals(["three"], self.redis.zrange(key, 2, 3))
# negative ends
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, 0, -1))
self.assertEquals(["one", "two"], self.redis.zrange(key, 0, -2))
self.assertEquals(["one"], self.redis.zrange(key, 0, -3))
self.assertEquals([], self.redis.zrange(key, 0, -4))
# negative starts
self.assertEquals([], self.redis.zrange(key, -1, 0))
self.assertEquals(["three"], self.redis.zrange(key, -1, -1))
self.assertEquals(["two", "three"], self.redis.zrange(key, -2, -1))
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, -3, -1))
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, -4, -1))
# desc
self.assertEquals(["three", "two", "one"], self.redis.zrange(key, 0, 2, desc=True))
self.assertEquals(["two", "one"], self.redis.zrange(key, 1, 2, desc=True))
self.assertEquals(["three", "two"], self.redis.zrange(key, 0, 1, desc=True))
def test_zrem(self):
key = "zset"
self.assertFalse(self.redis.zrem(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.assertEquals(1, self.redis.zcard(key))
self.assertTrue(self.redis.zrem(key, "one"))
self.assertEquals(0, self.redis.zcard(key))
def test_zscore(self):
key = "zset"
self.assertEquals(None, self.redis.zscore(key, "one"))
self.redis.zadd(key, "one", 1.0)
self.assertEquals(1.0, self.redis.zscore(key, "one"))
def test_zrank(self):
key = "zset"
self.assertEquals(None, self.redis.zrank(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(0, self.redis.zrank(key, "one"))
self.assertEquals(1, self.redis.zrank(key, "two"))
def test_zcount(self):
key = "zset"
self.assertEquals(0, self.redis.zcount(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(2, self.redis.zcount(key, "-inf", "inf"))
self.assertEquals(1, self.redis.zcount(key, "-inf", 1.0))
self.assertEquals(1, self.redis.zcount(key, "-inf", 1.5))
self.assertEquals(2, self.redis.zcount(key, "-inf", 2.0))
self.assertEquals(2, self.redis.zcount(key, "-inf", 2.5))
self.assertEquals(1, self.redis.zcount(key, 0.5, 1.0))
self.assertEquals(1, self.redis.zcount(key, 0.5, 1.5))
self.assertEquals(2, self.redis.zcount(key, 0.5, 2.0))
self.assertEquals(2, self.redis.zcount(key, 0.5, 2.5))
self.assertEquals(2, self.redis.zcount(key, 0.5, "inf"))
self.assertEquals(0, self.redis.zcount(key, "inf", "-inf"))
self.assertEquals(0, self.redis.zcount(key, 2.0, 0.5))
def test_zrangebyscore(self):
key = "zset"
self.assertEquals([], self.redis.zrangebyscore(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
self.assertEquals(["one", "two", "three"],
self.redis.zrangebyscore(key, "-inf", "inf"))
self.assertEquals([("one", 1.5), ("two", 2.5), ("three", 3.5)],
self.redis.zrangebyscore(key, "-inf", "inf", withscores=True))
self.assertEquals([("one", 1), ("two", 2), ("three", 3)],
self.redis.zrangebyscore(key,
"-inf",
"inf",
withscores=True,
score_cast_func=int))
self.assertEquals(["one"],
self.redis.zrangebyscore(key, 1.0, 2.0))
self.assertEquals(["one", "two"],
self.redis.zrangebyscore(key, 1.0, 3.0))
self.assertEquals(["one"],
self.redis.zrangebyscore(key, 1.0, 3.0, start=0, num=1))
self.assertEquals(["two"],
self.redis.zrangebyscore(key, 1.0, 3.0, start=1, num=1))
self.assertEquals(["two", "three"],
self.redis.zrangebyscore(key, 1.0, 3.5, start=1, num=4))
self.assertEquals([],
self.redis.zrangebyscore(key, 1.0, 3.5, start=3, num=4))
def test_zremrank(self):
key = "zset"
self.assertEquals(None, self.redis.zrevrank(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(1, self.redis.zrevrank(key, "one"))
self.assertEquals(0, self.redis.zrevrank(key, "two"))
def test_zrevrangebyscore(self):
key = "zset"
self.assertEquals([], self.redis.zrevrangebyscore(key, "inf", "-inf"))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
self.assertEquals(["three", "two", "one"],
self.redis.zrevrangebyscore(key, "inf", "-inf"))
self.assertEquals([("three", 3.5), ("two", 2.5), ("one", 1.5)],
self.redis.zrevrangebyscore(key, "inf", "-inf", withscores=True))
self.assertEquals([("three", 3), ("two", 2), ("one", 1)],
self.redis.zrevrangebyscore(key,
"inf",
"-inf",
withscores=True,
score_cast_func=int))
self.assertEquals(["one"],
self.redis.zrevrangebyscore(key, 2.0, 1.0))
self.assertEquals(["two", "one"],
self.redis.zrevrangebyscore(key, 3.0, 1.0))
self.assertEquals(["two"],
self.redis.zrevrangebyscore(key, 3.0, 1.0, start=0, num=1))
self.assertEquals(["one"],
self.redis.zrevrangebyscore(key, 3.0, 1.0, start=1, num=1))
self.assertEquals(["two", "one"],
self.redis.zrevrangebyscore(key, 3.5, 1.0, start=1, num=4))
self.assertEquals([],
self.redis.zrevrangebyscore(key, 3.5, 1.0, start=3, num=4))
def test_zremrangebyrank(self):
key = "zset"
self.assertEquals(0, self.redis.zremrangebyrank(key, 0, -1))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.redis.zadd(key, "three", 3.0)
self.assertEquals(2, self.redis.zremrangebyrank(key, 0, 1))
self.assertEquals(["three"], self.redis.zrange(key, 0, -1))
self.assertEquals(1, self.redis.zremrangebyrank(key, 0, -1))
self.assertEquals([], self.redis.zrange(key, 0, -1))
def test_zremrangebyscore(self):
key = "zset"
self.assertEquals(0, self.redis.zremrangebyscore(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.redis.zadd(key, "three", 3.0)
self.assertEquals(1, self.redis.zremrangebyscore(key, 0, 1))
self.assertEquals(["two", "three"], self.redis.zrange(key, 0, -1))
self.assertEquals(2, self.redis.zremrangebyscore(key, 2.0, "inf"))
self.assertEquals([], self.redis.zrange(key, 0, -1))
def test_zunionstore_no_keys(self):
key = "zset"
self.assertEquals(0, self.redis.zunionstore(key, ["zset1", "zset2"]))
def test_zunionstore_default(self):
# sum is default
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"]))
self.assertEquals([("one", 1.0), ("three", 3.0), ("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zunionstore_sum(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="sum"))
self.assertEquals([("one", 1.0), ("three", 3.0), ("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zunionstore_SUM(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="SUM"))
self.assertEquals([("one", 1.0), ("three", 3.0), ("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zunionstore_min(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="min"))
self.assertEquals([("one", 1.0), ("two", 2.0), ("three", 3.0)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zunionstore_MIN(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="MIN"))
self.assertEquals([("one", 1.0), ("two", 2.0), ("three", 3.0)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zunionstore_max(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
key = "zset"
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="max"))
self.assertEquals([("one", 1.0), ("two", 2.5), ("three", 3.0)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zunionstore_MAX(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
key = "zset"
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="MAX"))
self.assertEquals([("one", 1.0), ("two", 2.5), ("three", 3.0)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore_no_keys(self):
key = "zset"
# no keys
self.assertEquals(0, self.redis.zinterstore(key, ["zset1", "zset2"]))
def test_zinterstore_default(self):
# sum is default
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"]))
self.assertEquals([("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore_sum(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="sum"))
self.assertEquals([("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore_SUM(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="SUM"))
self.assertEquals([("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore_min(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="min"))
self.assertEquals([("two", 2.0)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore_MIN(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="MIN"))
self.assertEquals([("two", 2.0)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore_max(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="max"))
self.assertEquals([("two", 2.5)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore_MAX(self):
key = "zset"
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="MAX"))
self.assertEquals([("two", 2.5)],
self.redis.zrange(key, 0, -1, withscores=True))
class TestRedisSet(TestCase):
"""set tests"""
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_sadd(self):
key = "set"
values = ["one", "uno", "two", "three"]
for value in values:
self.assertEquals(1, self.redis.sadd(key, value))
def test_sadd_multiple(self):
key = "set"
values = ["one", "uno", "two", "three"]
self.assertEquals(4, self.redis.sadd(key, *values))
def test_sadd_duplicate_key(self):
key = "set"
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(0, self.redis.sadd(key, "one"))
def test_scard(self):
key = "set"
self.assertEquals(0, self.redis.scard(key))
self.assertFalse(key in self.redis.redis)
values = ["one", "uno", "two", "three"]
self.assertEquals(4, self.redis.sadd(key, *values))
self.assertEquals(4, self.redis.scard(key))
def test_sdiff(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sdiff([])
self.assertEquals(set(), self.redis.sdiff("w"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sdiff("x"))
self.assertEquals(set(["two", "three"]), self.redis.sdiff("x", "y"))
self.assertEquals(set(["two", "three"]), self.redis.sdiff(["x", "y"]))
self.assertEquals(set(["three"]), self.redis.sdiff("x", "y", "z"))
self.assertEquals(set(["three"]), self.redis.sdiff(["x", "y"], "z"))
def test_sdiffstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sdiffstore("w", [])
self.assertEquals(3, self.redis.sdiffstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
self.assertEquals(2, self.redis.sdiffstore("w", "x", "y"))
self.assertEquals(set(["two", "three"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sdiffstore("w", ["x", "y"]))
self.assertEquals(set(["two", "three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sdiffstore("w", "x", "y", "z"))
self.assertEquals(set(["three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sdiffstore("w", ["x", "y"], "z"))
self.assertEquals(set(["three"]), self.redis.smembers("w"))
def test_sinter(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sinter([])
self.assertEquals(set(), self.redis.sinter("w"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sinter("x"))
self.assertEquals(set(["one"]), self.redis.sinter("x", "y"))
self.assertEquals(set(["two"]), self.redis.sinter(["x", "z"]))
self.assertEquals(set(), self.redis.sinter("x", "y", "z"))
self.assertEquals(set(), self.redis.sinter(["x", "y"], "z"))
def test_sinterstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sinterstore("w", [])
self.assertEquals(3, self.redis.sinterstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
self.assertEquals(1, self.redis.sinterstore("w", "x", "y"))
self.assertEquals(set(["one"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sinterstore("w", ["x", "z"]))
self.assertEquals(set(["two"]), self.redis.smembers("w"))
self.assertEquals(0, self.redis.sinterstore("w", "x", "y", "z"))
self.assertEquals(set(), self.redis.smembers("w"))
self.assertEquals(0, self.redis.sinterstore("w", ["x", "y"], "z"))
self.assertEquals(set(), self.redis.smembers("w"))
def test_sismember(self):
key = "set"
self.assertFalse(self.redis.sismember(key, "one"))
self.assertFalse(key in self.redis.redis)
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertTrue(self.redis.sismember(key, "one"))
self.assertFalse(self.redis.sismember(key, "two"))
def test_ismember_numeric(self):
"""
Verify string conversion.
"""
key = "set"
self.assertEquals(1, self.redis.sadd(key, 1))
self.assertEquals(set(["1"]), self.redis.smembers(key))
self.assertTrue(self.redis.sismember(key, "1"))
self.assertTrue(self.redis.sismember(key, 1))
def test_smembers(self):
key = "set"
self.assertEquals(set(), self.redis.smembers(key))
self.assertFalse(key in self.redis.redis)
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(set(["one"]), self.redis.smembers(key))
self.assertEquals(1, self.redis.sadd(key, "two"))
self.assertEquals(set(["one", "two"]), self.redis.smembers(key))
def test_smove(self):
self.assertEquals(0, self.redis.smove("x", "y", "one"))
self.assertEquals(2, self.redis.sadd("x", "one", "two"))
self.assertEquals(set(["one", "two"]), self.redis.smembers("x"))
self.assertEquals(set(), self.redis.smembers("y"))
self.assertEquals(0, self.redis.smove("x", "y", "three"))
self.assertEquals(set(["one", "two"]), self.redis.smembers("x"))
self.assertEquals(set(), self.redis.smembers("y"))
self.assertEquals(1, self.redis.smove("x", "y", "one"))
self.assertEquals(set(["two"]), self.redis.smembers("x"))
self.assertEquals(set(["one"]), self.redis.smembers("y"))
def test_spop(self):
key = "set"
self.assertEquals(None, self.redis.spop(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals("one", self.redis.spop(key))
self.assertEquals(0, self.redis.scard(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(1, self.redis.sadd(key, "two"))
first = self.redis.spop(key)
self.assertTrue(first in ["one", "two"])
self.assertEquals(1, self.redis.scard(key))
second = self.redis.spop(key)
self.assertEquals("one" if first == "two" else "two", second)
self.assertEquals(0, self.redis.scard(key))
def test_srandmember(self):
key = "set"
# count is None
self.assertEquals(None, self.redis.srandmember(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals("one", self.redis.srandmember(key))
self.assertEquals(1, self.redis.scard(key))
self.assertEquals(1, self.redis.sadd(key, "two"))
self.assertTrue(self.redis.srandmember(key) in ["one", "two"])
self.assertEquals(2, self.redis.scard(key))
# count > 0
self.assertEquals([], self.redis.srandmember("empty", 1))
self.assertTrue(self.redis.srandmember(key, 1)[0] in ["one", "two"])
self.assertEquals(set(["one", "two"]),
set(self.redis.srandmember(key, 2)))
# count < 0
self.assertEquals([], self.redis.srandmember("empty", -1))
self.assertTrue(self.redis.srandmember(key, -1)[0] in ["one", "two"])
members = self.redis.srandmember(key, -2)
self.assertEquals(2, len(members))
for member in members:
self.assertTrue(member in ["one", "two"])
def test_srem(self):
key = "set"
self.assertEquals(0, self.redis.srem(key, "one"))
self.assertEquals(3, self.redis.sadd(key, "one", "two", "three"))
self.assertEquals(0, self.redis.srem(key, "four"))
self.assertEquals(2, self.redis.srem(key, "one", "three"))
self.assertEquals(1, self.redis.srem(key, "two", "four"))
def test_sunion(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sunion([])
self.assertEquals(set(), self.redis.sunion("v"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sunion("x"))
self.assertEquals(set(["one"]), self.redis.sunion("v", "y"))
self.assertEquals(set(["one", "two"]), self.redis.sunion(["y", "z"]))
self.assertEquals(set(["one", "two", "three"]),
self.redis.sunion("x", "y", "z"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.sunion(["x", "y"], "z"))
def test_sunionstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sunionstore("w", [])
self.assertEquals(0, self.redis.sunionstore("w", "v"))
self.assertEquals(set(), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
self.assertEquals(1, self.redis.sunionstore("w", "v", "y"))
self.assertEquals(set(["one"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sunionstore("w", ["y", "z"]))
self.assertEquals(set(["one", "two"]), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", "x", "y", "z"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", ["x", "y"], "z"))
self.assertEquals(set(["one", "two", "three"]),
self.redis.smembers("w"))
class TestPipeline(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_pipeline(self):
"""
Pipeline execution returns all of the saved up values.
"""
with self.redis.pipeline() as pipeline:
pipeline.echo("foo")
pipeline.echo("bar")
eq_(["foo", "bar"], pipeline.execute())
def test_set_and_get(self):
"""
Pipeline execution returns the pipeline, not the intermediate value.
"""
with self.redis.pipeline() as pipeline:
eq_(pipeline, pipeline.set("foo", "bar"))
eq_(pipeline, pipeline.get("foo"))
eq_([True, "bar"], pipeline.execute())
def test_scripts(self):
"""
Verify that script calls work across pipelines.
This test basically ensures that the pipeline shares
state with the mock redis instance.
"""
script_content = "redis.call('PING')"
sha = sha1(script_content).hexdigest()
self.redis.register_script(script_content)
# Script exists in mock redis
eq_([True], self.redis.script_exists(sha))
# Script exists in pipeline
eq_([True], self.redis.pipeline().script_exists(sha).execute()[0])
def test_watch(self):
"""
Verify watch puts the pipeline in immediate execution mode.
"""
with self.redis.pipeline() as pipeline:
pipeline.watch("key1", "key2")
eq_(True, pipeline.set("foo", "bar"))
eq_("bar", pipeline.get("foo"))
def test_multi(self):
"""
Test explicit transaction with multi command.
"""
with self.redis.pipeline() as pipeline:
pipeline.multi()
eq_(pipeline, pipeline.set("foo", "bar"))
eq_(pipeline, pipeline.get("foo"))
eq_([True, "bar"], pipeline.execute())
def test_multi_with_watch(self):
"""
Test explicit transaction with watched keys.
"""
with self.redis.pipeline() as pipeline:
pipeline.watch("foo")
eq_(True, pipeline.set("foo", "bar"))
eq_("bar", pipeline.get("foo"))
pipeline.multi()
eq_(pipeline, pipeline.set("foo", "baz"))
eq_(pipeline, pipeline.get("foo"))
eq_([True, "baz"], pipeline.execute())
def test_watch_after_multi(self):
"""
Cannot watch after multi.
"""
with self.redis.pipeline() as pipeline:
pipeline.multi()
with self.assertRaises(RedisError):
pipeline.watch()
def test_multiple_multi_calls(self):
"""
Cannot call multi mutliple times.
"""
with self.redis.pipeline() as pipeline:
pipeline.multi()
with self.assertRaises(RedisError):
pipeline.multi()
def test_multi_on_implicit_transaction(self):
"""
Cannot start an explicit transaction when commands have already been issued.
"""
with self.redis.pipeline() as pipeline:
pipeline.set("foo", "bar")
with self.assertRaises(RedisError):
pipeline.multi()
class TestPipeline(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_pipeline(self):
"""
Pipeline execution returns all of the saved up values.
"""
with self.redis.pipeline() as pipeline:
pipeline.echo("foo")
pipeline.echo("bar")
eq_(["foo", "bar"], pipeline.execute())
def test_set_and_get(self):
"""
Pipeline execution returns the pipeline, not the intermediate value.
"""
with self.redis.pipeline() as pipeline:
eq_(pipeline, pipeline.set("foo", "bar"))
eq_(pipeline, pipeline.get("foo"))
eq_([True, "bar"], pipeline.execute())
def test_scripts(self):
"""
Verify that script calls work across pipelines.
This test basically ensures that the pipeline shares
state with the mock redis instance.
"""
script_content = "redis.call('PING')"
sha = sha1(script_content).hexdigest()
self.redis.register_script(script_content)
# Script exists in mock redis
eq_([True], self.redis.script_exists(sha))
# Script exists in pipeline
eq_([True], self.redis.pipeline().script_exists(sha).execute()[0])
def test_watch(self):
"""
Verify watch puts the pipeline in immediate execution mode.
"""
with self.redis.pipeline() as pipeline:
pipeline.watch("key1", "key2")
eq_(True, pipeline.set("foo", "bar"))
eq_("bar", pipeline.get("foo"))
def test_multi(self):
"""
Test explicit transaction with multi command.
"""
with self.redis.pipeline() as pipeline:
pipeline.multi()
eq_(pipeline, pipeline.set("foo", "bar"))
eq_(pipeline, pipeline.get("foo"))
eq_([True, "bar"], pipeline.execute())
def test_multi_with_watch(self):
"""
Test explicit transaction with watched keys.
"""
with self.redis.pipeline() as pipeline:
pipeline.watch("foo")
eq_(True, pipeline.set("foo", "bar"))
eq_("bar", pipeline.get("foo"))
pipeline.multi()
eq_(pipeline, pipeline.set("foo", "baz"))
eq_(pipeline, pipeline.get("foo"))
eq_([True, "baz"], pipeline.execute())
def test_watch_after_multi(self):
"""
Cannot watch after multi.
"""
with self.redis.pipeline() as pipeline:
pipeline.multi()
with self.assertRaises(RedisError):
pipeline.watch()
def test_multiple_multi_calls(self):
"""
Cannot call multi mutliple times.
"""
with self.redis.pipeline() as pipeline:
pipeline.multi()
with self.assertRaises(RedisError):
pipeline.multi()
def test_multi_on_implicit_transaction(self):
"""
Cannot start an explicit transaction when commands have already been issued.
"""
with self.redis.pipeline() as pipeline:
pipeline.set("foo", "bar")
with self.assertRaises(RedisError):
pipeline.multi()
class TestRedisHash(TestCase):
"""hash tests"""
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_hexists(self):
hashkey = "hash"
self.assertFalse(self.redis.hexists(hashkey, "key"))
self.redis.hset(hashkey, "key", "value")
self.assertTrue(self.redis.hexists(hashkey, "key"))
self.assertFalse(self.redis.hexists(hashkey, "key2"))
def test_hgetall(self):
hashkey = "hash"
self.assertEquals({}, self.redis.hgetall(hashkey))
self.redis.hset(hashkey, "key", "value")
self.assertEquals({"key": "value"}, self.redis.hgetall(hashkey))
def test_hdel(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 1, 2: 2, 3: 3})
self.assertEquals(0, self.redis.hdel(hashkey, "foo"))
self.assertEquals({"1": "1", "2": "2", "3": "3"}, self.redis.hgetall(hashkey))
self.assertEquals(2, self.redis.hdel(hashkey, "1", 2))
self.assertEquals({"3": "3"}, self.redis.hgetall(hashkey))
self.assertEquals(1, self.redis.hdel(hashkey, "3", 4))
self.assertEquals({}, self.redis.hgetall(hashkey))
self.assertFalse(self.redis.exists(hashkey))
def test_hlen(self):
hashkey = "hash"
self.assertEquals(0, self.redis.hlen(hashkey))
self.redis.hset(hashkey, "key", "value")
self.assertEquals(1, self.redis.hlen(hashkey))
def test_hset(self):
hashkey = "hash"
self.redis.hset(hashkey, "key", "value")
self.assertEquals("value", self.redis.hget(hashkey, "key"))
def test_hget(self):
hashkey = "hash"
self.assertEquals(None, self.redis.hget(hashkey, "key"))
def test_hset_integral(self):
hashkey = "hash"
self.redis.hset(hashkey, 1, 2)
self.assertEquals("2", self.redis.hget(hashkey, 1))
self.assertEquals("2", self.redis.hget(hashkey, "1"))
def test_hsetnx(self):
hashkey = "hash"
self.assertEquals(1, self.redis.hsetnx(hashkey, "key", "value1"))
self.assertEquals("value1", self.redis.hget(hashkey, "key"))
self.assertEquals(0, self.redis.hsetnx(hashkey, "key", "value2"))
self.assertEquals("value1", self.redis.hget(hashkey, "key"))
def test_hmset(self):
hashkey = "hash"
self.redis.hmset(hashkey, {"key1": "value1", "key2": "value2"})
self.assertEquals("value1", self.redis.hget(hashkey, "key1"))
self.assertEquals("value2", self.redis.hget(hashkey, "key2"))
def test_hmset_integral(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 2, 3: 4})
self.assertEquals("2", self.redis.hget(hashkey, "1"))
self.assertEquals("2", self.redis.hget(hashkey, 1))
self.assertEquals("4", self.redis.hget(hashkey, "3"))
self.assertEquals("4", self.redis.hget(hashkey, 3))
def test_hmget(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 2, 3: 4})
self.assertEquals(["2", None, "4"], self.redis.hmget(hashkey, "1", "2", "3"))
self.assertEquals(["2", None, "4"], self.redis.hmget(hashkey, ["1", "2", "3"]))
self.assertEquals(["2", None, "4"], self.redis.hmget(hashkey, [1, 2, 3]))
def test_hincrby(self):
hashkey = "hash"
self.assertEquals(1, self.redis.hincrby(hashkey, "key", 1))
self.assertEquals(3, self.redis.hincrby(hashkey, "key", 2))
self.assertEquals("3", self.redis.hget(hashkey, "key"))
def test_hincrbyfloat(self):
hashkey = "hash"
self.assertEquals(1.2, self.redis.hincrbyfloat(hashkey, "key", 1.2))
self.assertEquals(3.5, self.redis.hincrbyfloat(hashkey, "key", 2.3))
self.assertEquals("3.5", self.redis.hget(hashkey, "key"))
def test_hkeys(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 2, 3: 4})
self.assertEquals(["1", "3"], sorted(self.redis.hkeys(hashkey)))
def test_hvals(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 2, 3: 4})
self.assertEquals(["2", "4"], sorted(self.redis.hvals(hashkey)))
class TestRedis(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_get_types(self):
'''
testing type conversions for set/get, hset/hget, sadd/smembers
Python bools, lists, dicts are returned as strings by
redis-py/redis.
'''
values = list([
True,
False,
[1, '2'],
{
'a': 1,
'b': 'c'
},
])
self.assertEqual(None, self.redis.get('key'))
for value in values:
self.redis.set('key', value)
self.assertEqual(str(value),
self.redis.get('key'),
"redis.get")
self.redis.hset('hkey', 'item', value)
self.assertEqual(str(value),
self.redis.hget('hkey', 'item'))
self.redis.sadd('skey', value)
self.assertEqual(set([str(value)]),
self.redis.smembers('skey'))
self.redis.flushdb()
def test_incr(self):
'''
incr, hincr when keys exist
'''
values = list([
(1, '2'),
('1', '2'),
])
for value in values:
self.redis.set('key', value[0])
self.redis.incr('key')
self.assertEqual(value[1],
self.redis.get('key'),
"redis.incr")
self.redis.hset('hkey', 'attr', value[0])
self.redis.hincrby('hkey', 'attr')
self.assertEqual(value[1],
self.redis.hget('hkey', 'attr'),
"redis.hincrby")
self.redis.flushdb()
def test_incr_init(self):
'''
incr, hincr, decr when keys do NOT exist
'''
self.redis.incr('key')
self.assertEqual('1', self.redis.get('key'))
self.redis.hincrby('hkey', 'attr')
self.assertEqual('1', self.redis.hget('hkey', 'attr'))
self.redis.decr('dkey')
self.assertEqual('-1', self.redis.get('dkey'))
def test_ttl(self):
self.redis.set('key', 'key')
self.redis.expire('key', 30)
result = self.redis.ttl('key')
# should be an int
self.assertTrue(isinstance(result, int))
# should be less than the timeout originally set
self.assertTrue(result <= 30)
def test_ttl_when_key_absent(self):
"""Test whether, like the redis-py lib, ttl returns None if the key is absent"""
self.assertEqual(self.redis.ttl('invalid_key'), None)
def test_ttl_no_timeout(self):
"""
Test whether, like the redis-py lib, ttl returns None if the key has no timeout set.
"""
self.redis.set('key', 'key')
self.assertEqual(self.redis.ttl('key'), None)
def test_push_pop_returns_str(self):
key = 'l'
values = ['5', 5, [], {}]
for v in values:
self.redis.rpush(key, v)
self.assertEquals(self.redis.lpop(key),
str(v))
class TestRedis(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_get(self):
self.assertEqual(None, self.redis.get('key'))
self.redis.redis['key'] = 'value'
self.assertEqual('value', self.redis.get('key'))
def test_set(self):
self.assertEqual(None, self.redis.redis.get('key'))
self.redis.set('key', 'value')
self.assertEqual('value', self.redis.redis.get('key'))
def test_get_types(self):
'''
Python bools, lists, dicts are returned as strings by
redis-py/redis.
'''
values = list([
True,
False,
[1, '2'],
{
'a': 1,
'b': 'c'
},
])
self.assertEqual(None, self.redis.get('key'))
for value in values:
self.redis.set('key', value)
self.assertEqual(str(value),
self.redis.get('key'),
"redis.get")
self.redis.hset('hkey', 'item', value)
self.assertEqual(str(value),
self.redis.hget('hkey', 'item'))
self.redis.sadd('skey', value)
self.assertEqual(set([str(value)]),
self.redis.smembers('skey'))
self.redis.flushdb()
def test_incr(self):
'''
incr, hincr when keys exist
'''
values = list([
(1, '2'),
('1', '2'),
])
for value in values:
self.redis.set('key', value[0])
self.redis.incr('key')
self.assertEqual(value[1],
self.redis.get('key'),
"redis.incr")
self.redis.hset('hkey', 'attr', value[0])
self.redis.hincrby('hkey', 'attr')
self.assertEqual(value[1],
self.redis.hget('hkey', 'attr'),
"redis.hincrby")
self.redis.flushdb()
def test_incr_init(self):
'''
incr, hincr, decr when keys do NOT exist
'''
self.redis.incr('key')
self.assertEqual('1', self.redis.get('key'))
self.redis.hincrby('hkey', 'attr')
self.assertEqual('1', self.redis.hget('hkey', 'attr'))
self.redis.decr('dkey')
self.assertEqual('-1', self.redis.get('dkey'))
def test_ttl(self):
self.redis.set('key', 'key')
self.redis.expire('key', 30)
assert self.redis.ttl('key') <= 30
self.assertEqual(self.redis.ttl('invalid_key'), -1)
def test_push_pop_returns_str(self):
key = 'l'
values = ['5', 5, [], {}]
for v in values:
self.redis.rpush(key, v)
self.assertEquals(self.redis.lpop(key),
str(v))
def test_llen(self):
self.assertEqual(self.redis.llen('key'), 0)
self.assertFalse(self.redis.exists('key'))
self.redis.rpush('key', 'value')
self.assertEqual(self.redis.llen('key'), 1)
def test_lrange(self):
self.assertEqual(self.redis.lrange('key', 0, 100), [])
self.assertFalse(self.redis.exists('key'))
for i in range(3):
self.redis.rpush('key', i)
self.assertEqual(self.redis.lrange('key', 2, 0), [])
self.assertEqual(self.redis.lrange('key', 0, 100), ['0', '1', '2'])
self.assertEqual(self.redis.lrange('key', 0, 2), ['0', '1', '2'])
self.assertEqual(self.redis.lrange('key', 1, 1), ['1'])
self.assertEqual(self.redis.lrange('key', 1, -1), ['1', '2'])
self.assertEqual(self.redis.lrange('key', 1, -2), ['1'])
self.assertEqual(self.redis.lrange('key', -3, -2), ['0', '1'])
self.assertEqual(self.redis.lrange('key', -1, -1), ['2'])
class TestRedisHash(TestCase):
"""hash tests"""
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_hexists(self):
hashkey = "hash"
self.assertFalse(self.redis.hexists(hashkey, "key"))
self.redis.hset(hashkey, "key", "value")
self.assertTrue(self.redis.hexists(hashkey, "key"))
self.assertFalse(self.redis.hexists(hashkey, "key2"))
def test_hgetall(self):
hashkey = "hash"
self.assertEquals({}, self.redis.hgetall(hashkey))
self.redis.hset(hashkey, "key", "value")
self.assertEquals({"key": "value"}, self.redis.hgetall(hashkey))
def test_hdel(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 1, 2: 2, 3: 3})
self.assertEquals(0, self.redis.hdel(hashkey, "foo"))
self.assertEquals({
"1": "1",
"2": "2",
"3": "3"
}, self.redis.hgetall(hashkey))
self.assertEquals(2, self.redis.hdel(hashkey, "1", 2))
self.assertEquals({"3": "3"}, self.redis.hgetall(hashkey))
self.assertEquals(1, self.redis.hdel(hashkey, "3", 4))
self.assertEquals({}, self.redis.hgetall(hashkey))
self.assertFalse(self.redis.exists(hashkey))
def test_hlen(self):
hashkey = "hash"
self.assertEquals(0, self.redis.hlen(hashkey))
self.redis.hset(hashkey, "key", "value")
self.assertEquals(1, self.redis.hlen(hashkey))
def test_hset(self):
hashkey = "hash"
self.redis.hset(hashkey, "key", "value")
self.assertEquals("value", self.redis.hget(hashkey, "key"))
def test_hget(self):
hashkey = "hash"
self.assertEquals(None, self.redis.hget(hashkey, "key"))
def test_hset_integral(self):
hashkey = "hash"
self.redis.hset(hashkey, 1, 2)
self.assertEquals("2", self.redis.hget(hashkey, 1))
self.assertEquals("2", self.redis.hget(hashkey, "1"))
def test_hsetnx(self):
hashkey = "hash"
self.assertEquals(1, self.redis.hsetnx(hashkey, "key", "value1"))
self.assertEquals("value1", self.redis.hget(hashkey, "key"))
self.assertEquals(0, self.redis.hsetnx(hashkey, "key", "value2"))
self.assertEquals("value1", self.redis.hget(hashkey, "key"))
def test_hmset(self):
hashkey = "hash"
self.redis.hmset(hashkey, {"key1": "value1", "key2": "value2"})
self.assertEquals("value1", self.redis.hget(hashkey, "key1"))
self.assertEquals("value2", self.redis.hget(hashkey, "key2"))
def test_hmset_integral(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 2, 3: 4})
self.assertEquals("2", self.redis.hget(hashkey, "1"))
self.assertEquals("2", self.redis.hget(hashkey, 1))
self.assertEquals("4", self.redis.hget(hashkey, "3"))
self.assertEquals("4", self.redis.hget(hashkey, 3))
def test_hmget(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 2, 3: 4})
self.assertEquals(["2", None, "4"],
self.redis.hmget(hashkey, "1", "2", "3"))
self.assertEquals(["2", None, "4"],
self.redis.hmget(hashkey, ["1", "2", "3"]))
self.assertEquals(["2", None, "4"],
self.redis.hmget(hashkey, [1, 2, 3]))
def test_hincrby(self):
hashkey = "hash"
self.assertEquals(1, self.redis.hincrby(hashkey, "key", 1))
self.assertEquals(3, self.redis.hincrby(hashkey, "key", 2))
self.assertEquals("3", self.redis.hget(hashkey, "key"))
def test_hincrbyfloat(self):
hashkey = "hash"
self.assertEquals(1.2, self.redis.hincrbyfloat(hashkey, "key", 1.2))
self.assertEquals(3.5, self.redis.hincrbyfloat(hashkey, "key", 2.3))
self.assertEquals("3.5", self.redis.hget(hashkey, "key"))
def test_hkeys(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 2, 3: 4})
self.assertEquals(["1", "3"], sorted(self.redis.hkeys(hashkey)))
def test_hvals(self):
hashkey = "hash"
self.redis.hmset(hashkey, {1: 2, 3: 4})
self.assertEquals(["2", "4"], sorted(self.redis.hvals(hashkey)))
class TestRedis(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_get(self):
self.assertEqual(None, self.redis.get('key'))
self.redis.redis['key'] = 'value'
self.assertEqual('value', self.redis.get('key'))
def test_set(self):
self.assertEqual(None, self.redis.redis.get('key'))
self.redis.set('key', 'value')
self.assertEqual('value', self.redis.redis.get('key'))
def test_get_types(self):
'''
Python bools, lists, dicts are returned as strings by
redis-py/redis.
'''
values = list([
True,
False,
[1, '2'],
{
'a': 1,
'b': 'c'
},
])
self.assertEqual(None, self.redis.get('key'))
for value in values:
self.redis.set('key', value)
self.assertEqual(str(value),
self.redis.get('key'),
"redis.get")
self.redis.hset('hkey', 'item', value)
self.assertEqual(str(value),
self.redis.hget('hkey', 'item'))
self.redis.sadd('skey', value)
self.assertEqual(set([str(value)]),
self.redis.smembers('skey'))
self.redis.flushdb()
def test_incr(self):
values = list([
(1, '2'),
('1', '2'),
])
for value in values:
self.redis.set('key', value[0])
self.redis.incr('key')
self.assertEqual(value[1],
self.redis.get('key'),
"redis.incr")
self.redis.hset('hkey', 'attr', value[0])
self.redis.hincrby('hkey', 'attr')
print self.redis.hget('hkey', 'attr')
self.assertEqual(value[1],
self.redis.hget('hkey', 'attr'),
"redis.hincrby")
self.redis.flushdb()
def test_ttl(self):
self.redis.set('key', 'key')
self.redis.expire('key', 30)
assert self.redis.ttl('key') <= 30
self.assertEqual(self.redis.ttl('invalid_key'), -1)
def test_push_pop_returns_str(self):
key = 'l'
values = ['5', 5, [], {}]
for v in values:
self.redis.rpush(key, v)
self.assertEquals(self.redis.lpop(key),
str(v))
class TestRedis(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_get(self):
self.assertEqual(None, self.redis.get('key'))
self.redis.redis['key'] = 'value'
self.assertEqual('value', self.redis.get('key'))
def test_set(self):
self.assertEqual(None, self.redis.redis.get('key'))
self.redis.set('key', 'value')
self.assertEqual('value', self.redis.redis.get('key'))
def test_get_types(self):
'''
Python bools, lists, dicts are returned as strings by
redis-py/redis.
'''
values = list([
True,
False,
[1, '2'],
{
'a': 1,
'b': 'c'
},
])
self.assertEqual(None, self.redis.get('key'))
for value in values:
self.redis.set('key', value)
self.assertEqual(str(value), self.redis.get('key'), "redis.get")
self.redis.hset('hkey', 'item', value)
self.assertEqual(str(value), self.redis.hget('hkey', 'item'))
self.redis.sadd('skey', value)
self.assertEqual(set([str(value)]), self.redis.smembers('skey'))
self.redis.flushdb()
def test_incr(self):
values = list([
(1, '2'),
('1', '2'),
])
for value in values:
self.redis.set('key', value[0])
self.redis.incr('key')
self.assertEqual(value[1], self.redis.get('key'), "redis.incr")
self.redis.hset('hkey', 'attr', value[0])
self.redis.hincrby('hkey', 'attr')
print self.redis.hget('hkey', 'attr')
self.assertEqual(value[1], self.redis.hget('hkey', 'attr'),
"redis.hincrby")
self.redis.flushdb()
def test_ttl(self):
self.redis.set('key', 'key')
self.redis.expire('key', 30)
assert self.redis.ttl('key') <= 30
self.assertEqual(self.redis.ttl('invalid_key'), -1)
def test_push_pop_returns_str(self):
key = 'l'
values = ['5', 5, [], {}]
for v in values:
self.redis.rpush(key, v)
self.assertEquals(self.redis.lpop(key), str(v))
class TestRedisSet(TestCase):
"""set tests"""
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_sadd(self):
key = "set"
values = ["one", "uno", "two", "three"]
for value in values:
self.assertEquals(1, self.redis.sadd(key, value))
def test_sadd_multiple(self):
key = "set"
values = ["one", "uno", "two", "three"]
self.assertEquals(4, self.redis.sadd(key, *values))
def test_sadd_duplicate_key(self):
key = "set"
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(0, self.redis.sadd(key, "one"))
def test_scard(self):
key = "set"
self.assertEquals(0, self.redis.scard(key))
self.assertFalse(key in self.redis.redis)
values = ["one", "uno", "two", "three"]
self.assertEquals(4, self.redis.sadd(key, *values))
self.assertEquals(4, self.redis.scard(key))
def test_sdiff(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sdiff([])
self.assertEquals(set(), self.redis.sdiff("w"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sdiff("x"))
self.assertEquals(set(["two", "three"]), self.redis.sdiff("x", "y"))
self.assertEquals(set(["two", "three"]), self.redis.sdiff(["x", "y"]))
self.assertEquals(set(["three"]), self.redis.sdiff("x", "y", "z"))
self.assertEquals(set(["three"]), self.redis.sdiff(["x", "y"], "z"))
def test_sdiffstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sdiffstore("w", [])
self.assertEquals(3, self.redis.sdiffstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sdiffstore("w", "x", "y"))
self.assertEquals(set(["two", "three"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sdiffstore("w", ["x", "y"]))
self.assertEquals(set(["two", "three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sdiffstore("w", "x", "y", "z"))
self.assertEquals(set(["three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sdiffstore("w", ["x", "y"], "z"))
self.assertEquals(set(["three"]), self.redis.smembers("w"))
def test_sinter(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sinter([])
self.assertEquals(set(), self.redis.sinter("w"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sinter("x"))
self.assertEquals(set(["one"]), self.redis.sinter("x", "y"))
self.assertEquals(set(["two"]), self.redis.sinter(["x", "z"]))
self.assertEquals(set(), self.redis.sinter("x", "y", "z"))
self.assertEquals(set(), self.redis.sinter(["x", "y"], "z"))
def test_sinterstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sinterstore("w", [])
self.assertEquals(3, self.redis.sinterstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sinterstore("w", "x", "y"))
self.assertEquals(set(["one"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sinterstore("w", ["x", "z"]))
self.assertEquals(set(["two"]), self.redis.smembers("w"))
self.assertEquals(0, self.redis.sinterstore("w", "x", "y", "z"))
self.assertEquals(set(), self.redis.smembers("w"))
self.assertEquals(0, self.redis.sinterstore("w", ["x", "y"], "z"))
self.assertEquals(set(), self.redis.smembers("w"))
def test_sismember(self):
key = "set"
self.assertFalse(self.redis.sismember(key, "one"))
self.assertFalse(key in self.redis.redis)
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertTrue(self.redis.sismember(key, "one"))
self.assertFalse(self.redis.sismember(key, "two"))
def test_ismember_numeric(self):
"""
Verify string conversion.
"""
key = "set"
self.assertEquals(1, self.redis.sadd(key, 1))
self.assertEquals(set(["1"]), self.redis.smembers(key))
self.assertTrue(self.redis.sismember(key, "1"))
self.assertTrue(self.redis.sismember(key, 1))
def test_smembers(self):
key = "set"
self.assertEquals(set(), self.redis.smembers(key))
self.assertFalse(key in self.redis.redis)
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(set(["one"]), self.redis.smembers(key))
self.assertEquals(1, self.redis.sadd(key, "two"))
self.assertEquals(set(["one", "two"]), self.redis.smembers(key))
def test_smove(self):
self.assertEquals(0, self.redis.smove("x", "y", "one"))
self.assertEquals(2, self.redis.sadd("x", "one", "two"))
self.assertEquals(set(["one", "two"]), self.redis.smembers("x"))
self.assertEquals(set(), self.redis.smembers("y"))
self.assertEquals(0, self.redis.smove("x", "y", "three"))
self.assertEquals(set(["one", "two"]), self.redis.smembers("x"))
self.assertEquals(set(), self.redis.smembers("y"))
self.assertEquals(1, self.redis.smove("x", "y", "one"))
self.assertEquals(set(["two"]), self.redis.smembers("x"))
self.assertEquals(set(["one"]), self.redis.smembers("y"))
def test_spop(self):
key = "set"
self.assertEquals(None, self.redis.spop(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals("one", self.redis.spop(key))
self.assertEquals(0, self.redis.scard(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(1, self.redis.sadd(key, "two"))
first = self.redis.spop(key)
self.assertTrue(first in ["one", "two"])
self.assertEquals(1, self.redis.scard(key))
second = self.redis.spop(key)
self.assertEquals("one" if first == "two" else "two", second)
self.assertEquals(0, self.redis.scard(key))
def test_srandmember(self):
key = "set"
# count is None
self.assertEquals(None, self.redis.srandmember(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals("one", self.redis.srandmember(key))
self.assertEquals(1, self.redis.scard(key))
self.assertEquals(1, self.redis.sadd(key, "two"))
self.assertTrue(self.redis.srandmember(key) in ["one", "two"])
self.assertEquals(2, self.redis.scard(key))
# count > 0
self.assertEquals([], self.redis.srandmember("empty", 1))
self.assertTrue(self.redis.srandmember(key, 1)[0] in ["one", "two"])
self.assertEquals(set(["one", "two"]), set(self.redis.srandmember(key, 2)))
# count < 0
self.assertEquals([], self.redis.srandmember("empty", -1))
self.assertTrue(self.redis.srandmember(key, -1)[0] in ["one", "two"])
members = self.redis.srandmember(key, -2)
self.assertEquals(2, len(members))
for member in members:
self.assertTrue(member in ["one", "two"])
def test_srem(self):
key = "set"
self.assertEquals(0, self.redis.srem(key, "one"))
self.assertEquals(3, self.redis.sadd(key, "one", "two", "three"))
self.assertEquals(0, self.redis.srem(key, "four"))
self.assertEquals(2, self.redis.srem(key, "one", "three"))
self.assertEquals(1, self.redis.srem(key, "two", "four"))
def test_sunion(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sunion([])
self.assertEquals(set(), self.redis.sunion("v"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sunion("x"))
self.assertEquals(set(["one"]), self.redis.sunion("v", "y"))
self.assertEquals(set(["one", "two"]), self.redis.sunion(["y", "z"]))
self.assertEquals(set(["one", "two", "three"]), self.redis.sunion("x", "y", "z"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sunion(["x", "y"], "z"))
def test_sunionstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sunionstore("w", [])
self.assertEquals(0, self.redis.sunionstore("w", "v"))
self.assertEquals(set(), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sunionstore("w", "v", "y"))
self.assertEquals(set(["one"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sunionstore("w", ["y", "z"]))
self.assertEquals(set(["one", "two"]), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", "x", "y", "z"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", ["x", "y"], "z"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
class TestRedis(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_get_types(self):
'''
testing type conversions for set/get, hset/hget, sadd/smembers
Python bools, lists, dicts are returned as strings by
redis-py/redis.
'''
values = list([
True,
False,
[1, '2'],
{
'a': 1,
'b': 'c'
},
])
self.assertEqual(None, self.redis.get('key'))
for value in values:
self.redis.set('key', value)
self.assertEqual(str(value), self.redis.get('key'), "redis.get")
self.redis.hset('hkey', 'item', value)
self.assertEqual(str(value), self.redis.hget('hkey', 'item'))
self.redis.sadd('skey', value)
self.assertEqual(set([str(value)]), self.redis.smembers('skey'))
self.redis.flushdb()
def test_incr(self):
'''
incr, hincr when keys exist
'''
values = list([
(1, '2'),
('1', '2'),
])
for value in values:
self.redis.set('key', value[0])
self.redis.incr('key')
self.assertEqual(value[1], self.redis.get('key'), "redis.incr")
self.redis.hset('hkey', 'attr', value[0])
self.redis.hincrby('hkey', 'attr')
self.assertEqual(value[1], self.redis.hget('hkey', 'attr'),
"redis.hincrby")
self.redis.flushdb()
def test_incr_init(self):
'''
incr, hincr, decr when keys do NOT exist
'''
self.redis.incr('key')
self.assertEqual('1', self.redis.get('key'))
self.redis.hincrby('hkey', 'attr')
self.assertEqual('1', self.redis.hget('hkey', 'attr'))
self.redis.decr('dkey')
self.assertEqual('-1', self.redis.get('dkey'))
def test_ttl(self):
self.redis.set('key', 'key')
self.redis.expire('key', 30)
result = self.redis.ttl('key')
# should be an int
self.assertTrue(isinstance(result, int))
# should be less than the timeout originally set
self.assertTrue(result <= 30)
def test_ttl_when_key_absent(self):
"""Test whether, like the redis-py lib, ttl returns None if the key is absent"""
self.assertEqual(self.redis.ttl('invalid_key'), None)
def test_ttl_no_timeout(self):
"""
Test whether, like the redis-py lib, ttl returns None if the key has no timeout set.
"""
self.redis.set('key', 'key')
self.assertEqual(self.redis.ttl('key'), None)
def test_push_pop_returns_str(self):
key = 'l'
values = ['5', 5, [], {}]
for v in values:
self.redis.rpush(key, v)
self.assertEquals(self.redis.lpop(key), str(v))
class TestRedis(TestCase):
def setUp(self):
self.redis = MockRedis()
self.redis.flushdb()
def test_get(self):
self.assertEqual(None, self.redis.get('key'))
self.redis.redis['key'] = 'value'
self.assertEqual('value', self.redis.get('key'))
def test_set(self):
self.assertEqual(None, self.redis.redis.get('key'))
self.redis.set('key', 'value')
self.assertEqual('value', self.redis.redis.get('key'))
def test_get_types(self):
'''
testing type coversions for set/get, hset/hget, sadd/smembers
Python bools, lists, dicts are returned as strings by
redis-py/redis.
'''
values = list([
True,
False,
[1, '2'],
{
'a': 1,
'b': 'c'
},
])
self.assertEqual(None, self.redis.get('key'))
for value in values:
self.redis.set('key', value)
self.assertEqual(str(value),
self.redis.get('key'),
"redis.get")
self.redis.hset('hkey', 'item', value)
self.assertEqual(str(value),
self.redis.hget('hkey', 'item'))
self.redis.sadd('skey', value)
self.assertEqual(set([str(value)]),
self.redis.smembers('skey'))
self.redis.flushdb()
def test_incr(self):
'''
incr, hincr when keys exist
'''
values = list([
(1, '2'),
('1', '2'),
])
for value in values:
self.redis.set('key', value[0])
self.redis.incr('key')
self.assertEqual(value[1],
self.redis.get('key'),
"redis.incr")
self.redis.hset('hkey', 'attr', value[0])
self.redis.hincrby('hkey', 'attr')
self.assertEqual(value[1],
self.redis.hget('hkey', 'attr'),
"redis.hincrby")
self.redis.flushdb()
def test_incr_init(self):
'''
incr, hincr, decr when keys do NOT exist
'''
self.redis.incr('key')
self.assertEqual('1', self.redis.get('key'))
self.redis.hincrby('hkey', 'attr')
self.assertEqual('1', self.redis.hget('hkey', 'attr'))
self.redis.decr('dkey')
self.assertEqual('-1', self.redis.get('dkey'))
def test_ttl(self):
self.redis.set('key', 'key')
self.redis.expire('key', 30)
assert self.redis.ttl('key') <= 30
self.assertEqual(self.redis.ttl('invalid_key'), -1)
def test_push_pop_returns_str(self):
key = 'l'
values = ['5', 5, [], {}]
for v in values:
self.redis.rpush(key, v)
self.assertEquals(self.redis.lpop(key),
str(v))
#### SET TESTS ####
def test_sadd(self):
key = "set"
values = ["one", "uno", "two", "three"]
for value in values:
self.assertEquals(1, self.redis.sadd(key, value))
def test_sadd_multiple(self):
key = "set"
values = ["one", "uno", "two", "three"]
self.assertEquals(4, self.redis.sadd(key, *values))
def test_sadd_duplicate_key(self):
key = "set"
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(0, self.redis.sadd(key, "one"))
def test_scard(self):
key = "set"
self.assertEquals(0, self.redis.scard(key))
self.assertFalse(key in self.redis.redis)
values = ["one", "uno", "two", "three"]
self.assertEquals(4, self.redis.sadd(key, *values))
self.assertEquals(4, self.redis.scard(key))
def test_sdiff(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sdiff([])
self.assertEquals(set(), self.redis.sdiff("w"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sdiff("x"))
self.assertEquals(set(["two", "three"]), self.redis.sdiff("x", "y"))
self.assertEquals(set(["two", "three"]), self.redis.sdiff(["x", "y"]))
self.assertEquals(set(["three"]), self.redis.sdiff("x", "y", "z"))
self.assertEquals(set(["three"]), self.redis.sdiff(["x", "y"], "z"))
def test_sdiffstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sdiffstore("w", [])
self.assertEquals(3, self.redis.sdiffstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sdiffstore("w", "x", "y"))
self.assertEquals(set(["two", "three"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sdiffstore("w", ["x", "y"]))
self.assertEquals(set(["two", "three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sdiffstore("w", "x", "y", "z"))
self.assertEquals(set(["three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sdiffstore("w", ["x", "y"], "z"))
self.assertEquals(set(["three"]), self.redis.smembers("w"))
def test_sinter(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sinter([])
self.assertEquals(set(), self.redis.sinter("w"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sinter("x"))
self.assertEquals(set(["one"]), self.redis.sinter("x", "y"))
self.assertEquals(set(["two"]), self.redis.sinter(["x", "z"]))
self.assertEquals(set(), self.redis.sinter("x", "y", "z"))
self.assertEquals(set(), self.redis.sinter(["x", "y"], "z"))
def test_sinterstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sinterstore("w", [])
self.assertEquals(3, self.redis.sinterstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sinterstore("w", "x", "y"))
self.assertEquals(set(["one"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sinterstore("w", ["x", "z"]))
self.assertEquals(set(["two"]), self.redis.smembers("w"))
self.assertEquals(0, self.redis.sinterstore("w", "x", "y", "z"))
self.assertEquals(set(), self.redis.smembers("w"))
self.assertEquals(0, self.redis.sinterstore("w", ["x", "y"], "z"))
self.assertEquals(set(), self.redis.smembers("w"))
def test_sismember(self):
key = "set"
self.assertEquals(0, self.redis.sismember(key, "one"))
self.assertFalse(key in self.redis.redis)
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(1, self.redis.sismember(key, "one"))
self.assertEquals(0, self.redis.sismember(key, "two"))
def test_smembers(self):
key = "set"
self.assertEquals(set(), self.redis.smembers(key))
self.assertFalse(key in self.redis.redis)
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(set(["one"]), self.redis.smembers(key))
self.assertEquals(1, self.redis.sadd(key, "two"))
self.assertEquals(set(["one", "two"]), self.redis.smembers(key))
def test_smove(self):
self.assertEquals(0, self.redis.smove("x", "y", "one"))
self.assertEquals(2, self.redis.sadd("x", "one", "two"))
self.assertEquals(set(["one", "two"]), self.redis.smembers("x"))
self.assertEquals(set(), self.redis.smembers("y"))
self.assertEquals(0, self.redis.smove("x", "y", "three"))
self.assertEquals(set(["one", "two"]), self.redis.smembers("x"))
self.assertEquals(set(), self.redis.smembers("y"))
self.assertEquals(1, self.redis.smove("x", "y", "one"))
self.assertEquals(set(["two"]), self.redis.smembers("x"))
self.assertEquals(set(["one"]), self.redis.smembers("y"))
def test_spop(self):
key = "set"
self.assertEquals(None, self.redis.spop(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals("one", self.redis.spop(key))
self.assertEquals(0, self.redis.scard(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals(1, self.redis.sadd(key, "two"))
first = self.redis.spop(key)
self.assertTrue(first in ["one", "two"])
self.assertEquals(1, self.redis.scard(key))
second = self.redis.spop(key)
self.assertEquals("one" if first == "two" else "two", second)
self.assertEquals(0, self.redis.scard(key))
def test_srandmember(self):
key = "set"
# count is None
self.assertEquals(None, self.redis.srandmember(key))
self.assertEquals(1, self.redis.sadd(key, "one"))
self.assertEquals("one", self.redis.srandmember(key))
self.assertEquals(1, self.redis.scard(key))
self.assertEquals(1, self.redis.sadd(key, "two"))
self.assertTrue(self.redis.srandmember(key) in ["one", "two"])
self.assertEquals(2, self.redis.scard(key))
# count > 0
self.assertEquals([], self.redis.srandmember("empty", 1))
self.assertTrue(self.redis.srandmember(key, 1)[0] in ["one", "two"])
self.assertEquals(set(["one", "two"]), set(self.redis.srandmember(key, 2)))
# count < 0
self.assertEquals([], self.redis.srandmember("empty", -1))
self.assertTrue(self.redis.srandmember(key, -1)[0] in ["one", "two"])
members = self.redis.srandmember(key, -2)
self.assertEquals(2, len(members))
for member in members:
self.assertTrue(member in ["one", "two"])
def test_srem(self):
key = "set"
self.assertEquals(0, self.redis.srem(key, "one"))
self.assertEquals(3, self.redis.sadd(key, "one", "two", "three"))
self.assertEquals(0, self.redis.srem(key, "four"))
self.assertEquals(2, self.redis.srem(key, "one", "three"))
self.assertEquals(1, self.redis.srem(key, "two", "four"))
def test_sunion(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sunion([])
self.assertEquals(set(), self.redis.sunion("v"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sunion("x"))
self.assertEquals(set(["one"]), self.redis.sunion("v", "y"))
self.assertEquals(set(["one", "two"]), self.redis.sunion(["y", "z"]))
self.assertEquals(set(["one", "two", "three"]), self.redis.sunion("x", "y", "z"))
self.assertEquals(set(["one", "two", "three"]), self.redis.sunion(["x", "y"], "z"))
def test_sunionstore(self):
self.redis.sadd("x", "one", "two", "three")
self.redis.sadd("y", "one")
self.redis.sadd("z", "two")
with self.assertRaises(Exception):
self.redis.sunionstore("w", [])
self.assertEquals(0, self.redis.sunionstore("w", "v"))
self.assertEquals(set(), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", "x"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
self.assertEquals(1, self.redis.sunionstore("w", "v", "y"))
self.assertEquals(set(["one"]), self.redis.smembers("w"))
self.assertEquals(2, self.redis.sunionstore("w", ["y", "z"]))
self.assertEquals(set(["one", "two"]), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", "x", "y", "z"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
self.assertEquals(3, self.redis.sunionstore("w", ["x", "y"], "z"))
self.assertEquals(set(["one", "two", "three"]), self.redis.smembers("w"))
#### SORTED SET TESTS ####
def test_zadd(self):
key = "zset"
values = [("one", 1), ("uno", 1), ("two", 2), ("three", 3)]
for member, score in values:
self.assertEquals(1, self.redis.zadd(key, member, score))
def test_zadd_strict(self):
"""Argument order for zadd depends on strictness"""
self.redis.strict = True
key = "zset"
values = [("one", 1), ("uno", 1), ("two", 2), ("three", 3)]
for member, score in values:
self.assertEquals(1, self.redis.zadd(key, score, member))
def test_zadd_duplicate_key(self):
key = "zset"
self.assertEquals(1, self.redis.zadd(key, "one", 1.0))
self.assertEquals(0, self.redis.zadd(key, "one", 2.0))
def test_zadd_wrong_type(self):
key = "zset"
self.redis.set(key, "value")
with self.assertRaises(Exception):
self.redis.zadd(key, "one", 2.0)
def test_zadd_multiple_bad_args(self):
key = "zset"
args = ["one", 1, "two"]
with self.assertRaises(Exception):
self.redis.zadd(key, *args)
def test_zadd_multiple_bad_score(self):
key = "zset"
with self.assertRaises(Exception):
self.redis.zadd(key, "one", "two")
def test_zadd_multiple_args(self):
key = "zset"
args = ["one", 1, "uno", 1, "two", 2, "three", 3]
self.assertEquals(4, self.redis.zadd(key, *args))
def test_zadd_multiple_kwargs(self):
key = "zset"
kwargs = {"one": 1, "uno": 1, "two": 2, "three": 3}
self.assertEquals(4, self.redis.zadd(key, **kwargs))
def test_zcard(self):
key = "zset"
self.assertEquals(0, self.redis.zcard(key))
self.redis.zadd(key, "one", 1)
self.assertEquals(1, self.redis.zcard(key))
self.redis.zadd(key, "one", 2)
self.assertEquals(1, self.redis.zcard(key))
self.redis.zadd(key, "two", 2)
self.assertEquals(2, self.redis.zcard(key))
def test_zincrby(self):
key = "zset"
self.assertEquals(1.0, self.redis.zincrby(key, "member1"))
self.assertEquals(2.0, self.redis.zincrby(key, "member2", 2))
self.assertEquals(-1.0, self.redis.zincrby(key, "member1", -2))
def test_zrange(self):
key = "zset"
self.assertEquals([], self.redis.zrange(key, 0, -1))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
# full range
self.assertEquals(["one", "two", "three"],
self.redis.zrange(key, 0, -1))
# withscores
self.assertEquals([("one", 1.5), ("two", 2.5), ("three", 3.5)],
self.redis.zrange(key, 0, -1, withscores=True))
# score_cast_func
self.assertEquals([("one", 1), ("two", 2), ("three", 3)],
self.redis.zrange(key, 0, -1, withscores=True, score_cast_func=int))
# positive ranges
self.assertEquals(["one"], self.redis.zrange(key, 0, 0))
self.assertEquals(["one", "two"], self.redis.zrange(key, 0, 1))
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, 0, 2))
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, 0, 3))
self.assertEquals(["two", "three"], self.redis.zrange(key, 1, 2))
self.assertEquals(["three"], self.redis.zrange(key, 2, 3))
# negative ends
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, 0, -1))
self.assertEquals(["one", "two"], self.redis.zrange(key, 0, -2))
self.assertEquals(["one"], self.redis.zrange(key, 0, -3))
self.assertEquals([], self.redis.zrange(key, 0, -4))
# negative starts
self.assertEquals([], self.redis.zrange(key, -1, 0))
self.assertEquals(["three"], self.redis.zrange(key, -1, -1))
self.assertEquals(["two", "three"], self.redis.zrange(key, -2, -1))
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, -3, -1))
self.assertEquals(["one", "two", "three"], self.redis.zrange(key, -4, -1))
# desc
self.assertEquals(["three", "two", "one"], self.redis.zrange(key, 0, 2, desc=True))
self.assertEquals(["two", "one"], self.redis.zrange(key, 1, 2, desc=True))
self.assertEquals(["three", "two"], self.redis.zrange(key, 0, 1, desc=True))
def test_zrem(self):
key = "zset"
self.assertFalse(self.redis.zrem(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.assertEquals(1, self.redis.zcard(key))
self.assertTrue(self.redis.zrem(key, "one"))
self.assertEquals(0, self.redis.zcard(key))
def test_zscore(self):
key = "zset"
self.assertEquals(None, self.redis.zscore(key, "one"))
self.redis.zadd(key, "one", 1.0)
self.assertEquals(1.0, self.redis.zscore(key, "one"))
def test_zrank(self):
key = "zset"
self.assertEquals(None, self.redis.zrank(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(0, self.redis.zrank(key, "one"))
self.assertEquals(1, self.redis.zrank(key, "two"))
def test_zcount(self):
key = "zset"
self.assertEquals(0, self.redis.zcount(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(2, self.redis.zcount(key, "-inf", "inf"))
self.assertEquals(1, self.redis.zcount(key, "-inf", 1.0))
self.assertEquals(1, self.redis.zcount(key, "-inf", 1.5))
self.assertEquals(2, self.redis.zcount(key, "-inf", 2.0))
self.assertEquals(2, self.redis.zcount(key, "-inf", 2.5))
self.assertEquals(1, self.redis.zcount(key, 0.5, 1.0))
self.assertEquals(1, self.redis.zcount(key, 0.5, 1.5))
self.assertEquals(2, self.redis.zcount(key, 0.5, 2.0))
self.assertEquals(2, self.redis.zcount(key, 0.5, 2.5))
self.assertEquals(2, self.redis.zcount(key, 0.5, "inf"))
self.assertEquals(0, self.redis.zcount(key, "inf", "-inf"))
self.assertEquals(0, self.redis.zcount(key, 2.0, 0.5))
def test_zrangebyscore(self):
key = "zset"
self.assertEquals([], self.redis.zrangebyscore(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
self.assertEquals(["one", "two", "three"],
self.redis.zrangebyscore(key, "-inf", "inf"))
self.assertEquals([("one", 1.5), ("two", 2.5), ("three", 3.5)],
self.redis.zrangebyscore(key, "-inf", "inf", withscores=True))
self.assertEquals([("one", 1), ("two", 2), ("three", 3)],
self.redis.zrangebyscore(key, "-inf", "inf", withscores=True, score_cast_func=int))
self.assertEquals(["one"],
self.redis.zrangebyscore(key, 1.0, 2.0))
self.assertEquals(["one", "two"],
self.redis.zrangebyscore(key, 1.0, 3.0))
self.assertEquals(["one"],
self.redis.zrangebyscore(key, 1.0, 3.0, start=0, num=1))
self.assertEquals(["two"],
self.redis.zrangebyscore(key, 1.0, 3.0, start=1, num=1))
self.assertEquals(["two", "three"],
self.redis.zrangebyscore(key, 1.0, 3.5, start=1, num=4))
self.assertEquals([],
self.redis.zrangebyscore(key, 1.0, 3.5, start=3, num=4))
def test_zremrank(self):
key = "zset"
self.assertEquals(None, self.redis.zrevrank(key, "two"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.assertEquals(1, self.redis.zrevrank(key, "one"))
self.assertEquals(0, self.redis.zrevrank(key, "two"))
def test_zrevrangebyscore(self):
key = "zset"
self.assertEquals([], self.redis.zrevrangebyscore(key, "inf", "-inf"))
self.redis.zadd(key, "one", 1.5)
self.redis.zadd(key, "two", 2.5)
self.redis.zadd(key, "three", 3.5)
self.assertEquals(["three", "two", "one"],
self.redis.zrevrangebyscore(key, "inf", "-inf"))
self.assertEquals([("three", 3.5), ("two", 2.5), ("one", 1.5)],
self.redis.zrevrangebyscore(key, "inf", "-inf", withscores=True))
self.assertEquals([("three", 3), ("two", 2), ("one", 1)],
self.redis.zrevrangebyscore(key, "inf", "-inf", withscores=True, score_cast_func=int))
self.assertEquals(["one"],
self.redis.zrevrangebyscore(key, 2.0, 1.0))
self.assertEquals(["two", "one"],
self.redis.zrevrangebyscore(key, 3.0, 1.0))
self.assertEquals(["two"],
self.redis.zrevrangebyscore(key, 3.0, 1.0, start=0, num=1))
self.assertEquals(["one"],
self.redis.zrevrangebyscore(key, 3.0, 1.0, start=1, num=1))
self.assertEquals(["two", "one"],
self.redis.zrevrangebyscore(key, 3.5, 1.0, start=1, num=4))
self.assertEquals([],
self.redis.zrevrangebyscore(key, 3.5, 1.0, start=3, num=4))
def test_zremrangebyrank(self):
key = "zset"
self.assertEquals(0, self.redis.zremrangebyrank(key, 0, -1))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.redis.zadd(key, "three", 3.0)
self.assertEquals(2, self.redis.zremrangebyrank(key, 0, 1))
self.assertEquals(["three"], self.redis.zrange(key, 0, -1))
self.assertEquals(1, self.redis.zremrangebyrank(key, 0, -1))
self.assertEquals([], self.redis.zrange(key, 0, -1))
def test_zremrangebyscore(self):
key = "zset"
self.assertEquals(0, self.redis.zremrangebyscore(key, "-inf", "inf"))
self.redis.zadd(key, "one", 1.0)
self.redis.zadd(key, "two", 2.0)
self.redis.zadd(key, "three", 3.0)
self.assertEquals(1, self.redis.zremrangebyscore(key, 0, 1))
self.assertEquals(["two", "three"], self.redis.zrange(key, 0, -1))
self.assertEquals(2, self.redis.zremrangebyscore(key, 2.0, "inf"))
self.assertEquals([], self.redis.zrange(key, 0, -1))
def test_zunionstore(self):
key = "zset"
# no keys
self.assertEquals(0, self.redis.zunionstore(key, ["zset1", "zset2"]))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# sum (default)
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"]))
self.assertEquals([("one", 1.0), ("three", 3.0), ("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# sum (explicit)
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="sum"))
self.assertEquals([("one", 1.0), ("three", 3.0), ("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# min
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="min"))
self.assertEquals([("one", 1.0), ("two", 2.0), ("three", 3.0)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# max
self.assertEquals(3, self.redis.zunionstore(key, ["zset1", "zset2"], aggregate="max"))
self.assertEquals([("one", 1.0), ("two", 2.5), ("three", 3.0)],
self.redis.zrange(key, 0, -1, withscores=True))
def test_zinterstore(self):
key = "zset"
# no keys
self.assertEquals(0, self.redis.zinterstore(key, ["zset1", "zset2"]))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# sum (default)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"]))
self.assertEquals([("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# sum (explicit)
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="sum"))
self.assertEquals([("two", 4.5)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# min
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="min"))
self.assertEquals([("two", 2.0)],
self.redis.zrange(key, 0, -1, withscores=True))
self.redis.zadd("zset1", "one", 1.0)
self.redis.zadd("zset1", "two", 2.0)
self.redis.zadd("zset2", "two", 2.5)
self.redis.zadd("zset2", "three", 3.0)
# max
self.assertEquals(1, self.redis.zinterstore(key, ["zset1", "zset2"], aggregate="max"))
self.assertEquals([("two", 2.5)],
self.redis.zrange(key, 0, -1, withscores=True))
