re
/
redis
forked from mirror/redis
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
redis/redis_test.go

3023 lines
81 KiB
Go
Raw Blame History

package redis_test
import (
"bytes"
"fmt"
"io"
"net"
"runtime"
"sort"
"strconv"
"sync"
"testing"
"time"
. "launchpad.net/gocheck"
"github.com/vmihailenco/redis"
)
const redisAddr = ":6379"
//------------------------------------------------------------------------------
func sortStrings(slice []string) []string {
sort.Strings(slice)
return slice
}
//------------------------------------------------------------------------------
type RedisShutdownTest struct {
client *redis.Client
}
var _ = Suite(&RedisShutdownTest{})
func (t *RedisShutdownTest) SetUpTest(c *C) {
t.client = redis.NewTCPClient(redisAddr, "", -1)
}
func (t *RedisShutdownTest) TestShutdown(c *C) {
c.Skip("shutdowns server")
shutdown := t.client.Shutdown()
c.Check(shutdown.Err(), Equals, io.EOF)
c.Check(shutdown.Val(), Equals, "")
ping := t.client.Ping()
c.Check(ping.Err(), ErrorMatches, "dial tcp <nil>:[0-9]+: connection refused")
c.Check(ping.Val(), Equals, "")
}
//------------------------------------------------------------------------------
type RedisConnectorTest struct{}
var _ = Suite(&RedisConnectorTest{})
func (t *RedisConnectorTest) TestTCPConnector(c *C) {
client := redis.NewTCPClient(":6379", "", -1)
ping := client.Ping()
c.Check(ping.Err(), IsNil)
c.Check(ping.Val(), Equals, "PONG")
}
func (t *RedisConnectorTest) TestUnixConnector(c *C) {
client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
ping := client.Ping()
c.Check(ping.Err(), IsNil)
c.Check(ping.Val(), Equals, "PONG")
}
//------------------------------------------------------------------------------
type RedisConnPoolTest struct {
openedConnCount, closedConnCount, initedConnCount int64
client *redis.Client
}
var _ = Suite(&RedisConnPoolTest{})
func (t *RedisConnPoolTest) SetUpTest(c *C) {
if t.client == nil {
openConn := func() (net.Conn, error) {
t.openedConnCount++
return net.Dial("tcp", redisAddr)
}
initConn := func(c *redis.Client) error {
t.initedConnCount++
return nil
}
closeConn := func(conn net.Conn) error {
t.closedConnCount++
return nil
}
t.client = redis.NewClient(openConn, closeConn, initConn)
t.client.ConnPool.(*redis.MultiConnPool).MaxCap = 10
}
}
func (t *RedisConnPoolTest) TearDownTest(c *C) {
t.resetRedis(c)
t.resetClient(c)
}
func (t *RedisConnPoolTest) resetRedis(c *C) {
// This is much faster than Flushall.
c.Assert(t.client.Select(1).Err(), IsNil)
c.Assert(t.client.FlushDb().Err(), IsNil)
c.Assert(t.client.Select(0).Err(), IsNil)
c.Assert(t.client.FlushDb().Err(), IsNil)
}
func (t *RedisConnPoolTest) resetClient(c *C) {
t.client.Close()
c.Check(t.closedConnCount, Equals, t.openedConnCount)
c.Check(t.initedConnCount, Equals, t.openedConnCount)
t.openedConnCount, t.closedConnCount, t.initedConnCount = 0, 0, 0
}
func (t *RedisConnPoolTest) TestConnPoolMaxCap(c *C) {
wg := &sync.WaitGroup{}
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
ping := t.client.Ping()
c.Assert(ping.Err(), IsNil)
c.Assert(ping.Val(), Equals, "PONG")
wg.Done()
}()
}
wg.Wait()
c.Assert(t.client.Close(), IsNil)
c.Assert(t.openedConnCount, Equals, int64(10))
c.Assert(t.closedConnCount, Equals, int64(10))
}
func (t *RedisConnPoolTest) TestConnPoolMaxCapOnPipelineClient(c *C) {
wg := &sync.WaitGroup{}
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
pipeline, err := t.client.PipelineClient()
c.Assert(err, IsNil)
ping := pipeline.Ping()
reqs, err := pipeline.RunQueued()
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 1)
c.Assert(ping.Err(), IsNil)
c.Assert(ping.Val(), Equals, "PONG")
c.Assert(pipeline.Close(), IsNil)
wg.Done()
}()
}
wg.Wait()
c.Assert(t.client.Close(), IsNil)
c.Assert(t.openedConnCount, Equals, int64(10))
c.Assert(t.closedConnCount, Equals, int64(10))
}
func (t *RedisConnPoolTest) TestConnPoolMaxCapOnMultiClient(c *C) {
wg := &sync.WaitGroup{}
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
multi, err := t.client.MultiClient()
c.Assert(err, IsNil)
var ping *redis.StatusReq
reqs, err := multi.Exec(func() {
ping = multi.Ping()
})
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 1)
c.Assert(ping.Err(), IsNil)
c.Assert(ping.Val(), Equals, "PONG")
c.Assert(multi.Close(), IsNil)
wg.Done()
}()
}
wg.Wait()
c.Assert(t.client.Close(), IsNil)
c.Assert(t.openedConnCount, Equals, int64(10))
c.Assert(t.closedConnCount, Equals, int64(10))
}
func (t *RedisConnPoolTest) TestConnPoolMaxCapOnPubSubClient(c *C) {
wg := &sync.WaitGroup{}
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
pubsub, err := t.client.PubSubClient()
c.Assert(err, IsNil)
_, err = pubsub.Subscribe()
c.Assert(err, IsNil)
c.Assert(pubsub.Close(), IsNil)
wg.Done()
}()
}
wg.Wait()
c.Assert(t.client.Close(), IsNil)
c.Assert(t.openedConnCount, Equals, int64(1000))
c.Assert(t.closedConnCount, Equals, int64(1000))
}
//------------------------------------------------------------------------------
type RedisTest struct {
openedConnCount, closedConnCount, initedConnCount int
client *redis.Client
}
var _ = Suite(&RedisTest{})
func Test(t *testing.T) { TestingT(t) }
func (t *RedisTest) SetUpTest(c *C) {
if t.client == nil {
openConn := func() (net.Conn, error) {
t.openedConnCount++
return net.Dial("tcp", redisAddr)
}
initConn := func(c *redis.Client) error {
t.initedConnCount++
return nil
}
closeConn := func(conn net.Conn) error {
t.closedConnCount++
return nil
}
t.client = redis.NewClient(openConn, closeConn, initConn)
t.client.ConnPool.(*redis.MultiConnPool).MaxCap = 10
}
}
func (t *RedisTest) TearDownTest(c *C) {
// Assert that all connections are in pool.
c.Assert(
t.client.ConnPool.(*redis.MultiConnPool).Len(),
Equals,
t.openedConnCount-t.closedConnCount,
)
c.Assert(t.openedConnCount, Equals, t.initedConnCount)
t.resetRedis(c)
}
func (t *RedisTest) resetRedis(c *C) {
// This is much faster than Flushall.
c.Assert(t.client.Select(1).Err(), IsNil)
c.Assert(t.client.FlushDb().Err(), IsNil)
c.Assert(t.client.Select(0).Err(), IsNil)
c.Assert(t.client.FlushDb().Err(), IsNil)
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestReqStringMethod(c *C) {
set := t.client.Set("foo", "bar")
c.Assert(set.String(), Equals, "SET foo bar: OK")
get := t.client.Get("foo")
c.Assert(get.String(), Equals, "GET foo: bar")
}
func (t *RedisTest) TestReqStringMethodError(c *C) {
get2 := t.client.Get("key_does_not_exists")
c.Assert(get2.String(), Equals, "GET key_does_not_exists: (nil)")
}
func (t *RedisTest) TestRunWithouthCheckingErrVal(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
}
func (t *RedisTest) TestGetSpecChars(c *C) {
set := t.client.Set("key", "hello1\r\nhello2\r\n")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello1\r\nhello2\r\n")
}
func (t *RedisTest) TestGetBigVal(c *C) {
val := string(bytes.Repeat([]byte{'*'}, 2<<16))
set := t.client.Set("key", val)
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, val)
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestConnPoolRemovesBrokenConn(c *C) {
conn, err := net.Dial("tcp", redisAddr)
c.Assert(err, IsNil)
c.Assert(conn.Close(), IsNil)
client := redis.NewTCPClient(redisAddr, "", -1)
client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
defer func() {
c.Assert(client.Close(), IsNil)
}()
c.Assert(client.ConnPool.Add(redis.NewConn(conn)), IsNil)
ping := client.Ping()
c.Assert(ping.Err().Error(), Equals, "use of closed network connection")
c.Assert(ping.Val(), Equals, "")
ping = client.Ping()
c.Assert(ping.Err(), IsNil)
c.Assert(ping.Val(), Equals, "PONG")
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestAuth(c *C) {
auth := t.client.Auth("password")
c.Assert(auth.Err(), ErrorMatches, "ERR Client sent AUTH, but no password is set")
c.Assert(auth.Val(), Equals, "")
}
func (t *RedisTest) TestEcho(c *C) {
echo := t.client.Echo("hello")
c.Assert(echo.Err(), IsNil)
c.Assert(echo.Val(), Equals, "hello")
}
func (t *RedisTest) TestPing(c *C) {
ping := t.client.Ping()
c.Assert(ping.Err(), IsNil)
c.Assert(ping.Val(), Equals, "PONG")
}
func (t *RedisTest) TestSelect(c *C) {
sel := t.client.Select(1)
c.Assert(sel.Err(), IsNil)
c.Assert(sel.Val(), Equals, "OK")
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestCmdKeysDel(c *C) {
set := t.client.Set("key1", "Hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
set = t.client.Set("key2", "World")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
del := t.client.Del("key1", "key2", "key3")
c.Assert(del.Err(), IsNil)
c.Assert(del.Val(), Equals, int64(2))
}
func (t *RedisTest) TestCmdKeysDump(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
dump := t.client.Dump("key")
c.Assert(dump.Err(), IsNil)
c.Assert(dump.Val(), Equals, "\x00\x05hello\x06\x00\xf5\x9f\xb7\xf6\x90a\x1c\x99")
}
func (t *RedisTest) TestCmdKeysExists(c *C) {
set := t.client.Set("key1", "Hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
exists := t.client.Exists("key1")
c.Assert(exists.Err(), IsNil)
c.Assert(exists.Val(), Equals, true)
exists = t.client.Exists("key2")
c.Assert(exists.Err(), IsNil)
c.Assert(exists.Val(), Equals, false)
}
func (t *RedisTest) TestCmdKeysExpire(c *C) {
set := t.client.Set("key", "Hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
expire := t.client.Expire("key", 10)
c.Assert(expire.Err(), IsNil)
c.Assert(expire.Val(), Equals, true)
ttl := t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Equals, int64(10))
set = t.client.Set("key", "Hello World")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
ttl = t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Equals, int64(-1))
}
func (t *RedisTest) TestCmdKeysExpireAt(c *C) {
set := t.client.Set("key", "Hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
exists := t.client.Exists("key")
c.Assert(exists.Err(), IsNil)
c.Assert(exists.Val(), Equals, true)
expireAt := t.client.ExpireAt("key", 1293840000)
c.Assert(expireAt.Err(), IsNil)
c.Assert(expireAt.Val(), Equals, true)
exists = t.client.Exists("key")
c.Assert(exists.Err(), IsNil)
c.Assert(exists.Val(), Equals, false)
}
func (t *RedisTest) TestCmdKeysKeys(c *C) {
mset := t.client.MSet("one", "1", "two", "2", "three", "3", "four", "4")
c.Assert(mset.Err(), IsNil)
c.Assert(mset.Val(), Equals, "OK")
keys := t.client.Keys("*o*")
c.Assert(keys.Err(), IsNil)
c.Assert(sortStrings(keys.Val()), DeepEquals, []string{"four", "one", "two"})
keys = t.client.Keys("t??")
c.Assert(keys.Err(), IsNil)
c.Assert(keys.Val(), DeepEquals, []string{"two"})
keys = t.client.Keys("*")
c.Assert(keys.Err(), IsNil)
c.Assert(
sortStrings(keys.Val()),
DeepEquals,
[]string{"four", "one", "three", "two"},
)
}
func (t *RedisTest) TestCmdKeysMigrate(c *C) {
migrate := t.client.Migrate("localhost", "6380", "key", 0, 0)
c.Assert(migrate.Err(), IsNil)
c.Assert(migrate.Val(), Equals, "NOKEY")
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
migrate = t.client.Migrate("localhost", "6380", "key", 0, 0)
c.Assert(migrate.Err(), ErrorMatches, "IOERR error or timeout writing to target instance")
c.Assert(migrate.Val(), Equals, "")
}
func (t *RedisTest) TestCmdKeysMove(c *C) {
move := t.client.Move("key", 1)
c.Assert(move.Err(), IsNil)
c.Assert(move.Val(), Equals, false)
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
move = t.client.Move("key", 1)
c.Assert(move.Err(), IsNil)
c.Assert(move.Val(), Equals, true)
get := t.client.Get("key")
c.Assert(get.Err(), Equals, redis.Nil)
c.Assert(get.Val(), Equals, "")
sel := t.client.Select(1)
c.Assert(sel.Err(), IsNil)
c.Assert(sel.Val(), Equals, "OK")
get = t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
func (t *RedisTest) TestCmdKeysObject(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
refCount := t.client.ObjectRefCount("key")
c.Assert(refCount.Err(), IsNil)
c.Assert(refCount.Val(), Equals, int64(1))
enc := t.client.ObjectEncoding("key")
c.Assert(enc.Err(), IsNil)
c.Assert(enc.Val(), Equals, "raw")
idleTime := t.client.ObjectIdleTime("key")
c.Assert(idleTime.Err(), IsNil)
c.Assert(idleTime.Val(), Equals, int64(0))
}
func (t *RedisTest) TestCmdKeysPersist(c *C) {
set := t.client.Set("key", "Hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
expire := t.client.Expire("key", 10)
c.Assert(expire.Err(), IsNil)
c.Assert(expire.Val(), Equals, true)
ttl := t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Equals, int64(10))
persist := t.client.Persist("key")
c.Assert(persist.Err(), IsNil)
c.Assert(persist.Val(), Equals, true)
ttl = t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Equals, int64(-1))
}
func (t *RedisTest) TestCmdKeysPExpire(c *C) {
set := t.client.Set("key", "Hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
pexpire := t.client.PExpire("key", 1900)
c.Assert(pexpire.Err(), IsNil)
c.Assert(pexpire.Val(), Equals, true)
ttl := t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Equals, int64(2))
pttl := t.client.PTTL("key")
c.Assert(pttl.Err(), IsNil)
c.Assert(pttl.Val() > 1800 && pttl.Val() <= 1900, Equals, true)
}
func (t *RedisTest) TestCmdKeysPExpireAt(c *C) {
set := t.client.Set("key", "Hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
pExpireAt := t.client.PExpireAt("key", 1555555555005)
c.Assert(pExpireAt.Err(), IsNil)
c.Assert(pExpireAt.Val(), Equals, true)
ttl := t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Not(Equals), int64(0))
pttl := t.client.PTTL("key")
c.Assert(pttl.Err(), IsNil)
c.Assert(pttl.Val(), Not(Equals), int64(0))
}
func (t *RedisTest) TestCmdKeysPTTL(c *C) {
set := t.client.Set("key", "Hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
expire := t.client.Expire("key", 1)
c.Assert(expire.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
pttl := t.client.PTTL("key")
c.Assert(pttl.Err(), IsNil)
c.Assert(pttl.Val() > 900 && pttl.Val() <= 1000, Equals, true)
}
func (t *RedisTest) TestCmdKeysRandomKey(c *C) {
randomKey := t.client.RandomKey()
c.Assert(randomKey.Err(), Equals, redis.Nil)
c.Assert(randomKey.Val(), Equals, "")
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
randomKey = t.client.RandomKey()
c.Assert(randomKey.Err(), IsNil)
c.Assert(randomKey.Val(), Equals, "key")
}
func (t *RedisTest) TestCmdKeysRename(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
status := t.client.Rename("key", "key1")
c.Assert(status.Err(), IsNil)
c.Assert(status.Val(), Equals, "OK")
get := t.client.Get("key1")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
func (t *RedisTest) TestCmdKeysRenameNX(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
renameNX := t.client.RenameNX("key", "key1")
c.Assert(renameNX.Err(), IsNil)
c.Assert(renameNX.Val(), Equals, true)
get := t.client.Get("key1")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
func (t *RedisTest) TestCmdKeysRestore(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
dump := t.client.Dump("key")
c.Assert(dump.Err(), IsNil)
del := t.client.Del("key")
c.Assert(del.Err(), IsNil)
restore := t.client.Restore("key", 0, dump.Val())
c.Assert(restore.Err(), IsNil)
c.Assert(restore.Val(), Equals, "OK")
type_ := t.client.Type("key")
c.Assert(type_.Err(), IsNil)
c.Assert(type_.Val(), Equals, "string")
lRange := t.client.Get("key")
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), Equals, "hello")
}
func (t *RedisTest) TestCmdKeysSort(c *C) {
lPush := t.client.LPush("list", "1")
c.Assert(lPush.Err(), IsNil)
c.Assert(lPush.Val(), Equals, int64(1))
lPush = t.client.LPush("list", "3")
c.Assert(lPush.Err(), IsNil)
c.Assert(lPush.Val(), Equals, int64(2))
lPush = t.client.LPush("list", "2")
c.Assert(lPush.Err(), IsNil)
c.Assert(lPush.Val(), Equals, int64(3))
sort := t.client.Sort("list", redis.Sort{Offset: 0, Count: 2, Order: "ASC"})
c.Assert(sort.Err(), IsNil)
c.Assert(sort.Val(), DeepEquals, []string{"1", "2"})
}
func (t *RedisTest) TestCmdKeysTTL(c *C) {
ttl := t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Equals, int64(-1))
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
expire := t.client.Expire("key", 60)
c.Assert(expire.Err(), IsNil)
c.Assert(expire.Val(), Equals, true)
ttl = t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Equals, int64(60))
}
func (t *RedisTest) TestCmdKeysType(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
type_ := t.client.Type("key")
c.Assert(type_.Err(), IsNil)
c.Assert(type_.Val(), Equals, "string")
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestStringsAppend(c *C) {
exists := t.client.Exists("key")
c.Assert(exists.Err(), IsNil)
c.Assert(exists.Val(), Equals, false)
append := t.client.Append("key", "Hello")
c.Assert(append.Err(), IsNil)
c.Assert(append.Val(), Equals, int64(5))
append = t.client.Append("key", " World")
c.Assert(append.Err(), IsNil)
c.Assert(append.Val(), Equals, int64(11))
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "Hello World")
}
func (t *RedisTest) TestStringsBitCount(c *C) {
set := t.client.Set("key", "foobar")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
bitCount := t.client.BitCount("key", nil)
c.Assert(bitCount.Err(), IsNil)
c.Assert(bitCount.Val(), Equals, int64(26))
bitCount = t.client.BitCount("key", &redis.BitCount{0, 0})
c.Assert(bitCount.Err(), IsNil)
c.Assert(bitCount.Val(), Equals, int64(4))
bitCount = t.client.BitCount("key", &redis.BitCount{1, 1})
c.Assert(bitCount.Err(), IsNil)
c.Assert(bitCount.Val(), Equals, int64(6))
}
func (t *RedisTest) TestStringsBitOpAnd(c *C) {
set := t.client.Set("key1", "1")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
set = t.client.Set("key2", "0")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
bitOpAnd := t.client.BitOpAnd("dest", "key1", "key2")
c.Assert(bitOpAnd.Err(), IsNil)
c.Assert(bitOpAnd.Val(), Equals, int64(1))
get := t.client.Get("dest")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "0")
}
func (t *RedisTest) TestStringsBitOpOr(c *C) {
set := t.client.Set("key1", "1")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
set = t.client.Set("key2", "0")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
bitOpOr := t.client.BitOpOr("dest", "key1", "key2")
c.Assert(bitOpOr.Err(), IsNil)
c.Assert(bitOpOr.Val(), Equals, int64(1))
get := t.client.Get("dest")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "1")
}
func (t *RedisTest) TestStringsBitOpXor(c *C) {
set := t.client.Set("key1", "\xff")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
set = t.client.Set("key2", "\x0f")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
bitOpXor := t.client.BitOpXor("dest", "key1", "key2")
c.Assert(bitOpXor.Err(), IsNil)
c.Assert(bitOpXor.Val(), Equals, int64(1))
get := t.client.Get("dest")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "\xf0")
}
func (t *RedisTest) TestStringsBitOpNot(c *C) {
set := t.client.Set("key1", "\x00")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
bitOpNot := t.client.BitOpNot("dest", "key1")
c.Assert(bitOpNot.Err(), IsNil)
c.Assert(bitOpNot.Val(), Equals, int64(1))
get := t.client.Get("dest")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "\xff")
}
func (t *RedisTest) TestStringsDecr(c *C) {
set := t.client.Set("key", "10")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
decr := t.client.Decr("key")
c.Assert(decr.Err(), IsNil)
c.Assert(decr.Val(), Equals, int64(9))
set = t.client.Set("key", "234293482390480948029348230948")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
decr = t.client.Decr("key")
c.Assert(decr.Err(), ErrorMatches, "ERR value is not an integer or out of range")
c.Assert(decr.Val(), Equals, int64(0))
}
func (t *RedisTest) TestStringsDecrBy(c *C) {
set := t.client.Set("key", "10")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
decrBy := t.client.DecrBy("key", 5)
c.Assert(decrBy.Err(), IsNil)
c.Assert(decrBy.Val(), Equals, int64(5))
}
func (t *RedisTest) TestStringsGet(c *C) {
get := t.client.Get("_")
c.Assert(get.Err(), Equals, redis.Nil)
c.Assert(get.Val(), Equals, "")
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
get = t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
func (t *RedisTest) TestStringsGetBit(c *C) {
setBit := t.client.SetBit("key", 7, 1)
c.Assert(setBit.Err(), IsNil)
c.Assert(setBit.Val(), Equals, int64(0))
getBit := t.client.GetBit("key", 0)
c.Assert(getBit.Err(), IsNil)
c.Assert(getBit.Val(), Equals, int64(0))
getBit = t.client.GetBit("key", 7)
c.Assert(getBit.Err(), IsNil)
c.Assert(getBit.Val(), Equals, int64(1))
getBit = t.client.GetBit("key", 100)
c.Assert(getBit.Err(), IsNil)
c.Assert(getBit.Val(), Equals, int64(0))
}
func (t *RedisTest) TestStringsGetRange(c *C) {
set := t.client.Set("key", "This is a string")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
getRange := t.client.GetRange("key", 0, 3)
c.Assert(getRange.Err(), IsNil)
c.Assert(getRange.Val(), Equals, "This")
getRange = t.client.GetRange("key", -3, -1)
c.Assert(getRange.Err(), IsNil)
c.Assert(getRange.Val(), Equals, "ing")
getRange = t.client.GetRange("key", 0, -1)
c.Assert(getRange.Err(), IsNil)
c.Assert(getRange.Val(), Equals, "This is a string")
getRange = t.client.GetRange("key", 10, 100)
c.Assert(getRange.Err(), IsNil)
c.Assert(getRange.Val(), Equals, "string")
}
func (t *RedisTest) TestStringsGetSet(c *C) {
incr := t.client.Incr("key")
c.Assert(incr.Err(), IsNil)
c.Assert(incr.Val(), Equals, int64(1))
getSet := t.client.GetSet("key", "0")
c.Assert(getSet.Err(), IsNil)
c.Assert(getSet.Val(), Equals, "1")
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "0")
}
func (t *RedisTest) TestStringsIncr(c *C) {
set := t.client.Set("key", "10")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
incr := t.client.Incr("key")
c.Assert(incr.Err(), IsNil)
c.Assert(incr.Val(), Equals, int64(11))
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "11")
}
func (t *RedisTest) TestStringsIncrBy(c *C) {
set := t.client.Set("key", "10")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
incrBy := t.client.IncrBy("key", 5)
c.Assert(incrBy.Err(), IsNil)
c.Assert(incrBy.Val(), Equals, int64(15))
}
func (t *RedisTest) TestIncrByFloat(c *C) {
set := t.client.Set("key", "10.50")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
incrByFloat := t.client.IncrByFloat("key", 0.1)
c.Assert(incrByFloat.Err(), IsNil)
c.Assert(incrByFloat.Val(), Equals, 10.6)
set = t.client.Set("key", "5.0e3")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
incrByFloat = t.client.IncrByFloat("key", 2.0e2)
c.Assert(incrByFloat.Err(), IsNil)
c.Assert(incrByFloat.Val(), Equals, float64(5200))
}
func (t *RedisTest) TestIncrByFloatOverflow(c *C) {
incrByFloat := t.client.IncrByFloat("key", 996945661)
c.Assert(incrByFloat.Err(), IsNil)
c.Assert(incrByFloat.Val(), Equals, float64(996945661))
}
func (t *RedisTest) TestStringsMSetMGet(c *C) {
mSet := t.client.MSet("key1", "hello1", "key2", "hello2")
c.Assert(mSet.Err(), IsNil)
c.Assert(mSet.Val(), Equals, "OK")
mGet := t.client.MGet("key1", "key2", "_")
c.Assert(mGet.Err(), IsNil)
c.Assert(mGet.Val(), DeepEquals, []interface{}{"hello1", "hello2", nil})
}
func (t *RedisTest) TestStringsMSetNX(c *C) {
mSetNX := t.client.MSetNX("key1", "hello1", "key2", "hello2")
c.Assert(mSetNX.Err(), IsNil)
c.Assert(mSetNX.Val(), Equals, true)
mSetNX = t.client.MSetNX("key2", "hello1", "key3", "hello2")
c.Assert(mSetNX.Err(), IsNil)
c.Assert(mSetNX.Val(), Equals, false)
}
func (t *RedisTest) TestStringsPSetEx(c *C) {
pSetEx := t.client.PSetEx("key", 1000, "hello")
c.Assert(pSetEx.Err(), IsNil)
c.Assert(pSetEx.Val(), Equals, "OK")
pttl := t.client.PTTL("key")
c.Assert(pttl.Err(), IsNil)
c.Assert(pttl.Val() > 900 && pttl.Val() <= 1000, Equals, true)
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
func (t *RedisTest) TestStringsSetGet(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
func (t *RedisTest) TestStringsSetEx(c *C) {
setEx := t.client.SetEx("key", 10, "hello")
c.Assert(setEx.Err(), IsNil)
c.Assert(setEx.Val(), Equals, "OK")
ttl := t.client.TTL("key")
c.Assert(ttl.Err(), IsNil)
c.Assert(ttl.Val(), Equals, int64(10))
}
func (t *RedisTest) TestStringsSetNX(c *C) {
setNX := t.client.SetNX("key", "hello")
c.Assert(setNX.Err(), IsNil)
c.Assert(setNX.Val(), Equals, true)
setNX = t.client.SetNX("key", "hello2")
c.Assert(setNX.Err(), IsNil)
c.Assert(setNX.Val(), Equals, false)
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
func (t *RedisTest) TestStringsSetRange(c *C) {
set := t.client.Set("key", "Hello World")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
range_ := t.client.SetRange("key", 6, "Redis")
c.Assert(range_.Err(), IsNil)
c.Assert(range_.Val(), Equals, int64(11))
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "Hello Redis")
}
func (t *RedisTest) TestStringsStrLen(c *C) {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
strLen := t.client.StrLen("key")
c.Assert(strLen.Err(), IsNil)
c.Assert(strLen.Val(), Equals, int64(5))
strLen = t.client.StrLen("_")
c.Assert(strLen.Err(), IsNil)
c.Assert(strLen.Val(), Equals, int64(0))
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestCmdHDel(c *C) {
hSet := t.client.HSet("hash", "key", "hello")
c.Assert(hSet.Err(), IsNil)
hDel := t.client.HDel("hash", "key")
c.Assert(hDel.Err(), IsNil)
c.Assert(hDel.Val(), Equals, int64(1))
hDel = t.client.HDel("hash", "key")
c.Assert(hDel.Err(), IsNil)
c.Assert(hDel.Val(), Equals, int64(0))
}
func (t *RedisTest) TestCmdHExists(c *C) {
hSet := t.client.HSet("hash", "key", "hello")
c.Assert(hSet.Err(), IsNil)
hExists := t.client.HExists("hash", "key")
c.Assert(hExists.Err(), IsNil)
c.Assert(hExists.Val(), Equals, true)
hExists = t.client.HExists("hash", "key1")
c.Assert(hExists.Err(), IsNil)
c.Assert(hExists.Val(), Equals, false)
}
func (t *RedisTest) TestCmdHGet(c *C) {
hSet := t.client.HSet("hash", "key", "hello")
c.Assert(hSet.Err(), IsNil)
hGet := t.client.HGet("hash", "key")
c.Assert(hGet.Err(), IsNil)
c.Assert(hGet.Val(), Equals, "hello")
hGet = t.client.HGet("hash", "key1")
c.Assert(hGet.Err(), Equals, redis.Nil)
c.Assert(hGet.Val(), Equals, "")
}
func (t *RedisTest) TestCmdHGetAll(c *C) {
hSet := t.client.HSet("hash", "key1", "hello1")
c.Assert(hSet.Err(), IsNil)
hSet = t.client.HSet("hash", "key2", "hello2")
c.Assert(hSet.Err(), IsNil)
hGetAll := t.client.HGetAll("hash")
c.Assert(hGetAll.Err(), IsNil)
c.Assert(hGetAll.Val(), DeepEquals, []string{"key1", "hello1", "key2", "hello2"})
}
func (t *RedisTest) TestCmdHGetAllMap(c *C) {
hSet := t.client.HSet("hash", "key1", "hello1")
c.Assert(hSet.Err(), IsNil)
hSet = t.client.HSet("hash", "key2", "hello2")
c.Assert(hSet.Err(), IsNil)
hGetAll := t.client.HGetAllMap("hash")
c.Assert(hGetAll.Err(), IsNil)
c.Assert(hGetAll.Val(), DeepEquals, map[string]string{"key1": "hello1", "key2": "hello2"})
}
func (t *RedisTest) TestCmdHIncrBy(c *C) {
hSet := t.client.HSet("hash", "key", "5")
c.Assert(hSet.Err(), IsNil)
hIncrBy := t.client.HIncrBy("hash", "key", 1)
c.Assert(hIncrBy.Err(), IsNil)
c.Assert(hIncrBy.Val(), Equals, int64(6))
hIncrBy = t.client.HIncrBy("hash", "key", -1)
c.Assert(hIncrBy.Err(), IsNil)
c.Assert(hIncrBy.Val(), Equals, int64(5))
hIncrBy = t.client.HIncrBy("hash", "key", -10)
c.Assert(hIncrBy.Err(), IsNil)
c.Assert(hIncrBy.Val(), Equals, int64(-5))
}
func (t *RedisTest) TestCmdHIncrByFloat(c *C) {
hSet := t.client.HSet("hash", "field", "10.50")
c.Assert(hSet.Err(), IsNil)
c.Assert(hSet.Val(), Equals, true)
hIncrByFloat := t.client.HIncrByFloat("hash", "field", 0.1)
c.Assert(hIncrByFloat.Err(), IsNil)
c.Assert(hIncrByFloat.Val(), Equals, 10.6)
hSet = t.client.HSet("hash", "field", "5.0e3")
c.Assert(hSet.Err(), IsNil)
c.Assert(hSet.Val(), Equals, false)
hIncrByFloat = t.client.HIncrByFloat("hash", "field", 2.0e2)
c.Assert(hIncrByFloat.Err(), IsNil)
c.Assert(hIncrByFloat.Val(), Equals, float64(5200))
}
func (t *RedisTest) TestCmdHKeys(c *C) {
hSet := t.client.HSet("hash", "key1", "hello1")
c.Assert(hSet.Err(), IsNil)
hSet = t.client.HSet("hash", "key2", "hello2")
c.Assert(hSet.Err(), IsNil)
hKeys := t.client.HKeys("hash")
c.Assert(hKeys.Err(), IsNil)
c.Assert(hKeys.Val(), DeepEquals, []string{"key1", "key2"})
}
func (t *RedisTest) TestCmdHLen(c *C) {
hSet := t.client.HSet("hash", "key1", "hello1")
c.Assert(hSet.Err(), IsNil)
hSet = t.client.HSet("hash", "key2", "hello2")
c.Assert(hSet.Err(), IsNil)
hLen := t.client.HLen("hash")
c.Assert(hLen.Err(), IsNil)
c.Assert(hLen.Val(), Equals, int64(2))
}
func (t *RedisTest) TestCmdHMGet(c *C) {
hSet := t.client.HSet("hash", "key1", "hello1")
c.Assert(hSet.Err(), IsNil)
hSet = t.client.HSet("hash", "key2", "hello2")
c.Assert(hSet.Err(), IsNil)
hMGet := t.client.HMGet("hash", "key1", "key2", "_")
c.Assert(hMGet.Err(), IsNil)
c.Assert(hMGet.Val(), DeepEquals, []interface{}{"hello1", "hello2", nil})
}
func (t *RedisTest) TestCmdHMSet(c *C) {
hMSet := t.client.HMSet("hash", "key1", "hello1", "key2", "hello2")
c.Assert(hMSet.Err(), IsNil)
c.Assert(hMSet.Val(), Equals, "OK")
hGet := t.client.HGet("hash", "key1")
c.Assert(hGet.Err(), IsNil)
c.Assert(hGet.Val(), Equals, "hello1")
hGet = t.client.HGet("hash", "key2")
c.Assert(hGet.Err(), IsNil)
c.Assert(hGet.Val(), Equals, "hello2")
}
func (t *RedisTest) TestCmdHSet(c *C) {
hSet := t.client.HSet("hash", "key", "hello")
c.Assert(hSet.Err(), IsNil)
c.Assert(hSet.Val(), Equals, true)
hGet := t.client.HGet("hash", "key")
c.Assert(hGet.Err(), IsNil)
c.Assert(hGet.Val(), Equals, "hello")
}
func (t *RedisTest) TestCmdHSetNX(c *C) {
hSetNX := t.client.HSetNX("hash", "key", "hello")
c.Assert(hSetNX.Err(), IsNil)
c.Assert(hSetNX.Val(), Equals, true)
hSetNX = t.client.HSetNX("hash", "key", "hello")
c.Assert(hSetNX.Err(), IsNil)
c.Assert(hSetNX.Val(), Equals, false)
hGet := t.client.HGet("hash", "key")
c.Assert(hGet.Err(), IsNil)
c.Assert(hGet.Val(), Equals, "hello")
}
func (t *RedisTest) TestCmdHVals(c *C) {
hSet := t.client.HSet("hash", "key1", "hello1")
c.Assert(hSet.Err(), IsNil)
hSet = t.client.HSet("hash", "key2", "hello2")
c.Assert(hSet.Err(), IsNil)
hVals := t.client.HVals("hash")
c.Assert(hVals.Err(), IsNil)
c.Assert(hVals.Val(), DeepEquals, []string{"hello1", "hello2"})
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestCmdListsBLPop(c *C) {
rPush := t.client.RPush("list1", "a", "b", "c")
c.Assert(rPush.Err(), IsNil)
bLPop := t.client.BLPop(0, "list1", "list2")
c.Assert(bLPop.Err(), IsNil)
c.Assert(bLPop.Val(), DeepEquals, []string{"list1", "a"})
}
func (t *RedisTest) TestCmdListsBLPopBlocks(c *C) {
started := make(chan bool)
done := make(chan bool)
go func() {
started <- true
bLPop := t.client.BLPop(0, "list")
c.Assert(bLPop.Err(), IsNil)
c.Assert(bLPop.Val(), DeepEquals, []string{"list", "a"})
done <- true
}()
<-started
select {
case <-done:
c.Error("BLPop is not blocked")
case <-time.After(time.Second):
// ok
}
rPush := t.client.RPush("list", "a")
c.Assert(rPush.Err(), IsNil)
select {
case <-done:
// ok
case <-time.After(time.Second):
c.Error("BLPop is still blocked")
// ok
}
}
func (t *RedisTest) TestCmdListsBLPopTimeout(c *C) {
bLPop := t.client.BLPop(1, "list1")
c.Assert(bLPop.Err(), Equals, redis.Nil)
c.Assert(bLPop.Val(), IsNil)
}
func (t *RedisTest) TestCmdListsBRPop(c *C) {
rPush := t.client.RPush("list1", "a", "b", "c")
c.Assert(rPush.Err(), IsNil)
bRPop := t.client.BRPop(0, "list1", "list2")
c.Assert(bRPop.Err(), IsNil)
c.Assert(bRPop.Val(), DeepEquals, []string{"list1", "c"})
}
func (t *RedisTest) TestCmdListsBRPopBlocks(c *C) {
started := make(chan bool)
done := make(chan bool)
go func() {
started <- true
bRPop := t.client.BRPop(0, "list")
c.Assert(bRPop.Err(), IsNil)
c.Assert(bRPop.Val(), DeepEquals, []string{"list", "a"})
done <- true
}()
<-started
select {
case <-done:
c.Error("BRPop is not blocked")
case <-time.After(time.Second):
// ok
}
rPush := t.client.RPush("list", "a")
c.Assert(rPush.Err(), IsNil)
select {
case <-done:
// ok
case <-time.After(time.Second):
c.Error("BRPop is still blocked")
// ok
}
}
func (t *RedisTest) TestCmdListsBRPopLPush(c *C) {
rPush := t.client.RPush("list1", "a", "b", "c")
c.Assert(rPush.Err(), IsNil)
bRPopLPush := t.client.BRPopLPush("list1", "list2", 0)
c.Assert(bRPopLPush.Err(), IsNil)
c.Assert(bRPopLPush.Val(), Equals, "c")
}
func (t *RedisTest) TestCmdListsLIndex(c *C) {
lPush := t.client.LPush("list", "World")
c.Assert(lPush.Err(), IsNil)
lPush = t.client.LPush("list", "Hello")
c.Assert(lPush.Err(), IsNil)
lIndex := t.client.LIndex("list", 0)
c.Assert(lIndex.Err(), IsNil)
c.Assert(lIndex.Val(), Equals, "Hello")
lIndex = t.client.LIndex("list", -1)
c.Assert(lIndex.Err(), IsNil)
c.Assert(lIndex.Val(), Equals, "World")
lIndex = t.client.LIndex("list", 3)
c.Assert(lIndex.Err(), Equals, redis.Nil)
c.Assert(lIndex.Val(), Equals, "")
}
func (t *RedisTest) TestCmdListsLInsert(c *C) {
rPush := t.client.RPush("list", "Hello")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "World")
c.Assert(rPush.Err(), IsNil)
lInsert := t.client.LInsert("list", "BEFORE", "World", "There")
c.Assert(lInsert.Err(), IsNil)
c.Assert(lInsert.Val(), Equals, int64(3))
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"Hello", "There", "World"})
}
func (t *RedisTest) TestCmdListsLLen(c *C) {
lPush := t.client.LPush("list", "World")
c.Assert(lPush.Err(), IsNil)
lPush = t.client.LPush("list", "Hello")
c.Assert(lPush.Err(), IsNil)
lLen := t.client.LLen("list")
c.Assert(lLen.Err(), IsNil)
c.Assert(lLen.Val(), Equals, int64(2))
}
func (t *RedisTest) TestCmdListsLPop(c *C) {
rPush := t.client.RPush("list", "one")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "two")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "three")
c.Assert(rPush.Err(), IsNil)
lPop := t.client.LPop("list")
c.Assert(lPop.Err(), IsNil)
c.Assert(lPop.Val(), Equals, "one")
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"two", "three"})
}
func (t *RedisTest) TestCmdListsLPush(c *C) {
lPush := t.client.LPush("list", "World")
c.Assert(lPush.Err(), IsNil)
lPush = t.client.LPush("list", "Hello")
c.Assert(lPush.Err(), IsNil)
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"Hello", "World"})
}
func (t *RedisTest) TestCmdListsLPushX(c *C) {
lPush := t.client.LPush("list", "World")
c.Assert(lPush.Err(), IsNil)
lPushX := t.client.LPushX("list", "Hello")
c.Assert(lPushX.Err(), IsNil)
c.Assert(lPushX.Val(), Equals, int64(2))
lPushX = t.client.LPushX("list2", "Hello")
c.Assert(lPushX.Err(), IsNil)
c.Assert(lPushX.Val(), Equals, int64(0))
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"Hello", "World"})
lRange = t.client.LRange("list2", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{})
}
func (t *RedisTest) TestCmdListsLRange(c *C) {
rPush := t.client.RPush("list", "one")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "two")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "three")
c.Assert(rPush.Err(), IsNil)
lRange := t.client.LRange("list", 0, 0)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"one"})
lRange = t.client.LRange("list", -3, 2)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"one", "two", "three"})
lRange = t.client.LRange("list", -100, 100)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"one", "two", "three"})
lRange = t.client.LRange("list", 5, 10)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{})
}
func (t *RedisTest) TestCmdListsLRem(c *C) {
rPush := t.client.RPush("list", "hello")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "hello")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "key")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "hello")
c.Assert(rPush.Err(), IsNil)
lRem := t.client.LRem("list", -2, "hello")
c.Assert(lRem.Err(), IsNil)
c.Assert(lRem.Val(), Equals, int64(2))
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"hello", "key"})
}
func (t *RedisTest) TestCmdListsLSet(c *C) {
rPush := t.client.RPush("list", "one")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "two")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "three")
c.Assert(rPush.Err(), IsNil)
lSet := t.client.LSet("list", 0, "four")
c.Assert(lSet.Err(), IsNil)
c.Assert(lSet.Val(), Equals, "OK")
lSet = t.client.LSet("list", -2, "five")
c.Assert(lSet.Err(), IsNil)
c.Assert(lSet.Val(), Equals, "OK")
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"four", "five", "three"})
}
func (t *RedisTest) TestCmdListsLTrim(c *C) {
rPush := t.client.RPush("list", "one")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "two")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "three")
c.Assert(rPush.Err(), IsNil)
lTrim := t.client.LTrim("list", 1, -1)
c.Assert(lTrim.Err(), IsNil)
c.Assert(lTrim.Val(), Equals, "OK")
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"two", "three"})
}
func (t *RedisTest) TestCmdListsRPop(c *C) {
rPush := t.client.RPush("list", "one")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "two")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "three")
c.Assert(rPush.Err(), IsNil)
rPop := t.client.RPop("list")
c.Assert(rPop.Err(), IsNil)
c.Assert(rPop.Val(), Equals, "three")
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"one", "two"})
}
func (t *RedisTest) TestCmdListsRPopLPush(c *C) {
rPush := t.client.RPush("list", "one")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "two")
c.Assert(rPush.Err(), IsNil)
rPush = t.client.RPush("list", "three")
c.Assert(rPush.Err(), IsNil)
rPopLPush := t.client.RPopLPush("list", "list2")
c.Assert(rPopLPush.Err(), IsNil)
c.Assert(rPopLPush.Val(), Equals, "three")
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"one", "two"})
lRange = t.client.LRange("list2", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"three"})
}
func (t *RedisTest) TestCmdListsRPush(c *C) {
rPush := t.client.RPush("list", "Hello")
c.Assert(rPush.Err(), IsNil)
c.Assert(rPush.Val(), Equals, int64(1))
rPush = t.client.RPush("list", "World")
c.Assert(rPush.Err(), IsNil)
c.Assert(rPush.Val(), Equals, int64(2))
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"Hello", "World"})
}
func (t *RedisTest) TestCmdListsRPushX(c *C) {
rPush := t.client.RPush("list", "Hello")
c.Assert(rPush.Err(), IsNil)
c.Assert(rPush.Val(), Equals, int64(1))
rPushX := t.client.RPushX("list", "World")
c.Assert(rPushX.Err(), IsNil)
c.Assert(rPushX.Val(), Equals, int64(2))
rPushX = t.client.RPushX("list2", "World")
c.Assert(rPushX.Err(), IsNil)
c.Assert(rPushX.Val(), Equals, int64(0))
lRange := t.client.LRange("list", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{"Hello", "World"})
lRange = t.client.LRange("list2", 0, -1)
c.Assert(lRange.Err(), IsNil)
c.Assert(lRange.Val(), DeepEquals, []string{})
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestSAdd(c *C) {
sAdd := t.client.SAdd("set", "Hello")
c.Assert(sAdd.Err(), IsNil)
c.Assert(sAdd.Val(), Equals, int64(1))
sAdd = t.client.SAdd("set", "World")
c.Assert(sAdd.Err(), IsNil)
c.Assert(sAdd.Val(), Equals, int64(1))
sAdd = t.client.SAdd("set", "World")
c.Assert(sAdd.Err(), IsNil)
c.Assert(sAdd.Val(), Equals, int64(0))
sMembers := t.client.SMembers("set")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sortStrings(sMembers.Val()), DeepEquals, []string{"Hello", "World"})
}
func (t *RedisTest) TestSCard(c *C) {
sAdd := t.client.SAdd("set", "Hello")
c.Assert(sAdd.Err(), IsNil)
c.Assert(sAdd.Val(), Equals, int64(1))
sAdd = t.client.SAdd("set", "World")
c.Assert(sAdd.Err(), IsNil)
c.Assert(sAdd.Val(), Equals, int64(1))
sCard := t.client.SCard("set")
c.Assert(sCard.Err(), IsNil)
c.Assert(sCard.Val(), Equals, int64(2))
}
func (t *RedisTest) TestSDiff(c *C) {
sAdd := t.client.SAdd("set1", "a")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "b")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "d")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "e")
c.Assert(sAdd.Err(), IsNil)
sDiff := t.client.SDiff("set1", "set2")
c.Assert(sDiff.Err(), IsNil)
c.Assert(sortStrings(sDiff.Val()), DeepEquals, []string{"a", "b"})
}
func (t *RedisTest) TestSDiffStore(c *C) {
sAdd := t.client.SAdd("set1", "a")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "b")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "d")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "e")
c.Assert(sAdd.Err(), IsNil)
sDiffStore := t.client.SDiffStore("set", "set1", "set2")
c.Assert(sDiffStore.Err(), IsNil)
c.Assert(sDiffStore.Val(), Equals, int64(2))
sMembers := t.client.SMembers("set")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sortStrings(sMembers.Val()), DeepEquals, []string{"a", "b"})
}
func (t *RedisTest) TestSInter(c *C) {
sAdd := t.client.SAdd("set1", "a")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "b")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "d")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "e")
c.Assert(sAdd.Err(), IsNil)
sInter := t.client.SInter("set1", "set2")
c.Assert(sInter.Err(), IsNil)
c.Assert(sInter.Val(), DeepEquals, []string{"c"})
}
func (t *RedisTest) TestSInterStore(c *C) {
sAdd := t.client.SAdd("set1", "a")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "b")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "d")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "e")
c.Assert(sAdd.Err(), IsNil)
sInterStore := t.client.SInterStore("set", "set1", "set2")
c.Assert(sInterStore.Err(), IsNil)
c.Assert(sInterStore.Val(), Equals, int64(1))
sMembers := t.client.SMembers("set")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sMembers.Val(), DeepEquals, []string{"c"})
}
func (t *RedisTest) TestIsMember(c *C) {
sAdd := t.client.SAdd("set", "one")
c.Assert(sAdd.Err(), IsNil)
sIsMember := t.client.SIsMember("set", "one")
c.Assert(sIsMember.Err(), IsNil)
c.Assert(sIsMember.Val(), Equals, true)
sIsMember = t.client.SIsMember("set", "two")
c.Assert(sIsMember.Err(), IsNil)
c.Assert(sIsMember.Val(), Equals, false)
}
func (t *RedisTest) TestSMembers(c *C) {
sAdd := t.client.SAdd("set", "Hello")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set", "World")
c.Assert(sAdd.Err(), IsNil)
sMembers := t.client.SMembers("set")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sortStrings(sMembers.Val()), DeepEquals, []string{"Hello", "World"})
}
func (t *RedisTest) TestSMove(c *C) {
sAdd := t.client.SAdd("set1", "one")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "two")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "three")
c.Assert(sAdd.Err(), IsNil)
sMove := t.client.SMove("set1", "set2", "two")
c.Assert(sMove.Err(), IsNil)
c.Assert(sMove.Val(), Equals, true)
sMembers := t.client.SMembers("set1")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sMembers.Val(), DeepEquals, []string{"one"})
sMembers = t.client.SMembers("set2")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sortStrings(sMembers.Val()), DeepEquals, []string{"three", "two"})
}
func (t *RedisTest) TestSPop(c *C) {
sAdd := t.client.SAdd("set", "one")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set", "two")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set", "three")
c.Assert(sAdd.Err(), IsNil)
sPop := t.client.SPop("set")
c.Assert(sPop.Err(), IsNil)
c.Assert(sPop.Val(), Not(Equals), "")
sMembers := t.client.SMembers("set")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sMembers.Val(), HasLen, 2)
}
func (t *RedisTest) TestSRandMember(c *C) {
sAdd := t.client.SAdd("set", "one")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set", "two")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set", "three")
c.Assert(sAdd.Err(), IsNil)
sRandMember := t.client.SRandMember("set")
c.Assert(sRandMember.Err(), IsNil)
c.Assert(sRandMember.Val(), Not(Equals), "")
sMembers := t.client.SMembers("set")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sMembers.Val(), HasLen, 3)
}
func (t *RedisTest) TestSRem(c *C) {
sAdd := t.client.SAdd("set", "one")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set", "two")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set", "three")
c.Assert(sAdd.Err(), IsNil)
sRem := t.client.SRem("set", "one")
c.Assert(sRem.Err(), IsNil)
c.Assert(sRem.Val(), Equals, int64(1))
sRem = t.client.SRem("set", "four")
c.Assert(sRem.Err(), IsNil)
c.Assert(sRem.Val(), Equals, int64(0))
sMembers := t.client.SMembers("set")
c.Assert(sMembers.Err(), IsNil)
c.Assert(
sortStrings(sMembers.Val()),
DeepEquals,
[]string{"three", "two"},
)
}
func (t *RedisTest) TestSUnion(c *C) {
sAdd := t.client.SAdd("set1", "a")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "b")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "d")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "e")
c.Assert(sAdd.Err(), IsNil)
sUnion := t.client.SUnion("set1", "set2")
c.Assert(sUnion.Err(), IsNil)
c.Assert(sUnion.Val(), HasLen, 5)
}
func (t *RedisTest) TestSUnionStore(c *C) {
sAdd := t.client.SAdd("set1", "a")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "b")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set1", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "c")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "d")
c.Assert(sAdd.Err(), IsNil)
sAdd = t.client.SAdd("set2", "e")
c.Assert(sAdd.Err(), IsNil)
sUnionStore := t.client.SUnionStore("set", "set1", "set2")
c.Assert(sUnionStore.Err(), IsNil)
c.Assert(sUnionStore.Val(), Equals, int64(5))
sMembers := t.client.SMembers("set")
c.Assert(sMembers.Err(), IsNil)
c.Assert(sMembers.Val(), HasLen, 5)
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestZAdd(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
c.Assert(zAdd.Val(), Equals, int64(1))
zAdd = t.client.ZAdd("zset", redis.Z{1, "uno"})
c.Assert(zAdd.Err(), IsNil)
c.Assert(zAdd.Val(), Equals, int64(1))
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
c.Assert(zAdd.Val(), Equals, int64(1))
zAdd = t.client.ZAdd("zset", redis.Z{3, "two"})
c.Assert(zAdd.Err(), IsNil)
c.Assert(zAdd.Val(), Equals, int64(0))
zRange := t.client.ZRangeWithScores("zset", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"one", "1", "uno", "1", "two", "3"})
}
func (t *RedisTest) TestZCard(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zCard := t.client.ZCard("zset")
c.Assert(zCard.Err(), IsNil)
c.Assert(zCard.Val(), Equals, int64(2))
}
func (t *RedisTest) TestZCount(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zCount := t.client.ZCount("zset", "-inf", "+inf")
c.Assert(zCount.Err(), IsNil)
c.Assert(zCount.Val(), Equals, int64(3))
zCount = t.client.ZCount("zset", "(1", "3")
c.Assert(zCount.Err(), IsNil)
c.Assert(zCount.Val(), Equals, int64(2))
}
func (t *RedisTest) TestZIncrBy(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zIncrBy := t.client.ZIncrBy("zset", 2, "one")
c.Assert(zIncrBy.Err(), IsNil)
c.Assert(zIncrBy.Val(), Equals, float64(3))
zRange := t.client.ZRangeWithScores("zset", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"two", "2", "one", "3"})
}
func (t *RedisTest) TestZInterStore(c *C) {
zAdd := t.client.ZAdd("zset1", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset1", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset2", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset2", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset3", redis.Z{3, "two"})
c.Assert(zAdd.Err(), IsNil)
zInterStore := t.client.ZInterStore(
"out", redis.ZStore{Weights: []int64{2, 3}}, "zset1", "zset2")
c.Assert(zInterStore.Err(), IsNil)
c.Assert(zInterStore.Val(), Equals, int64(2))
zRange := t.client.ZRangeWithScores("out", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"one", "5", "two", "10"})
}
func (t *RedisTest) TestZRange(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRange := t.client.ZRange("zset", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"one", "two", "three"})
zRange = t.client.ZRange("zset", 2, 3)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"three"})
zRange = t.client.ZRange("zset", -2, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"two", "three"})
}
func (t *RedisTest) TestZRangeWithScoresMap(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRange := t.client.ZRangeWithScoresMap("zset", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, map[string]float64{"one": 1, "two": 2, "three": 3})
zRange = t.client.ZRangeWithScoresMap("zset", 2, 3)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, map[string]float64{"three": 3})
zRange = t.client.ZRangeWithScoresMap("zset", -2, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, map[string]float64{"two": 2, "three": 3})
}
func (t *RedisTest) TestZRangeByScore(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRangeByScore := t.client.ZRangeByScore("zset", "-inf", "+inf", 0, 0)
c.Assert(zRangeByScore.Err(), IsNil)
c.Assert(zRangeByScore.Val(), DeepEquals, []string{"one", "two", "three"})
zRangeByScore = t.client.ZRangeByScore("zset", "1", "2", 0, 0)
c.Assert(zRangeByScore.Err(), IsNil)
c.Assert(zRangeByScore.Val(), DeepEquals, []string{"one", "two"})
zRangeByScore = t.client.ZRangeByScore("zset", "(1", "2", 0, 0)
c.Assert(zRangeByScore.Err(), IsNil)
c.Assert(zRangeByScore.Val(), DeepEquals, []string{"two"})
zRangeByScore = t.client.ZRangeByScore("zset", "(1", "(2", 0, 0)
c.Assert(zRangeByScore.Err(), IsNil)
c.Assert(zRangeByScore.Val(), DeepEquals, []string{})
}
func (t *RedisTest) TestZRangeByScoreWithScoresMap(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRangeByScore := t.client.ZRangeByScoreWithScoresMap("zset", "-inf", "+inf", 0, 0)
c.Assert(zRangeByScore.Err(), IsNil)
c.Assert(zRangeByScore.Val(), DeepEquals, map[string]float64{"one": 1, "two": 2, "three": 3})
zRangeByScore = t.client.ZRangeByScoreWithScoresMap("zset", "1", "2", 0, 0)
c.Assert(zRangeByScore.Err(), IsNil)
c.Assert(zRangeByScore.Val(), DeepEquals, map[string]float64{"one": 1, "two": 2})
zRangeByScore = t.client.ZRangeByScoreWithScoresMap("zset", "(1", "2", 0, 0)
c.Assert(zRangeByScore.Err(), IsNil)
c.Assert(zRangeByScore.Val(), DeepEquals, map[string]float64{"two": 2})
zRangeByScore = t.client.ZRangeByScoreWithScoresMap("zset", "(1", "(2", 0, 0)
c.Assert(zRangeByScore.Err(), IsNil)
c.Assert(zRangeByScore.Val(), DeepEquals, map[string]float64{})
}
func (t *RedisTest) TestZRank(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRank := t.client.ZRank("zset", "three")
c.Assert(zRank.Err(), IsNil)
c.Assert(zRank.Val(), Equals, int64(2))
zRank = t.client.ZRank("zset", "four")
c.Assert(zRank.Err(), Equals, redis.Nil)
c.Assert(zRank.Val(), Equals, int64(0))
}
func (t *RedisTest) TestZRem(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRem := t.client.ZRem("zset", "two")
c.Assert(zRem.Err(), IsNil)
c.Assert(zRem.Val(), Equals, int64(1))
zRange := t.client.ZRangeWithScores("zset", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"one", "1", "three", "3"})
}
func (t *RedisTest) TestZRemRangeByRank(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRemRangeByRank := t.client.ZRemRangeByRank("zset", 0, 1)
c.Assert(zRemRangeByRank.Err(), IsNil)
c.Assert(zRemRangeByRank.Val(), Equals, int64(2))
zRange := t.client.ZRangeWithScores("zset", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"three", "3"})
}
func (t *RedisTest) TestZRemRangeByScore(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRemRangeByScore := t.client.ZRemRangeByScore("zset", "-inf", "(2")
c.Assert(zRemRangeByScore.Err(), IsNil)
c.Assert(zRemRangeByScore.Val(), Equals, int64(1))
zRange := t.client.ZRangeWithScores("zset", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"two", "2", "three", "3"})
}
func (t *RedisTest) TestZRevRange(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRevRange := t.client.ZRevRange("zset", "0", "-1")
c.Assert(zRevRange.Err(), IsNil)
c.Assert(zRevRange.Val(), DeepEquals, []string{"three", "two", "one"})
zRevRange = t.client.ZRevRange("zset", "2", "3")
c.Assert(zRevRange.Err(), IsNil)
c.Assert(zRevRange.Val(), DeepEquals, []string{"one"})
zRevRange = t.client.ZRevRange("zset", "-2", "-1")
c.Assert(zRevRange.Err(), IsNil)
c.Assert(zRevRange.Val(), DeepEquals, []string{"two", "one"})
}
func (t *RedisTest) TestZRevRangeWithScoresMap(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRevRange := t.client.ZRevRangeWithScoresMap("zset", "0", "-1")
c.Assert(zRevRange.Err(), IsNil)
c.Assert(zRevRange.Val(), DeepEquals, map[string]float64{"three": 3, "two": 2, "one": 1})
zRevRange = t.client.ZRevRangeWithScoresMap("zset", "2", "3")
c.Assert(zRevRange.Err(), IsNil)
c.Assert(zRevRange.Val(), DeepEquals, map[string]float64{"one": 1})
zRevRange = t.client.ZRevRangeWithScoresMap("zset", "-2", "-1")
c.Assert(zRevRange.Err(), IsNil)
c.Assert(zRevRange.Val(), DeepEquals, map[string]float64{"two": 2, "one": 1})
}
func (t *RedisTest) TestZRevRangeByScore(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRevRangeByScore := t.client.ZRevRangeByScore("zset", "+inf", "-inf", 0, 0)
c.Assert(zRevRangeByScore.Err(), IsNil)
c.Assert(zRevRangeByScore.Val(), DeepEquals, []string{"three", "two", "one"})
zRevRangeByScore = t.client.ZRevRangeByScore("zset", "2", "(1", 0, 0)
c.Assert(zRevRangeByScore.Err(), IsNil)
c.Assert(zRevRangeByScore.Val(), DeepEquals, []string{"two"})
zRevRangeByScore = t.client.ZRevRangeByScore("zset", "(2", "(1", 0, 0)
c.Assert(zRevRangeByScore.Err(), IsNil)
c.Assert(zRevRangeByScore.Val(), DeepEquals, []string{})
}
func (t *RedisTest) TestZRevRangeByScoreWithScoresMap(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRevRangeByScore := t.client.ZRevRangeByScoreWithScoresMap("zset", "+inf", "-inf", 0, 0)
c.Assert(zRevRangeByScore.Err(), IsNil)
c.Assert(zRevRangeByScore.Val(), DeepEquals, map[string]float64{"three": 3, "two": 2, "one": 1})
zRevRangeByScore = t.client.ZRevRangeByScoreWithScoresMap("zset", "2", "(1", 0, 0)
c.Assert(zRevRangeByScore.Err(), IsNil)
c.Assert(zRevRangeByScore.Val(), DeepEquals, map[string]float64{"two": 2})
zRevRangeByScore = t.client.ZRevRangeByScoreWithScoresMap("zset", "(2", "(1", 0, 0)
c.Assert(zRevRangeByScore.Err(), IsNil)
c.Assert(zRevRangeByScore.Val(), DeepEquals, map[string]float64{})
}
func (t *RedisTest) TestZRevRank(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zRevRank := t.client.ZRevRank("zset", "one")
c.Assert(zRevRank.Err(), IsNil)
c.Assert(zRevRank.Val(), Equals, int64(2))
zRevRank = t.client.ZRevRank("zset", "four")
c.Assert(zRevRank.Err(), Equals, redis.Nil)
c.Assert(zRevRank.Val(), Equals, int64(0))
}
func (t *RedisTest) TestZScore(c *C) {
zAdd := t.client.ZAdd("zset", redis.Z{1.001, "one"})
c.Assert(zAdd.Err(), IsNil)
zScore := t.client.ZScore("zset", "one")
c.Assert(zScore.Err(), IsNil)
c.Assert(zScore.Val(), Equals, float64(1.001))
}
func (t *RedisTest) TestZUnionStore(c *C) {
zAdd := t.client.ZAdd("zset1", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset1", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset2", redis.Z{1, "one"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset2", redis.Z{2, "two"})
c.Assert(zAdd.Err(), IsNil)
zAdd = t.client.ZAdd("zset2", redis.Z{3, "three"})
c.Assert(zAdd.Err(), IsNil)
zUnionStore := t.client.ZUnionStore(
"out", redis.ZStore{Weights: []int64{2, 3}}, "zset1", "zset2")
c.Assert(zUnionStore.Err(), IsNil)
c.Assert(zUnionStore.Val(), Equals, int64(3))
zRange := t.client.ZRangeWithScores("out", 0, -1)
c.Assert(zRange.Err(), IsNil)
c.Assert(zRange.Val(), DeepEquals, []string{"one", "5", "three", "9", "two", "10"})
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestPatternPubSub(c *C) {
pubsub, err := t.client.PubSubClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(pubsub.Close(), IsNil)
}()
ch, err := pubsub.PSubscribe("mychannel*")
c.Assert(err, IsNil)
c.Assert(ch, Not(IsNil))
pub := t.client.Publish("mychannel1", "hello")
c.Assert(pub.Err(), IsNil)
c.Assert(pub.Val(), Equals, int64(1))
err = pubsub.PUnsubscribe("mychannel*")
c.Assert(err, IsNil)
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "psubscribe")
c.Assert(msg.Channel, Equals, "mychannel*")
c.Assert(msg.Number, Equals, int64(1))
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "pmessage")
c.Assert(msg.ChannelPattern, Equals, "mychannel*")
c.Assert(msg.Channel, Equals, "mychannel1")
c.Assert(msg.Message, Equals, "hello")
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "punsubscribe")
c.Assert(msg.Channel, Equals, "mychannel*")
c.Assert(msg.Number, Equals, int64(0))
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
}
func (t *RedisTest) TestPubSub(c *C) {
pubsub, err := t.client.PubSubClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(pubsub.Close(), IsNil)
}()
ch, err := pubsub.Subscribe("mychannel")
c.Assert(err, IsNil)
c.Assert(ch, Not(IsNil))
ch2, err := pubsub.Subscribe("mychannel2")
c.Assert(err, IsNil)
c.Assert(ch2, Equals, ch)
pub := t.client.Publish("mychannel", "hello")
c.Assert(pub.Err(), IsNil)
c.Assert(pub.Val(), Equals, int64(1))
pub = t.client.Publish("mychannel2", "hello2")
c.Assert(pub.Err(), IsNil)
c.Assert(pub.Val(), Equals, int64(1))
err = pubsub.Unsubscribe("mychannel")
c.Assert(err, IsNil)
err = pubsub.Unsubscribe("mychannel2")
c.Assert(err, IsNil)
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "subscribe")
c.Assert(msg.Channel, Equals, "mychannel")
c.Assert(msg.Number, Equals, int64(1))
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "subscribe")
c.Assert(msg.Channel, Equals, "mychannel2")
c.Assert(msg.Number, Equals, int64(2))
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "message")
c.Assert(msg.Channel, Equals, "mychannel")
c.Assert(msg.Message, Equals, "hello")
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "message")
c.Assert(msg.Channel, Equals, "mychannel2")
c.Assert(msg.Message, Equals, "hello2")
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "unsubscribe")
c.Assert(msg.Channel, Equals, "mychannel")
c.Assert(msg.Number, Equals, int64(1))
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
select {
case msg := <-ch:
c.Assert(msg.Err, Equals, nil)
c.Assert(msg.Name, Equals, "unsubscribe")
c.Assert(msg.Channel, Equals, "mychannel2")
c.Assert(msg.Number, Equals, int64(0))
case <-time.After(time.Second):
c.Error("Channel is empty.")
}
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestPipeline(c *C) {
set := t.client.Set("key2", "hello2")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
pipeline, err := t.client.PipelineClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(pipeline.Close(), IsNil)
}()
set = pipeline.Set("key1", "hello1")
get := pipeline.Get("key2")
incr := pipeline.Incr("key3")
getNil := pipeline.Get("key4")
reqs, err := pipeline.RunQueued()
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 4)
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello2")
c.Assert(incr.Err(), IsNil)
c.Assert(incr.Val(), Equals, int64(1))
c.Assert(getNil.Err(), Equals, redis.Nil)
c.Assert(getNil.Val(), Equals, "")
}
func (t *RedisTest) TestPipelineDiscardQueued(c *C) {
pipeline, err := t.client.PipelineClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(pipeline.Close(), IsNil)
}()
pipeline.Get("key")
pipeline.DiscardQueued()
reqs, err := pipeline.RunQueued()
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 0)
}
func (t *RedisTest) TestPipelineFunc(c *C) {
var get *redis.StringReq
reqs, err := t.client.Pipelined(func(c *redis.PipelineClient) {
get = c.Get("foo")
})
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 1)
c.Assert(get.Err(), Equals, redis.Nil)
c.Assert(get.Val(), Equals, "")
}
func (t *RedisTest) TestPipelineErrValNotSet(c *C) {
pipeline, err := t.client.PipelineClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(pipeline.Close(), IsNil)
}()
get := pipeline.Get("key")
c.Assert(get.Err(), ErrorMatches, "redis: value is not set")
}
func (t *RedisTest) TestPipelineRunQueuedOnEmptyQueue(c *C) {
pipeline, err := t.client.PipelineClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(pipeline.Close(), IsNil)
}()
reqs, err := pipeline.RunQueued()
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 0)
}
func (t *RedisTest) TestPipelineIncrFromGoroutines(c *C) {
pipeline, err := t.client.PipelineClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(pipeline.Close(), IsNil)
}()
wg := &sync.WaitGroup{}
for i := int64(0); i < 20000; i++ {
wg.Add(1)
go func() {
pipeline.Incr("TestIncrPipeliningFromGoroutinesKey")
wg.Done()
}()
}
wg.Wait()
reqs, err := pipeline.RunQueued()
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 20000)
for _, req := range reqs {
if req.Err() != nil {
c.Errorf("got %v, expected nil", req.Err())
}
}
get := t.client.Get("TestIncrPipeliningFromGoroutinesKey")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "20000")
}
func (t *RedisTest) TestPipelineEchoFromGoroutines(c *C) {
pipeline, err := t.client.PipelineClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(pipeline.Close(), IsNil)
}()
wg := &sync.WaitGroup{}
for i := int64(0); i < 1000; i += 2 {
wg.Add(1)
go func() {
msg1 := "echo" + strconv.FormatInt(i, 10)
msg2 := "echo" + strconv.FormatInt(i+1, 10)
echo1 := pipeline.Echo(msg1)
echo2 := pipeline.Echo(msg2)
reqs, err := pipeline.RunQueued()
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 2)
c.Assert(echo1.Err(), IsNil)
c.Assert(echo1.Val(), Equals, msg1)
c.Assert(echo2.Err(), IsNil)
c.Assert(echo2.Val(), Equals, msg2)
wg.Done()
}()
}
wg.Wait()
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestMultiExec(c *C) {
multi, err := t.client.MultiClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(multi.Close(), IsNil)
}()
var (
set *redis.StatusReq
get *redis.StringReq
)
reqs, err := multi.Exec(func() {
set = multi.Set("key", "hello")
get = multi.Get("key")
})
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 2)
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
func (t *RedisTest) TestMultiExecDiscard(c *C) {
multi, err := t.client.MultiClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(multi.Close(), IsNil)
}()
reqs, err := multi.Exec(func() {
multi.Set("key1", "hello1")
multi.Discard()
multi.Set("key2", "hello2")
})
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 1)
get := t.client.Get("key1")
c.Assert(get.Err(), Equals, redis.Nil)
c.Assert(get.Val(), Equals, "")
get = t.client.Get("key2")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello2")
}
func (t *RedisTest) TestMultiExecEmpty(c *C) {
multi, err := t.client.MultiClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(multi.Close(), IsNil)
}()
reqs, err := multi.Exec(func() {})
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 0)
ping := multi.Ping()
c.Check(ping.Err(), IsNil)
c.Check(ping.Val(), Equals, "PONG")
}
func (t *RedisTest) TestMultiExecOnEmptyQueue(c *C) {
multi, err := t.client.MultiClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(multi.Close(), IsNil)
}()
reqs, err := multi.Exec(func() {})
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 0)
}
func (t *RedisTest) TestMultiExecIncrTransaction(c *C) {
multi, err := t.client.MultiClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(multi.Close(), IsNil)
}()
reqs, err := multi.Exec(func() {
for i := int64(0); i < 20000; i++ {
multi.Incr("TestIncrTransactionKey")
}
})
c.Assert(err, IsNil)
c.Assert(reqs, HasLen, 20000)
for _, req := range reqs {
if req.Err() != nil {
c.Errorf("got %v, expected nil", req.Err())
}
}
get := t.client.Get("TestIncrTransactionKey")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "20000")
}
func (t *RedisTest) transactionalIncr(c *C) ([]redis.Req, error) {
multi, err := t.client.MultiClient()
c.Assert(err, IsNil)
defer func() {
c.Assert(multi.Close(), IsNil)
}()
watch := multi.Watch("key")
c.Assert(watch.Err(), IsNil)
c.Assert(watch.Val(), Equals, "OK")
get := multi.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Not(Equals), redis.Nil)
v, err := strconv.ParseInt(get.Val(), 10, 64)
c.Assert(err, IsNil)
reqs, err := multi.Exec(func() {
multi.Set("key", strconv.FormatInt(v+1, 10))
})
if err == redis.Nil {
return t.transactionalIncr(c)
}
return reqs, err
}
func (t *RedisTest) TestWatchUnwatch(c *C) {
set := t.client.Set("key", "0")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
wg := &sync.WaitGroup{}
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
reqs, err := t.transactionalIncr(c)
c.Assert(reqs, HasLen, 1)
c.Assert(err, IsNil)
c.Assert(reqs[0].Err(), IsNil)
wg.Done()
}()
}
wg.Wait()
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "1000")
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestSyncEchoFromGoroutines(c *C) {
wg := &sync.WaitGroup{}
for i := int64(0); i < 1000; i++ {
wg.Add(1)
go func() {
msg := "echo" + strconv.FormatInt(i, 10)
echo := t.client.Echo(msg)
c.Assert(echo.Err(), IsNil)
c.Assert(echo.Val(), Equals, msg)
wg.Done()
}()
}
wg.Wait()
}
func (t *RedisTest) TestIncrFromGoroutines(c *C) {
wg := &sync.WaitGroup{}
for i := int64(0); i < 20000; i++ {
wg.Add(1)
go func() {
incr := t.client.Incr("TestIncrFromGoroutinesKey")
c.Assert(incr.Err(), IsNil)
wg.Done()
}()
}
wg.Wait()
get := t.client.Get("TestIncrFromGoroutinesKey")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "20000")
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestCmdBgRewriteAOF(c *C) {
r := t.client.BgRewriteAOF()
c.Assert(r.Err(), IsNil)
c.Assert(r.Val(), Equals, "Background append only file rewriting started")
}
func (t *RedisTest) TestCmdBgSave(c *C) {
// workaround for "ERR Can't BGSAVE while AOF log rewriting is in progress"
time.Sleep(time.Second)
r := t.client.BgSave()
c.Assert(r.Err(), IsNil)
c.Assert(r.Val(), Equals, "Background saving started")
}
func (t *RedisTest) TestCmdClientKill(c *C) {
r := t.client.ClientKill("1.1.1.1:1111")
c.Assert(r.Err(), ErrorMatches, "ERR No such client")
c.Assert(r.Val(), Equals, "")
}
func (t *RedisTest) TestCmdConfigGet(c *C) {
r := t.client.ConfigGet("*")
c.Assert(r.Err(), IsNil)
c.Assert(len(r.Val()) > 0, Equals, true)
}
func (t *RedisTest) TestCmdConfigResetStat(c *C) {
r := t.client.ConfigResetStat()
c.Assert(r.Err(), IsNil)
c.Assert(r.Val(), Equals, "OK")
}
func (t *RedisTest) TestCmdConfigSet(c *C) {
configGet := t.client.ConfigGet("maxmemory")
c.Assert(configGet.Err(), IsNil)
c.Assert(configGet.Val(), HasLen, 2)
c.Assert(configGet.Val()[0], Equals, "maxmemory")
configSet := t.client.ConfigSet("maxmemory", configGet.Val()[1].(string))
c.Assert(configSet.Err(), IsNil)
c.Assert(configSet.Val(), Equals, "OK")
}
func (t *RedisTest) TestCmdDbSize(c *C) {
dbSize := t.client.DbSize()
c.Assert(dbSize.Err(), IsNil)
c.Assert(dbSize.Val(), Equals, int64(0))
}
func (t *RedisTest) TestCmdFlushAll(c *C) {
// TODO
}
func (t *RedisTest) TestCmdFlushDb(c *C) {
// TODO
}
func (t *RedisTest) TestCmdInfo(c *C) {
info := t.client.Info()
c.Assert(info.Err(), IsNil)
c.Assert(info.Val(), Not(Equals), "")
}
func (t *RedisTest) TestCmdLastSave(c *C) {
lastSave := t.client.LastSave()
c.Assert(lastSave.Err(), IsNil)
c.Assert(lastSave.Val(), Not(Equals), 0)
}
func (t *RedisTest) TestCmdSave(c *C) {
save := t.client.Save()
c.Assert(save.Err(), IsNil)
c.Assert(save.Val(), Equals, "OK")
}
func (t *RedisTest) TestSlaveOf(c *C) {
slaveOf := t.client.SlaveOf("localhost", "8888")
c.Assert(slaveOf.Err(), IsNil)
c.Assert(slaveOf.Val(), Equals, "OK")
slaveOf = t.client.SlaveOf("NO", "ONE")
c.Assert(slaveOf.Err(), IsNil)
c.Assert(slaveOf.Val(), Equals, "OK")
}
func (t *RedisTest) TestTime(c *C) {
time := t.client.Time()
c.Assert(time.Err(), IsNil)
c.Assert(time.Val(), HasLen, 2)
}
//------------------------------------------------------------------------------
func (t *RedisTest) TestScriptingEval(c *C) {
eval := t.client.Eval(
"return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}",
[]string{"key1", "key2"},
[]string{"first", "second"},
)
c.Assert(eval.Err(), IsNil)
c.Assert(eval.Val(), DeepEquals, []interface{}{"key1", "key2", "first", "second"})
eval = t.client.Eval(
"return redis.call('set',KEYS[1],'bar')",
[]string{"foo"},
[]string{},
)
c.Assert(eval.Err(), IsNil)
c.Assert(eval.Val(), Equals, "OK")
eval = t.client.Eval("return 10", []string{}, []string{})
c.Assert(eval.Err(), IsNil)
c.Assert(eval.Val(), Equals, int64(10))
eval = t.client.Eval("return {1,2,{3,'Hello World!'}}", []string{}, []string{})
c.Assert(eval.Err(), IsNil)
// DeepEquals can't compare nested slices.
c.Assert(
fmt.Sprintf("%#v", eval.Val()),
Equals,
`[]interface {}{1, 2, []interface {}{3, "Hello World!"}}`,
)
}
func (t *RedisTest) TestScriptingEvalSha(c *C) {
set := t.client.Set("foo", "bar")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
eval := t.client.Eval("return redis.call('get','foo')", []string{}, []string{})
c.Assert(eval.Err(), IsNil)
c.Assert(eval.Val(), Equals, "bar")
evalSha := t.client.EvalSha("6b1bf486c81ceb7edf3c093f4c48582e38c0e791", []string{}, []string{})
c.Assert(evalSha.Err(), IsNil)
c.Assert(evalSha.Val(), Equals, "bar")
evalSha = t.client.EvalSha("ffffffffffffffffffffffffffffffffffffffff", []string{}, []string{})
c.Assert(evalSha.Err(), ErrorMatches, "NOSCRIPT No matching script. Please use EVAL.")
c.Assert(evalSha.Val(), Equals, nil)
}
func (t *RedisTest) TestScriptingScriptExists(c *C) {
scriptLoad := t.client.ScriptLoad("return 1")
c.Assert(scriptLoad.Err(), IsNil)
c.Assert(scriptLoad.Val(), Equals, "e0e1f9fabfc9d4800c877a703b823ac0578ff8db")
scriptExists := t.client.ScriptExists(
"e0e1f9fabfc9d4800c877a703b823ac0578ff8db",
"ffffffffffffffffffffffffffffffffffffffff",
)
c.Assert(scriptExists.Err(), IsNil)
c.Assert(scriptExists.Val(), DeepEquals, []bool{true, false})
}
func (t *RedisTest) TestScriptingScriptFlush(c *C) {
scriptFlush := t.client.ScriptFlush()
c.Assert(scriptFlush.Err(), IsNil)
c.Assert(scriptFlush.Val(), Equals, "OK")
}
func (t *RedisTest) TestScriptingScriptKill(c *C) {
scriptKill := t.client.ScriptKill()
c.Assert(scriptKill.Err(), ErrorMatches, ".*No scripts in execution right now.")
c.Assert(scriptKill.Val(), Equals, "")
}
func (t *RedisTest) TestScriptingScriptLoad(c *C) {
scriptLoad := t.client.ScriptLoad("return redis.call('get','foo')")
c.Assert(scriptLoad.Err(), IsNil)
c.Assert(scriptLoad.Val(), Equals, "6b1bf486c81ceb7edf3c093f4c48582e38c0e791")
}
//------------------------------------------------------------------------------
func (t *RedisTest) BenchmarkRedisPing(c *C) {
c.StopTimer()
runtime.LockOSThread()
t.client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
for i := 0; i < 10; i++ {
ping := t.client.Ping()
c.Assert(ping.Err(), IsNil)
c.Assert(ping.Val(), Equals, "PONG")
}
c.StartTimer()
for i := 0; i < c.N; i++ {
t.client.Ping()
}
}
func (t *RedisTest) BenchmarkRedisSet(c *C) {
c.StopTimer()
runtime.LockOSThread()
t.client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
for i := 0; i < 10; i++ {
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
c.Assert(set.Val(), Equals, "OK")
}
c.StartTimer()
for i := 0; i < c.N; i++ {
t.client.Set("key", "hello")
}
}
func (t *RedisTest) BenchmarkRedisGetNil(c *C) {
c.StopTimer()
runtime.LockOSThread()
t.client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
for i := 0; i < 10; i++ {
get := t.client.Get("key")
c.Assert(get.Err(), Equals, redis.Nil)
c.Assert(get.Val(), Equals, "")
}
c.StartTimer()
for i := 0; i < c.N; i++ {
t.client.Get("key")
}
}
func (t *RedisTest) BenchmarkRedisGet(c *C) {
c.StopTimer()
runtime.LockOSThread()
t.client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
set := t.client.Set("key", "hello")
c.Assert(set.Err(), IsNil)
for i := 0; i < 10; i++ {
get := t.client.Get("key")
c.Assert(get.Err(), IsNil)
c.Assert(get.Val(), Equals, "hello")
}
c.StartTimer()
for i := 0; i < c.N; i++ {
t.client.Get("key")
}
}
func (t *RedisTest) BenchmarkRedisMGet(c *C) {
c.StopTimer()
runtime.LockOSThread()
t.client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
mSet := t.client.MSet("key1", "hello1", "key2", "hello2")
c.Assert(mSet.Err(), IsNil)
for i := 0; i < 10; i++ {
mGet := t.client.MGet("key1", "key2")
c.Assert(mGet.Err(), IsNil)
c.Assert(mGet.Val(), DeepEquals, []interface{}{"hello1", "hello2"})
}
c.StartTimer()
for i := 0; i < c.N; i++ {
t.client.MGet("key1", "key2")
}
}
func (t *RedisTest) BenchmarkRedisWriteRead(c *C) {
c.StopTimer()
runtime.LockOSThread()
conn, _, err := t.client.ConnPool.Get()
c.Assert(err, IsNil)
for i := 0; i < 10; i++ {
err := t.client.WriteReq(conn, redis.NewStatusReq("PING"))
c.Assert(err, IsNil)
line, _, err := conn.Rd.ReadLine()
c.Assert(err, IsNil)
c.Assert(line, DeepEquals, []byte("+PONG"))
}
c.StartTimer()
for i := 0; i < c.N; i++ {
t.client.WriteReq(conn, redis.NewStatusReq("PING"))
conn.Rd.ReadLine()
}
c.StopTimer()
t.client.ConnPool.Add(conn)
c.StartTimer()
}
Reference in New Issue View Git Blame Copy Permalink