From 10b855713d59c5fc5b359fc1830713642b610b1e Mon Sep 17 00:00:00 2001 From: kevin Date: Wed, 7 Oct 2020 19:00:15 +0800 Subject: [PATCH] add more tests --- core/stores/kv/store_test.go | 188 ++++++++++++++++++++++++++++++++++- 1 file changed, 187 insertions(+), 1 deletion(-) diff --git a/core/stores/kv/store_test.go b/core/stores/kv/store_test.go index c9b212b4..d4543826 100644 --- a/core/stores/kv/store_test.go +++ b/core/stores/kv/store_test.go @@ -6,6 +6,7 @@ import ( "github.com/alicebob/miniredis" "github.com/stretchr/testify/assert" + "github.com/tal-tech/go-zero/core/hash" "github.com/tal-tech/go-zero/core/stores/cache" "github.com/tal-tech/go-zero/core/stores/redis" "github.com/tal-tech/go-zero/core/stringx" @@ -15,6 +16,10 @@ var s1, _ = miniredis.Run() var s2, _ = miniredis.Run() func TestRedis_Exists(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Exists("foo") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { ok, err := client.Exists("a") assert.Nil(t, err) @@ -27,6 +32,10 @@ func TestRedis_Exists(t *testing.T) { } func TestRedis_Eval(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Eval(`redis.call("EXISTS", KEYS[1])`, "key1") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { _, err := client.Eval(`redis.call("EXISTS", KEYS[1])`, "notexist") assert.Equal(t, redis.Nil, err) @@ -41,6 +50,12 @@ func TestRedis_Eval(t *testing.T) { } func TestRedis_Hgetall(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + err := store.Hset("a", "aa", "aaa") + assert.NotNil(t, err) + _, err = store.Hgetall("a") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "bb", "bbb")) @@ -54,6 +69,10 @@ func TestRedis_Hgetall(t *testing.T) { } func TestRedis_Hvals(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Hvals("a") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "bb", "bbb")) @@ -64,6 +83,10 @@ func TestRedis_Hvals(t *testing.T) { } func TestRedis_Hsetnx(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Hsetnx("a", "dd", "ddd") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "bb", "bbb")) @@ -80,6 +103,12 @@ func TestRedis_Hsetnx(t *testing.T) { } func TestRedis_HdelHlen(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Hdel("a", "aa") + assert.NotNil(t, err) + _, err = store.Hlen("a") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "bb", "bbb")) @@ -96,6 +125,10 @@ func TestRedis_HdelHlen(t *testing.T) { } func TestRedis_HIncrBy(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Hincrby("key", "field", 3) + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { val, err := client.Hincrby("key", "field", 2) assert.Nil(t, err) @@ -107,6 +140,10 @@ func TestRedis_HIncrBy(t *testing.T) { } func TestRedis_Hkeys(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Hkeys("a") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "bb", "bbb")) @@ -117,6 +154,10 @@ func TestRedis_Hkeys(t *testing.T) { } func TestRedis_Hmget(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Hmget("a", "aa", "bb") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "bb", "bbb")) @@ -130,6 +171,12 @@ func TestRedis_Hmget(t *testing.T) { } func TestRedis_Hmset(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + err := store.Hmset("a", map[string]string{ + "aa": "aaa", + }) + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { assert.Nil(t, client.Hmset("a", map[string]string{ "aa": "aaa", @@ -142,6 +189,10 @@ func TestRedis_Hmset(t *testing.T) { } func TestRedis_Incr(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Incr("a") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { val, err := client.Incr("a") assert.Nil(t, err) @@ -153,6 +204,10 @@ func TestRedis_Incr(t *testing.T) { } func TestRedis_IncrBy(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Incrby("a", 2) + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { val, err := client.Incrby("a", 2) assert.Nil(t, err) @@ -164,6 +219,20 @@ func TestRedis_IncrBy(t *testing.T) { } func TestRedis_List(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Lpush("key", "value1", "value2") + assert.NotNil(t, err) + _, err = store.Rpush("key", "value3", "value4") + assert.NotNil(t, err) + _, err = store.Llen("key") + assert.NotNil(t, err) + _, err = store.Lrange("key", 0, 10) + assert.NotNil(t, err) + _, err = store.Lpop("key") + assert.NotNil(t, err) + _, err = store.Lrem("key", 0, "val") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { val, err := client.Lpush("key", "value1", "value2") assert.Nil(t, err) @@ -202,6 +271,14 @@ func TestRedis_List(t *testing.T) { } func TestRedis_Persist(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Persist("key") + assert.NotNil(t, err) + err = store.Expire("key", 5) + assert.NotNil(t, err) + err = store.Expireat("key", time.Now().Unix()+5) + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { ok, err := client.Persist("key") assert.Nil(t, err) @@ -225,8 +302,16 @@ func TestRedis_Persist(t *testing.T) { } func TestRedis_Sscan(t *testing.T) { + key := "list" + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Sadd(key, nil) + assert.NotNil(t, err) + _, _, err = store.Sscan(key, 0, "", 100) + assert.NotNil(t, err) + _, err = store.Del(key) + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { - key := "list" var list []string for i := 0; i < 1550; i++ { list = append(list, stringx.Randn(i)) @@ -254,6 +339,20 @@ func TestRedis_Sscan(t *testing.T) { } func TestRedis_Set(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Scard("key") + assert.NotNil(t, err) + _, err = store.Sismember("key", 2) + assert.NotNil(t, err) + _, err = store.Srem("key", 3, 4) + assert.NotNil(t, err) + _, err = store.Smembers("key") + assert.NotNil(t, err) + _, err = store.Srandmember("key", 1) + assert.NotNil(t, err) + _, err = store.Spop("key") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { num, err := client.Sadd("key", 1, 2, 3, 4) assert.Nil(t, err) @@ -290,6 +389,14 @@ func TestRedis_Set(t *testing.T) { } func TestRedis_SetGetDel(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + err := store.Set("hello", "world") + assert.NotNil(t, err) + _, err = store.Get("hello") + assert.NotNil(t, err) + _, err = store.Del("hello") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { err := client.Set("hello", "world") assert.Nil(t, err) @@ -303,6 +410,16 @@ func TestRedis_SetGetDel(t *testing.T) { } func TestRedis_SetExNx(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + err := store.Setex("hello", "world", 5) + assert.NotNil(t, err) + _, err = store.Setnx("newhello", "newworld") + assert.NotNil(t, err) + _, err = store.Ttl("hello") + assert.NotNil(t, err) + _, err = store.SetnxEx("newhello", "newworld", 5) + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { err := client.Setex("hello", "world", 5) assert.Nil(t, err) @@ -337,6 +454,16 @@ func TestRedis_SetExNx(t *testing.T) { } func TestRedis_SetGetDelHashField(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + err := store.Hset("key", "field", "value") + assert.NotNil(t, err) + _, err = store.Hget("key", "field") + assert.NotNil(t, err) + _, err = store.Hexists("key", "field") + assert.NotNil(t, err) + _, err = store.Hdel("key", "field") + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { err := client.Hset("key", "field", "value") assert.Nil(t, err) @@ -356,6 +483,48 @@ func TestRedis_SetGetDelHashField(t *testing.T) { } func TestRedis_SortedSet(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Zadd("key", 1, "value1") + assert.NotNil(t, err) + _, err = store.Zscore("key", "value1") + assert.NotNil(t, err) + _, err = store.Zcount("key", 6, 7) + assert.NotNil(t, err) + _, err = store.Zincrby("key", 3, "value1") + assert.NotNil(t, err) + _, err = store.Zrank("key", "value2") + assert.NotNil(t, err) + _, err = store.Zrem("key", "value2", "value3") + assert.NotNil(t, err) + _, err = store.Zremrangebyscore("key", 6, 7) + assert.NotNil(t, err) + _, err = store.Zremrangebyrank("key", 1, 2) + assert.NotNil(t, err) + _, err = store.Zcard("key") + assert.NotNil(t, err) + _, err = store.Zrange("key", 0, -1) + assert.NotNil(t, err) + _, err = store.Zrevrange("key", 0, -1) + assert.NotNil(t, err) + _, err = store.ZrangeWithScores("key", 0, -1) + assert.NotNil(t, err) + _, err = store.ZrangebyscoreWithScores("key", 5, 8) + assert.NotNil(t, err) + _, err = store.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1) + assert.NotNil(t, err) + _, err = store.ZrevrangebyscoreWithScores("key", 5, 8) + assert.NotNil(t, err) + _, err = store.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1) + assert.NotNil(t, err) + _, err = store.Zadds("key", redis.Pair{ + Key: "value2", + Score: 6, + }, redis.Pair{ + Key: "value3", + Score: 7, + }) + assert.NotNil(t, err) + runOnCluster(t, func(client Store) { ok, err := client.Zadd("key", 1, "value1") assert.Nil(t, err) @@ -471,9 +640,26 @@ func TestRedis_SortedSet(t *testing.T) { Score: 5, }, }, pairs) + val, err = client.Zadds("key", redis.Pair{ + Key: "value2", + Score: 6, + }, redis.Pair{ + Key: "value3", + Score: 7, + }) + assert.Nil(t, err) + assert.Equal(t, int64(2), val) }) } +func TestRedis_HyperLogLog(t *testing.T) { + store := clusterStore{dispatcher: hash.NewConsistentHash()} + _, err := store.Pfadd("key") + assert.NotNil(t, err) + _, err = store.Pfcount("key") + assert.NotNil(t, err) +} + func runOnCluster(t *testing.T, fn func(cluster Store)) { s1.FlushAll() s2.FlushAll()