gf/contrib/nosql/redis/redis_z_group_hash_test.go
John Guo 6ff4ed84e5
version v2.3.0 ()
* v2.3.0

* up

* up

* up
2023-01-11 19:19:41 +08:00

336 lines
6.6 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"
"github.com/gogf/gf/v2/test/gtest"
)
func Test_GroupHash_HSet(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
field1 = "field1"
field1Value = "Hello"
fields = map[string]interface{}{
field1: field1Value,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HGet(ctx, key, field1)
t.AssertNil(err)
t.Assert(r1.String(), field1Value)
})
}
func Test_GroupHash_HSetNX(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
field1 = "field1"
field1Value = "Hello"
key = "myhash"
)
r1, err := redis.HSetNX(ctx, key, field1, field1Value)
t.AssertNil(err)
t.Assert(r1, 1)
r2, err := redis.HSetNX(ctx, key, field1, "World")
t.AssertNil(err)
t.Assert(r2, 0)
})
}
func Test_GroupHash_HStrLen(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
field1 = "field1"
field1Value = "Hello"
field2 = "field2"
field2Value = "Hello World"
fields = map[string]interface{}{
field1: field1Value,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
fieldValueLen, err := redis.HStrLen(ctx, key, field1)
t.AssertNil(err)
t.Assert(5, fieldValueLen)
fields[field2] = field2Value
_, err = redis.HSet(ctx, key, fields)
t.AssertNil(err)
fieldValueLen, err = redis.HStrLen(ctx, key, field2)
t.AssertNil(err)
t.Assert(11, fieldValueLen)
})
}
func Test_GroupHash_HExists(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
field1 = "field1"
field1Value = "Hello"
fields = map[string]interface{}{
field1: field1Value,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HExists(ctx, key, field1)
t.AssertNil(err)
t.Assert(1, r1)
r2, err := redis.HExists(ctx, key, "name")
t.AssertNil(err)
t.Assert(0, r2)
})
}
func Test_GroupHash_HDel(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
k1 = "k1"
v1 = "v1"
k2 = "k2"
v2 = "v2"
k3 = "k3"
v3 = "v3"
fields = map[string]interface{}{
k1: v1,
k2: v2,
k3: v3,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HDel(ctx, key, k1)
t.AssertNil(err)
t.Assert(1, r1)
r2, err := redis.HDel(ctx, key, k1)
t.AssertNil(err)
t.Assert(0, r2)
r3, err := redis.HDel(ctx, key, k2, k3)
t.AssertNil(err)
t.Assert(2, r3)
})
}
func Test_GroupHash_HLen(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
field1 = "field1"
field1Value = "Hello"
fields = map[string]interface{}{
field1: field1Value,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
fieldLen, err := redis.HLen(ctx, key)
t.AssertNil(err)
t.Assert(1, fieldLen)
fields = map[string]interface{}{
"k1": "v1",
"k2": "v2",
}
fieldLen, err = redis.HSet(ctx, key, fields)
t.AssertNil(err)
t.Assert(2, fieldLen)
})
}
func Test_GroupHash_HIncrBy(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
field1 = "field1"
field1Value = 1
fields = map[string]interface{}{
field1: field1Value,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HIncrBy(ctx, key, field1, 2)
t.AssertNil(err)
t.Assert(3, r1)
r2, err := redis.HGet(ctx, key, field1)
t.AssertNil(err)
t.Assert(3, r2.Int64())
r3, err := redis.HIncrBy(ctx, key, field1, -1)
t.AssertNil(err)
t.Assert(2, r3)
})
}
func Test_GroupHash_HIncrByFloat(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
field1 = "field1"
field1Value = 10.50
fields = map[string]interface{}{
field1: field1Value,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HIncrByFloat(ctx, key, field1, 0.1)
t.AssertNil(err)
t.Assert(10.60, r1)
r2, err := redis.HGet(ctx, key, field1)
t.AssertNil(err)
t.Assert(10.60, r2.Float64())
r3, err := redis.HIncrByFloat(ctx, key, field1, -5)
t.AssertNil(err)
t.Assert(5.60, r3)
})
}
func Test_GroupHash_HMSet(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
k1 = "k1"
v1 = "v1"
k2 = "k2"
v2 = "v2"
fields = map[string]interface{}{
k1: v1,
k2: v2,
}
)
err := redis.HMSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HGet(ctx, key, k1)
t.AssertNil(err)
t.Assert(r1.String(), v1)
r2, err := redis.HGet(ctx, key, k2)
t.AssertNil(err)
t.Assert(r2.String(), v2)
})
}
func Test_GroupHash_HMGet(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
k1 = "k1"
v1 = "v1"
k2 = "k2"
v2 = "v2"
fields = map[string]interface{}{
k1: v1,
k2: v2,
}
)
err := redis.HMSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HMGet(ctx, key, k1, k2)
t.AssertNil(err)
t.Assert(r1, []string{v1, v2})
})
}
func Test_GroupHash_HKeys(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
k1 = "k1"
v1 = "v1"
fields = map[string]interface{}{
k1: v1,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HKeys(ctx, key)
t.AssertNil(err)
t.Assert(r1, []string{k1})
})
}
func Test_GroupHash_HVals(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
k1 = "k1"
v1 = "v1"
fields = map[string]interface{}{
k1: v1,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HVals(ctx, key)
t.AssertNil(err)
t.Assert(r1, []string{v1})
})
}
func Test_GroupHash_HGetAll(t *testing.T) {
defer redis.FlushAll(ctx)
gtest.C(t, func(t *gtest.T) {
var (
key = "myhash"
k1 = "k1"
v1 = "v1"
k2 = "k2"
v2 = "v2"
fields = map[string]interface{}{
k1: v1,
k2: v2,
}
)
_, err := redis.HSet(ctx, key, fields)
t.AssertNil(err)
r1, err := redis.HGetAll(ctx, key)
t.Assert(r1.Map(), fields)
})
}