zeromicro
/
go-zero
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: add more tests (#3954)

Browse Source
master^2
Kevin Wan 9 months ago committed by GitHub
parent 0ee44c7064
commit 8e97c5819f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 133 additions and 124 deletions
Show Stats Download Patch File Download Diff File

3
core/stores/redis/redis.go
Unescape Escape View File

@ -2080,7 +2080,8 @@ func (s *Redis) Zaddnx(key string, score int64, value string) (val bool, err err
} }
// ZaddnxCtx is the implementation of redis zadd nx command. // ZaddnxCtx is the implementation of redis zadd nx command.
func (s *Redis) ZaddnxCtx(ctx context.Context, key string, score int64, value string) (val bool, err error) { func (s *Redis) ZaddnxCtx(ctx context.Context, key string, score int64, value string) (
val bool, err error) {
return s.ZaddnxFloatCtx(ctx, key, float64(score), value) return s.ZaddnxFloatCtx(ctx, key, float64(score), value)
} }

254
core/stores/redis/redis_test.go
Unescape Escape View File

@ -177,7 +177,7 @@ func TestRedis_NonBlock(t *testing.T) {
func TestRedis_Decr(t *testing.T) { func TestRedis_Decr(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Decr("a") _, err := newRedis(client.Addr, badType()).Decr("a")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Decr("a") val, err := client.Decr("a")
assert.Nil(t, err) assert.Nil(t, err)
@ -190,7 +190,7 @@ func TestRedis_Decr(t *testing.T) {
func TestRedis_DecrBy(t *testing.T) { func TestRedis_DecrBy(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Decrby("a", 2) _, err := newRedis(client.Addr, badType()).Decrby("a", 2)
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Decrby("a", 2) val, err := client.Decrby("a", 2)
assert.Nil(t, err) assert.Nil(t, err)
@ -203,7 +203,7 @@ func TestRedis_DecrBy(t *testing.T) {
func TestRedis_Exists(t *testing.T) { func TestRedis_Exists(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Exists("a") _, err := newRedis(client.Addr, badType()).Exists("a")
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err := client.Exists("a") ok, err := client.Exists("a")
assert.Nil(t, err) assert.Nil(t, err)
@ -217,7 +217,7 @@ func TestRedis_Exists(t *testing.T) {
func TestRedisTLS_Exists(t *testing.T) { func TestRedisTLS_Exists(t *testing.T) {
runOnRedisTLS(t, func(client *Redis) { runOnRedisTLS(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Exists("a") _, err := newRedis(client.Addr, badType()).Exists("a")
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err := client.Exists("a") ok, err := client.Exists("a")
assert.NotNil(t, err) assert.NotNil(t, err)
@ -232,7 +232,7 @@ func TestRedisTLS_Exists(t *testing.T) {
func TestRedis_ExistsMany(t *testing.T) { func TestRedis_ExistsMany(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
// Attempt to create a new Redis instance with an incorrect type and call ExistsMany // Attempt to create a new Redis instance with an incorrect type and call ExistsMany
_, err := New(client.Addr, badType()).ExistsMany("key1", "key2") _, err := newRedis(client.Addr, badType()).ExistsMany("key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
// Check if key1 and key2 exist, expecting that they do not // Check if key1 and key2 exist, expecting that they do not
@ -261,7 +261,7 @@ func TestRedis_ExistsMany(t *testing.T) {
func TestRedis_Eval(t *testing.T) { func TestRedis_Eval(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"}) _, err := newRedis(client.Addr, badType()).Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"})
assert.NotNil(t, err) assert.NotNil(t, err)
_, err = client.Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"}) _, err = client.Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"})
assert.Equal(t, Nil, err) assert.Equal(t, Nil, err)
@ -279,7 +279,7 @@ func TestRedis_ScriptRun(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
sc := NewScript(`redis.call("EXISTS", KEYS[1])`) sc := NewScript(`redis.call("EXISTS", KEYS[1])`)
sc2 := NewScript(`return redis.call("EXISTS", KEYS[1])`) sc2 := NewScript(`return redis.call("EXISTS", KEYS[1])`)
_, err := New(client.Addr, badType()).ScriptRun(sc, []string{"notexist"}) _, err := newRedis(client.Addr, badType()).ScriptRun(sc, []string{"notexist"})
assert.NotNil(t, err) assert.NotNil(t, err)
_, err = client.ScriptRun(sc, []string{"notexist"}) _, err = client.ScriptRun(sc, []string{"notexist"})
assert.Equal(t, Nil, err) assert.Equal(t, Nil, err)
@ -297,7 +297,7 @@ func TestRedis_GeoHash(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := client.GeoHash("parent", "child1", "child2") _, err := client.GeoHash("parent", "child1", "child2")
assert.Error(t, err) assert.Error(t, err)
_, err = New(client.Addr, badType()).GeoHash("parent", "child1", "child2") _, err = newRedis(client.Addr, badType()).GeoHash("parent", "child1", "child2")
assert.Error(t, err) assert.Error(t, err)
}) })
} }
@ -306,7 +306,7 @@ func TestRedis_Hgetall(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "aa", "aaa"))
assert.Nil(t, client.Hset("a", "bb", "bbb")) assert.Nil(t, client.Hset("a", "bb", "bbb"))
_, err := New(client.Addr, badType()).Hgetall("a") _, err := newRedis(client.Addr, badType()).Hgetall("a")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err := client.Hgetall("a") vals, err := client.Hgetall("a")
assert.Nil(t, err) assert.Nil(t, err)
@ -319,10 +319,10 @@ func TestRedis_Hgetall(t *testing.T) {
func TestRedis_Hvals(t *testing.T) { func TestRedis_Hvals(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
assert.NotNil(t, New(client.Addr, badType()).Hset("a", "aa", "aaa")) assert.NotNil(t, newRedis(client.Addr, badType()).Hset("a", "aa", "aaa"))
assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "aa", "aaa"))
assert.Nil(t, client.Hset("a", "bb", "bbb")) assert.Nil(t, client.Hset("a", "bb", "bbb"))
_, err := New(client.Addr, badType()).Hvals("a") _, err := newRedis(client.Addr, badType()).Hvals("a")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err := client.Hvals("a") vals, err := client.Hvals("a")
assert.Nil(t, err) assert.Nil(t, err)
@ -334,7 +334,7 @@ func TestRedis_Hsetnx(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "aa", "aaa"))
assert.Nil(t, client.Hset("a", "bb", "bbb")) assert.Nil(t, client.Hset("a", "bb", "bbb"))
_, err := New(client.Addr, badType()).Hsetnx("a", "bb", "ccc") _, err := newRedis(client.Addr, badType()).Hsetnx("a", "bb", "ccc")
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err := client.Hsetnx("a", "bb", "ccc") ok, err := client.Hsetnx("a", "bb", "ccc")
assert.Nil(t, err) assert.Nil(t, err)
@ -352,7 +352,7 @@ func TestRedis_HdelHlen(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "aa", "aaa"))
assert.Nil(t, client.Hset("a", "bb", "bbb")) assert.Nil(t, client.Hset("a", "bb", "bbb"))
_, err := New(client.Addr, badType()).Hlen("a") _, err := newRedis(client.Addr, badType()).Hlen("a")
assert.NotNil(t, err) assert.NotNil(t, err)
num, err := client.Hlen("a") num, err := client.Hlen("a")
assert.Nil(t, err) assert.Nil(t, err)
@ -368,7 +368,7 @@ func TestRedis_HdelHlen(t *testing.T) {
func TestRedis_HIncrBy(t *testing.T) { func TestRedis_HIncrBy(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Hincrby("key", "field", 2) _, err := newRedis(client.Addr, badType()).Hincrby("key", "field", 2)
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Hincrby("key", "field", 2) val, err := client.Hincrby("key", "field", 2)
assert.Nil(t, err) assert.Nil(t, err)
@ -383,7 +383,7 @@ func TestRedis_Hkeys(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "aa", "aaa"))
assert.Nil(t, client.Hset("a", "bb", "bbb")) assert.Nil(t, client.Hset("a", "bb", "bbb"))
_, err := New(client.Addr, badType()).Hkeys("a") _, err := newRedis(client.Addr, badType()).Hkeys("a")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err := client.Hkeys("a") vals, err := client.Hkeys("a")
assert.Nil(t, err) assert.Nil(t, err)
@ -395,7 +395,7 @@ func TestRedis_Hmget(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "aa", "aaa"))
assert.Nil(t, client.Hset("a", "bb", "bbb")) assert.Nil(t, client.Hset("a", "bb", "bbb"))
_, err := New(client.Addr, badType()).Hmget("a", "aa", "bb") _, err := newRedis(client.Addr, badType()).Hmget("a", "aa", "bb")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err := client.Hmget("a", "aa", "bb") vals, err := client.Hmget("a", "aa", "bb")
assert.Nil(t, err) assert.Nil(t, err)
@ -408,7 +408,7 @@ func TestRedis_Hmget(t *testing.T) {
func TestRedis_Hmset(t *testing.T) { func TestRedis_Hmset(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
assert.NotNil(t, New(client.Addr, badType()).Hmset("a", nil)) assert.NotNil(t, newRedis(client.Addr, badType()).Hmset("a", nil))
assert.Nil(t, client.Hmset("a", map[string]string{ assert.Nil(t, client.Hmset("a", map[string]string{
"aa": "aaa", "aa": "aaa",
"bb": "bbb", "bb": "bbb",
@ -433,7 +433,7 @@ func TestRedis_Hscan(t *testing.T) {
var cursor uint64 = 0 var cursor uint64 = 0
sum := 0 sum := 0
for { for {
_, _, err := New(client.Addr, badType()).Hscan(key, cursor, "*", 100) _, _, err := newRedis(client.Addr, badType()).Hscan(key, cursor, "*", 100)
assert.NotNil(t, err) assert.NotNil(t, err)
reMap, next, err := client.Hscan(key, cursor, "*", 100) reMap, next, err := client.Hscan(key, cursor, "*", 100)
assert.Nil(t, err) assert.Nil(t, err)
@ -445,7 +445,7 @@ func TestRedis_Hscan(t *testing.T) {
} }
assert.Equal(t, sum, 3100) assert.Equal(t, sum, 3100)
_, err = New(client.Addr, badType()).Del(key) _, err = newRedis(client.Addr, badType()).Del(key)
assert.Error(t, err) assert.Error(t, err)
_, err = client.Del(key) _, err = client.Del(key)
assert.NoError(t, err) assert.NoError(t, err)
@ -462,7 +462,7 @@ func TestRedis_Hscan(t *testing.T) {
func TestRedis_Incr(t *testing.T) { func TestRedis_Incr(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Incr("a") _, err := newRedis(client.Addr, badType()).Incr("a")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Incr("a") val, err := client.Incr("a")
assert.Nil(t, err) assert.Nil(t, err)
@ -475,7 +475,7 @@ func TestRedis_Incr(t *testing.T) {
func TestRedis_IncrBy(t *testing.T) { func TestRedis_IncrBy(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Incrby("a", 2) _, err := newRedis(client.Addr, badType()).Incrby("a", 2)
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Incrby("a", 2) val, err := client.Incrby("a", 2)
assert.Nil(t, err) assert.Nil(t, err)
@ -492,7 +492,7 @@ func TestRedis_Keys(t *testing.T) {
assert.Nil(t, err) assert.Nil(t, err)
err = client.Set("key2", "value2") err = client.Set("key2", "value2")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).Keys("*") _, err = newRedis(client.Addr, badType()).Keys("*")
assert.NotNil(t, err) assert.NotNil(t, err)
keys, err := client.Keys("*") keys, err := client.Keys("*")
assert.Nil(t, err) assert.Nil(t, err)
@ -504,13 +504,13 @@ func TestRedis_HyperLogLog(t *testing.T) {
t.Run("hyperloglog", func(t *testing.T) { t.Run("hyperloglog", func(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
client.Ping() client.Ping()
r := New(client.Addr) r := newRedis(client.Addr)
_, err := New(client.Addr, badType()).Pfadd("key1", "val1") _, err := newRedis(client.Addr, badType()).Pfadd("key1", "val1")
assert.Error(t, err) assert.Error(t, err)
ok, err := r.Pfadd("key1", "val1") ok, err := r.Pfadd("key1", "val1")
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, ok) assert.True(t, ok)
_, err = New(client.Addr, badType()).Pfcount("key1") _, err = newRedis(client.Addr, badType()).Pfcount("key1")
assert.Error(t, err) assert.Error(t, err)
val, err := r.Pfcount("key1") val, err := r.Pfcount("key1")
assert.Nil(t, err) assert.Nil(t, err)
@ -521,7 +521,7 @@ func TestRedis_HyperLogLog(t *testing.T) {
val, err = r.Pfcount("key2") val, err = r.Pfcount("key2")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(1), val) assert.Equal(t, int64(1), val)
err = New(client.Addr, badType()).Pfmerge("key3", "key1", "key2") err = newRedis(client.Addr, badType()).Pfmerge("key3", "key1", "key2")
assert.Error(t, err) assert.Error(t, err)
err = r.Pfmerge("key1", "key2") err = r.Pfmerge("key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
@ -542,22 +542,22 @@ func TestRedis_HyperLogLog(t *testing.T) {
func TestRedis_List(t *testing.T) { func TestRedis_List(t *testing.T) {
t.Run("list", func(t *testing.T) { t.Run("list", func(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Lpush("key", "value1", "value2") _, err := newRedis(client.Addr, badType()).Lpush("key", "value1", "value2")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Lpush("key", "value1", "value2") val, err := client.Lpush("key", "value1", "value2")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 2, val) assert.Equal(t, 2, val)
_, err = New(client.Addr, badType()).Rpush("key", "value3", "value4") _, err = newRedis(client.Addr, badType()).Rpush("key", "value3", "value4")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err = client.Rpush("key", "value3", "value4") val, err = client.Rpush("key", "value3", "value4")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 4, val) assert.Equal(t, 4, val)
_, err = New(client.Addr, badType()).Llen("key") _, err = newRedis(client.Addr, badType()).Llen("key")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err = client.Llen("key") val, err = client.Llen("key")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 4, val) assert.Equal(t, 4, val)
_, err = New(client.Addr, badType()).Lindex("key", 1) _, err = newRedis(client.Addr, badType()).Lindex("key", 1)
assert.NotNil(t, err) assert.NotNil(t, err)
value, err := client.Lindex("key", 0) value, err := client.Lindex("key", 0)
assert.Nil(t, err) assert.Nil(t, err)
@ -565,7 +565,7 @@ func TestRedis_List(t *testing.T) {
vals, err := client.Lrange("key", 0, 10) vals, err := client.Lrange("key", 0, 10)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []string{"value2", "value1", "value3", "value4"}, vals) assert.EqualValues(t, []string{"value2", "value1", "value3", "value4"}, vals)
_, err = New(client.Addr, badType()).Lpop("key") _, err = newRedis(client.Addr, badType()).Lpop("key")
assert.NotNil(t, err) assert.NotNil(t, err)
v, err := client.Lpop("key") v, err := client.Lpop("key")
assert.Nil(t, err) assert.Nil(t, err)
@ -573,7 +573,7 @@ func TestRedis_List(t *testing.T) {
val, err = client.Lpush("key", "value1", "value2") val, err = client.Lpush("key", "value1", "value2")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 5, val) assert.Equal(t, 5, val)
_, err = New(client.Addr, badType()).Rpop("key") _, err = newRedis(client.Addr, badType()).Rpop("key")
assert.NotNil(t, err) assert.NotNil(t, err)
v, err = client.Rpop("key") v, err = client.Rpop("key")
assert.Nil(t, err) assert.Nil(t, err)
@ -581,12 +581,12 @@ func TestRedis_List(t *testing.T) {
val, err = client.Rpush("key", "value4", "value3", "value3") val, err = client.Rpush("key", "value4", "value3", "value3")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 7, val) assert.Equal(t, 7, val)
_, err = New(client.Addr, badType()).Lrem("key", 2, "value1") _, err = newRedis(client.Addr, badType()).Lrem("key", 2, "value1")
assert.NotNil(t, err) assert.NotNil(t, err)
n, err := client.Lrem("key", 2, "value1") n, err := client.Lrem("key", 2, "value1")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 2, n) assert.Equal(t, 2, n)
_, err = New(client.Addr, badType()).Lrange("key", 0, 10) _, err = newRedis(client.Addr, badType()).Lrange("key", 0, 10)
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err = client.Lrange("key", 0, 10) vals, err = client.Lrange("key", 0, 10)
assert.Nil(t, err) assert.Nil(t, err)
@ -597,7 +597,7 @@ func TestRedis_List(t *testing.T) {
vals, err = client.Lrange("key", 0, 10) vals, err = client.Lrange("key", 0, 10)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []string{"value2", "value3", "value4"}, vals) assert.EqualValues(t, []string{"value2", "value3", "value4"}, vals)
err = New(client.Addr, badType()).Ltrim("key", 0, 1) err = newRedis(client.Addr, badType()).Ltrim("key", 0, 1)
assert.Error(t, err) assert.Error(t, err)
err = client.Ltrim("key", 0, 1) err = client.Ltrim("key", 0, 1)
assert.Nil(t, err) assert.Nil(t, err)
@ -667,7 +667,7 @@ func TestRedis_Mget(t *testing.T) {
assert.Nil(t, err) assert.Nil(t, err)
err = client.Set("key2", "value2") err = client.Set("key2", "value2")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).Mget("key1", "key0", "key2", "key3") _, err = newRedis(client.Addr, badType()).Mget("key1", "key0", "key2", "key3")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err := client.Mget("key1", "key0", "key2", "key3") vals, err := client.Mget("key1", "key0", "key2", "key3")
assert.Nil(t, err) assert.Nil(t, err)
@ -686,7 +686,7 @@ func TestRedis_Mget(t *testing.T) {
func TestRedis_SetBit(t *testing.T) { func TestRedis_SetBit(t *testing.T) {
t.Run("setbit", func(t *testing.T) { t.Run("setbit", func(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).SetBit("key", 1, 1) _, err := newRedis(client.Addr, badType()).SetBit("key", 1, 1)
assert.Error(t, err) assert.Error(t, err)
val, err := client.SetBit("key", 1, 1) val, err := client.SetBit("key", 1, 1)
if assert.NoError(t, err) { if assert.NoError(t, err) {
@ -709,7 +709,7 @@ func TestRedis_GetBit(t *testing.T) {
val, err := client.SetBit("key", 2, 1) val, err := client.SetBit("key", 2, 1)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0, val) assert.Equal(t, 0, val)
_, err = New(client.Addr, badType()).GetBit("key", 2) _, err = newRedis(client.Addr, badType()).GetBit("key", 2)
assert.NotNil(t, err) assert.NotNil(t, err)
v, err := client.GetBit("key", 2) v, err := client.GetBit("key", 2)
assert.Nil(t, err) assert.Nil(t, err)
@ -733,7 +733,7 @@ func TestRedis_BitCount(t *testing.T) {
assert.Equal(t, 0, val) assert.Equal(t, 0, val)
} }
_, err := New(client.Addr, badType()).BitCount("key", 0, -1) _, err := newRedis(client.Addr, badType()).BitCount("key", 0, -1)
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.BitCount("key", 0, -1) val, err := client.BitCount("key", 0, -1)
assert.Nil(t, err) assert.Nil(t, err)
@ -763,7 +763,7 @@ func TestRedis_BitOpAnd(t *testing.T) {
assert.Nil(t, err) assert.Nil(t, err)
err = client.Set("key2", "1") err = client.Set("key2", "1")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).BitOpAnd("destKey", "key1", "key2") _, err = newRedis(client.Addr, badType()).BitOpAnd("destKey", "key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.BitOpAnd("destKey", "key1", "key2") val, err := client.BitOpAnd("destKey", "key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
@ -779,7 +779,7 @@ func TestRedis_BitOpNot(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
err := client.Set("key1", "\u0000") err := client.Set("key1", "\u0000")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).BitOpNot("destKey", "key1") _, err = newRedis(client.Addr, badType()).BitOpNot("destKey", "key1")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.BitOpNot("destKey", "key1") val, err := client.BitOpNot("destKey", "key1")
assert.Nil(t, err) assert.Nil(t, err)
@ -796,7 +796,7 @@ func TestRedis_BitOpOr(t *testing.T) {
assert.Nil(t, err) assert.Nil(t, err)
err = client.Set("key2", "0") err = client.Set("key2", "0")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).BitOpOr("destKey", "key1", "key2") _, err = newRedis(client.Addr, badType()).BitOpOr("destKey", "key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.BitOpOr("destKey", "key1", "key2") val, err := client.BitOpOr("destKey", "key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
@ -813,7 +813,7 @@ func TestRedis_BitOpXor(t *testing.T) {
assert.Nil(t, err) assert.Nil(t, err)
err = client.Set("key2", "\x0f") err = client.Set("key2", "\x0f")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).BitOpXor("destKey", "key1", "key2") _, err = newRedis(client.Addr, badType()).BitOpXor("destKey", "key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.BitOpXor("destKey", "key1", "key2") val, err := client.BitOpXor("destKey", "key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
@ -830,7 +830,7 @@ func TestRedis_BitPos(t *testing.T) {
err := client.Set("key", "\xff\xf0\x00") err := client.Set("key", "\xff\xf0\x00")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).BitPos("key", 0, 0, -1) _, err = newRedis(client.Addr, badType()).BitPos("key", 0, 0, -1)
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.BitPos("key", 0, 0, 2) val, err := client.BitPos("key", 0, 0, 2)
assert.Nil(t, err) assert.Nil(t, err)
@ -856,7 +856,7 @@ func TestRedis_BitPos(t *testing.T) {
func TestRedis_Persist(t *testing.T) { func TestRedis_Persist(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Persist("key") _, err := newRedis(client.Addr, badType()).Persist("key")
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err := client.Persist("key") ok, err := client.Persist("key")
assert.Nil(t, err) assert.Nil(t, err)
@ -866,14 +866,14 @@ func TestRedis_Persist(t *testing.T) {
ok, err = client.Persist("key") ok, err = client.Persist("key")
assert.Nil(t, err) assert.Nil(t, err)
assert.False(t, ok) assert.False(t, ok)
err = New(client.Addr, badType()).Expire("key", 5) err = newRedis(client.Addr, badType()).Expire("key", 5)
assert.NotNil(t, err) assert.NotNil(t, err)
err = client.Expire("key", 5) err = client.Expire("key", 5)
assert.Nil(t, err) assert.Nil(t, err)
ok, err = client.Persist("key") ok, err = client.Persist("key")
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, ok) assert.True(t, ok)
err = New(client.Addr, badType()).Expireat("key", time.Now().Unix()+5) err = newRedis(client.Addr, badType()).Expireat("key", time.Now().Unix()+5)
assert.NotNil(t, err) assert.NotNil(t, err)
err = client.Expireat("key", time.Now().Unix()+5) err = client.Expireat("key", time.Now().Unix()+5)
assert.Nil(t, err) assert.Nil(t, err)
@ -896,7 +896,7 @@ func TestRedis_Scan(t *testing.T) {
assert.Nil(t, err) assert.Nil(t, err)
err = client.Set("key2", "value2") err = client.Set("key2", "value2")
assert.Nil(t, err) assert.Nil(t, err)
_, _, err = New(client.Addr, badType()).Scan(0, "*", 100) _, _, err = newRedis(client.Addr, badType()).Scan(0, "*", 100)
assert.NotNil(t, err) assert.NotNil(t, err)
keys, _, err := client.Scan(0, "*", 100) keys, _, err := client.Scan(0, "*", 100)
assert.Nil(t, err) assert.Nil(t, err)
@ -918,7 +918,7 @@ func TestRedis_Sscan(t *testing.T) {
var cursor uint64 = 0 var cursor uint64 = 0
sum := 0 sum := 0
for { for {
_, _, err := New(client.Addr, badType()).Sscan(key, cursor, "", 100) _, _, err := newRedis(client.Addr, badType()).Sscan(key, cursor, "", 100)
assert.NotNil(t, err) assert.NotNil(t, err)
keys, next, err := client.Sscan(key, cursor, "", 100) keys, next, err := client.Sscan(key, cursor, "", 100)
assert.Nil(t, err) assert.Nil(t, err)
@ -930,7 +930,7 @@ func TestRedis_Sscan(t *testing.T) {
} }
assert.Equal(t, sum, 1550) assert.Equal(t, sum, 1550)
_, err = New(client.Addr, badType()).Del(key) _, err = newRedis(client.Addr, badType()).Del(key)
assert.NotNil(t, err) assert.NotNil(t, err)
_, err = client.Del(key) _, err = client.Del(key)
assert.Nil(t, err) assert.Nil(t, err)
@ -940,48 +940,48 @@ func TestRedis_Sscan(t *testing.T) {
func TestRedis_Set(t *testing.T) { func TestRedis_Set(t *testing.T) {
t.Run("set", func(t *testing.T) { t.Run("set", func(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).Sadd("key", 1, 2, 3, 4) _, err := newRedis(client.Addr, badType()).Sadd("key", 1, 2, 3, 4)
assert.NotNil(t, err) assert.NotNil(t, err)
num, err := client.Sadd("key", 1, 2, 3, 4) num, err := client.Sadd("key", 1, 2, 3, 4)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 4, num) assert.Equal(t, 4, num)
_, err = New(client.Addr, badType()).Scard("key") _, err = newRedis(client.Addr, badType()).Scard("key")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Scard("key") val, err := client.Scard("key")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(4), val) assert.Equal(t, int64(4), val)
_, err = New(client.Addr, badType()).Sismember("key", 2) _, err = newRedis(client.Addr, badType()).Sismember("key", 2)
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err := client.Sismember("key", 2) ok, err := client.Sismember("key", 2)
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, ok) assert.True(t, ok)
_, err = New(client.Addr, badType()).Srem("key", 3, 4) _, err = newRedis(client.Addr, badType()).Srem("key", 3, 4)
assert.NotNil(t, err) assert.NotNil(t, err)
num, err = client.Srem("key", 3, 4) num, err = client.Srem("key", 3, 4)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 2, num) assert.Equal(t, 2, num)
_, err = New(client.Addr, badType()).Smembers("key") _, err = newRedis(client.Addr, badType()).Smembers("key")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err := client.Smembers("key") vals, err := client.Smembers("key")
assert.Nil(t, err) assert.Nil(t, err)
assert.ElementsMatch(t, []string{"1", "2"}, vals) assert.ElementsMatch(t, []string{"1", "2"}, vals)
_, err = New(client.Addr, badType()).Srandmember("key", 1) _, err = newRedis(client.Addr, badType()).Srandmember("key", 1)
assert.NotNil(t, err) assert.NotNil(t, err)
members, err := client.Srandmember("key", 1) members, err := client.Srandmember("key", 1)
assert.Nil(t, err) assert.Nil(t, err)
assert.Len(t, members, 1) assert.Len(t, members, 1)
assert.Contains(t, []string{"1", "2"}, members[0]) assert.Contains(t, []string{"1", "2"}, members[0])
_, err = New(client.Addr, badType()).Spop("key") _, err = newRedis(client.Addr, badType()).Spop("key")
assert.NotNil(t, err) assert.NotNil(t, err)
member, err := client.Spop("key") member, err := client.Spop("key")
assert.Nil(t, err) assert.Nil(t, err)
assert.Contains(t, []string{"1", "2"}, member) assert.Contains(t, []string{"1", "2"}, member)
_, err = New(client.Addr, badType()).Smembers("key") _, err = newRedis(client.Addr, badType()).Smembers("key")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err = client.Smembers("key") vals, err = client.Smembers("key")
assert.Nil(t, err) assert.Nil(t, err)
assert.NotContains(t, vals, member) assert.NotContains(t, vals, member)
_, err = New(client.Addr, badType()).Sadd("key1", 1, 2, 3, 4) _, err = newRedis(client.Addr, badType()).Sadd("key1", 1, 2, 3, 4)
assert.NotNil(t, err) assert.NotNil(t, err)
num, err = client.Sadd("key1", 1, 2, 3, 4) num, err = client.Sadd("key1", 1, 2, 3, 4)
assert.Nil(t, err) assert.Nil(t, err)
@ -989,32 +989,32 @@ func TestRedis_Set(t *testing.T) {
num, err = client.Sadd("key2", 2, 3, 4, 5) num, err = client.Sadd("key2", 2, 3, 4, 5)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 4, num) assert.Equal(t, 4, num)
_, err = New(client.Addr, badType()).Sunion("key1", "key2") _, err = newRedis(client.Addr, badType()).Sunion("key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err = client.Sunion("key1", "key2") vals, err = client.Sunion("key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
assert.ElementsMatch(t, []string{"1", "2", "3", "4", "5"}, vals) assert.ElementsMatch(t, []string{"1", "2", "3", "4", "5"}, vals)
_, err = New(client.Addr, badType()).Sunionstore("key3", "key1", "key2") _, err = newRedis(client.Addr, badType()).Sunionstore("key3", "key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
num, err = client.Sunionstore("key3", "key1", "key2") num, err = client.Sunionstore("key3", "key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 5, num) assert.Equal(t, 5, num)
_, err = New(client.Addr, badType()).Sdiff("key1", "key2") _, err = newRedis(client.Addr, badType()).Sdiff("key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err = client.Sdiff("key1", "key2") vals, err = client.Sdiff("key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []string{"1"}, vals) assert.EqualValues(t, []string{"1"}, vals)
_, err = New(client.Addr, badType()).Sdiffstore("key4", "key1", "key2") _, err = newRedis(client.Addr, badType()).Sdiffstore("key4", "key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
num, err = client.Sdiffstore("key4", "key1", "key2") num, err = client.Sdiffstore("key4", "key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 1, num) assert.Equal(t, 1, num)
_, err = New(client.Addr, badType()).Sinter("key1", "key2") _, err = newRedis(client.Addr, badType()).Sinter("key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err = client.Sinter("key1", "key2") vals, err = client.Sinter("key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
assert.ElementsMatch(t, []string{"2", "3", "4"}, vals) assert.ElementsMatch(t, []string{"2", "3", "4"}, vals)
_, err = New(client.Addr, badType()).Sinterstore("key4", "key1", "key2") _, err = newRedis(client.Addr, badType()).Sinterstore("key4", "key1", "key2")
assert.NotNil(t, err) assert.NotNil(t, err)
num, err = client.Sinterstore("key4", "key1", "key2") num, err = client.Sinterstore("key4", "key1", "key2")
assert.Nil(t, err) assert.Nil(t, err)
@ -1044,7 +1044,7 @@ func TestRedis_Set(t *testing.T) {
func TestRedis_GetSet(t *testing.T) { func TestRedis_GetSet(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := New(client.Addr, badType()).GetSet("hello", "world") _, err := newRedis(client.Addr, badType()).GetSet("hello", "world")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.GetSet("hello", "world") val, err := client.GetSet("hello", "world")
assert.Nil(t, err) assert.Nil(t, err)
@ -1066,11 +1066,11 @@ func TestRedis_GetSet(t *testing.T) {
func TestRedis_SetGetDel(t *testing.T) { func TestRedis_SetGetDel(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
err := New(client.Addr, badType()).Set("hello", "world") err := newRedis(client.Addr, badType()).Set("hello", "world")
assert.NotNil(t, err) assert.NotNil(t, err)
err = client.Set("hello", "world") err = client.Set("hello", "world")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).Get("hello") _, err = newRedis(client.Addr, badType()).Get("hello")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Get("hello") val, err := client.Get("hello")
assert.Nil(t, err) assert.Nil(t, err)
@ -1083,11 +1083,11 @@ func TestRedis_SetGetDel(t *testing.T) {
func TestRedis_SetExNx(t *testing.T) { func TestRedis_SetExNx(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
err := New(client.Addr, badType()).Setex("hello", "world", 5) err := newRedis(client.Addr, badType()).Setex("hello", "world", 5)
assert.NotNil(t, err) assert.NotNil(t, err)
err = client.Setex("hello", "world", 5) err = client.Setex("hello", "world", 5)
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).Setnx("hello", "newworld") _, err = newRedis(client.Addr, badType()).Setnx("hello", "newworld")
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err := client.Setnx("hello", "newworld") ok, err := client.Setnx("hello", "newworld")
assert.Nil(t, err) assert.Nil(t, err)
@ -1104,7 +1104,7 @@ func TestRedis_SetExNx(t *testing.T) {
ttl, err := client.Ttl("hello") ttl, err := client.Ttl("hello")
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, ttl > 0) assert.True(t, ttl > 0)
_, err = New(client.Addr, badType()).SetnxEx("newhello", "newworld", 5) _, err = newRedis(client.Addr, badType()).SetnxEx("newhello", "newworld", 5)
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err = client.SetnxEx("newhello", "newworld", 5) ok, err = client.SetnxEx("newhello", "newworld", 5)
assert.Nil(t, err) assert.Nil(t, err)
@ -1126,17 +1126,17 @@ func TestRedis_SetGetDelHashField(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
err := client.Hset("key", "field", "value") err := client.Hset("key", "field", "value")
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).Hget("key", "field") _, err = newRedis(client.Addr, badType()).Hget("key", "field")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err := client.Hget("key", "field") val, err := client.Hget("key", "field")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, "value", val) assert.Equal(t, "value", val)
_, err = New(client.Addr, badType()).Hexists("key", "field") _, err = newRedis(client.Addr, badType()).Hexists("key", "field")
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err := client.Hexists("key", "field") ok, err := client.Hexists("key", "field")
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, ok) assert.True(t, ok)
_, err = New(client.Addr, badType()).Hdel("key", "field") _, err = newRedis(client.Addr, badType()).Hdel("key", "field")
assert.NotNil(t, err) assert.NotNil(t, err)
ret, err := client.Hdel("key", "field") ret, err := client.Hdel("key", "field")
assert.Nil(t, err) assert.Nil(t, err)
@ -1179,17 +1179,17 @@ func TestRedis_SortedSet(t *testing.T) {
val, err := client.Zscore("key", "value1") val, err := client.Zscore("key", "value1")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(2), val) assert.Equal(t, int64(2), val)
_, err = New(client.Addr, badType()).Zincrby("key", 3, "value1") _, err = newRedis(client.Addr, badType()).Zincrby("key", 3, "value1")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err = client.Zincrby("key", 3, "value1") val, err = client.Zincrby("key", 3, "value1")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(5), val) assert.Equal(t, int64(5), val)
_, err = New(client.Addr, badType()).Zscore("key", "value1") _, err = newRedis(client.Addr, badType()).Zscore("key", "value1")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err = client.Zscore("key", "value1") val, err = client.Zscore("key", "value1")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(5), val) assert.Equal(t, int64(5), val)
_, err = New(client.Addr, badType()).Zadds("key") _, err = newRedis(client.Addr, badType()).Zadds("key")
assert.NotNil(t, err) assert.NotNil(t, err)
val, err = client.Zadds("key", Pair{ val, err = client.Zadds("key", Pair{
Key: "value2", Key: "value2",
@ -1200,7 +1200,7 @@ func TestRedis_SortedSet(t *testing.T) {
}) })
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(2), val) assert.Equal(t, int64(2), val)
_, err = New(client.Addr, badType()).ZRevRangeWithScores("key", 1, 3) _, err = newRedis(client.Addr, badType()).ZRevRangeWithScores("key", 1, 3)
assert.NotNil(t, err) assert.NotNil(t, err)
_, err = client.ZRevRangeWithScores("key", 1, 3) _, err = client.ZRevRangeWithScores("key", 1, 3)
assert.Nil(t, err) assert.Nil(t, err)
@ -1224,11 +1224,11 @@ func TestRedis_SortedSet(t *testing.T) {
rank, err = client.Zrevrank("key", "value1") rank, err = client.Zrevrank("key", "value1")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(2), rank) assert.Equal(t, int64(2), rank)
_, err = New(client.Addr, badType()).Zrank("key", "value4") _, err = newRedis(client.Addr, badType()).Zrank("key", "value4")
assert.NotNil(t, err) assert.NotNil(t, err)
_, err = client.Zrank("key", "value4") _, err = client.Zrank("key", "value4")
assert.Equal(t, Nil, err) assert.Equal(t, Nil, err)
_, err = New(client.Addr, badType()).Zrem("key", "value2", "value3") _, err = newRedis(client.Addr, badType()).Zrem("key", "value2", "value3")
assert.NotNil(t, err) assert.NotNil(t, err)
num, err := client.Zrem("key", "value2", "value3") num, err := client.Zrem("key", "value2", "value3")
assert.Nil(t, err) assert.Nil(t, err)
@ -1242,7 +1242,7 @@ func TestRedis_SortedSet(t *testing.T) {
ok, err = client.Zadd("key", 8, "value4") ok, err = client.Zadd("key", 8, "value4")
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, ok) assert.True(t, ok)
_, err = New(client.Addr, badType()).Zremrangebyscore("key", 6, 7) _, err = newRedis(client.Addr, badType()).Zremrangebyscore("key", 6, 7)
assert.NotNil(t, err) assert.NotNil(t, err)
num, err = client.Zremrangebyscore("key", 6, 7) num, err = client.Zremrangebyscore("key", 6, 7)
assert.Nil(t, err) assert.Nil(t, err)
@ -1250,37 +1250,37 @@ func TestRedis_SortedSet(t *testing.T) {
ok, err = client.Zadd("key", 6, "value2") ok, err = client.Zadd("key", 6, "value2")
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, ok) assert.True(t, ok)
_, err = New(client.Addr, badType()).Zadd("key", 7, "value3") _, err = newRedis(client.Addr, badType()).Zadd("key", 7, "value3")
assert.NotNil(t, err) assert.NotNil(t, err)
ok, err = client.Zadd("key", 7, "value3") ok, err = client.Zadd("key", 7, "value3")
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, ok) assert.True(t, ok)
_, err = New(client.Addr, badType()).Zcount("key", 6, 7) _, err = newRedis(client.Addr, badType()).Zcount("key", 6, 7)
assert.NotNil(t, err) assert.NotNil(t, err)
num, err = client.Zcount("key", 6, 7) num, err = client.Zcount("key", 6, 7)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 2, num) assert.Equal(t, 2, num)
_, err = New(client.Addr, badType()).Zremrangebyrank("key", 1, 2) _, err = newRedis(client.Addr, badType()).Zremrangebyrank("key", 1, 2)
assert.NotNil(t, err) assert.NotNil(t, err)
num, err = client.Zremrangebyrank("key", 1, 2) num, err = client.Zremrangebyrank("key", 1, 2)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 2, num) assert.Equal(t, 2, num)
_, err = New(client.Addr, badType()).Zcard("key") _, err = newRedis(client.Addr, badType()).Zcard("key")
assert.NotNil(t, err) assert.NotNil(t, err)
card, err := client.Zcard("key") card, err := client.Zcard("key")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 2, card) assert.Equal(t, 2, card)
_, err = New(client.Addr, badType()).Zrange("key", 0, -1) _, err = newRedis(client.Addr, badType()).Zrange("key", 0, -1)
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err := client.Zrange("key", 0, -1) vals, err := client.Zrange("key", 0, -1)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []string{"value1", "value4"}, vals) assert.EqualValues(t, []string{"value1", "value4"}, vals)
_, err = New(client.Addr, badType()).Zrevrange("key", 0, -1) _, err = newRedis(client.Addr, badType()).Zrevrange("key", 0, -1)
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err = client.Zrevrange("key", 0, -1) vals, err = client.Zrevrange("key", 0, -1)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []string{"value4", "value1"}, vals) assert.EqualValues(t, []string{"value4", "value1"}, vals)
_, err = New(client.Addr, badType()).ZrangeWithScores("key", 0, -1) _, err = newRedis(client.Addr, badType()).ZrangeWithScores("key", 0, -1)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrangeWithScores("key", 0, -1) pairs, err = client.ZrangeWithScores("key", 0, -1)
assert.Nil(t, err) assert.Nil(t, err)
@ -1294,7 +1294,7 @@ func TestRedis_SortedSet(t *testing.T) {
Score: 8, Score: 8,
}, },
}, pairs) }, pairs)
_, err = New(client.Addr, badType()).ZrangebyscoreWithScores("key", 5, 8) _, err = newRedis(client.Addr, badType()).ZrangebyscoreWithScores("key", 5, 8)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrangebyscoreWithScores("key", 5, 8) pairs, err = client.ZrangebyscoreWithScores("key", 5, 8)
assert.Nil(t, err) assert.Nil(t, err)
@ -1308,7 +1308,7 @@ func TestRedis_SortedSet(t *testing.T) {
Score: 8, Score: 8,
}, },
}, pairs) }, pairs)
_, err = New(client.Addr, badType()).ZrangebyscoreWithScoresAndLimit( _, err = newRedis(client.Addr, badType()).ZrangebyscoreWithScoresAndLimit(
"key", 5, 8, 1, 1) "key", 5, 8, 1, 1)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1) pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1)
@ -1322,7 +1322,7 @@ func TestRedis_SortedSet(t *testing.T) {
pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 0) pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 0)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0, len(pairs)) assert.Equal(t, 0, len(pairs))
_, err = New(client.Addr, badType()).ZrevrangebyscoreWithScores("key", 5, 8) _, err = newRedis(client.Addr, badType()).ZrevrangebyscoreWithScores("key", 5, 8)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrevrangebyscoreWithScores("key", 5, 8) pairs, err = client.ZrevrangebyscoreWithScores("key", 5, 8)
assert.Nil(t, err) assert.Nil(t, err)
@ -1336,7 +1336,7 @@ func TestRedis_SortedSet(t *testing.T) {
Score: 5, Score: 5,
}, },
}, pairs) }, pairs)
_, err = New(client.Addr, badType()).ZrevrangebyscoreWithScoresAndLimit( _, err = newRedis(client.Addr, badType()).ZrevrangebyscoreWithScoresAndLimit(
"key", 5, 8, 1, 1) "key", 5, 8, 1, 1)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1) pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1)
@ -1350,7 +1350,7 @@ func TestRedis_SortedSet(t *testing.T) {
pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 0) pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 0)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0, len(pairs)) assert.Equal(t, 0, len(pairs))
_, err = New(client.Addr, badType()).Zrevrank("key", "value") _, err = newRedis(client.Addr, badType()).Zrevrank("key", "value")
assert.NotNil(t, err) assert.NotNil(t, err)
_, _ = client.Zadd("second", 2, "aa") _, _ = client.Zadd("second", 2, "aa")
_, _ = client.Zadd("third", 3, "bbb") _, _ = client.Zadd("third", 3, "bbb")
@ -1361,7 +1361,7 @@ func TestRedis_SortedSet(t *testing.T) {
}) })
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(2), val) assert.Equal(t, int64(2), val)
_, err = New(client.Addr, badType()).Zunionstore("union", &ZStore{}) _, err = newRedis(client.Addr, badType()).Zunionstore("union", &ZStore{})
assert.NotNil(t, err) assert.NotNil(t, err)
vals, err = client.Zrange("union", 0, 10000) vals, err = client.Zrange("union", 0, 10000)
assert.Nil(t, err) assert.Nil(t, err)
@ -1488,10 +1488,10 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
val, err := client.ZscoreByFloat("key", "value1") val, err := client.ZscoreByFloat("key", "value1")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 10.345, val) assert.Equal(t, 10.345, val)
_, err = New(client.Addr, badType()).ZscoreByFloat("key", "value1") _, err = newRedis(client.Addr, badType()).ZscoreByFloat("key", "value1")
assert.Error(t, err) assert.Error(t, err)
_, _ = client.ZaddFloat("key", 10.346, "value2") _, _ = client.ZaddFloat("key", 10.346, "value2")
_, err = New(client.Addr, badType()).ZRevRangeWithScoresByFloat("key", 0, -1) _, err = newRedis(client.Addr, badType()).ZRevRangeWithScoresByFloat("key", 0, -1)
assert.NotNil(t, err) assert.NotNil(t, err)
_, err = client.ZRevRangeWithScoresByFloat("key", 0, -1) _, err = client.ZRevRangeWithScoresByFloat("key", 0, -1)
assert.Nil(t, err) assert.Nil(t, err)
@ -1510,7 +1510,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
}, },
}, pairs) }, pairs)
_, err = New(client.Addr, badType()).ZrangeWithScoresByFloat("key", 0, -1) _, err = newRedis(client.Addr, badType()).ZrangeWithScoresByFloat("key", 0, -1)
assert.Error(t, err) assert.Error(t, err)
pairs, err = client.ZrangeWithScoresByFloat("key", 0, -1) pairs, err = client.ZrangeWithScoresByFloat("key", 0, -1)
@ -1527,7 +1527,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
}, pairs) }, pairs)
} }
_, err = New(client.Addr, badType()).ZrangebyscoreWithScoresByFloat("key", 0, 20) _, err = newRedis(client.Addr, badType()).ZrangebyscoreWithScoresByFloat("key", 0, 20)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrangebyscoreWithScoresByFloat("key", 0, 20) pairs, err = client.ZrangebyscoreWithScoresByFloat("key", 0, 20)
assert.Nil(t, err) assert.Nil(t, err)
@ -1543,7 +1543,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
}, pairs) }, pairs)
_, err = client.ZrangebyscoreWithScoresByFloatAndLimit("key", 10.1, 12.2, 1, 0) _, err = client.ZrangebyscoreWithScoresByFloatAndLimit("key", 10.1, 12.2, 1, 0)
assert.NoError(t, err) assert.NoError(t, err)
_, err = New(client.Addr, badType()).ZrangebyscoreWithScoresByFloatAndLimit( _, err = newRedis(client.Addr, badType()).ZrangebyscoreWithScoresByFloatAndLimit(
"key", 10.1, 12.2, 1, 1) "key", 10.1, 12.2, 1, 1)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrangebyscoreWithScoresByFloatAndLimit("key", 10.1, 12.2, 1, 1) pairs, err = client.ZrangebyscoreWithScoresByFloatAndLimit("key", 10.1, 12.2, 1, 1)
@ -1554,7 +1554,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
Score: 10.346, Score: 10.346,
}, },
}, pairs) }, pairs)
_, err = New(client.Addr, badType()).ZrevrangebyscoreWithScoresByFloat("key", 10, 12) _, err = newRedis(client.Addr, badType()).ZrevrangebyscoreWithScoresByFloat("key", 10, 12)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrevrangebyscoreWithScoresByFloat("key", 10, 12) pairs, err = client.ZrevrangebyscoreWithScoresByFloat("key", 10, 12)
assert.Nil(t, err) assert.Nil(t, err)
@ -1570,7 +1570,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
}, pairs) }, pairs)
_, err = client.ZrevrangebyscoreWithScoresByFloatAndLimit("key", 10, 12, 1, 0) _, err = client.ZrevrangebyscoreWithScoresByFloatAndLimit("key", 10, 12, 1, 0)
assert.NoError(t, err) assert.NoError(t, err)
_, err = New(client.Addr, badType()).ZrevrangebyscoreWithScoresByFloatAndLimit( _, err = newRedis(client.Addr, badType()).ZrevrangebyscoreWithScoresByFloatAndLimit(
"key", 10, 12, 1, 1) "key", 10, 12, 1, 1)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrevrangebyscoreWithScoresByFloatAndLimit("key", 10, 12, 1, 1) pairs, err = client.ZrevrangebyscoreWithScoresByFloatAndLimit("key", 10, 12, 1, 1)
@ -1586,19 +1586,27 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
func TestRedis_Zaddnx(t *testing.T) { func TestRedis_Zaddnx(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
_, err := newRedis(client.Addr, badType()).Zaddnx("key", 1, "value1")
assert.Error(t, err)
ok, err := client.Zadd("key", 1, "value1") ok, err := client.Zadd("key", 1, "value1")
assert.Nil(t, err) assert.NoError(t, err)
assert.True(t, ok) assert.True(t, ok)
ok, err = client.Zaddnx("key", 2, "value1") ok, err = client.Zaddnx("key", 2, "value1")
assert.Nil(t, err) assert.NoError(t, err)
assert.False(t, ok) assert.False(t, ok)
ok, err = client.ZaddFloat("key", 1.1, "value2") ok, err = client.ZaddFloat("key", 1.1, "value2")
assert.Nil(t, err) assert.NoError(t, err)
assert.True(t, ok) assert.True(t, ok)
ok, err = client.ZaddnxFloat("key", 1.1, "value3") ok, err = client.ZaddnxFloat("key", 1.1, "value3")
assert.Nil(t, err) assert.NoError(t, err)
assert.True(t, ok) assert.True(t, ok)
assert.NoError(t, client.Set("newkey", "value"))
ok, err = client.Zaddnx("newkey", 1, "value")
assert.Error(t, err)
assert.False(t, ok)
}) })
} }
@ -1607,12 +1615,12 @@ func TestRedis_IncrbyFloat(t *testing.T) {
incrVal, err := client.IncrbyFloat("key", 0.002) incrVal, err := client.IncrbyFloat("key", 0.002)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0.002, incrVal) assert.Equal(t, 0.002, incrVal)
_, err = New(client.Addr, badType()).IncrbyFloat("key", -0.001) _, err = newRedis(client.Addr, badType()).IncrbyFloat("key", -0.001)
assert.Error(t, err) assert.Error(t, err)
incrVal2, err := client.IncrbyFloat("key", -0.001) incrVal2, err := client.IncrbyFloat("key", -0.001)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0.001, incrVal2) assert.Equal(t, 0.001, incrVal2)
_, err = New(client.Addr, badType()).HincrbyFloat("hkey", "i", 0.002) _, err = newRedis(client.Addr, badType()).HincrbyFloat("hkey", "i", 0.002)
assert.Error(t, err) assert.Error(t, err)
hincrVal, err := client.HincrbyFloat("hkey", "i", 0.002) hincrVal, err := client.HincrbyFloat("hkey", "i", 0.002)
assert.Nil(t, err) assert.Nil(t, err)
@ -1625,7 +1633,7 @@ func TestRedis_IncrbyFloat(t *testing.T) {
func TestRedis_Pipelined(t *testing.T) { func TestRedis_Pipelined(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
assert.NotNil(t, New(client.Addr, badType()).Pipelined(func(pipeliner Pipeliner) error { assert.NotNil(t, newRedis(client.Addr, badType()).Pipelined(func(pipeliner Pipeliner) error {
return nil return nil
})) }))
err := client.Pipelined( err := client.Pipelined(
@ -1637,7 +1645,7 @@ func TestRedis_Pipelined(t *testing.T) {
}, },
) )
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).Ttl("pipelined_counter") _, err = newRedis(client.Addr, badType()).Ttl("pipelined_counter")
assert.NotNil(t, err) assert.NotNil(t, err)
ttl, err := client.Ttl("pipelined_counter") ttl, err := client.Ttl("pipelined_counter")
assert.Nil(t, err) assert.Nil(t, err)
@ -1654,17 +1662,17 @@ func TestRedis_Pipelined(t *testing.T) {
func TestRedisString(t *testing.T) { func TestRedisString(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
client.Ping() client.Ping()
_, err := getRedis(New(client.Addr, Cluster())) _, err := getRedis(newRedis(client.Addr, Cluster()))
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, client.Addr, client.String()) assert.Equal(t, client.Addr, client.String())
assert.NotNil(t, New(client.Addr, badType()).Ping()) assert.NotNil(t, newRedis(client.Addr, badType()).Ping())
}) })
} }
func TestRedisScriptLoad(t *testing.T) { func TestRedisScriptLoad(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
client.Ping() client.Ping()
_, err := New(client.Addr, badType()).ScriptLoad("foo") _, err := newRedis(client.Addr, badType()).ScriptLoad("foo")
assert.NotNil(t, err) assert.NotNil(t, err)
_, err = client.ScriptLoad("foo") _, err = client.ScriptLoad("foo")
assert.NotNil(t, err) assert.NotNil(t, err)
@ -1676,7 +1684,7 @@ func TestRedisEvalSha(t *testing.T) {
client.Ping() client.Ping()
scriptHash, err := client.ScriptLoad(`return redis.call("EXISTS", KEYS[1])`) scriptHash, err := client.ScriptLoad(`return redis.call("EXISTS", KEYS[1])`)
assert.Nil(t, err) assert.Nil(t, err)
_, err = New(client.Addr, badType()).EvalSha(scriptHash, []string{"key1"}) _, err = newRedis(client.Addr, badType()).EvalSha(scriptHash, []string{"key1"})
assert.Error(t, err) assert.Error(t, err)
result, err := client.EvalSha(scriptHash, []string{"key1"}) result, err := client.EvalSha(scriptHash, []string{"key1"})
assert.Nil(t, err) assert.Nil(t, err)
@ -1759,7 +1767,7 @@ func TestRedis_Zscan(t *testing.T) {
var cursor uint64 = 0 var cursor uint64 = 0
sum := 0 sum := 0
for { for {
_, _, err := New(client.Addr, badType()).Zscan(key, cursor, "value_*", 100) _, _, err := newRedis(client.Addr, badType()).Zscan(key, cursor, "value_*", 100)
assert.NotNil(t, err) assert.NotNil(t, err)
keys, next, err := client.Zscan(key, cursor, "value_*", 100) keys, next, err := client.Zscan(key, cursor, "value_*", 100)
assert.Nil(t, err) assert.Nil(t, err)
@ -1771,7 +1779,7 @@ func TestRedis_Zscan(t *testing.T) {
} }
assert.Equal(t, sum, 3100) assert.Equal(t, sum, 3100)
_, err := New(client.Addr, badType()).Del(key) _, err := newRedis(client.Addr, badType()).Del(key)
assert.NotNil(t, err) assert.NotNil(t, err)
_, err = client.Del(key) _, err = client.Del(key)
assert.Nil(t, err) assert.Nil(t, err)
@ -1827,13 +1835,13 @@ func TestRedisGeo(t *testing.T) {
v, err := client.GeoAdd("sicily", geoLocation...) v, err := client.GeoAdd("sicily", geoLocation...)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(2), v) assert.Equal(t, int64(2), v)
_, err = New(client.Addr, badType()).GeoDist("sicily", "Palermo", "Catania", "m") _, err = newRedis(client.Addr, badType()).GeoDist("sicily", "Palermo", "Catania", "m")
assert.Error(t, err) assert.Error(t, err)
v2, err := client.GeoDist("sicily", "Palermo", "Catania", "m") v2, err := client.GeoDist("sicily", "Palermo", "Catania", "m")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 166274, int(v2)) assert.Equal(t, 166274, int(v2))
// GeoHash not support // GeoHash not support
_, err = New(client.Addr, badType()).GeoPos("sicily", "Palermo", "Catania") _, err = newRedis(client.Addr, badType()).GeoPos("sicily", "Palermo", "Catania")
assert.Error(t, err) assert.Error(t, err)
v3, err := client.GeoPos("sicily", "Palermo", "Catania") v3, err := client.GeoPos("sicily", "Palermo", "Catania")
assert.Nil(t, err) assert.Nil(t, err)
@ -1841,7 +1849,7 @@ func TestRedisGeo(t *testing.T) {
assert.Equal(t, int64(v3[0].Latitude), int64(38)) assert.Equal(t, int64(v3[0].Latitude), int64(38))
assert.Equal(t, int64(v3[1].Longitude), int64(15)) assert.Equal(t, int64(v3[1].Longitude), int64(15))
assert.Equal(t, int64(v3[1].Latitude), int64(37)) assert.Equal(t, int64(v3[1].Latitude), int64(37))
_, err = New(client.Addr, badType()).GeoRadius("sicily", 15, 37, _, err = newRedis(client.Addr, badType()).GeoRadius("sicily", 15, 37,
&red.GeoRadiusQuery{WithDist: true, Unit: "km", Radius: 200}) &red.GeoRadiusQuery{WithDist: true, Unit: "km", Radius: 200})
assert.Error(t, err) assert.Error(t, err)
v4, err := client.GeoRadius("sicily", 15, 37, &red.GeoRadiusQuery{ v4, err := client.GeoRadius("sicily", 15, 37, &red.GeoRadiusQuery{
@ -1852,12 +1860,12 @@ func TestRedisGeo(t *testing.T) {
assert.Equal(t, int64(v4[0].Dist), int64(190)) assert.Equal(t, int64(v4[0].Dist), int64(190))
assert.Equal(t, int64(v4[1].Dist), int64(56)) assert.Equal(t, int64(v4[1].Dist), int64(56))
geoLocation2 := []*GeoLocation{{Longitude: 13.583333, Latitude: 37.316667, Name: "Agrigento"}} geoLocation2 := []*GeoLocation{{Longitude: 13.583333, Latitude: 37.316667, Name: "Agrigento"}}
_, err = New(client.Addr, badType()).GeoAdd("sicily", geoLocation2...) _, err = newRedis(client.Addr, badType()).GeoAdd("sicily", geoLocation2...)
assert.Error(t, err) assert.Error(t, err)
v5, err := client.GeoAdd("sicily", geoLocation2...) v5, err := client.GeoAdd("sicily", geoLocation2...)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(1), v5) assert.Equal(t, int64(1), v5)
_, err = New(client.Addr, badType()).GeoRadiusByMember("sicily", "Agrigento", _, err = newRedis(client.Addr, badType()).GeoRadiusByMember("sicily", "Agrigento",
&red.GeoRadiusQuery{Unit: "km", Radius: 100}) &red.GeoRadiusQuery{Unit: "km", Radius: 100})
assert.Error(t, err) assert.Error(t, err)
v6, err := client.GeoRadiusByMember("sicily", "Agrigento", v6, err := client.GeoRadiusByMember("sicily", "Agrigento",
@ -1904,7 +1912,7 @@ func TestSetSlowThreshold(t *testing.T) {
func TestRedis_WithPass(t *testing.T) { func TestRedis_WithPass(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
err := New(client.Addr, WithPass("any")).Ping() err := newRedis(client.Addr, WithPass("any")).Ping()
assert.NotNil(t, err) assert.NotNil(t, err)
}) })
} }
@ -1924,7 +1932,7 @@ func runOnRedisWithError(t *testing.T, fn func(client *Redis)) {
s := miniredis.RunT(t) s := miniredis.RunT(t)
s.SetError("mock error") s.SetError("mock error")
fn(New(s.Addr())) fn(newRedis(s.Addr()))
} }
func runOnRedisTLS(t *testing.T, fn func(client *Redis)) { func runOnRedisTLS(t *testing.T, fn func(client *Redis)) {
@ -1946,7 +1954,7 @@ func runOnRedisTLS(t *testing.T, fn func(client *Redis)) {
_ = client.Close() _ = client.Close()
} }
}() }()
fn(New(s.Addr(), WithTLS())) fn(newRedis(s.Addr(), WithTLS()))
} }
func badType() Option { func badType() Option {

Write Preview
Loading…
Cancel
Save