def testRedisLPUSHListOfValues(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
yield db.delete("trex:LPUSH")
yield db.lpush("trex:LPUSH", [1, 2, 3])
result = yield db.lrange("trex:LPUSH", 0, -1)
self.assertEqual(result, [3, 2, 1])
yield db.disconnect()
def setUp(self):
self.db = yield redis.Connection(REDIS_HOST,
REDIS_PORT,
reconnect=False)
self.db1 = None
self.redis_2_6 = yield self.is_redis_2_6()
yield self.db.script_flush()
def testRedisPublish(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
for value in ("foo", "bar"):
yield db.publish("test_publish", value)
yield db.disconnect()
def testRedisError(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
yield db.set('trex:a', 'test')
try:
yield db.sort('trex:a', end='a')
except trex.exceptions.RedisError:
pass
else:
yield db.disconnect()
self.fail('RedisError not raised')
try:
yield db.incr('trex:a')
except trex.exceptions.ResponseError:
pass
else:
yield db.disconnect()
self.fail('ResponseError not raised on redis error')
yield db.disconnect()
try:
yield db.get('trex:a')
except trex.exceptions.ConnectionError:
pass
else:
self.fail('ConnectionError not raised')
def testRedisRPUSHSingleValue(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
yield db.delete("trex:RPUSH")
yield db.lpush("trex:RPUSH", "singlevalue")
result = yield db.lpop("trex:RPUSH")
self.assertEqual(result, "singlevalue")
yield db.disconnect()
def testRedisHSetHGet(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
for hk in ("foo", "bar"):
yield db.hset("trex:HSetHGet", hk, 1)
result = yield db.hget("trex:HSetHGet", hk)
self.assertEqual(result, 1)
yield db.disconnect()
def test_ConnectionDB1(self):
db = yield redis.Connection(REDIS_HOST,
REDIS_PORT,
dbid=1,
reconnect=False)
yield self._assert_simple_sets_on_pipeline(db=db)
yield db.disconnect()
def testRedisHGetAll(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
d = {u"key1": u"uno", u"key2": u"dos"}
yield db.hmset("trex:HGetAll", d)
s = yield db.hgetall("trex:HGetAll")
self.assertEqual(d, s)
yield db.disconnect()
def test_charset_None(self):
db = yield redis.Connection(charset=None)
yield db.set(self.TEST_KEY, self.TEST_VALUE_BINARY)
result = yield db.get(self.TEST_KEY)
self.assertTrue(type(result) == str)
self.assertEqual(result, self.TEST_VALUE_BINARY)
yield db.delete(self.TEST_KEY)
yield db.disconnect()
def testWatchEdgeCase_1(self):
rapi = yield redis.Connection(REDIS_HOST, REDIS_PORT)
tx = yield rapi.multi("foobar")
yield tx.unwatch()
self.assertTrue(tx.inTransaction)
yield tx.discard()
self.assertFalse(tx.inTransaction)
yield rapi.disconnect()
def testRedisOperationTime(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
time = yield db.time()
self.assertIsInstance(time, list)
self.assertEqual(len(time), 2)
self.assertIsInstance(time[0], int)
self.assertIsInstance(time[1], int)
yield db.disconnect()
def test_charset_default(self):
db = yield redis.Connection()
yield db.set(self.TEST_KEY, self.TEST_VALUE_UNICODE)
result = yield db.get(self.TEST_KEY)
self.assertTrue(type(result) == unicode)
self.assertEqual(result, self.TEST_VALUE_UNICODE)
yield db.delete(self.TEST_KEY)
yield db.disconnect()
def testRedisWithWatchAndMulti(self):
rapi = yield redis.Connection(REDIS_HOST, REDIS_PORT)
tx = yield rapi.watch("trex:testRedisWithWatchAndMulti")
yield tx.multi()
yield tx.unwatch()
self.assertTrue(tx.inTransaction)
yield tx.commit()
self.assertFalse(tx.inTransaction)
yield rapi.disconnect()
def testRedisOperations1(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
# test set() operation
kvpairs = (("trex:test1", "foo"), ("trex:test2", "bar"))
for key, value in kvpairs:
yield db.set(key, value)
result = yield db.get(key)
self.assertEqual(result, value)
yield db.disconnect()
def testWatchEdgeCase_2(self):
rapi = yield redis.Connection(REDIS_HOST, REDIS_PORT)
tx = yield rapi.multi()
try:
yield tx.watch("foobar")
except trex.exceptions.ResponseError:
pass
yield tx.unwatch()
self.assertTrue(tx.inTransaction)
yield tx.discard()
self.assertFalse(tx.inTransaction)
yield rapi.disconnect()
def testRedisWithOnlyWatchUnwatch(self):
rapi = yield redis.Connection(REDIS_HOST, REDIS_PORT)
k = "trex:testRedisWithOnlyWatchAndUnwatch"
tx = yield rapi.watch(k)
self.assertTrue(tx.inTransaction)
yield tx.set(k, "bar")
v = yield tx.get(k)
self.assertEqual("bar", v)
yield tx.unwatch()
self.assertFalse(tx.inTransaction)
yield rapi.disconnect()
def testRedisHIncrBy(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
yield db.hset("trex:HIncrBy", "value", 1)
yield db.hincr("trex:HIncrBy", "value")
yield db.hincrby("trex:HIncrBy", "value", 2)
result = yield db.hget("trex:HIncrBy", "value")
self.assertEqual(result, 4)
yield db.hincrby("trex:HIncrBy", "value", 10)
yield db.hdecr("trex:HIncrBy", "value")
result = yield db.hget("trex:HIncrBy", "value")
self.assertEqual(result, 13)
yield db.disconnect()
def testRedisHMSetHMGet(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
t_dict = {}
t_dict['key1'] = 'uno'
t_dict['key2'] = 'dos'
yield db.hmset("trex:HMSetHMGet", t_dict)
ks = t_dict.keys()
ks.reverse()
vs = t_dict.values()
vs.reverse()
res = yield db.hmget("trex:HMSetHMGet", ks)
self.assertEqual(vs, res)
yield db.disconnect()
def testRedisOperations2(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
k = ["trex:a", "trex:b"]
v = [1, 2]
yield db.mset(dict(zip(k, v)))
values = yield db.mget(k)
self.assertEqual(values, v)
k = ['trex:a', 'trex:notset', 'trex:b']
values = yield db.mget(k)
self.assertEqual(values, [1, None, 2])
yield db.disconnect()
def testRedisConnection(self):
rapi = yield redis.Connection(REDIS_HOST, REDIS_PORT)
# test set() operation
transaction = yield rapi.multi("trex:test_transaction")
self.assertTrue(transaction.inTransaction)
for key, value in (("trex:test_transaction", "foo"),
("trex:test_transaction", "bar")):
yield transaction.set(key, value)
yield transaction.commit()
self.assertFalse(transaction.inTransaction)
result = yield rapi.get("trex:test_transaction")
self.assertEqual(result, "bar")
yield rapi.disconnect()
def testRedisHKeysHVals(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
t_dict = {}
t_dict['key1'] = 'uno'
t_dict['key2'] = 'dos'
yield db.hmset("trex:HKeysHVals", t_dict)
vs_u = [unicode(v) for v in t_dict.values()]
ks_u = [unicode(k) for k in t_dict.keys()]
k_res = yield db.hkeys("trex:HKeysHVals")
v_res = yield db.hvals("trex:HKeysHVals")
self.assertEqual(ks_u, k_res)
self.assertEqual(vs_u, v_res)
yield db.disconnect()
def testRedisOperationsSet2(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
key, value = "trex:test_exists", "foo"
# ensure value does not exits and new value sets
yield db.delete(key)
yield db.set(key, value, only_if_not_exists=True)
result_1 = yield db.get(key)
self.assertEqual(result_1, value)
# new values not set cos, values exists
yield db.set(key, "foo2", only_if_not_exists=True)
result_2 = yield db.get(key)
# nothing changed result is same "foo"
self.assertEqual(result_2, value)
yield db.disconnect()
def testRedisOperationsSet3(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
key, value = "trex:test_not_exists", "foo_not_exists"
# ensure that such key does not exits, and value not sets
yield db.delete(key)
yield db.set(key, value, only_if_exists=True)
result_1 = yield db.get(key)
self.assertEqual(result_1, None)
# ensure key exits, and value updates
yield db.set(key, value)
yield db.set(key, "foo", only_if_exists=True)
result_2 = yield db.get(key)
self.assertEqual(result_2, "foo")
yield db.disconnect()
def testRedisHLenHDelMulti(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
t_dict = {}
t_dict['key1'] = 'uno'
t_dict['key2'] = 'dos'
s = yield db.hmset("trex:HDelHExists", t_dict)
r_len = yield db.hlen("trex:HDelHExists")
self.assertEqual(r_len, 2)
s = yield db.hdel("trex:HDelHExists", ["key1", "key2"])
r_len = yield db.hlen("trex:HDelHExists")
self.assertEqual(r_len, 0)
s = yield db.hexists("trex:HDelHExists", ["key1", "key2"])
self.assertEqual(s, 0)
yield db.disconnect()
def testNestedMultiBulkTransaction(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
test1 = {u"foo1": u"bar1", u"something": u"else"}
test2 = {u"foo2": u"bar2", u"something": u"else"}
t = yield db.multi()
yield t.hmset("trex:nmb:test1", test1)
yield t.hgetall("trex:nmb:test1")
yield t.hmset("trex:nmb:test2", test2)
yield t.hgetall("trex:nmb:test2")
r = yield t.commit()
self.assertEqual(r[0], "OK")
self.assertEqual(sorted(r[1].keys()), sorted(test1.keys()))
self.assertEqual(sorted(r[1].values()), sorted(test1.values()))
self.assertEqual(r[2], "OK")
self.assertEqual(sorted(r[3].keys()), sorted(test2.keys()))
self.assertEqual(sorted(r[3].values()), sorted(test2.values()))
yield db.disconnect()
def test_script_kill(self):
self._skipCheck()
try:
result = yield self.db.script_kill()
except trex.exceptions.NoScriptRunning:
pass
except:
raise self.failureException(
'%s raised instead of %s:\n %s' %
(sys.exc_info()[0], 'trex.exceptions.NoScriptRunning',
failure.Failure().getTraceback()))
else:
raise self.failureException(
'%s not raised (%r returned)' %
('trex.exceptions.ResponseError', result))
# Run an infinite loop script from one connection
# and kill it from another.
inf_loop = "while 1 do end"
self.db1 = yield redis.Connection(REDIS_HOST,
REDIS_PORT,
reconnect=False)
eval_deferred = self.db1.eval(inf_loop)
reactor.iterate()
r = yield self.db.script_kill()
self.assertEqual(r, 'OK')
try:
result = yield eval_deferred
except trex.exceptions.ResponseError:
pass
except:
raise self.failureException(
'%s raised instead of %s:\n %s' %
(sys.exc_info()[0], 'trex.exceptions.ResponseError',
failure.Failure().getTraceback()))
else:
raise self.failureException(
'%s not raised (%r returned)' %
('trex.exceptions.ResponseError', result))
def testRedisOperationsSet1(self):
def sleep(secs):
d = defer.Deferred()
reactor.callLater(secs, d.callback, None)
return d
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
key, value = "trex:test1", "foo"
# test expiration in milliseconds
yield db.set(key, value, pexpire=10)
result_1 = yield db.get(key)
self.assertEqual(result_1, value)
yield sleep(0.015)
result_2 = yield db.get(key)
self.assertEqual(result_2, None)
# same thing but timeout in seconds
yield db.set(key, value, expire=1)
result_3 = yield db.get(key)
self.assertEqual(result_3, value)
yield sleep(1.001)
result_4 = yield db.get(key)
self.assertEqual(result_4, None)
yield db.disconnect()
def test_Connection(self):
db = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False)
self.assertEqual(isinstance(db, redis.ConnectionHandler), True)
yield db.disconnect()
def setUp(self):
self.db = yield redis.Connection(REDIS_HOST,
REDIS_PORT,
reconnect=False)
self.redis_2_8_9 = yield self.checkVersion(2, 8, 9)
yield self.db.delete(*self._KEYS)
def setUp(self):
self.db = yield redis.Connection(REDIS_HOST, REDIS_PORT,
reconnect=False)
