mock/mock_test.go at main

mirror of https://github.com/hanzokv/mock.git synced 2026-10-30 19:45:21 +00:00

Files

T

zeekayandHanzo Dev 7015fe8288 refactor: follow hanzokv/go v9.22.0 package rename redis -> kv

github.com/hanzokv/go/v9 v9.22.0 renamed its Go package from "redis" to
"kv"; the import path is unchanged. A mock library is typed against the
client it wraps, so this is not cosmetic: every exported signature in
this package (ClientMock, ClusterClientMock, all Expect* methods) is
expressed in terms of the client's types, and none of them resolve under
the old qualifier.

What changed:

- go.mod: github.com/hanzokv/go/v9 v9.21.1 -> v9.22.0
- every "redis." qualifier -> "kv." The import stays unaliased, matching
  the convention in hanzokv/go's own sources.
- package redismock -> package kvmock, matching the hanzokv/mock repo
- our own vocabulary follows the client it mocks: RedisNil() -> KVNil(),
  isRedisNil/redisNil -> isKVNil/kvNil, redisClientType -> kvClientType,
  redisClient/redisCluster -> kvClient/kvCluster,
  redisClientHook -> kvClientHook, TestRedisMock -> TestKVMock
- comments and README speak kv
- gofmt: import blocks in the ginkgo test files were left unsorted by the
  fork commit; formatting them is a side effect of touching them

Opaque test payloads are left alone -- they are data, not vocabulary.

Verified: go build ./..., go vet ./..., go test ./..., and
go test ./... -short -race all pass.

Co-authored-by: Hanzo Dev <[email protected]>

2026-07-26 08:42:54 -07:00

1788 lines

42 KiB

Go

