mirror of
https://gitee.com/johng/gf.git
synced 2024-11-29 18:57:44 +08:00
612 lines
17 KiB
Go
612 lines
17 KiB
Go
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
// If a copy of the MIT was not distributed with this file,
|
|
// You can obtain one at https://github.com/gogf/gf.
|
|
|
|
package redis_test
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gogf/gf/v2/database/gredis"
|
|
"github.com/gogf/gf/v2/os/gtime"
|
|
"github.com/gogf/gf/v2/test/gtest"
|
|
"github.com/gogf/gf/v2/util/guid"
|
|
)
|
|
|
|
var (
|
|
TestKey = "mykey"
|
|
TestValue = "hello"
|
|
)
|
|
|
|
func Test_GroupGeneric_Copy(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
var (
|
|
k1 = guid.S()
|
|
v1 = guid.S()
|
|
k2 = guid.S()
|
|
result int64
|
|
err error
|
|
)
|
|
_, err = redis.GroupString().Set(ctx, k1, v1)
|
|
t.AssertNil(err)
|
|
result, err = redis.GroupGeneric().Copy(ctx, k1, k2)
|
|
t.AssertEQ(result, int64(1))
|
|
t.AssertNil(err)
|
|
v2, err := redis.GroupString().Get(ctx, k2)
|
|
t.AssertNil(err)
|
|
t.Assert(v2.String(), v1)
|
|
})
|
|
// With Option.
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
var (
|
|
k1 = guid.S()
|
|
v1 = guid.S()
|
|
k2 = guid.S()
|
|
result int64
|
|
err error
|
|
)
|
|
_, err = redis.GroupString().Set(ctx, k1, v1)
|
|
t.AssertNil(err)
|
|
result, err = redis.GroupGeneric().Copy(ctx, k1, k2, gredis.CopyOption{
|
|
DB: 1,
|
|
REPLACE: true,
|
|
})
|
|
t.AssertEQ(result, int64(1))
|
|
t.AssertNil(err)
|
|
v2, err := redis.GroupString().Get(ctx, k2)
|
|
t.AssertNil(err)
|
|
t.Assert(v2.String(), v1)
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Exists(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
var (
|
|
k1 = "k1"
|
|
v1 = "v1"
|
|
k2 = "k2"
|
|
v2 = "v2"
|
|
)
|
|
_, err := redis.GroupString().Set(ctx, k1, v1)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().Exists(ctx, k1)
|
|
t.AssertEQ(result, int64(1))
|
|
t.AssertNil(err)
|
|
result, err = redis.GroupGeneric().Exists(ctx, "nosuchkey")
|
|
t.AssertEQ(result, int64(0))
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupString().Set(ctx, k2, v2)
|
|
t.AssertNil(err)
|
|
result, err = redis.GroupGeneric().Exists(ctx, k1, k2)
|
|
t.AssertNil(err)
|
|
t.Assert(result, int64(2))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Type(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
_, err := redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupList().LPush(ctx, "k2", "v2")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupSet().SAdd(ctx, "k3", "v3")
|
|
t.AssertNil(err)
|
|
|
|
t1, err := redis.GroupGeneric().Type(ctx, "k1")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(t1, "string")
|
|
t2, err := redis.GroupGeneric().Type(ctx, "k2")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(t2, "list")
|
|
t3, err := redis.GroupGeneric().Type(ctx, "k3")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(t3, "set")
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Unlink(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
_, err := redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupString().Set(ctx, "k2", "v2")
|
|
t.AssertNil(err)
|
|
|
|
result, err := redis.GroupGeneric().Unlink(ctx, "k1", "k2", "k3")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(2))
|
|
v1, err := redis.GroupString().Get(ctx, "k1")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(v1.String(), "")
|
|
v2, err := redis.GroupString().Get(ctx, "k2")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(v2.String(), "")
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Rename(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
_, err := redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
err = redis.GroupGeneric().Rename(ctx, "k1", "k2")
|
|
t.AssertNil(err)
|
|
v1, err := redis.GroupString().Get(ctx, "k1")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(v1.String(), "")
|
|
v2, err := redis.GroupString().Get(ctx, "k2")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(v2.String(), "v1")
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_RenameNX(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
_, err := redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupString().Set(ctx, "k2", "v2")
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().RenameNX(ctx, "k1", "k2")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(0))
|
|
result, err = redis.GroupGeneric().RenameNX(ctx, "k1", "k3")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
v2, err := redis.GroupString().Get(ctx, "k2")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(v2.String(), "v2")
|
|
v3, err := redis.GroupString().Get(ctx, "k3")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(v3.String(), "v1")
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Move(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushAll(ctx)
|
|
_, err := redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().Move(ctx, "k1", 0)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Del(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
_, err := redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupString().Set(ctx, "k2", "v2")
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().Del(ctx, "k1", "k2", "k3")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(2))
|
|
v1, err := redis.GroupString().Get(ctx, "k1")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(v1.String(), "")
|
|
v2, err := redis.GroupString().Get(ctx, "k2")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(v2.String(), "")
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_RandomKey(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
key, err := redis.GroupGeneric().RandomKey(ctx)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(key, "")
|
|
|
|
_, err = redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupString().Set(ctx, "k2", "v2")
|
|
t.AssertNil(err)
|
|
|
|
key, err = redis.GroupGeneric().RandomKey(ctx)
|
|
t.AssertNil(err)
|
|
t.AssertIN(key, []string{"k1", "k2"})
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_DBSize(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
dbSize, err := redis.GroupGeneric().DBSize(ctx)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(dbSize, int64(0))
|
|
|
|
_, err = redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupString().Set(ctx, "k2", "v2")
|
|
t.AssertNil(err)
|
|
|
|
dbSize, err = redis.GroupGeneric().DBSize(ctx)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(dbSize, int64(2))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Keys(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
err := redis.GroupString().MSet(ctx, map[string]interface{}{
|
|
"firstname": "Jack",
|
|
"lastname": "Stuntman",
|
|
"age": 35,
|
|
})
|
|
t.AssertNil(err)
|
|
keys, err := redis.GroupGeneric().Keys(ctx, "*name*")
|
|
t.AssertNil(err)
|
|
t.AssertIN(keys, []string{"lastname", "firstname"})
|
|
keys, err = redis.GroupGeneric().Keys(ctx, "a??")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(keys, []string{"age"})
|
|
keys, err = redis.GroupGeneric().Keys(ctx, "*")
|
|
t.AssertNil(err)
|
|
t.AssertIN(keys, []string{"lastname", "firstname", "age"})
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Scan(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
err := redis.GroupString().MSet(ctx, map[string]interface{}{
|
|
"firstname": "Jack",
|
|
"lastname": "Stuntman",
|
|
"age": 35,
|
|
"nickname": "Jumper",
|
|
})
|
|
t.AssertNil(err)
|
|
|
|
performScan := func(cursor uint64, option ...gredis.ScanOption) ([]string, error) {
|
|
var allKeys = []string{}
|
|
for {
|
|
var nextCursor uint64
|
|
var keys []string
|
|
var err error
|
|
|
|
if option != nil {
|
|
nextCursor, keys, err = redis.Scan(ctx, cursor, option[0])
|
|
} else {
|
|
nextCursor, keys, err = redis.Scan(ctx, cursor)
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
allKeys = append(allKeys, keys...)
|
|
if nextCursor == 0 {
|
|
break
|
|
}
|
|
cursor = nextCursor
|
|
}
|
|
return allKeys, nil
|
|
}
|
|
|
|
// Test scanning for keys with `*name*` pattern
|
|
optWithName := gredis.ScanOption{Match: "*name*", Count: 10}
|
|
keysWithName, err := performScan(0, optWithName)
|
|
t.AssertNil(err)
|
|
t.AssertGE(len(keysWithName), 3)
|
|
t.AssertIN(keysWithName, []string{"lastname", "firstname", "nickname"})
|
|
|
|
// Test scanning with a pattern that matches exactly one key
|
|
optWithAge := gredis.ScanOption{Match: "a??", Count: 10}
|
|
keysWithAge, err := performScan(0, optWithAge)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(len(keysWithAge), 1)
|
|
t.AssertEQ(keysWithAge, []string{"age"})
|
|
|
|
// Test scanning for all keys
|
|
optWithAll := gredis.ScanOption{Match: "*", Count: 10}
|
|
all, err := performScan(0, optWithAll)
|
|
t.AssertNil(err)
|
|
t.AssertGE(len(all), 4)
|
|
t.AssertIN(all, []string{"lastname", "firstname", "age", "nickname"})
|
|
|
|
// Test empty pattern
|
|
optWithEmptyPattern := gredis.ScanOption{Match: ""}
|
|
emptyPatternKeys, err := performScan(0, optWithEmptyPattern)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(len(emptyPatternKeys), 4)
|
|
|
|
// Test pattern with no matches
|
|
optWithNoMatch := gredis.ScanOption{Match: "xyz*", Count: 10}
|
|
noMatchKeys, err := performScan(0, optWithNoMatch)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(len(noMatchKeys), 0)
|
|
|
|
// Test scanning for keys with invalid count value
|
|
optWithInvalidCount := gredis.ScanOption{Count: -1}
|
|
_, err = performScan(0, optWithInvalidCount)
|
|
t.AssertNQ(err, nil)
|
|
|
|
// Test scanning for all keys without options
|
|
allWithoutOpt, err := performScan(0)
|
|
t.AssertNil(err)
|
|
t.AssertGE(len(allWithoutOpt), 4)
|
|
t.AssertIN(all, []string{"lastname", "firstname", "age", "nickname"})
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_FlushDB(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupString().Set(ctx, "k2", "v2")
|
|
t.AssertNil(err)
|
|
|
|
dbSize, err := redis.GroupGeneric().DBSize(ctx)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(dbSize, int64(2))
|
|
|
|
err = redis.GroupGeneric().FlushDB(ctx)
|
|
t.AssertNil(err)
|
|
|
|
dbSize, err = redis.GroupGeneric().DBSize(ctx)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(dbSize, int64(0))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_FlushAll(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, "k1", "v1")
|
|
t.AssertNil(err)
|
|
_, err = redis.GroupString().Set(ctx, "k2", "v2")
|
|
t.AssertNil(err)
|
|
|
|
dbSize, err := redis.GroupGeneric().DBSize(ctx)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(dbSize, int64(2))
|
|
|
|
err = redis.GroupGeneric().FlushAll(ctx)
|
|
t.AssertNil(err)
|
|
|
|
dbSize, err = redis.GroupGeneric().DBSize(ctx)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(dbSize, int64(0))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Expire(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().Expire(ctx, TestKey, 1)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
ttl, err := redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(ttl, int64(1))
|
|
})
|
|
// With Option.
|
|
// Starting with Redis version 7.0.0: Added options: NX, XX, GT and LT.
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
ttl, err := redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(ttl, int64(-1))
|
|
result, err := redis.GroupGeneric().Expire(ctx, TestKey, 1, gredis.ExpireOption{XX: true})
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(0))
|
|
ttl, err = redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(ttl, int64(-1))
|
|
result, err = redis.GroupGeneric().Expire(ctx, TestKey, 1, gredis.ExpireOption{NX: true})
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
ttl, err = redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(ttl, int64(1))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_ExpireAt(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().Exists(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
result, err = redis.GroupGeneric().ExpireAt(ctx, TestKey, time.Now().Add(time.Millisecond*100))
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
time.Sleep(time.Millisecond * 200)
|
|
result, err = redis.GroupGeneric().Exists(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(0))
|
|
})
|
|
// With Option.
|
|
// Starting with Redis version 7.0.0: Added options: NX, XX, GT and LT.
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
ttl, err := redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(ttl, int64(-1))
|
|
result, err := redis.GroupGeneric().ExpireAt(ctx, TestKey, time.Now().Add(time.Millisecond*100), gredis.ExpireOption{XX: true})
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(0))
|
|
result, err = redis.GroupGeneric().ExpireAt(ctx, TestKey, time.Now().Add(time.Minute), gredis.ExpireOption{NX: true})
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
ttl, err = redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertGT(ttl, int64(0))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_ExpireTime(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
expireTime := time.Now().Add(time.Minute)
|
|
result, err := redis.GroupGeneric().ExpireAt(ctx, TestKey, expireTime)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
resultTime, err := redis.GroupGeneric().ExpireTime(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(resultTime.Int64(), expireTime.Unix())
|
|
|
|
_, err = redis.GroupString().Set(ctx, "noExpireKey", TestValue)
|
|
t.AssertNil(err)
|
|
resultTime, err = redis.GroupGeneric().ExpireTime(ctx, "noExpireKey")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(resultTime.Int64(), int64(-1))
|
|
|
|
resultTime, err = redis.GroupGeneric().ExpireTime(ctx, "noExistKey")
|
|
t.AssertNil(err)
|
|
t.AssertEQ(resultTime.Int64(), int64(-2))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_TTL(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().Expire(ctx, TestKey, 10)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
result, err = redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(10))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_Persist(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().Expire(ctx, TestKey, 10)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
result, err = redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(10))
|
|
result, err = redis.GroupGeneric().Persist(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
result, err = redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(-1))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_PExpire(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().PExpire(ctx, TestKey, 2500)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
result, err = redis.GroupGeneric().PTTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertLE(result, int64(2500))
|
|
})
|
|
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().PExpire(ctx, TestKey, 2500, gredis.ExpireOption{
|
|
NX: true,
|
|
})
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
|
|
result, err = redis.GroupGeneric().PExpire(ctx, TestKey, 2500, gredis.ExpireOption{
|
|
NX: true,
|
|
})
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(0))
|
|
|
|
result, err = redis.GroupGeneric().PTTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertLE(result, int64(2500))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_PExpireAt(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().PExpireAt(ctx, TestKey, time.Now().Add(-time.Hour))
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
result, err = redis.GroupGeneric().TTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(-2))
|
|
result, err = redis.GroupGeneric().PTTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(-2))
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_PExpireTime(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
expireTime := time.Now().Add(time.Hour)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().PExpireAt(ctx, TestKey, expireTime)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
resultTime, err := redis.GroupGeneric().PExpireTime(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(resultTime.Int64(), gtime.NewFromTime(expireTime).TimestampMilli())
|
|
})
|
|
}
|
|
|
|
func Test_GroupGeneric_PTTL(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer redis.FlushDB(ctx)
|
|
|
|
_, err := redis.GroupString().Set(ctx, TestKey, TestValue)
|
|
t.AssertNil(err)
|
|
result, err := redis.GroupGeneric().Expire(ctx, TestKey, 1)
|
|
t.AssertNil(err)
|
|
t.AssertEQ(result, int64(1))
|
|
result, err = redis.GroupGeneric().PTTL(ctx, TestKey)
|
|
t.AssertNil(err)
|
|
t.AssertLE(result, int64(1000))
|
|
})
|
|
}
|