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_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_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))
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):
'''
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 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))