Raw Permalink Blame History

 package kvmock
 import (
 	"context"
 	"errors"
 	"testing"
 	"time"
 	"github.com/hanzokv/go/v9"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 var (
 	ctx = context.TODO()
 )
 func TestKVMock(t *testing.T) {
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "kv mock")
 }
 func operationStringCmd(base baseMock, expected func() *ExpectedString, actual func() *kv.StringCmd) {
 	var (
 		setErr = errors.New("string cmd error")
 		str    string
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	str, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(str).To(Equal(""))
 	base.ClearExpect()
 	expected()
 	str, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(str).To(Equal(""))
 	base.ClearExpect()
 	expected().SetVal("value")
 	str, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(str).To(Equal("value"))
 }
 func operationStatusCmd(base baseMock, expected func() *ExpectedStatus, actual func() *kv.StatusCmd) {
 	var (
 		setErr = errors.New("status cmd error")
 		str    string
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	str, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(str).To(Equal(""))
 	base.ClearExpect()
 	expected()
 	str, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(str).To(Equal(""))
 	base.ClearExpect()
 	expected().SetVal("OK")
 	str, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(str).To(Equal("OK"))
 }
 func operationIntCmd(base baseMock, expected func() *ExpectedInt, actual func() *kv.IntCmd) {
 	var (
 		setErr = errors.New("int cmd error")
 		val    int64
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(int64(0)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(int64(0)))
 	base.ClearExpect()
 	expected().SetVal(1024)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(int64(1024)))
 }
 func operationBoolCmd(base baseMock, expected func() *ExpectedBool, actual func() *kv.BoolCmd) {
 	var (
 		setErr = errors.New("bool cmd error")
 		val    bool
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(BeFalse())
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(BeFalse())
 	base.ClearExpect()
 	expected().SetVal(true)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(BeTrue())
 }
 func operationStringSliceCmd(base baseMock, expected func() *ExpectedStringSlice, actual func() *kv.StringSliceCmd) {
 	var (
 		setErr = errors.New("string slice cmd error")
 		val    []string
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]string(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]string(nil)))
 	base.ClearExpect()
 	expected().SetVal([]string{"redis", "move"})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]string{"redis", "move"}))
 }
 func operationKeyValueSliceCmd(base baseMock, expected func() *ExpectedKeyValueSlice, actual func() *kv.KeyValueSliceCmd) {
 	var (
 		setErr = errors.New("key value slice cmd error")
 		val    []kv.KeyValue
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.KeyValue(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.KeyValue(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.KeyValue{
 		{Key: "k1", Value: "v1"},
 		{Key: "k2", Value: "v2"},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.KeyValue{
 		{Key: "k1", Value: "v1"},
 		{Key: "k2", Value: "v2"},
 	}))
 }
 func operationDurationCmd(base baseMock, expected func() *ExpectedDuration, actual func() *kv.DurationCmd) {
 	var (
 		setErr = errors.New("duration cmd error")
 		val    time.Duration
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(time.Duration(0)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(time.Duration(0)))
 	base.ClearExpect()
 	expected().SetVal(2 * time.Hour)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(2 * time.Hour))
 }
 func operationSliceCmd(base baseMock, expected func() *ExpectedSlice, actual func() *kv.SliceCmd) {
 	var (
 		setErr = errors.New("slice cmd error")
 		val    []interface{}
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]interface{}(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]interface{}(nil)))
 	base.ClearExpect()
 	expected().SetVal([]interface{}{"mock", "slice"})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]interface{}{"mock", "slice"}))
 }
 func operationFloatCmd(base baseMock, expected func() *ExpectedFloat, actual func() *kv.FloatCmd) {
 	var (
 		setErr = errors.New("float cmd error")
 		val    float64
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(float64(0)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(float64(0)))
 	base.ClearExpect()
 	expected().SetVal(1)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(float64(1)))
 }
 func operationFloatSliceCmd(base baseMock, expected func() *ExpectedFloatSlice, actual func() *kv.FloatSliceCmd) {
 	var (
 		setErr = errors.New("float slice cmd error")
 		val    []float64
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]float64(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]float64(nil)))
 	base.ClearExpect()
 	expected().SetVal([]float64{11.11, 22.22, 99.99999})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]float64{11.11, 22.22, 99.99999}))
 }
 func operationIntSliceCmd(base baseMock, expected func() *ExpectedIntSlice, actual func() *kv.IntSliceCmd) {
 	var (
 		setErr = errors.New("int slice cmd error")
 		val    []int64
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]int64(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]int64(nil)))
 	base.ClearExpect()
 	expected().SetVal([]int64{1, 2, 3, 4})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]int64{1, 2, 3, 4}))
 }
 func operationScanCmd(base baseMock, expected func() *ExpectedScan, actual func() *kv.ScanCmd) {
 	var (
 		setErr = errors.New("scan cmd error")
 		page   []string
 		cursor uint64
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	page, cursor, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(page).To(Equal([]string(nil)))
 	Expect(cursor).To(Equal(uint64(0)))
 	base.ClearExpect()
 	expected()
 	page, cursor, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(page).To(Equal([]string(nil)))
 	Expect(cursor).To(Equal(uint64(0)))
 	base.ClearExpect()
 	expected().SetVal([]string{"key1", "key2", "key3"}, 5)
 	page, cursor, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(page).To(Equal([]string{"key1", "key2", "key3"}))
 	Expect(cursor).To(Equal(uint64(5)))
 }
 func operationMapStringStringCmd(base baseMock, expected func() *ExpectedMapStringString, actual func() *kv.MapStringStringCmd) {
 	var (
 		setErr = errors.New("map string string cmd error")
 		val    map[string]string
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(map[string]string(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(map[string]string(nil)))
 	base.ClearExpect()
 	expected().SetVal(map[string]string{"key": "value", "key2": "value2"})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(map[string]string{"key": "value", "key2": "value2"}))
 }
 func operationStringStructMapCmd(base baseMock, expected func() *ExpectedStringStructMap, actual func() *kv.StringStructMapCmd) {
 	var (
 		setErr = errors.New("string struct map cmd error")
 		val    map[string]struct{}
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(map[string]struct{}(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(map[string]struct{}(nil)))
 	base.ClearExpect()
 	expected().SetVal([]string{"key1", "key2"})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(map[string]struct{}{"key1": {}, "key2": {}}))
 }
 func operationXMessageSliceCmd(base baseMock, expected func() *ExpectedXMessageSlice, actual func() *kv.XMessageSliceCmd) {
 	var (
 		setErr = errors.New("x message slice cmd error")
 		val    []kv.XMessage
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.XMessage(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.XMessage(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.XMessage{
 		{ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
 		{ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
 		{ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.XMessage{
 		{ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
 		{ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
 		{ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
 	}))
 }
 func operationXStreamSliceCmd(base baseMock, expected func() *ExpectedXStreamSlice, actual func() *kv.XStreamSliceCmd) {
 	var (
 		setErr = errors.New("x stream slice cmd error")
 		val    []kv.XStream
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.XStream(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.XStream(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.XStream{{
 		Stream: "stream",
 		Messages: []kv.XMessage{
 			{ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
 			{ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
 		}},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.XStream{{
 		Stream: "stream",
 		Messages: []kv.XMessage{
 			{ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
 			{ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
 		}},
 	}))
 }
 func operationXPendingCmd(base baseMock, expected func() *ExpectedXPending, actual func() *kv.XPendingCmd) {
 	var (
 		setErr = errors.New("x pending cmd error")
 		val    *kv.XPending
 		valNil *kv.XPending
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(valNil))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(valNil))
 	base.ClearExpect()
 	expected().SetVal(&kv.XPending{
 		Count:     3,
 		Lower:     "1-0",
 		Higher:    "3-0",
 		Consumers: map[string]int64{"consumer": 3},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(&kv.XPending{
 		Count:     3,
 		Lower:     "1-0",
 		Higher:    "3-0",
 		Consumers: map[string]int64{"consumer": 3},
 	}))
 }
 func operationXPendingExtCmd(base baseMock, expected func() *ExpectedXPendingExt, actual func() *kv.XPendingExtCmd) {
 	var (
 		setErr = errors.New("x pending ext cmd error")
 		val    []kv.XPendingExt
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.XPendingExt(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.XPendingExt(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.XPendingExt{
 		{ID: "1-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
 		{ID: "2-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
 		{ID: "3-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.XPendingExt{
 		{ID: "1-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
 		{ID: "2-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
 		{ID: "3-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
 	}))
 }
 func operationXAutoClaimCmd(base baseMock, expected func() *ExpectedXAutoClaim, actual func() *kv.XAutoClaimCmd) {
 	var (
 		setErr = errors.New("x auto claim cmd error")
 		start  string
 		val    []kv.XMessage
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, start, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(start).To(Equal(""))
 	Expect(val).To(Equal([]kv.XMessage(nil)))
 	base.ClearExpect()
 	expected()
 	val, start, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(start).To(Equal(""))
 	Expect(val).To(Equal([]kv.XMessage(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.XMessage{
 		{ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
 		{ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
 		{ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
 	}, "3-0")
 	val, start, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(start).To(Equal("3-0"))
 	Expect(val).To(Equal([]kv.XMessage{
 		{ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
 		{ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
 		{ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
 	}))
 }
 func operationXAutoClaimJustIDCmd(base baseMock, expected func() *ExpectedXAutoClaimJustID, actual func() *kv.XAutoClaimJustIDCmd) {
 	var (
 		setErr = errors.New("x auto claim just id cmd error")
 		start  string
 		val    []string
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, start, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(start).To(Equal(""))
 	Expect(val).To(Equal([]string(nil)))
 	base.ClearExpect()
 	expected()
 	val, start, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(start).To(Equal(""))
 	Expect(val).To(Equal([]string(nil)))
 	base.ClearExpect()
 	expected().SetVal([]string{"1-0", "2-0", "3-0"}, "3-0")
 	val, start, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(start).To(Equal("3-0"))
 	Expect(val).To(Equal([]string{"1-0", "2-0", "3-0"}))
 }
 func operationXInfoGroupsCmd(base baseMock, expected func() *ExpectedXInfoGroups, actual func() *kv.XInfoGroupsCmd) {
 	var (
 		setErr = errors.New("x info group cmd error")
 		val    []kv.XInfoGroup
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.XInfoGroup(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.XInfoGroup(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.XInfoGroup{
 		{Name: "name1", Consumers: 1, Pending: 2, LastDeliveredID: "last1"},
 		{Name: "name2", Consumers: 1, Pending: 2, LastDeliveredID: "last2"},
 		{Name: "name3", Consumers: 1, Pending: 2, LastDeliveredID: "last2"},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.XInfoGroup{
 		{Name: "name1", Consumers: 1, Pending: 2, LastDeliveredID: "last1"},
 		{Name: "name2", Consumers: 1, Pending: 2, LastDeliveredID: "last2"},
 		{Name: "name3", Consumers: 1, Pending: 2, LastDeliveredID: "last2"},
 	}))
 }
 func operationXInfoStreamCmd(base baseMock, expected func() *ExpectedXInfoStream, actual func() *kv.XInfoStreamCmd) {
 	var (
 		setErr = errors.New("x info stream cmd error")
 		val    *kv.XInfoStream
 		nilVal *kv.XInfoStream
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(nilVal))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(nilVal))
 	base.ClearExpect()
 	expected().SetVal(&kv.XInfoStream{
 		Length:          1,
 		RadixTreeKeys:   10,
 		RadixTreeNodes:  20,
 		Groups:          30,
 		LastGeneratedID: "id",
 		FirstEntry: kv.XMessage{
 			ID: "first_id",
 			Values: map[string]interface{}{
 				"first_key": "first_value",
 			},
 		},
 		LastEntry: kv.XMessage{
 			ID: "last_id",
 			Values: map[string]interface{}{
 				"last_key": "last_value",
 			},
 		},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(&kv.XInfoStream{
 		Length:          1,
 		RadixTreeKeys:   10,
 		RadixTreeNodes:  20,
 		Groups:          30,
 		LastGeneratedID: "id",
 		FirstEntry: kv.XMessage{
 			ID: "first_id",
 			Values: map[string]interface{}{
 				"first_key": "first_value",
 			},
 		},
 		LastEntry: kv.XMessage{
 			ID: "last_id",
 			Values: map[string]interface{}{
 				"last_key": "last_value",
 			},
 		},
 	}))
 }
 func operationXInfoConsumersCmd(base baseMock, expected func() *ExpectedXInfoConsumers, actual func() *kv.XInfoConsumersCmd) {
 	var (
 		setErr = errors.New("x info consumers cmd error")
 		val    []kv.XInfoConsumer
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.XInfoConsumer(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.XInfoConsumer(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.XInfoConsumer{
 		{
 			Name:    "c1",
 			Pending: 2,
 			Idle:    1,
 		},
 		{
 			Name:    "c2",
 			Pending: 1,
 			Idle:    2,
 		},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.XInfoConsumer{
 		{
 			Name:    "c1",
 			Pending: 2,
 			Idle:    1,
 		},
 		{
 			Name:    "c2",
 			Pending: 1,
 			Idle:    2,
 		},
 	}))
 }
 func operationXInfoStreamFullCmd(base baseMock, expected func() *ExpectedXInfoStreamFull, actual func() *kv.XInfoStreamFullCmd) {
 	var (
 		setErr = errors.New("x info stream full cmd error")
 		val    *kv.XInfoStreamFull
 		valNil *kv.XInfoStreamFull
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(valNil))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(valNil))
 	now := time.Now()
 	now2 := now.Add(3 * time.Hour)
 	now3 := now.Add(5 * time.Hour)
 	now4 := now.Add(6 * time.Hour)
 	now5 := now.Add(8 * time.Hour)
 	now6 := now.Add(9 * time.Hour)
 	base.ClearExpect()
 	expected().SetVal(&kv.XInfoStreamFull{
 		Length:          3,
 		RadixTreeKeys:   4,
 		RadixTreeNodes:  5,
 		LastGeneratedID: "3-3",
 		Entries: []kv.XMessage{
 			{
 				ID: "1-0",
 				Values: map[string]interface{}{
 					"key1": "val1",
 					"key2": "val2",
 				},
 			},
 		},
 		Groups: []kv.XInfoStreamGroup{
 			{
 				Name:            "group1",
 				LastDeliveredID: "10-1",
 				PelCount:        3,
 				Pending: []kv.XInfoStreamGroupPending{
 					{
 						ID:            "5-1",
 						Consumer:      "consumer1",
 						DeliveryTime:  now,
 						DeliveryCount: 9,
 					},
 					{
 						ID:            "5-2",
 						Consumer:      "consumer2",
 						DeliveryTime:  now,
 						DeliveryCount: 8,
 					},
 				},
 				Consumers: []kv.XInfoStreamConsumer{
 					{
 						Name:     "consumer3",
 						SeenTime: now2,
 						PelCount: 7,
 						Pending: []kv.XInfoStreamConsumerPending{
 							{
 								ID:            "6-1",
 								DeliveryTime:  now3,
 								DeliveryCount: 3,
 							},
 							{
 								ID:            "6-2",
 								DeliveryTime:  now4,
 								DeliveryCount: 2,
 							},
 						},
 					},
 					{
 						Name:     "consumer4",
 						SeenTime: now,
 						PelCount: 6,
 						Pending: []kv.XInfoStreamConsumerPending{
 							{
 								ID:            "7-1",
 								DeliveryTime:  now5,
 								DeliveryCount: 5,
 							},
 							{
 								ID:            "8-2",
 								DeliveryTime:  now6,
 								DeliveryCount: 6,
 							},
 						},
 					},
 				},
 			},
 		},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(&kv.XInfoStreamFull{
 		Length:          3,
 		RadixTreeKeys:   4,
 		RadixTreeNodes:  5,
 		LastGeneratedID: "3-3",
 		Entries: []kv.XMessage{
 			{
 				ID: "1-0",
 				Values: map[string]interface{}{
 					"key1": "val1",
 					"key2": "val2",
 				},
 			},
 		},
 		Groups: []kv.XInfoStreamGroup{
 			{
 				Name:            "group1",
 				LastDeliveredID: "10-1",
 				PelCount:        3,
 				Pending: []kv.XInfoStreamGroupPending{
 					{
 						ID:            "5-1",
 						Consumer:      "consumer1",
 						DeliveryTime:  now,
 						DeliveryCount: 9,
 					},
 					{
 						ID:            "5-2",
 						Consumer:      "consumer2",
 						DeliveryTime:  now,
 						DeliveryCount: 8,
 					},
 				},
 				Consumers: []kv.XInfoStreamConsumer{
 					{
 						Name:     "consumer3",
 						SeenTime: now2,
 						PelCount: 7,
 						Pending: []kv.XInfoStreamConsumerPending{
 							{
 								ID:            "6-1",
 								DeliveryTime:  now3,
 								DeliveryCount: 3,
 							},
 							{
 								ID:            "6-2",
 								DeliveryTime:  now4,
 								DeliveryCount: 2,
 							},
 						},
 					},
 					{
 						Name:     "consumer4",
 						SeenTime: now,
 						PelCount: 6,
 						Pending: []kv.XInfoStreamConsumerPending{
 							{
 								ID:            "7-1",
 								DeliveryTime:  now5,
 								DeliveryCount: 5,
 							},
 							{
 								ID:            "8-2",
 								DeliveryTime:  now6,
 								DeliveryCount: 6,
 							},
 						},
 					},
 				},
 			},
 		},
 	}))
 }
 func operationZWithKeyCmd(base baseMock, expected func() *ExpectedZWithKey, actual func() *kv.ZWithKeyCmd) {
 	var (
 		setErr = errors.New("z with key cmd error")
 		val    *kv.ZWithKey
 		valNil *kv.ZWithKey
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(valNil))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(valNil))
 	base.ClearExpect()
 	expected().SetVal(&kv.ZWithKey{
 		Z: kv.Z{
 			Score:  3,
 			Member: "three",
 		},
 		Key: "zset1",
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(&kv.ZWithKey{
 		Z: kv.Z{
 			Score:  3,
 			Member: "three",
 		},
 		Key: "zset1",
 	}))
 }
 func operationZSliceCmd(base baseMock, expected func() *ExpectedZSlice, actual func() *kv.ZSliceCmd) {
 	var (
 		setErr = errors.New("z slice cmd error")
 		val    []kv.Z
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.Z(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.Z(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.Z{{
 		Score:  5,
 		Member: "one",
 	}, {
 		Score:  10,
 		Member: "two",
 	}})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.Z{{
 		Score:  5,
 		Member: "one",
 	}, {
 		Score:  10,
 		Member: "two",
 	}}))
 }
 func operationTimeCmd(base baseMock, expected func() *ExpectedTime, actual func() *kv.TimeCmd) {
 	var (
 		setErr = errors.New("time cmd error")
 		val    time.Time
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(time.Time{}))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(time.Time{}))
 	base.ClearExpect()
 	now := time.Now()
 	expected().SetVal(now)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(now))
 }
 func operationCmdCmd(base baseMock, expected func() *ExpectedCmd, actual func() *kv.Cmd) {
 	var (
 		setErr = errors.New("cmd error")
 		val    interface{}
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(BeNil())
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(BeNil())
 	base.ClearExpect()
 	expected().SetVal(interface{}(1024))
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(interface{}(1024)))
 }
 func operationBoolSliceCmd(base baseMock, expected func() *ExpectedBoolSlice, actual func() *kv.BoolSliceCmd) {
 	var (
 		setErr = errors.New("bool slice cmd error")
 		val    []bool
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]bool(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]bool(nil)))
 	base.ClearExpect()
 	expected().SetVal([]bool{true, false, true})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]bool{true, false, true}))
 }
 func operationMapStringIntCmd(base baseMock, expected func() *ExpectedMapStringInt, actual func() *kv.MapStringIntCmd) {
 	var (
 		setErr = errors.New("map string int cmd error")
 		val    map[string]int64
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(map[string]int64(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(map[string]int64(nil)))
 	base.ClearExpect()
 	expected().SetVal(map[string]int64{"key": 1, "key2": 2})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(map[string]int64{"key": 1, "key2": 2}))
 }
 func operationClusterSlotsCmd(base baseMock, expected func() *ExpectedClusterSlots, actual func() *kv.ClusterSlotsCmd) {
 	var (
 		setErr = errors.New("cluster slots cmd error")
 		val    []kv.ClusterSlot
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.ClusterSlot(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.ClusterSlot(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.ClusterSlot{
 		{Start: 1, End: 2, Nodes: []kv.ClusterNode{
 			{ID: "1", Addr: "1.1.1.1"},
 			{ID: "2", Addr: "2.2.2.2"},
 		}},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.ClusterSlot{
 		{Start: 1, End: 2, Nodes: []kv.ClusterNode{
 			{ID: "1", Addr: "1.1.1.1"},
 			{ID: "2", Addr: "2.2.2.2"},
 		}},
 	}))
 }
 func operationClusterLinksCmd(base baseMock, expected func() *ExpectedClusterLinks, actual func() *kv.ClusterLinksCmd) {
 	var (
 		setErr = errors.New("cluster links cmd error")
 		val    []kv.ClusterLink
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.ClusterLink(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.ClusterLink(nil)))
 	links := []kv.ClusterLink{
 		{
 			Direction:           "to",
 			Node:                "8149d745fa551e40764fecaf7cab9dbdf6b659ae",
 			CreateTime:          1639442739375,
 			Events:              "rw",
 			SendBufferAllocated: 4512,
 			SendBufferUsed:      1254,
 		},
 		{
 			Direction:           "from",
 			Node:                "8149d745fa551e40764fecaf7cab9dbdf6b659ae",
 			CreateTime:          1639442739411,
 			Events:              "r",
 			SendBufferAllocated: 0,
 			SendBufferUsed:      0,
 		},
 	}
 	base.ClearExpect()
 	expected().SetVal(links)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(links))
 }
 func operationGeoLocationCmd(base baseMock, expected func() *ExpectedGeoLocation, actual func() *kv.GeoLocationCmd) {
 	var (
 		setErr = errors.New("geo location cmd error")
 		val    []kv.GeoLocation
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.GeoLocation(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.GeoLocation(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.GeoLocation{
 		{Longitude: 13.361389, Latitude: 38.115556, Name: "Palermo"},
 		{Longitude: 15.087269, Latitude: 37.502669, Name: "Catania"},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.GeoLocation{
 		{Longitude: 13.361389, Latitude: 38.115556, Name: "Palermo"},
 		{Longitude: 15.087269, Latitude: 37.502669, Name: "Catania"},
 	}))
 }
 func operationGeoPosCmd(base baseMock, expected func() *ExpectedGeoPos, actual func() *kv.GeoPosCmd) {
 	var (
 		setErr = errors.New("geo pos cmd error")
 		val    []*kv.GeoPos
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]*kv.GeoPos(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]*kv.GeoPos(nil)))
 	base.ClearExpect()
 	expected().SetVal([]*kv.GeoPos{
 		{
 			Longitude: 13.361389338970184,
 			Latitude:  38.1155563954963,
 		},
 		{
 			Longitude: 15.087267458438873,
 			Latitude:  37.50266842333162,
 		},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]*kv.GeoPos{
 		{
 			Longitude: 13.361389338970184,
 			Latitude:  38.1155563954963,
 		},
 		{
 			Longitude: 15.087267458438873,
 			Latitude:  37.50266842333162,
 		},
 	}))
 }
 func operationGeoSearchLocationCmd(base baseMock, expected func() *ExpectedGeoSearchLocation, actual func() *kv.GeoSearchLocationCmd) {
 	var (
 		setErr = errors.New("geo search location cmd error")
 		val    []kv.GeoLocation
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.GeoLocation(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.GeoLocation(nil)))
 	base.ClearExpect()
 	expected().SetVal([]kv.GeoLocation{
 		{
 			Name:      "Catania",
 			Longitude: 15.08726745843887329,
 			Latitude:  37.50266842333162032,
 			Dist:      56.4413,
 			GeoHash:   3479447370796909,
 		},
 		{
 			Name:      "Palermo",
 			Longitude: 13.36138933897018433,
 			Latitude:  38.11555639549629859,
 			Dist:      190.4424,
 			GeoHash:   3479099956230698,
 		},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.GeoLocation{
 		{
 			Name:      "Catania",
 			Longitude: 15.08726745843887329,
 			Latitude:  37.50266842333162032,
 			Dist:      56.4413,
 			GeoHash:   3479447370796909,
 		},
 		{
 			Name:      "Palermo",
 			Longitude: 13.36138933897018433,
 			Latitude:  38.11555639549629859,
 			Dist:      190.4424,
 			GeoHash:   3479099956230698,
 		},
 	}))
 }
 func operationSlowLogCmd(base baseMock, expected func() *ExpectedSlowLog, actual func() *kv.SlowLogCmd) {
 	var (
 		setErr = errors.New("slow log cmd error")
 		val    []kv.SlowLog
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.SlowLog(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.SlowLog(nil)))
 	now := time.Now()
 	now1 := now.Add(time.Hour)
 	base.ClearExpect()
 	expected().SetVal([]kv.SlowLog{
 		{
 			ID:         1,
 			Time:       now,
 			Duration:   3 * time.Millisecond,
 			Args:       []string{"a", "b", "c"},
 			ClientAddr: "127.0.0.1:1234",
 			ClientName: "client_hi",
 		},
 		{
 			ID:         2,
 			Time:       now1,
 			Duration:   4 * time.Millisecond,
 			Args:       []string{"x", "y", "z"},
 			ClientAddr: "127.0.0.1:6379",
 			ClientName: "client_hi",
 		},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal([]kv.SlowLog{
 		{
 			ID:         1,
 			Time:       now,
 			Duration:   3 * time.Millisecond,
 			Args:       []string{"a", "b", "c"},
 			ClientAddr: "127.0.0.1:1234",
 			ClientName: "client_hi",
 		},
 		{
 			ID:         2,
 			Time:       now1,
 			Duration:   4 * time.Millisecond,
 			Args:       []string{"x", "y", "z"},
 			ClientAddr: "127.0.0.1:6379",
 			ClientName: "client_hi",
 		},
 	}))
 }
 func operationKeyValuesCmd(base baseMock, expected func() *ExpectedKeyValues, actual func() *kv.KeyValuesCmd) {
 	var (
 		setErr = errors.New("key values cmd error")
 		key    string
 		val    []string
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	key, val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(key).To(Equal(""))
 	Expect(val).To(Equal([]string(nil)))
 	base.ClearExpect()
 	expected()
 	key, val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(key).To(Equal(""))
 	Expect(val).To(Equal([]string(nil)))
 	base.ClearExpect()
 	expected().SetVal("key1", []string{"v1", "v2"})
 	key, val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(key).To(Equal("key1"))
 	Expect(val).To(Equal([]string{"v1", "v2"}))
 }
 func operationZSliceWithKeyCmd(base baseMock, expected func() *ExpectedZSliceWithKey, actual func() *kv.ZSliceWithKeyCmd) {
 	var (
 		setErr = errors.New("z slice with key cmd error")
 		key    string
 		val    []kv.Z
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	key, val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(key).To(Equal(""))
 	Expect(val).To(Equal([]kv.Z(nil)))
 	base.ClearExpect()
 	expected()
 	key, val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(key).To(Equal(""))
 	Expect(val).To(Equal([]kv.Z(nil)))
 	base.ClearExpect()
 	expected().SetVal("key1", []kv.Z{
 		{Score: 100, Member: "one"},
 		{Score: 200, Member: "two"},
 	})
 	key, val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(key).To(Equal("key1"))
 	Expect(val).To(Equal([]kv.Z{
 		{Score: 100, Member: "one"},
 		{Score: 200, Member: "two"},
 	}))
 }
 func operationFunctionListCmd(base baseMock, expected func() *ExpectedFunctionList, actual func() *kv.FunctionListCmd) {
 	var (
 		setErr = errors.New("function list cmd error")
 		val    []kv.Library
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.Library(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.Library(nil)))
 	libs := []kv.Library{
 		{
 			Name:   "lib1",
 			Engine: "LUA",
 			Functions: []kv.Function{
 				{
 					Name:        "lib1func1",
 					Description: "lib1 func1 desc",
 					Flags:       []string{"no-writes", "allow-stale"},
 				},
 			},
 			Code: "test code 1",
 		},
 		{
 			Name:   "lib2",
 			Engine: "LUA",
 			Functions: []kv.Function{
 				{
 					Name:        "lib2func1",
 					Description: "lib1 func1 desc",
 					Flags:       []string{"no-writes", "allow-stale"},
 				},
 				{
 					Name:        "lib2func2",
 					Description: "lib2 func2 desc",
 					Flags:       []string{"no-writes"},
 				},
 			},
 			Code: "test code 2",
 		},
 	}
 	base.ClearExpect()
 	expected().SetVal(libs)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(libs))
 }
 func operationLCSCmd(base baseMock, expected func() *ExpectedLCS, actual func() *kv.LCSCmd) {
 	var (
 		setErr = errors.New("lcs cmd error")
 		val    *kv.LCSMatch
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(BeNil())
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(BeNil())
 	lcs := &kv.LCSMatch{
 		MatchString: "match string",
 	}
 	base.ClearExpect()
 	expected().SetVal(lcs)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(lcs))
 	lcs = &kv.LCSMatch{
 		MatchString: "",
 		Matches: []kv.LCSMatchedPosition{
 			{
 				Key1:     kv.LCSPosition{Start: 3, End: 5},
 				Key2:     kv.LCSPosition{Start: 1, End: 3},
 				MatchLen: 2,
 			},
 			{
 				Key1:     kv.LCSPosition{Start: 5, End: 8},
 				Key2:     kv.LCSPosition{Start: 2, End: 5},
 				MatchLen: 3,
 			},
 		},
 		Len: 3,
 	}
 	base.ClearExpect()
 	expected().SetVal(lcs)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(lcs))
 }
 func operationKeyFlagsCmd(base baseMock, expected func() *ExpectedKeyFlags, actual func() *kv.KeyFlagsCmd) {
 	var (
 		setErr = errors.New("key flags cmd error")
 		val    []kv.KeyFlags
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.KeyFlags(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.KeyFlags(nil)))
 	kfs := []kv.KeyFlags{
 		{
 			Key:   "test1",
 			Flags: []string{"flag1", "flag2"},
 		},
 		{
 			Key:   "test2",
 			Flags: []string{"flag3", "flag4"},
 		},
 	}
 	base.ClearExpect()
 	expected().SetVal(kfs)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(kfs))
 }
 func operationClusterShardsCmd(base baseMock, expected func() *ExpectedClusterShards, actual func() *kv.ClusterShardsCmd) {
 	var (
 		setErr = errors.New("cluster shareds cmd error")
 		val    []kv.ClusterShard
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.ClusterShard(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.ClusterShard(nil)))
 	cs := []kv.ClusterShard{
 		{
 			Slots: []kv.SlotRange{
 				{Start: 0, End: 1999},
 				{Start: 4000, End: 5999},
 			},
 			Nodes: []kv.Node{
 				{
 					ID:                "e10b7051d6bf2d5febd39a2be297bbaea6084111",
 					Endpoint:          "127.0.0.1",
 					IP:                "127.0.0.1",
 					Hostname:          "host",
 					Port:              30001,
 					TLSPort:           1999,
 					Role:              "master",
 					ReplicationOffset: 72156,
 					Health:            "online",
 				},
 				{
 					ID:                "fd20502fe1b32fc32c15b69b0a9537551f162f1f",
 					Endpoint:          "127.0.0.1",
 					IP:                "127.0.0.1",
 					Hostname:          "host",
 					Port:              30002,
 					TLSPort:           1999,
 					Role:              "replica",
 					ReplicationOffset: 72156,
 					Health:            "online",
 				},
 			},
 		},
 	}
 	base.ClearExpect()
 	expected().SetVal(cs)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(cs))
 }
 func operationTSTimestampValueCmd(base baseMock, expected func() *ExpectedTSTimestampValue, actual func() *kv.TSTimestampValueCmd) {
 	var (
 		setErr = errors.New("ts timestamp value cmd error")
 		val    kv.TSTimestampValue
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(kv.TSTimestampValue{}))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(kv.TSTimestampValue{}))
 	tsv := kv.TSTimestampValue{
 		Timestamp: 1000,
 		Value:     1,
 	}
 	base.ClearExpect()
 	expected().SetVal(tsv)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(tsv))
 }
 func operationMapStringInterfaceCmd(base baseMock, expected func() *ExpectedMapStringInterface, actual func() *kv.MapStringInterfaceCmd) {
 	var (
 		setErr = errors.New("map string interface cmd error")
 		val    map[string]interface{}
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(map[string]interface{}(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(map[string]interface{}(nil)))
 	base.ClearExpect()
 	expected().SetVal(map[string]interface{}{
 		"key1": "val1",
 		"key2": 2,
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(map[string]interface{}{
 		"key1": "val1",
 		"key2": 2,
 	}))
 }
 func operationTSTimestampValueSliceCmd(base baseMock, expected func() *ExpectedTSTimestampValueSlice, actual func() *kv.TSTimestampValueSliceCmd) {
 	var (
 		setErr = errors.New("ts timestamp value slice cmd error")
 		val    []kv.TSTimestampValue
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal([]kv.TSTimestampValue(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal([]kv.TSTimestampValue(nil)))
 	tsv := []kv.TSTimestampValue{
 		{
 			Timestamp: 1000,
 			Value:     1,
 		},
 		{
 			Timestamp: 2000,
 			Value:     2,
 		},
 	}
 	base.ClearExpect()
 	expected().SetVal(tsv)
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(tsv))
 }
 func operationMapStringSliceInterfaceCmd(base baseMock, expected func() *ExpectedMapStringSliceInterface, actual func() *kv.MapStringSliceInterfaceCmd) {
 	var (
 		setErr = errors.New("map string slice interface cmd error")
 		val    map[string][]interface{}
 		err    error
 	)
 	base.ClearExpect()
 	expected().SetErr(setErr)
 	val, err = actual().Result()
 	Expect(err).To(Equal(setErr))
 	Expect(val).To(Equal(map[string][]interface{}(nil)))
 	base.ClearExpect()
 	expected()
 	val, err = actual().Result()
 	Expect(err).To(HaveOccurred())
 	Expect(val).To(Equal(map[string][]interface{}(nil)))
 	base.ClearExpect()
 	expected().SetVal(map[string][]interface{}{
 		"key1": {"val1", 1},
 		"key2": {"val2", 2},
 	})
 	val, err = actual().Result()
 	Expect(err).NotTo(HaveOccurred())
 	Expect(val).To(Equal(map[string][]interface{}{
 		"key1": {"val1", 1},
 		"key2": {"val2", 2},
 	}))
 }

1788 lines 42 KiB Go Raw Permalink Blame History

1788 lines

42 KiB

Go

Raw Permalink Blame History