From 34d412c48b5bb774ba5fc5f2d9cf33d7c4446a68 Mon Sep 17 00:00:00 2001 From: PYxy Date: Wed, 27 Sep 2023 17:07:13 +0800 Subject: [PATCH 01/10] =?UTF-8?q?ActiveRequest=20=E9=99=90=E6=B5=81=20?= =?UTF-8?q?=E5=8D=95=E6=9C=BA=20=E4=BB=A5=E5=8F=8A=20redis=20=E9=9B=86?= =?UTF-8?q?=E7=BE=A4=E9=99=90=E6=B5=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- go.mod | 1 + go.sum | 2 + .../activelimit/local_limit/locallimit.go | 34 ++ .../local_limit/locallimit_test.go | 90 +++++ internal/activelimit/mocks/active_mock.go | 65 ++++ .../activelimit/redis_limit/activeAdd.lua | 14 + .../activelimit/redis_limit/activeSub.lua | 13 + .../activelimit/redis_limit/redislimit.go | 32 ++ .../redis_limit/redislimit_test.go | 159 +++++++++ internal/activelimit/type.go | 8 + internal/integration/activelimit_test.go | 331 ++++++++++++++++++ middlewares/activelimit/builder.go | 84 +++++ middlewares/activelimit/builder_test.go | 156 +++++++++ 13 files changed, 989 insertions(+) create mode 100644 internal/activelimit/local_limit/locallimit.go create mode 100644 internal/activelimit/local_limit/locallimit_test.go create mode 100644 internal/activelimit/mocks/active_mock.go create mode 100644 internal/activelimit/redis_limit/activeAdd.lua create mode 100644 internal/activelimit/redis_limit/activeSub.lua create mode 100644 internal/activelimit/redis_limit/redislimit.go create mode 100644 internal/activelimit/redis_limit/redislimit_test.go create mode 100644 internal/activelimit/type.go create mode 100644 internal/integration/activelimit_test.go create mode 100644 middlewares/activelimit/builder.go create mode 100644 middlewares/activelimit/builder_test.go diff --git a/go.mod b/go.mod index 379257d..f055963 100644 --- a/go.mod +++ b/go.mod @@ -6,6 +6,7 @@ require ( github.com/gin-gonic/gin v1.9.1 github.com/redis/go-redis/v9 v9.1.0 github.com/stretchr/testify v1.8.3 + go.uber.org/atomic v1.11.0 go.uber.org/mock v0.3.0 ) diff --git a/go.sum b/go.sum index 6376821..0ded11c 100644 --- a/go.sum +++ b/go.sum @@ -70,6 +70,8 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= go.uber.org/mock v0.3.0 h1:3mUxI1No2/60yUYax92Pt8eNOEecx2D3lcXZh2NEZJo= go.uber.org/mock v0.3.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= diff --git a/internal/activelimit/local_limit/locallimit.go b/internal/activelimit/local_limit/locallimit.go new file mode 100644 index 0000000..15ab11e --- /dev/null +++ b/internal/activelimit/local_limit/locallimit.go @@ -0,0 +1,34 @@ +package local_limit + +import ( + "context" + + "go.uber.org/atomic" +) + +type LocalLimit struct { + countActive *atomic.Int64 + //这里可以增加字段 以及对应的字段进行 分别限流 + //先判断总数 再判断单个限流目标的数量就行 +} + +func NewLocalLimit() *LocalLimit { + return &LocalLimit{ + countActive: atomic.NewInt64(0), + } +} + +func (l *LocalLimit) Add(ctx context.Context, key string, maxCount int64) (bool, error) { + // 并直接占坑成功 + if l.countActive.Add(1) <= maxCount { + return false, nil + } else { + l.countActive.Sub(1) + return true, nil + } +} + +func (l *LocalLimit) Sub(ctx context.Context, key string) (bool, error) { + l.countActive.Sub(1) + return true, nil +} diff --git a/internal/activelimit/local_limit/locallimit_test.go b/internal/activelimit/local_limit/locallimit_test.go new file mode 100644 index 0000000..3f549c1 --- /dev/null +++ b/internal/activelimit/local_limit/locallimit_test.go @@ -0,0 +1,90 @@ +package local_limit + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func TestNewLocalLimit(t *testing.T) { + testCases := []struct { + name string + createLimit func() *LocalLimit + before func(localLimit *LocalLimit, key string, maxCount int64) + maxCount int64 + key string + wantBool bool + wantErr error + interval time.Duration + }{ + { + name: "正常操作", + + createLimit: func() *LocalLimit { + return NewLocalLimit() + }, + before: func(localLimit *LocalLimit, key string, maxCount int64) { + //limited, err := localLimit.Add(context.Background(), key, maxCount) + //assert.Equal(t, limited, false) + //assert.Equal(t, err, nil) + }, + maxCount: 1, + key: "test", + wantBool: false, + wantErr: nil, + }, + { + name: "请求过多了", + + createLimit: func() *LocalLimit { + return NewLocalLimit() + }, + before: func(localLimit *LocalLimit, key string, maxCount int64) { + limited, err := localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, false) + assert.Equal(t, err, nil) + }, + maxCount: 1, + key: "test", + wantBool: true, + wantErr: nil, + }, + { + name: "请求过多了,等待别人退出", + + createLimit: func() *LocalLimit { + return NewLocalLimit() + }, + before: func(localLimit *LocalLimit, key string, maxCount int64) { + limited, err := localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, false) + assert.Equal(t, err, nil) + go func() { + time.Sleep(time.Millisecond * 10) + limited, err = localLimit.Sub(context.Background(), key) + assert.Equal(t, limited, true) + assert.Equal(t, err, nil) + }() + + }, + interval: time.Millisecond * 20, + maxCount: 1, + key: "test", + wantBool: false, + wantErr: nil, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + l := tc.createLimit() + tc.before(l, tc.key, tc.maxCount) + time.Sleep(tc.interval) + limited, err := l.Add(context.Background(), tc.key, tc.maxCount) + assert.Equal(t, tc.wantErr, err) + assert.Equal(t, tc.wantBool, limited) + }) + } +} diff --git a/internal/activelimit/mocks/active_mock.go b/internal/activelimit/mocks/active_mock.go new file mode 100644 index 0000000..802b4d8 --- /dev/null +++ b/internal/activelimit/mocks/active_mock.go @@ -0,0 +1,65 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: F:\git_push\ginx\internal\activelimit\type.go + +// Package activeLimitmocks is a generated GoMock package. +package activeLimitmocks + +import ( + context "context" + reflect "reflect" + + gomock "go.uber.org/mock/gomock" +) + +// MockLimiter is a mock of Limiter interface. +type MockLimiter struct { + ctrl *gomock.Controller + recorder *MockLimiterMockRecorder +} + +// MockLimiterMockRecorder is the mock recorder for MockLimiter. +type MockLimiterMockRecorder struct { + mock *MockLimiter +} + +// NewMockLimiter creates a new mock instance. +func NewMockLimiter(ctrl *gomock.Controller) *MockLimiter { + mock := &MockLimiter{ctrl: ctrl} + mock.recorder = &MockLimiterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockLimiter) EXPECT() *MockLimiterMockRecorder { + return m.recorder +} + +// Add mocks base method. +func (m *MockLimiter) Add(ctx context.Context, key string, maxCount int64) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Add", ctx, key, maxCount) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Add indicates an expected call of Add. +func (mr *MockLimiterMockRecorder) Add(ctx, key, maxCount interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockLimiter)(nil).Add), ctx, key, maxCount) +} + +// Sub mocks base method. +func (m *MockLimiter) Sub(ctx context.Context, key string) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Sub", ctx, key) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Sub indicates an expected call of Sub. +func (mr *MockLimiterMockRecorder) Sub(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sub", reflect.TypeOf((*MockLimiter)(nil).Sub), ctx, key) +} diff --git a/internal/activelimit/redis_limit/activeAdd.lua b/internal/activelimit/redis_limit/activeAdd.lua new file mode 100644 index 0000000..bdadb71 --- /dev/null +++ b/internal/activelimit/redis_limit/activeAdd.lua @@ -0,0 +1,14 @@ +-- 限流对象 +local key = KEYS[1] +-- 最大限流个数 +local maxActive = tonumber(ARGV[1]) + +local countActive = tonumber(redis.call('INCR', key)) +if countActive <= maxActive then + return "false" +else + redis.call('DECR', key) + return "true" +end + + diff --git a/internal/activelimit/redis_limit/activeSub.lua b/internal/activelimit/redis_limit/activeSub.lua new file mode 100644 index 0000000..94c9c92 --- /dev/null +++ b/internal/activelimit/redis_limit/activeSub.lua @@ -0,0 +1,13 @@ +-- 限流对象 +local key = KEYS[1] + +local curCnt = tonumber(redis.call('DECR', key)) +if curCnt < 0 then + redis.call('Set', key, 0) + return "false" +else + return "true" +end + + + diff --git a/internal/activelimit/redis_limit/redislimit.go b/internal/activelimit/redis_limit/redislimit.go new file mode 100644 index 0000000..2ba4d70 --- /dev/null +++ b/internal/activelimit/redis_limit/redislimit.go @@ -0,0 +1,32 @@ +package redis_limit + +import ( + "context" + _ "embed" + + "github.com/redis/go-redis/v9" +) + +//go:embed activeAdd.lua +var LuaActiveAdd string + +//go:embed activeSub.lua +var LuaActiveSub string + +type RedisLimit struct { + cmd redis.Cmdable +} + +func NewRedisLimit(cmd redis.Cmdable) *RedisLimit { + return &RedisLimit{cmd: cmd} +} + +func (r *RedisLimit) Add(ctx context.Context, key string, maxCount int64) (bool, error) { + //TODO implement me + return r.cmd.Eval(ctx, LuaActiveAdd, []string{key}, maxCount).Bool() +} + +func (r *RedisLimit) Sub(ctx context.Context, key string) (bool, error) { + //TODO implement me + return r.cmd.Eval(ctx, LuaActiveSub, []string{key}).Bool() +} diff --git a/internal/activelimit/redis_limit/redislimit_test.go b/internal/activelimit/redis_limit/redislimit_test.go new file mode 100644 index 0000000..bc314ed --- /dev/null +++ b/internal/activelimit/redis_limit/redislimit_test.go @@ -0,0 +1,159 @@ +package redis_limit + +import ( + "context" + "testing" + "time" + + "github.com/redis/go-redis/v9" + "github.com/stretchr/testify/assert" +) + +func TestNewRedisLimit(t *testing.T) { + redisClient := redis.NewClient(&redis.Options{ + Addr: "localhost:16379", + Password: "", + DB: 0, + }) + ctx, cancel := context.WithTimeout(context.Background(), time.Second*3) + defer cancel() + err := redisClient.Ping(ctx).Err() + if err != nil { + panic("redis 连接失败") + } + testCases := []struct { + name string + createLimit func() *RedisLimit + before func(localLimit *RedisLimit, key string, maxCount int64) + + maxCount int64 + key string + wantBool bool + wantErr error + interval time.Duration + after func(localLimit *RedisLimit, string2 string) (int64, error) + afterCount int64 + afterErr error + }{ + { + name: "正常通行没有退出", + createLimit: func() *RedisLimit { + return NewRedisLimit(redisClient) + }, + before: func(localLimit *RedisLimit, key string, maxCount int64) { + + }, + maxCount: 1, + key: "test", + wantBool: false, + wantErr: nil, + after: func(localLimit *RedisLimit, key string) (int64, error) { + defer func() { + redisClient.Del(context.Background(), key) + }() + return redisClient.Get(context.Background(), key).Int64() + }, + afterCount: 1, + afterErr: nil, + }, + { + name: "正常通行并退出", + createLimit: func() *RedisLimit { + return NewRedisLimit(redisClient) + }, + before: func(localLimit *RedisLimit, key string, maxCount int64) { + + }, + maxCount: 1, + key: "test", + wantBool: false, + wantErr: nil, + after: func(localLimit *RedisLimit, key string) (int64, error) { + defer func() { + redisClient.Del(context.Background(), key) + }() + //退出 + limited, err := localLimit.Sub(context.Background(), key) + assert.Equal(t, limited, true) + assert.Equal(t, err, nil) + return redisClient.Get(context.Background(), key).Int64() + }, + afterCount: 0, + afterErr: nil, + }, + { + name: "被阻塞", + createLimit: func() *RedisLimit { + return NewRedisLimit(redisClient) + }, + before: func(localLimit *RedisLimit, key string, maxCount int64) { + limited, err := localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, false) + assert.Equal(t, err, nil) + }, + maxCount: 1, + key: "test", + wantBool: true, + wantErr: nil, + after: func(localLimit *RedisLimit, key string) (int64, error) { + defer func() { + redisClient.Del(context.Background(), key) + }() + //退出 + return redisClient.Get(context.Background(), key).Int64() + }, + afterCount: 1, + afterErr: nil, + }, + { + name: "被阻塞,等别人出来了就可以进去了", + createLimit: func() *RedisLimit { + return NewRedisLimit(redisClient) + }, + before: func(localLimit *RedisLimit, key string, maxCount int64) { + limited, err := localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, false) + assert.Equal(t, err, nil) + go func() { + time.Sleep(time.Millisecond * 10) + limited, err = localLimit.Sub(context.Background(), key) + assert.Equal(t, limited, true) + assert.Equal(t, err, nil) + }() + }, + maxCount: 1, + key: "test", + wantBool: false, + wantErr: nil, + after: func(localLimit *RedisLimit, key string) (int64, error) { + defer func() { + redisClient.Del(context.Background(), key) + }() + //退出 + limited, err := localLimit.Sub(context.Background(), key) + assert.Equal(t, limited, true) + assert.Equal(t, err, nil) + return redisClient.Get(context.Background(), key).Int64() + }, + interval: time.Millisecond * 20, + afterCount: 0, + afterErr: nil, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + l := tc.createLimit() + tc.before(l, tc.key, tc.maxCount) + time.Sleep(tc.interval) + limited, err := l.Add(context.Background(), tc.key, tc.maxCount) + assert.Equal(t, tc.wantErr, err) + assert.Equal(t, tc.wantBool, limited) + + afterCount, err := tc.after(l, tc.key) + assert.Equal(t, tc.afterCount, afterCount) + assert.Equal(t, tc.afterErr, err) + + }) + } +} diff --git a/internal/activelimit/type.go b/internal/activelimit/type.go new file mode 100644 index 0000000..fee549b --- /dev/null +++ b/internal/activelimit/type.go @@ -0,0 +1,8 @@ +package activelimit + +import "context" + +type Limiter interface { + Add(ctx context.Context, key string, maxCount int64) (bool, error) + Sub(ctx context.Context, key string) (bool, error) +} diff --git a/internal/integration/activelimit_test.go b/internal/integration/activelimit_test.go new file mode 100644 index 0000000..ac86efe --- /dev/null +++ b/internal/integration/activelimit_test.go @@ -0,0 +1,331 @@ +//go:build e2e + +package integration + +import ( + "context" + "fmt" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/gin-gonic/gin" + "github.com/redis/go-redis/v9" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/ecodeclub/ginx/internal/activelimit" + "github.com/ecodeclub/ginx/internal/activelimit/local_limit" + "github.com/ecodeclub/ginx/internal/activelimit/redis_limit" + activelimit2 "github.com/ecodeclub/ginx/middlewares/activelimit" +) + +func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { + + testCases := []struct { + name string + maxCount int64 + key string + getReq func() *http.Request + createLimit func() activelimit.Limiter + createMiddleware func(limiter activelimit.Limiter) gin.HandlerFunc + before func(localLimit activelimit.Limiter, key string, maxCount int64) + + after func(localLimit activelimit.Limiter, key string) (int64, error) + //响应的code + wantCode int + + //检查退出的时候redis 状态 + afterCount int64 + afterErr error + }{ + { + name: "开启限流,LocalLimit正常操作", + + createLimit: func() activelimit.Limiter { + return local_limit.NewLocalLimit() + }, + createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { + return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { + return "test" + }).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(localLimit activelimit.Limiter, key string, maxCount int64) { + + }, + after: func(localLimit activelimit.Limiter, key string) (int64, error) { + return 0, nil + }, + + maxCount: 1, + key: "test", + wantCode: 200, + + afterCount: 0, + afterErr: nil, + }, + { + name: "开启限流,LocalLimit 有一个人很久没出来,新请求被限流", + + createLimit: func() activelimit.Limiter { + return local_limit.NewLocalLimit() + }, + createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { + return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { + return "test" + }).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(localLimit activelimit.Limiter, key string, maxCount int64) { + limited, err := localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, false) + assert.Equal(t, err, nil) + }, + after: func(localLimit activelimit.Limiter, key string) (int64, error) { + return 0, nil + }, + + maxCount: 1, + key: "test", + wantCode: http.StatusTooManyRequests, + + afterCount: 0, + afterErr: nil, + }, + + { + name: "关闭限流,LocalLimit 有一个人很久没出来,新请求正常返回", + + createLimit: func() activelimit.Limiter { + return local_limit.NewLocalLimit() + }, + createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { + return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { + return "test" + }).SetStatue(false).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(localLimit activelimit.Limiter, key string, maxCount int64) { + limited, err := localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, false) + assert.Equal(t, err, nil) + }, + after: func(localLimit activelimit.Limiter, key string) (int64, error) { + return 0, nil + }, + + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + + afterCount: 0, + afterErr: nil, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + + server := gin.Default() + l := tc.createLimit() + server.Use(tc.createMiddleware(l)) + server.GET("/activelimit", func(ctx *gin.Context) { + ctx.Status(http.StatusOK) + }) + resp := httptest.NewRecorder() + tc.before(l, tc.key, tc.maxCount) + server.ServeHTTP(resp, tc.getReq()) + assert.Equal(t, tc.wantCode, resp.Code) + + afterCount, err := tc.after(l, tc.key) + + assert.Equal(t, tc.afterCount, afterCount) + assert.Equal(t, tc.afterErr, err) + }) + } + +} + +func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { + redisClient := redis.NewClient(&redis.Options{ + Addr: "localhost:16379", + Password: "", + DB: 0, + }) + ctx, cancel := context.WithTimeout(context.Background(), time.Second*3) + defer cancel() + err := redisClient.Ping(ctx).Err() + if err != nil { + panic("redis 连接失败") + } + defer func() { + _ = redisClient.Close() + }() + + testCases := []struct { + name string + maxCount int64 + key string + getReq func() *http.Request + createLimit func() activelimit.Limiter + createMiddleware func(limiter activelimit.Limiter) gin.HandlerFunc + before func(localLimit activelimit.Limiter, key string, maxCount int64) + + after func(localLimit activelimit.Limiter, key string) (int64, error) + + //响应的code + wantCode int + + //检查退出的时候redis 状态 + afterCount int64 + afterErr error + }{ + { + name: "RedisLimit正常操作", + + createLimit: func() activelimit.Limiter { + return redis_limit.NewRedisLimit(redisClient) + }, + createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { + return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { + return "test" + }).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(localLimit activelimit.Limiter, key string, maxCount int64) { + //limited, err := localLimit.Add(context.Background(), key, maxCount) + //assert.Equal(t, limited, false) + //assert.Equal(t, err, nil) + }, + after: func(localLimit activelimit.Limiter, key string) (int64, error) { + defer func() { + err = redisClient.Del(context.Background(), key).Err() + assert.Equal(t, err, nil) + }() + return redisClient.Get(context.Background(), key).Int64() + }, + + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + + afterCount: 0, + afterErr: nil, + }, + { + name: "RedisLimit,有一个人长时间没退出,导致限流", + + createLimit: func() activelimit.Limiter { + return redis_limit.NewRedisLimit(redisClient) + }, + createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { + return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { + return "test" + }).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(localLimit activelimit.Limiter, key string, maxCount int64) { + limited, err := localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, false) + assert.Equal(t, err, nil) + limited, err = localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, true) + assert.Equal(t, err, nil) + }, + after: func(localLimit activelimit.Limiter, key string) (int64, error) { + defer func() { + err = redisClient.Del(context.Background(), key).Err() + assert.Equal(t, err, nil) + }() + return redisClient.Get(context.Background(), key).Int64() + }, + maxCount: 1, + key: "test", + wantCode: http.StatusTooManyRequests, + afterCount: 1, + afterErr: nil, + }, + { + name: "RedisLimit,没有开启限流,有一个人长时间没退出,不会限流", + + createLimit: func() activelimit.Limiter { + return redis_limit.NewRedisLimit(redisClient) + }, + createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { + return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { + return "test" + }).SetStatue(false).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(localLimit activelimit.Limiter, key string, maxCount int64) { + limited, err := localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, false) + assert.Equal(t, err, nil) + limited, err = localLimit.Add(context.Background(), key, maxCount) + assert.Equal(t, limited, true) + assert.Equal(t, err, nil) + }, + after: func(localLimit activelimit.Limiter, key string) (int64, error) { + defer func() { + err = redisClient.Del(context.Background(), key).Err() + assert.Equal(t, err, nil) + }() + return redisClient.Get(context.Background(), key).Int64() + }, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + afterCount: 1, + afterErr: nil, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + + server := gin.Default() + l := tc.createLimit() + server.Use(tc.createMiddleware(l)) + server.GET("/activelimit", func(ctx *gin.Context) { + ctx.Status(http.StatusOK) + }) + resp := httptest.NewRecorder() + tc.before(l, tc.key, tc.maxCount) + + fmt.Println(redisClient.Get(context.Background(), "test").Int64()) + server.ServeHTTP(resp, tc.getReq()) + assert.Equal(t, tc.wantCode, resp.Code) + + afterCount, err := tc.after(l, tc.key) + + assert.Equal(t, tc.afterCount, afterCount) + assert.Equal(t, tc.afterErr, err) + }) + } +} diff --git a/middlewares/activelimit/builder.go b/middlewares/activelimit/builder.go new file mode 100644 index 0000000..df13127 --- /dev/null +++ b/middlewares/activelimit/builder.go @@ -0,0 +1,84 @@ +package activelimit + +import ( + "fmt" + "net/http" + + "github.com/gin-gonic/gin" + "go.uber.org/atomic" + + "github.com/ecodeclub/ginx/internal/activelimit" +) + +type ActiveLimit struct { + limiter activelimit.Limiter + //最大限制个数 + MaxActive *atomic.Int64 + ////当前活跃个数 + //CountActive *atomic.Int64 + //是否开启限流 + Statue *atomic.Bool + genKeyFn func(ctx *gin.Context) string +} + +// NewActiveLimit 全局限流 +func NewActiveLimit(maxActive int64, limiter activelimit.Limiter, genKeyFn func(ctx *gin.Context) string) *ActiveLimit { + return &ActiveLimit{ + limiter: limiter, + MaxActive: atomic.NewInt64(maxActive), + //CountActive: atomic.NewInt64(0), + Statue: atomic.NewBool(true), + genKeyFn: genKeyFn, + } +} + +func (b *ActiveLimit) SetStatue(statue bool) *ActiveLimit { + b.Statue.Store(statue) + return b +} + +func (b *ActiveLimit) SetMaxActive(maxActive int64) *ActiveLimit { + b.MaxActive.Store(maxActive) + return b +} + +func (b *ActiveLimit) Build() gin.HandlerFunc { + return func(ctx *gin.Context) { + //开启限流 + if b.Statue.Load() { + ////直接减一操作 下面必加一成功 + //defer b.countActive.Sub(1) + //// 并直接占坑成功 + //if b.countActive.Add(1) <= b.MaxActive.Load() { + // ctx.Next() + //} else { + // ctx.AbortWithStatus(http.StatusTooManyRequests) + //} + //return + limited, err := b.limiter.Add(ctx, b.genKeyFn(ctx), b.MaxActive.Load()) + if err != nil { + ctx.AbortWithStatus(http.StatusInternalServerError) + return + } + if limited { + ctx.AbortWithStatus(http.StatusTooManyRequests) + } else { + defer func() { + limited, err = b.limiter.Sub(ctx, b.genKeyFn(ctx)) + + if err != nil { + fmt.Println("减一操作异常,需要关注一下:", err) + return + } + if !limited { + fmt.Println("可能有人搞你的redis 或者代码有问题") + } + }() + ctx.Next() + } + return + + } + ctx.Next() + } +} diff --git a/middlewares/activelimit/builder_test.go b/middlewares/activelimit/builder_test.go new file mode 100644 index 0000000..1ecd9ec --- /dev/null +++ b/middlewares/activelimit/builder_test.go @@ -0,0 +1,156 @@ +package activelimit + +import ( + "errors" + "net/http" + "net/http/httptest" + "testing" + + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + + activeLimitmocks "github.com/ecodeclub/ginx/internal/activelimit/mocks" +) + +func TestActiveLimit_Build(t *testing.T) { + testCases := []struct { + name string + mock func(ctrl *gomock.Controller) *ActiveLimit + getReq func() *http.Request + wantCode int + }{ + { + name: "开启限流,系统异常", + mock: func(ctrl *gomock.Controller) *ActiveLimit { + limit := activeLimitmocks.NewMockLimiter(ctrl) + limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( + false, errors.New("限流判断异常")) + + al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { + return "active-req" + }) + return al + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + wantCode: 500, + }, + { + name: "开启限流,被限流了", + mock: func(ctrl *gomock.Controller) *ActiveLimit { + limit := activeLimitmocks.NewMockLimiter(ctrl) + limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( + true, nil) + al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { + return "active-req" + }) + return al + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + wantCode: 429, + }, + { + name: "开启限流,正常请求,但是减一操作异常", + mock: func(ctrl *gomock.Controller) *ActiveLimit { + limit := activeLimitmocks.NewMockLimiter(ctrl) + limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( + false, nil) + limit.EXPECT().Sub(gomock.Any(), gomock.Any()).Return( + true, errors.New("减一操作异常")) + al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { + return "active-req" + }) + return al + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + wantCode: 200, + }, + { + name: "开启限流,正常请求,但是减一操作异常2", + mock: func(ctrl *gomock.Controller) *ActiveLimit { + limit := activeLimitmocks.NewMockLimiter(ctrl) + limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( + false, nil) + limit.EXPECT().Sub(gomock.Any(), gomock.Any()).Return( + false, nil) + al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { + return "active-req" + }) + return al + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + wantCode: 200, + }, + { + name: "开启限流,正常请求,全部正常", + mock: func(ctrl *gomock.Controller) *ActiveLimit { + limit := activeLimitmocks.NewMockLimiter(ctrl) + limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( + false, nil) + limit.EXPECT().Sub(gomock.Any(), gomock.Any()).Return( + true, nil) + al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { + return "active-req" + }) + return al + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + wantCode: 200, + }, + { + name: "关闭限流,正常请求", + mock: func(ctrl *gomock.Controller) *ActiveLimit { + limit := activeLimitmocks.NewMockLimiter(ctrl) + al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { + return "active-req" + }) + return al.SetStatue(false) + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + wantCode: 200, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + ctl := gomock.NewController(t) + + server := gin.Default() + + server.Use(tc.mock(ctl).Build()) + server.GET("/activelimit", func(ctx *gin.Context) { + ctx.Status(http.StatusOK) + }) + resp := httptest.NewRecorder() + + server.ServeHTTP(resp, tc.getReq()) + assert.Equal(t, tc.wantCode, resp.Code) + + }) + } +} From 2882d1a98fbebcbf924dda8769474e5fce0064fb Mon Sep 17 00:00:00 2001 From: Pyxy Date: Sat, 30 Sep 2023 09:45:13 +0800 Subject: [PATCH 02/10] =?UTF-8?q?=E7=AE=80=E5=8C=96,=E5=8E=BB=E6=8A=BD?= =?UTF-8?q?=E8=B1=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LICENSE | 2 +- go.mod | 2 + go.sum | 4 + .../activelimit/local_limit/locallimit.go | 34 -- .../local_limit/locallimit_test.go | 90 ----- internal/activelimit/mocks/active_mock.go | 65 ---- .../activelimit/redis_limit/activeAdd.lua | 14 - .../activelimit/redis_limit/activeSub.lua | 13 - .../activelimit/redis_limit/redislimit.go | 32 -- .../redis_limit/redislimit_test.go | 159 -------- internal/activelimit/type.go | 8 - internal/integration/activelimit_test.go | 360 +++++++++++------- middlewares/activelimit/builder.go | 84 ---- middlewares/activelimit/builder_test.go | 156 -------- middlewares/activelimit/locallimit/builder.go | 58 +++ middlewares/activelimit/redislimit/builder.go | 64 ++++ middlewares/ratelimit/redis_slide_window.go | 4 +- 17 files changed, 352 insertions(+), 797 deletions(-) delete mode 100644 internal/activelimit/local_limit/locallimit.go delete mode 100644 internal/activelimit/local_limit/locallimit_test.go delete mode 100644 internal/activelimit/mocks/active_mock.go delete mode 100644 internal/activelimit/redis_limit/activeAdd.lua delete mode 100644 internal/activelimit/redis_limit/activeSub.lua delete mode 100644 internal/activelimit/redis_limit/redislimit.go delete mode 100644 internal/activelimit/redis_limit/redislimit_test.go delete mode 100644 internal/activelimit/type.go delete mode 100644 middlewares/activelimit/builder.go delete mode 100644 middlewares/activelimit/builder_test.go create mode 100644 middlewares/activelimit/locallimit/builder.go create mode 100644 middlewares/activelimit/redislimit/builder.go diff --git a/LICENSE b/LICENSE index 261eeb9..d57e925 100644 --- a/LICENSE +++ b/LICENSE @@ -94,7 +94,7 @@ (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and - (b) You must cause any modified files to carry prominent notices + (a) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works diff --git a/go.mod b/go.mod index f055963..b71504a 100644 --- a/go.mod +++ b/go.mod @@ -34,9 +34,11 @@ require ( github.com/ugorji/go/codec v1.2.11 // indirect golang.org/x/arch v0.3.0 // indirect golang.org/x/crypto v0.9.0 // indirect + golang.org/x/mod v0.11.0 // indirect golang.org/x/net v0.10.0 // indirect golang.org/x/sys v0.8.0 // indirect golang.org/x/text v0.9.0 // indirect + golang.org/x/tools v0.6.0 // indirect google.golang.org/protobuf v1.30.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 0ded11c..abed3fd 100644 --- a/go.sum +++ b/go.sum @@ -79,6 +79,8 @@ golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k= golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g= golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0= +golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU= +golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M= golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -87,6 +89,8 @@ golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= diff --git a/internal/activelimit/local_limit/locallimit.go b/internal/activelimit/local_limit/locallimit.go deleted file mode 100644 index 15ab11e..0000000 --- a/internal/activelimit/local_limit/locallimit.go +++ /dev/null @@ -1,34 +0,0 @@ -package local_limit - -import ( - "context" - - "go.uber.org/atomic" -) - -type LocalLimit struct { - countActive *atomic.Int64 - //这里可以增加字段 以及对应的字段进行 分别限流 - //先判断总数 再判断单个限流目标的数量就行 -} - -func NewLocalLimit() *LocalLimit { - return &LocalLimit{ - countActive: atomic.NewInt64(0), - } -} - -func (l *LocalLimit) Add(ctx context.Context, key string, maxCount int64) (bool, error) { - // 并直接占坑成功 - if l.countActive.Add(1) <= maxCount { - return false, nil - } else { - l.countActive.Sub(1) - return true, nil - } -} - -func (l *LocalLimit) Sub(ctx context.Context, key string) (bool, error) { - l.countActive.Sub(1) - return true, nil -} diff --git a/internal/activelimit/local_limit/locallimit_test.go b/internal/activelimit/local_limit/locallimit_test.go deleted file mode 100644 index 3f549c1..0000000 --- a/internal/activelimit/local_limit/locallimit_test.go +++ /dev/null @@ -1,90 +0,0 @@ -package local_limit - -import ( - "context" - "testing" - "time" - - "github.com/stretchr/testify/assert" -) - -func TestNewLocalLimit(t *testing.T) { - testCases := []struct { - name string - createLimit func() *LocalLimit - before func(localLimit *LocalLimit, key string, maxCount int64) - maxCount int64 - key string - wantBool bool - wantErr error - interval time.Duration - }{ - { - name: "正常操作", - - createLimit: func() *LocalLimit { - return NewLocalLimit() - }, - before: func(localLimit *LocalLimit, key string, maxCount int64) { - //limited, err := localLimit.Add(context.Background(), key, maxCount) - //assert.Equal(t, limited, false) - //assert.Equal(t, err, nil) - }, - maxCount: 1, - key: "test", - wantBool: false, - wantErr: nil, - }, - { - name: "请求过多了", - - createLimit: func() *LocalLimit { - return NewLocalLimit() - }, - before: func(localLimit *LocalLimit, key string, maxCount int64) { - limited, err := localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, false) - assert.Equal(t, err, nil) - }, - maxCount: 1, - key: "test", - wantBool: true, - wantErr: nil, - }, - { - name: "请求过多了,等待别人退出", - - createLimit: func() *LocalLimit { - return NewLocalLimit() - }, - before: func(localLimit *LocalLimit, key string, maxCount int64) { - limited, err := localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, false) - assert.Equal(t, err, nil) - go func() { - time.Sleep(time.Millisecond * 10) - limited, err = localLimit.Sub(context.Background(), key) - assert.Equal(t, limited, true) - assert.Equal(t, err, nil) - }() - - }, - interval: time.Millisecond * 20, - maxCount: 1, - key: "test", - wantBool: false, - wantErr: nil, - }, - } - - for _, tc := range testCases { - t.Run(tc.name, func(t *testing.T) { - l := tc.createLimit() - tc.before(l, tc.key, tc.maxCount) - time.Sleep(tc.interval) - limited, err := l.Add(context.Background(), tc.key, tc.maxCount) - assert.Equal(t, tc.wantErr, err) - assert.Equal(t, tc.wantBool, limited) - }) - } -} diff --git a/internal/activelimit/mocks/active_mock.go b/internal/activelimit/mocks/active_mock.go deleted file mode 100644 index 802b4d8..0000000 --- a/internal/activelimit/mocks/active_mock.go +++ /dev/null @@ -1,65 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: F:\git_push\ginx\internal\activelimit\type.go - -// Package activeLimitmocks is a generated GoMock package. -package activeLimitmocks - -import ( - context "context" - reflect "reflect" - - gomock "go.uber.org/mock/gomock" -) - -// MockLimiter is a mock of Limiter interface. -type MockLimiter struct { - ctrl *gomock.Controller - recorder *MockLimiterMockRecorder -} - -// MockLimiterMockRecorder is the mock recorder for MockLimiter. -type MockLimiterMockRecorder struct { - mock *MockLimiter -} - -// NewMockLimiter creates a new mock instance. -func NewMockLimiter(ctrl *gomock.Controller) *MockLimiter { - mock := &MockLimiter{ctrl: ctrl} - mock.recorder = &MockLimiterMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockLimiter) EXPECT() *MockLimiterMockRecorder { - return m.recorder -} - -// Add mocks base method. -func (m *MockLimiter) Add(ctx context.Context, key string, maxCount int64) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Add", ctx, key, maxCount) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Add indicates an expected call of Add. -func (mr *MockLimiterMockRecorder) Add(ctx, key, maxCount interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockLimiter)(nil).Add), ctx, key, maxCount) -} - -// Sub mocks base method. -func (m *MockLimiter) Sub(ctx context.Context, key string) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Sub", ctx, key) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Sub indicates an expected call of Sub. -func (mr *MockLimiterMockRecorder) Sub(ctx, key interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sub", reflect.TypeOf((*MockLimiter)(nil).Sub), ctx, key) -} diff --git a/internal/activelimit/redis_limit/activeAdd.lua b/internal/activelimit/redis_limit/activeAdd.lua deleted file mode 100644 index bdadb71..0000000 --- a/internal/activelimit/redis_limit/activeAdd.lua +++ /dev/null @@ -1,14 +0,0 @@ --- 限流对象 -local key = KEYS[1] --- 最大限流个数 -local maxActive = tonumber(ARGV[1]) - -local countActive = tonumber(redis.call('INCR', key)) -if countActive <= maxActive then - return "false" -else - redis.call('DECR', key) - return "true" -end - - diff --git a/internal/activelimit/redis_limit/activeSub.lua b/internal/activelimit/redis_limit/activeSub.lua deleted file mode 100644 index 94c9c92..0000000 --- a/internal/activelimit/redis_limit/activeSub.lua +++ /dev/null @@ -1,13 +0,0 @@ --- 限流对象 -local key = KEYS[1] - -local curCnt = tonumber(redis.call('DECR', key)) -if curCnt < 0 then - redis.call('Set', key, 0) - return "false" -else - return "true" -end - - - diff --git a/internal/activelimit/redis_limit/redislimit.go b/internal/activelimit/redis_limit/redislimit.go deleted file mode 100644 index 2ba4d70..0000000 --- a/internal/activelimit/redis_limit/redislimit.go +++ /dev/null @@ -1,32 +0,0 @@ -package redis_limit - -import ( - "context" - _ "embed" - - "github.com/redis/go-redis/v9" -) - -//go:embed activeAdd.lua -var LuaActiveAdd string - -//go:embed activeSub.lua -var LuaActiveSub string - -type RedisLimit struct { - cmd redis.Cmdable -} - -func NewRedisLimit(cmd redis.Cmdable) *RedisLimit { - return &RedisLimit{cmd: cmd} -} - -func (r *RedisLimit) Add(ctx context.Context, key string, maxCount int64) (bool, error) { - //TODO implement me - return r.cmd.Eval(ctx, LuaActiveAdd, []string{key}, maxCount).Bool() -} - -func (r *RedisLimit) Sub(ctx context.Context, key string) (bool, error) { - //TODO implement me - return r.cmd.Eval(ctx, LuaActiveSub, []string{key}).Bool() -} diff --git a/internal/activelimit/redis_limit/redislimit_test.go b/internal/activelimit/redis_limit/redislimit_test.go deleted file mode 100644 index bc314ed..0000000 --- a/internal/activelimit/redis_limit/redislimit_test.go +++ /dev/null @@ -1,159 +0,0 @@ -package redis_limit - -import ( - "context" - "testing" - "time" - - "github.com/redis/go-redis/v9" - "github.com/stretchr/testify/assert" -) - -func TestNewRedisLimit(t *testing.T) { - redisClient := redis.NewClient(&redis.Options{ - Addr: "localhost:16379", - Password: "", - DB: 0, - }) - ctx, cancel := context.WithTimeout(context.Background(), time.Second*3) - defer cancel() - err := redisClient.Ping(ctx).Err() - if err != nil { - panic("redis 连接失败") - } - testCases := []struct { - name string - createLimit func() *RedisLimit - before func(localLimit *RedisLimit, key string, maxCount int64) - - maxCount int64 - key string - wantBool bool - wantErr error - interval time.Duration - after func(localLimit *RedisLimit, string2 string) (int64, error) - afterCount int64 - afterErr error - }{ - { - name: "正常通行没有退出", - createLimit: func() *RedisLimit { - return NewRedisLimit(redisClient) - }, - before: func(localLimit *RedisLimit, key string, maxCount int64) { - - }, - maxCount: 1, - key: "test", - wantBool: false, - wantErr: nil, - after: func(localLimit *RedisLimit, key string) (int64, error) { - defer func() { - redisClient.Del(context.Background(), key) - }() - return redisClient.Get(context.Background(), key).Int64() - }, - afterCount: 1, - afterErr: nil, - }, - { - name: "正常通行并退出", - createLimit: func() *RedisLimit { - return NewRedisLimit(redisClient) - }, - before: func(localLimit *RedisLimit, key string, maxCount int64) { - - }, - maxCount: 1, - key: "test", - wantBool: false, - wantErr: nil, - after: func(localLimit *RedisLimit, key string) (int64, error) { - defer func() { - redisClient.Del(context.Background(), key) - }() - //退出 - limited, err := localLimit.Sub(context.Background(), key) - assert.Equal(t, limited, true) - assert.Equal(t, err, nil) - return redisClient.Get(context.Background(), key).Int64() - }, - afterCount: 0, - afterErr: nil, - }, - { - name: "被阻塞", - createLimit: func() *RedisLimit { - return NewRedisLimit(redisClient) - }, - before: func(localLimit *RedisLimit, key string, maxCount int64) { - limited, err := localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, false) - assert.Equal(t, err, nil) - }, - maxCount: 1, - key: "test", - wantBool: true, - wantErr: nil, - after: func(localLimit *RedisLimit, key string) (int64, error) { - defer func() { - redisClient.Del(context.Background(), key) - }() - //退出 - return redisClient.Get(context.Background(), key).Int64() - }, - afterCount: 1, - afterErr: nil, - }, - { - name: "被阻塞,等别人出来了就可以进去了", - createLimit: func() *RedisLimit { - return NewRedisLimit(redisClient) - }, - before: func(localLimit *RedisLimit, key string, maxCount int64) { - limited, err := localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, false) - assert.Equal(t, err, nil) - go func() { - time.Sleep(time.Millisecond * 10) - limited, err = localLimit.Sub(context.Background(), key) - assert.Equal(t, limited, true) - assert.Equal(t, err, nil) - }() - }, - maxCount: 1, - key: "test", - wantBool: false, - wantErr: nil, - after: func(localLimit *RedisLimit, key string) (int64, error) { - defer func() { - redisClient.Del(context.Background(), key) - }() - //退出 - limited, err := localLimit.Sub(context.Background(), key) - assert.Equal(t, limited, true) - assert.Equal(t, err, nil) - return redisClient.Get(context.Background(), key).Int64() - }, - interval: time.Millisecond * 20, - afterCount: 0, - afterErr: nil, - }, - } - - for _, tc := range testCases { - t.Run(tc.name, func(t *testing.T) { - l := tc.createLimit() - tc.before(l, tc.key, tc.maxCount) - time.Sleep(tc.interval) - limited, err := l.Add(context.Background(), tc.key, tc.maxCount) - assert.Equal(t, tc.wantErr, err) - assert.Equal(t, tc.wantBool, limited) - - afterCount, err := tc.after(l, tc.key) - assert.Equal(t, tc.afterCount, afterCount) - assert.Equal(t, tc.afterErr, err) - - }) - } -} diff --git a/internal/activelimit/type.go b/internal/activelimit/type.go deleted file mode 100644 index fee549b..0000000 --- a/internal/activelimit/type.go +++ /dev/null @@ -1,8 +0,0 @@ -package activelimit - -import "context" - -type Limiter interface { - Add(ctx context.Context, key string, maxCount int64) (bool, error) - Sub(ctx context.Context, key string) (bool, error) -} diff --git a/internal/integration/activelimit_test.go b/internal/integration/activelimit_test.go index ac86efe..83da1c4 100644 --- a/internal/integration/activelimit_test.go +++ b/internal/integration/activelimit_test.go @@ -5,20 +5,17 @@ package integration import ( "context" "fmt" + "github.com/ecodeclub/ginx/middlewares/activelimit/locallimit" + "github.com/ecodeclub/ginx/middlewares/activelimit/redislimit" + "github.com/redis/go-redis/v9" "net/http" "net/http/httptest" "testing" "time" "github.com/gin-gonic/gin" - "github.com/redis/go-redis/v9" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - - "github.com/ecodeclub/ginx/internal/activelimit" - "github.com/ecodeclub/ginx/internal/activelimit/local_limit" - "github.com/ecodeclub/ginx/internal/activelimit/redis_limit" - activelimit2 "github.com/ecodeclub/ginx/middlewares/activelimit" ) func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { @@ -26,114 +23,155 @@ func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { testCases := []struct { name string maxCount int64 - key string getReq func() *http.Request - createLimit func() activelimit.Limiter - createMiddleware func(limiter activelimit.Limiter) gin.HandlerFunc - before func(localLimit activelimit.Limiter, key string, maxCount int64) + createMiddleware func() gin.HandlerFunc + before func(server *gin.Engine) - after func(localLimit activelimit.Limiter, key string) (int64, error) + after func() //响应的code wantCode int - - //检查退出的时候redis 状态 - afterCount int64 - afterErr error + // + interval time.Duration }{ { name: "开启限流,LocalLimit正常操作", - createLimit: func() activelimit.Limiter { - return local_limit.NewLocalLimit() - }, - createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { - return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { - return "test" - }).Build() + createMiddleware: func() gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(1).SetStatue(true).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) require.NoError(t, err) return req }, - before: func(localLimit activelimit.Limiter, key string, maxCount int64) { + before: func(server *gin.Engine) { }, - after: func(localLimit activelimit.Limiter, key string) (int64, error) { - return 0, nil + after: func() { + }, maxCount: 1, - key: "test", wantCode: 200, - - afterCount: 0, - afterErr: nil, }, { name: "开启限流,LocalLimit 有一个人很久没出来,新请求被限流", - createLimit: func() activelimit.Limiter { - return local_limit.NewLocalLimit() - }, - createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { - return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { - return "test" - }).Build() + createMiddleware: func() gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(1).SetStatue(true).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) require.NoError(t, err) return req }, - before: func(localLimit activelimit.Limiter, key string, maxCount int64) { - limited, err := localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, false) - assert.Equal(t, err, nil) + before: func(server *gin.Engine) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) }, - after: func(localLimit activelimit.Limiter, key string) (int64, error) { - return 0, nil + after: func() { + }, maxCount: 1, - key: "test", wantCode: http.StatusTooManyRequests, + }, + { + name: "开启限流,LocalLimit 有一个人很久没出来,等待前面的请求退出后,成功通过", - afterCount: 0, - afterErr: nil, + createMiddleware: func() gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(1).SetStatue(true).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + fmt.Println("阻塞的人出来了...") + assert.Equal(t, 200, resp.Code) + }, + after: func() { + + }, + interval: time.Millisecond * 600, + maxCount: 1, + wantCode: http.StatusOK, }, + { + name: "关闭限流,请求正常执行", + createMiddleware: func() gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(1).SetStatue(false).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + + }, + after: func() { + }, + + maxCount: 1, + wantCode: 200, + }, { name: "关闭限流,LocalLimit 有一个人很久没出来,新请求正常返回", + createMiddleware: func() gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(1).SetStatue(false).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + after: func() { - createLimit: func() activelimit.Limiter { - return local_limit.NewLocalLimit() }, - createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { - return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { - return "test" - }).SetStatue(false).Build() + + maxCount: 1, + wantCode: 200, + }, + { + name: "关闭限流,LocalLimit 有一个人很久没出来,新请求正常返回", + createMiddleware: func() gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(1).SetStatue(false).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) require.NoError(t, err) return req }, - before: func(localLimit activelimit.Limiter, key string, maxCount int64) { - limited, err := localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, false) - assert.Equal(t, err, nil) + before: func(server *gin.Engine) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) }, - after: func(localLimit activelimit.Limiter, key string) (int64, error) { - return 0, nil + after: func() { + }, maxCount: 1, - key: "test", - wantCode: http.StatusOK, - - afterCount: 0, - afterErr: nil, + wantCode: 200, }, } @@ -141,20 +179,27 @@ func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { t.Run(tc.name, func(t *testing.T) { server := gin.Default() - l := tc.createLimit() - server.Use(tc.createMiddleware(l)) + server.Use(tc.createMiddleware()) server.GET("/activelimit", func(ctx *gin.Context) { ctx.Status(http.StatusOK) }) + server.GET("/activelimit3", func(ctx *gin.Context) { + time.Sleep(time.Millisecond * 300) + ctx.Status(http.StatusOK) + }) resp := httptest.NewRecorder() - tc.before(l, tc.key, tc.maxCount) + go func() { + tc.before(server) + }() + //加延时保证 tc.before 执行 + time.Sleep(time.Millisecond * 10) + + time.Sleep(tc.interval) server.ServeHTTP(resp, tc.getReq()) assert.Equal(t, tc.wantCode, resp.Code) - afterCount, err := tc.after(l, tc.key) + tc.after() - assert.Equal(t, tc.afterCount, afterCount) - assert.Equal(t, tc.afterErr, err) }) } @@ -170,7 +215,7 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { defer cancel() err := redisClient.Ping(ctx).Err() if err != nil { - panic("redis 连接失败") + panic("redislimit 连接失败") } defer func() { _ = redisClient.Close() @@ -181,11 +226,11 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { maxCount int64 key string getReq func() *http.Request - createLimit func() activelimit.Limiter - createMiddleware func(limiter activelimit.Limiter) gin.HandlerFunc - before func(localLimit activelimit.Limiter, key string, maxCount int64) + createMiddleware func() gin.HandlerFunc + before func(server *gin.Engine, key string) - after func(localLimit activelimit.Limiter, key string) (int64, error) + interval time.Duration + after func(string2 string) (int64, error) //响应的code wantCode int @@ -195,31 +240,22 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { afterErr error }{ { - name: "RedisLimit正常操作", + name: "开启限流,RedisLimit正常操作", - createLimit: func() activelimit.Limiter { - return redis_limit.NewRedisLimit(redisClient) - }, - createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { - return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { - return "test" - }).Build() + createMiddleware: func() gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(true).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) require.NoError(t, err) return req }, - before: func(localLimit activelimit.Limiter, key string, maxCount int64) { - //limited, err := localLimit.Add(context.Background(), key, maxCount) - //assert.Equal(t, limited, false) - //assert.Equal(t, err, nil) + before: func(server *gin.Engine, key string) { + }, - after: func(localLimit activelimit.Limiter, key string) (int64, error) { - defer func() { - err = redisClient.Del(context.Background(), key).Err() - assert.Equal(t, err, nil) - }() + interval: time.Millisecond * 10, + after: func(key string) (int64, error) { + return redisClient.Get(context.Background(), key).Int64() }, @@ -231,34 +267,28 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { afterErr: nil, }, { - name: "RedisLimit,有一个人长时间没退出,导致限流", + name: "开启限流,RedisLimit,有一个人长时间没退出,导致限流", - createLimit: func() activelimit.Limiter { - return redis_limit.NewRedisLimit(redisClient) - }, - createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { - return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { - return "test" - }).Build() + createMiddleware: func() gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(true).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) require.NoError(t, err) return req }, - before: func(localLimit activelimit.Limiter, key string, maxCount int64) { - limited, err := localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, false) - assert.Equal(t, err, nil) - limited, err = localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, true) - assert.Equal(t, err, nil) - }, - after: func(localLimit activelimit.Limiter, key string) (int64, error) { - defer func() { - err = redisClient.Del(context.Background(), key).Err() - assert.Equal(t, err, nil) - }() + before: func(server *gin.Engine, key string) { + + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + + interval: time.Millisecond * 50, + after: func(key string) (int64, error) { + return redisClient.Get(context.Background(), key).Int64() }, maxCount: 1, @@ -268,61 +298,113 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { afterErr: nil, }, { - name: "RedisLimit,没有开启限流,有一个人长时间没退出,不会限流", + name: "开启限流,RedisLimit,有一个人长时间没退出,等待前面退出后,正常请求....", - createLimit: func() activelimit.Limiter { - return redis_limit.NewRedisLimit(redisClient) - }, - createMiddleware: func(limiter activelimit.Limiter) gin.HandlerFunc { - return activelimit2.NewActiveLimit(1, limiter, func(ctx *gin.Context) string { - return "test" - }).SetStatue(false).Build() + createMiddleware: func() gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(true).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) require.NoError(t, err) return req }, - before: func(localLimit activelimit.Limiter, key string, maxCount int64) { - limited, err := localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, false) - assert.Equal(t, err, nil) - limited, err = localLimit.Add(context.Background(), key, maxCount) - assert.Equal(t, limited, true) - assert.Equal(t, err, nil) - }, - after: func(localLimit activelimit.Limiter, key string) (int64, error) { - defer func() { - err = redisClient.Del(context.Background(), key).Err() - assert.Equal(t, err, nil) - }() + before: func(server *gin.Engine, key string) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + interval: time.Millisecond * 200, + after: func(key string) (int64, error) { + return redisClient.Get(context.Background(), key).Int64() }, maxCount: 1, key: "test", wantCode: http.StatusOK, - afterCount: 1, + afterCount: 0, afterErr: nil, }, + { + name: "关闭限流,RedisLimit, 请求正常退出", + + createMiddleware: func() gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(false).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + after: func(key string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + }, + { + name: "关闭限流,RedisLimit,,有一个人长时间没退出,不会限流", + + createMiddleware: func() gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(false).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + after: func(key string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + }, } for _, tc := range testCases { + //这里延时的原因是 保证builder 中的defer 延时操作不会导致测试的异常 + time.Sleep(time.Millisecond * 100) + redisClient.Del(context.Background(), tc.key) + fmt.Println(redisClient.Get(context.Background(), tc.key).Int64()) t.Run(tc.name, func(t *testing.T) { server := gin.Default() - l := tc.createLimit() - server.Use(tc.createMiddleware(l)) + server.Use(tc.createMiddleware()) server.GET("/activelimit", func(ctx *gin.Context) { ctx.Status(http.StatusOK) }) + server.GET("/activelimit3", func(ctx *gin.Context) { + time.Sleep(time.Millisecond * 100) + ctx.Status(http.StatusOK) + }) resp := httptest.NewRecorder() - tc.before(l, tc.key, tc.maxCount) - - fmt.Println(redisClient.Get(context.Background(), "test").Int64()) + go func() { + tc.before(server, tc.key) + }() + time.Sleep(tc.interval) server.ServeHTTP(resp, tc.getReq()) assert.Equal(t, tc.wantCode, resp.Code) - afterCount, err := tc.after(l, tc.key) + afterCount, err := tc.after(tc.key) assert.Equal(t, tc.afterCount, afterCount) assert.Equal(t, tc.afterErr, err) diff --git a/middlewares/activelimit/builder.go b/middlewares/activelimit/builder.go deleted file mode 100644 index df13127..0000000 --- a/middlewares/activelimit/builder.go +++ /dev/null @@ -1,84 +0,0 @@ -package activelimit - -import ( - "fmt" - "net/http" - - "github.com/gin-gonic/gin" - "go.uber.org/atomic" - - "github.com/ecodeclub/ginx/internal/activelimit" -) - -type ActiveLimit struct { - limiter activelimit.Limiter - //最大限制个数 - MaxActive *atomic.Int64 - ////当前活跃个数 - //CountActive *atomic.Int64 - //是否开启限流 - Statue *atomic.Bool - genKeyFn func(ctx *gin.Context) string -} - -// NewActiveLimit 全局限流 -func NewActiveLimit(maxActive int64, limiter activelimit.Limiter, genKeyFn func(ctx *gin.Context) string) *ActiveLimit { - return &ActiveLimit{ - limiter: limiter, - MaxActive: atomic.NewInt64(maxActive), - //CountActive: atomic.NewInt64(0), - Statue: atomic.NewBool(true), - genKeyFn: genKeyFn, - } -} - -func (b *ActiveLimit) SetStatue(statue bool) *ActiveLimit { - b.Statue.Store(statue) - return b -} - -func (b *ActiveLimit) SetMaxActive(maxActive int64) *ActiveLimit { - b.MaxActive.Store(maxActive) - return b -} - -func (b *ActiveLimit) Build() gin.HandlerFunc { - return func(ctx *gin.Context) { - //开启限流 - if b.Statue.Load() { - ////直接减一操作 下面必加一成功 - //defer b.countActive.Sub(1) - //// 并直接占坑成功 - //if b.countActive.Add(1) <= b.MaxActive.Load() { - // ctx.Next() - //} else { - // ctx.AbortWithStatus(http.StatusTooManyRequests) - //} - //return - limited, err := b.limiter.Add(ctx, b.genKeyFn(ctx), b.MaxActive.Load()) - if err != nil { - ctx.AbortWithStatus(http.StatusInternalServerError) - return - } - if limited { - ctx.AbortWithStatus(http.StatusTooManyRequests) - } else { - defer func() { - limited, err = b.limiter.Sub(ctx, b.genKeyFn(ctx)) - - if err != nil { - fmt.Println("减一操作异常,需要关注一下:", err) - return - } - if !limited { - fmt.Println("可能有人搞你的redis 或者代码有问题") - } - }() - ctx.Next() - } - return - - } - ctx.Next() - } -} diff --git a/middlewares/activelimit/builder_test.go b/middlewares/activelimit/builder_test.go deleted file mode 100644 index 1ecd9ec..0000000 --- a/middlewares/activelimit/builder_test.go +++ /dev/null @@ -1,156 +0,0 @@ -package activelimit - -import ( - "errors" - "net/http" - "net/http/httptest" - "testing" - - "github.com/gin-gonic/gin" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - "go.uber.org/mock/gomock" - - activeLimitmocks "github.com/ecodeclub/ginx/internal/activelimit/mocks" -) - -func TestActiveLimit_Build(t *testing.T) { - testCases := []struct { - name string - mock func(ctrl *gomock.Controller) *ActiveLimit - getReq func() *http.Request - wantCode int - }{ - { - name: "开启限流,系统异常", - mock: func(ctrl *gomock.Controller) *ActiveLimit { - limit := activeLimitmocks.NewMockLimiter(ctrl) - limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( - false, errors.New("限流判断异常")) - - al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { - return "active-req" - }) - return al - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - wantCode: 500, - }, - { - name: "开启限流,被限流了", - mock: func(ctrl *gomock.Controller) *ActiveLimit { - limit := activeLimitmocks.NewMockLimiter(ctrl) - limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( - true, nil) - al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { - return "active-req" - }) - return al - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - wantCode: 429, - }, - { - name: "开启限流,正常请求,但是减一操作异常", - mock: func(ctrl *gomock.Controller) *ActiveLimit { - limit := activeLimitmocks.NewMockLimiter(ctrl) - limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( - false, nil) - limit.EXPECT().Sub(gomock.Any(), gomock.Any()).Return( - true, errors.New("减一操作异常")) - al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { - return "active-req" - }) - return al - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - wantCode: 200, - }, - { - name: "开启限流,正常请求,但是减一操作异常2", - mock: func(ctrl *gomock.Controller) *ActiveLimit { - limit := activeLimitmocks.NewMockLimiter(ctrl) - limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( - false, nil) - limit.EXPECT().Sub(gomock.Any(), gomock.Any()).Return( - false, nil) - al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { - return "active-req" - }) - return al - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - wantCode: 200, - }, - { - name: "开启限流,正常请求,全部正常", - mock: func(ctrl *gomock.Controller) *ActiveLimit { - limit := activeLimitmocks.NewMockLimiter(ctrl) - limit.EXPECT().Add(gomock.Any(), gomock.Any(), gomock.Any()).Return( - false, nil) - limit.EXPECT().Sub(gomock.Any(), gomock.Any()).Return( - true, nil) - al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { - return "active-req" - }) - return al - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - wantCode: 200, - }, - { - name: "关闭限流,正常请求", - mock: func(ctrl *gomock.Controller) *ActiveLimit { - limit := activeLimitmocks.NewMockLimiter(ctrl) - al := NewActiveLimit(1, limit, func(ctx *gin.Context) string { - return "active-req" - }) - return al.SetStatue(false) - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - wantCode: 200, - }, - } - - for _, tc := range testCases { - t.Run(tc.name, func(t *testing.T) { - ctl := gomock.NewController(t) - - server := gin.Default() - - server.Use(tc.mock(ctl).Build()) - server.GET("/activelimit", func(ctx *gin.Context) { - ctx.Status(http.StatusOK) - }) - resp := httptest.NewRecorder() - - server.ServeHTTP(resp, tc.getReq()) - assert.Equal(t, tc.wantCode, resp.Code) - - }) - } -} diff --git a/middlewares/activelimit/locallimit/builder.go b/middlewares/activelimit/locallimit/builder.go new file mode 100644 index 0000000..077259d --- /dev/null +++ b/middlewares/activelimit/locallimit/builder.go @@ -0,0 +1,58 @@ +package locallimit + +import ( + "fmt" + "github.com/gin-gonic/gin" + "go.uber.org/atomic" + "net/http" +) + +type LocalActiveLimit struct { + //最大限制个数 + MaxActive *atomic.Int64 + //当前活跃个数 + countActive *atomic.Int64 + //是否开启限流 + Statue *atomic.Bool +} + +// NewLocalActiveLimit 全局限流 +func NewLocalActiveLimit(maxActive int64) *LocalActiveLimit { + return &LocalActiveLimit{ + MaxActive: atomic.NewInt64(maxActive), + countActive: atomic.NewInt64(0), + Statue: atomic.NewBool(true), + } +} + +func (a *LocalActiveLimit) SetStatue(statue bool) *LocalActiveLimit { + a.Statue.Store(statue) + return a +} + +func (a *LocalActiveLimit) SetMaxActive(maxActive int64) *LocalActiveLimit { + a.MaxActive.Store(maxActive) + return a +} + +func (a *LocalActiveLimit) Build() gin.HandlerFunc { + return func(ctx *gin.Context) { + //开启限流 + if a.Statue.Load() { + //直接减一操作 下面必加一成功 + defer func() { + fmt.Println("简易操作....:") + a.countActive.Sub(1) + }() + // 并直接占坑成功 + if a.countActive.Add(1) <= a.MaxActive.Load() { + ctx.Next() + } else { + ctx.AbortWithStatus(http.StatusTooManyRequests) + } + return + + } + ctx.Next() + } +} diff --git a/middlewares/activelimit/redislimit/builder.go b/middlewares/activelimit/redislimit/builder.go new file mode 100644 index 0000000..1bfc895 --- /dev/null +++ b/middlewares/activelimit/redislimit/builder.go @@ -0,0 +1,64 @@ +package redislimit + +import ( + "github.com/gin-gonic/gin" + "github.com/redis/go-redis/v9" + "go.uber.org/atomic" + "net/http" +) + +type RedisActiveLimit struct { + //最大限制个数 + MaxActive *atomic.Int64 + + //是否开启限流 + Statue *atomic.Bool + //用来记录连接数的key + key string + cmd redis.Cmdable +} + +// NewRedisActiveLimit 全局限流 +func NewRedisActiveLimit(cmd redis.Cmdable, maxActive int64, key string) *RedisActiveLimit { + return &RedisActiveLimit{ + MaxActive: atomic.NewInt64(maxActive), + Statue: atomic.NewBool(true), + key: key, + cmd: cmd, + } +} + +func (a *RedisActiveLimit) SetStatue(statue bool) *RedisActiveLimit { + a.Statue.Store(statue) + return a +} + +func (a *RedisActiveLimit) SetMaxActive(maxActive int64) *RedisActiveLimit { + a.MaxActive.Store(maxActive) + return a +} + +func (a *RedisActiveLimit) Build() gin.HandlerFunc { + return func(ctx *gin.Context) { + //开启限流 + if a.Statue.Load() { + currentCount, err := a.cmd.Incr(ctx, a.key).Result() + if err != nil { + //为了安全性 直接返回异常 + ctx.AbortWithStatus(http.StatusInternalServerError) + return + } + defer func() { + _ = a.cmd.Decr(ctx, a.key).Err() + }() + if currentCount <= a.MaxActive.Load() { + ctx.Next() + } else { + ctx.AbortWithStatus(http.StatusTooManyRequests) + } + return + + } + ctx.Next() + } +} diff --git a/middlewares/ratelimit/redis_slide_window.go b/middlewares/ratelimit/redis_slide_window.go index b90f488..51e6ba7 100644 --- a/middlewares/ratelimit/redis_slide_window.go +++ b/middlewares/ratelimit/redis_slide_window.go @@ -8,8 +8,8 @@ import ( "github.com/ecodeclub/ginx/internal/ratelimit" ) -// NewRedisSlidingWindowLimiter 创建一个基于 redis 的滑动窗口限流器. -// cmd: 可传入 redis 的客户端 +// NewRedisSlidingWindowLimiter 创建一个基于 redislimit 的滑动窗口限流器. +// cmd: 可传入 redislimit 的客户端 // interval: 窗口大小 // rate: 阈值 // 表示: 在 interval 内允许 rate 个请求 From ff8038a711d7908f95544adc207e13f4d44ed82e Mon Sep 17 00:00:00 2001 From: Pyxy Date: Sun, 1 Oct 2023 08:30:29 +0800 Subject: [PATCH 03/10] =?UTF-8?q?=E6=B7=BB=E5=8A=A0redis=20ActiveLimit=20?= =?UTF-8?q?=E5=8D=95=E5=85=83=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/activelimit/mocks/redis_mock.go | 12454 ++++++++++++++++ internal/integration/activelimit_test.go | 153 +- middlewares/activelimit/locallimit/builder.go | 36 +- middlewares/activelimit/redislimit/builder.go | 39 +- .../activelimit/redislimit/builder_test.go | 224 + 5 files changed, 12718 insertions(+), 188 deletions(-) create mode 100644 internal/activelimit/mocks/redis_mock.go create mode 100644 middlewares/activelimit/redislimit/builder_test.go diff --git a/internal/activelimit/mocks/redis_mock.go b/internal/activelimit/mocks/redis_mock.go new file mode 100644 index 0000000..2bd8266 --- /dev/null +++ b/internal/activelimit/mocks/redis_mock.go @@ -0,0 +1,12454 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: G:\go-up\pkg\mod\github.com\redis\go-redis\v9@v9.1.0\commands.go +// +// Generated by this command: +// +// mockgen.exe -source=G:\go-up\pkg\mod\github.com\redis\go-redis\v9@v9.1.0\commands.go -package=redismocks -destination=G:\go-up\src\ginx\internal\activelimit\mocks\redis_mock.go +// +// Package redismocks is a generated GoMock package. +package redismocks + +import ( + context "context" + reflect "reflect" + time "time" + + redis "github.com/redis/go-redis/v9" + gomock "go.uber.org/mock/gomock" +) + +// MockCmdable is a mock of Cmdable interface. +type MockCmdable struct { + ctrl *gomock.Controller + recorder *MockCmdableMockRecorder +} + +// MockCmdableMockRecorder is the mock recorder for MockCmdable. +type MockCmdableMockRecorder struct { + mock *MockCmdable +} + +// NewMockCmdable creates a new mock instance. +func NewMockCmdable(ctrl *gomock.Controller) *MockCmdable { + mock := &MockCmdable{ctrl: ctrl} + mock.recorder = &MockCmdableMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCmdable) EXPECT() *MockCmdableMockRecorder { + return m.recorder +} + +// ACLDryRun mocks base method. +func (m *MockCmdable) ACLDryRun(ctx context.Context, username string, command ...any) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, username} + for _, a := range command { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ACLDryRun", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ACLDryRun indicates an expected call of ACLDryRun. +func (mr *MockCmdableMockRecorder) ACLDryRun(ctx, username any, command ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, username}, command...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDryRun", reflect.TypeOf((*MockCmdable)(nil).ACLDryRun), varargs...) +} + +// ACLLog mocks base method. +func (m *MockCmdable) ACLLog(ctx context.Context, count int64) *redis.ACLLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLog", ctx, count) + ret0, _ := ret[0].(*redis.ACLLogCmd) + return ret0 +} + +// ACLLog indicates an expected call of ACLLog. +func (mr *MockCmdableMockRecorder) ACLLog(ctx, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockCmdable)(nil).ACLLog), ctx, count) +} + +// ACLLogReset mocks base method. +func (m *MockCmdable) ACLLogReset(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLogReset", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ACLLogReset indicates an expected call of ACLLogReset. +func (mr *MockCmdableMockRecorder) ACLLogReset(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockCmdable)(nil).ACLLogReset), ctx) +} + +// Append mocks base method. +func (m *MockCmdable) Append(ctx context.Context, key, value string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Append", ctx, key, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Append indicates an expected call of Append. +func (mr *MockCmdableMockRecorder) Append(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockCmdable)(nil).Append), ctx, key, value) +} + +// BFAdd mocks base method. +func (m *MockCmdable) BFAdd(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFAdd", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFAdd indicates an expected call of BFAdd. +func (mr *MockCmdableMockRecorder) BFAdd(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockCmdable)(nil).BFAdd), ctx, key, element) +} + +// BFCard mocks base method. +func (m *MockCmdable) BFCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BFCard indicates an expected call of BFCard. +func (mr *MockCmdableMockRecorder) BFCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockCmdable)(nil).BFCard), ctx, key) +} + +// BFExists mocks base method. +func (m *MockCmdable) BFExists(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFExists", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFExists indicates an expected call of BFExists. +func (mr *MockCmdableMockRecorder) BFExists(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockCmdable)(nil).BFExists), ctx, key, element) +} + +// BFInfo mocks base method. +func (m *MockCmdable) BFInfo(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfo", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfo indicates an expected call of BFInfo. +func (mr *MockCmdableMockRecorder) BFInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockCmdable)(nil).BFInfo), ctx, key) +} + +// BFInfoArg mocks base method. +func (m *MockCmdable) BFInfoArg(ctx context.Context, key, option string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoArg", ctx, key, option) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoArg indicates an expected call of BFInfoArg. +func (mr *MockCmdableMockRecorder) BFInfoArg(ctx, key, option any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockCmdable)(nil).BFInfoArg), ctx, key, option) +} + +// BFInfoCapacity mocks base method. +func (m *MockCmdable) BFInfoCapacity(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoCapacity", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoCapacity indicates an expected call of BFInfoCapacity. +func (mr *MockCmdableMockRecorder) BFInfoCapacity(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockCmdable)(nil).BFInfoCapacity), ctx, key) +} + +// BFInfoExpansion mocks base method. +func (m *MockCmdable) BFInfoExpansion(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoExpansion", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoExpansion indicates an expected call of BFInfoExpansion. +func (mr *MockCmdableMockRecorder) BFInfoExpansion(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockCmdable)(nil).BFInfoExpansion), ctx, key) +} + +// BFInfoFilters mocks base method. +func (m *MockCmdable) BFInfoFilters(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoFilters", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoFilters indicates an expected call of BFInfoFilters. +func (mr *MockCmdableMockRecorder) BFInfoFilters(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockCmdable)(nil).BFInfoFilters), ctx, key) +} + +// BFInfoItems mocks base method. +func (m *MockCmdable) BFInfoItems(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoItems", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoItems indicates an expected call of BFInfoItems. +func (mr *MockCmdableMockRecorder) BFInfoItems(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockCmdable)(nil).BFInfoItems), ctx, key) +} + +// BFInfoSize mocks base method. +func (m *MockCmdable) BFInfoSize(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoSize", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoSize indicates an expected call of BFInfoSize. +func (mr *MockCmdableMockRecorder) BFInfoSize(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockCmdable)(nil).BFInfoSize), ctx, key) +} + +// BFInsert mocks base method. +func (m *MockCmdable) BFInsert(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFInsert indicates an expected call of BFInsert. +func (mr *MockCmdableMockRecorder) BFInsert(ctx, key, options any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInsert", reflect.TypeOf((*MockCmdable)(nil).BFInsert), varargs...) +} + +// BFLoadChunk mocks base method. +func (m *MockCmdable) BFLoadChunk(ctx context.Context, key string, iterator int64, data any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFLoadChunk", ctx, key, iterator, data) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFLoadChunk indicates an expected call of BFLoadChunk. +func (mr *MockCmdableMockRecorder) BFLoadChunk(ctx, key, iterator, data any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockCmdable)(nil).BFLoadChunk), ctx, key, iterator, data) +} + +// BFMAdd mocks base method. +func (m *MockCmdable) BFMAdd(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMAdd", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMAdd indicates an expected call of BFMAdd. +func (mr *MockCmdableMockRecorder) BFMAdd(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMAdd", reflect.TypeOf((*MockCmdable)(nil).BFMAdd), varargs...) +} + +// BFMExists mocks base method. +func (m *MockCmdable) BFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMExists indicates an expected call of BFMExists. +func (mr *MockCmdableMockRecorder) BFMExists(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMExists", reflect.TypeOf((*MockCmdable)(nil).BFMExists), varargs...) +} + +// BFReserve mocks base method. +func (m *MockCmdable) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserve", ctx, key, errorRate, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserve indicates an expected call of BFReserve. +func (mr *MockCmdableMockRecorder) BFReserve(ctx, key, errorRate, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockCmdable)(nil).BFReserve), ctx, key, errorRate, capacity) +} + +// BFReserveArgs mocks base method. +func (m *MockCmdable) BFReserveArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveArgs indicates an expected call of BFReserveArgs. +func (mr *MockCmdableMockRecorder) BFReserveArgs(ctx, key, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveArgs", reflect.TypeOf((*MockCmdable)(nil).BFReserveArgs), ctx, key, options) +} + +// BFReserveExpansion mocks base method. +func (m *MockCmdable) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveExpansion", ctx, key, errorRate, capacity, expansion) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveExpansion indicates an expected call of BFReserveExpansion. +func (mr *MockCmdableMockRecorder) BFReserveExpansion(ctx, key, errorRate, capacity, expansion any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockCmdable)(nil).BFReserveExpansion), ctx, key, errorRate, capacity, expansion) +} + +// BFReserveNonScaling mocks base method. +func (m *MockCmdable) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveNonScaling", ctx, key, errorRate, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveNonScaling indicates an expected call of BFReserveNonScaling. +func (mr *MockCmdableMockRecorder) BFReserveNonScaling(ctx, key, errorRate, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockCmdable)(nil).BFReserveNonScaling), ctx, key, errorRate, capacity) +} + +// BFScanDump mocks base method. +func (m *MockCmdable) BFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFScanDump", ctx, key, iterator) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// BFScanDump indicates an expected call of BFScanDump. +func (mr *MockCmdableMockRecorder) BFScanDump(ctx, key, iterator any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockCmdable)(nil).BFScanDump), ctx, key, iterator) +} + +// BLMPop mocks base method. +func (m *MockCmdable) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout, direction, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// BLMPop indicates an expected call of BLMPop. +func (mr *MockCmdableMockRecorder) BLMPop(ctx, timeout, direction, count any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout, direction, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMPop", reflect.TypeOf((*MockCmdable)(nil).BLMPop), varargs...) +} + +// BLMove mocks base method. +func (m *MockCmdable) BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BLMove", ctx, source, destination, srcpos, destpos, timeout) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BLMove indicates an expected call of BLMove. +func (mr *MockCmdableMockRecorder) BLMove(ctx, source, destination, srcpos, destpos, timeout any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMove", reflect.TypeOf((*MockCmdable)(nil).BLMove), ctx, source, destination, srcpos, destpos, timeout) +} + +// BLPop mocks base method. +func (m *MockCmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BLPop indicates an expected call of BLPop. +func (mr *MockCmdableMockRecorder) BLPop(ctx, timeout any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLPop", reflect.TypeOf((*MockCmdable)(nil).BLPop), varargs...) +} + +// BRPop mocks base method. +func (m *MockCmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BRPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BRPop indicates an expected call of BRPop. +func (mr *MockCmdableMockRecorder) BRPop(ctx, timeout any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPop", reflect.TypeOf((*MockCmdable)(nil).BRPop), varargs...) +} + +// BRPopLPush mocks base method. +func (m *MockCmdable) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BRPopLPush", ctx, source, destination, timeout) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BRPopLPush indicates an expected call of BRPopLPush. +func (mr *MockCmdableMockRecorder) BRPopLPush(ctx, source, destination, timeout any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockCmdable)(nil).BRPopLPush), ctx, source, destination, timeout) +} + +// BZMPop mocks base method. +func (m *MockCmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout, order, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// BZMPop indicates an expected call of BZMPop. +func (mr *MockCmdableMockRecorder) BZMPop(ctx, timeout, order, count any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout, order, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZMPop", reflect.TypeOf((*MockCmdable)(nil).BZMPop), varargs...) +} + +// BZPopMax mocks base method. +func (m *MockCmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMax indicates an expected call of BZPopMax. +func (mr *MockCmdableMockRecorder) BZPopMax(ctx, timeout any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMax", reflect.TypeOf((*MockCmdable)(nil).BZPopMax), varargs...) +} + +// BZPopMin mocks base method. +func (m *MockCmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMin indicates an expected call of BZPopMin. +func (mr *MockCmdableMockRecorder) BZPopMin(ctx, timeout any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMin", reflect.TypeOf((*MockCmdable)(nil).BZPopMin), varargs...) +} + +// BgRewriteAOF mocks base method. +func (m *MockCmdable) BgRewriteAOF(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgRewriteAOF", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgRewriteAOF indicates an expected call of BgRewriteAOF. +func (mr *MockCmdableMockRecorder) BgRewriteAOF(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockCmdable)(nil).BgRewriteAOF), ctx) +} + +// BgSave mocks base method. +func (m *MockCmdable) BgSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgSave indicates an expected call of BgSave. +func (mr *MockCmdableMockRecorder) BgSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockCmdable)(nil).BgSave), ctx) +} + +// BitCount mocks base method. +func (m *MockCmdable) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitCount", ctx, key, bitCount) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitCount indicates an expected call of BitCount. +func (mr *MockCmdableMockRecorder) BitCount(ctx, key, bitCount any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockCmdable)(nil).BitCount), ctx, key, bitCount) +} + +// BitField mocks base method. +func (m *MockCmdable) BitField(ctx context.Context, key string, args ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitField", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// BitField indicates an expected call of BitField. +func (mr *MockCmdableMockRecorder) BitField(ctx, key any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockCmdable)(nil).BitField), varargs...) +} + +// BitOpAnd mocks base method. +func (m *MockCmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpAnd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpAnd indicates an expected call of BitOpAnd. +func (mr *MockCmdableMockRecorder) BitOpAnd(ctx, destKey any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAnd", reflect.TypeOf((*MockCmdable)(nil).BitOpAnd), varargs...) +} + +// BitOpNot mocks base method. +func (m *MockCmdable) BitOpNot(ctx context.Context, destKey, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitOpNot", ctx, destKey, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpNot indicates an expected call of BitOpNot. +func (mr *MockCmdableMockRecorder) BitOpNot(ctx, destKey, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockCmdable)(nil).BitOpNot), ctx, destKey, key) +} + +// BitOpOr mocks base method. +func (m *MockCmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpOr", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpOr indicates an expected call of BitOpOr. +func (mr *MockCmdableMockRecorder) BitOpOr(ctx, destKey any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOr", reflect.TypeOf((*MockCmdable)(nil).BitOpOr), varargs...) +} + +// BitOpXor mocks base method. +func (m *MockCmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpXor", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpXor indicates an expected call of BitOpXor. +func (mr *MockCmdableMockRecorder) BitOpXor(ctx, destKey any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpXor", reflect.TypeOf((*MockCmdable)(nil).BitOpXor), varargs...) +} + +// BitPos mocks base method. +func (m *MockCmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key, bit} + for _, a := range pos { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitPos", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPos indicates an expected call of BitPos. +func (mr *MockCmdableMockRecorder) BitPos(ctx, key, bit any, pos ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key, bit}, pos...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPos", reflect.TypeOf((*MockCmdable)(nil).BitPos), varargs...) +} + +// BitPosSpan mocks base method. +func (m *MockCmdable) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitPosSpan", ctx, key, bit, start, end, span) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPosSpan indicates an expected call of BitPosSpan. +func (mr *MockCmdableMockRecorder) BitPosSpan(ctx, key, bit, start, end, span any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPosSpan", reflect.TypeOf((*MockCmdable)(nil).BitPosSpan), ctx, key, bit, start, end, span) +} + +// CFAdd mocks base method. +func (m *MockCmdable) CFAdd(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAdd", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAdd indicates an expected call of CFAdd. +func (mr *MockCmdableMockRecorder) CFAdd(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockCmdable)(nil).CFAdd), ctx, key, element) +} + +// CFAddNX mocks base method. +func (m *MockCmdable) CFAddNX(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAddNX", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAddNX indicates an expected call of CFAddNX. +func (mr *MockCmdableMockRecorder) CFAddNX(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockCmdable)(nil).CFAddNX), ctx, key, element) +} + +// CFCount mocks base method. +func (m *MockCmdable) CFCount(ctx context.Context, key string, element any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFCount", ctx, key, element) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// CFCount indicates an expected call of CFCount. +func (mr *MockCmdableMockRecorder) CFCount(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockCmdable)(nil).CFCount), ctx, key, element) +} + +// CFDel mocks base method. +func (m *MockCmdable) CFDel(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFDel", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFDel indicates an expected call of CFDel. +func (mr *MockCmdableMockRecorder) CFDel(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockCmdable)(nil).CFDel), ctx, key, element) +} + +// CFExists mocks base method. +func (m *MockCmdable) CFExists(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFExists", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFExists indicates an expected call of CFExists. +func (mr *MockCmdableMockRecorder) CFExists(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockCmdable)(nil).CFExists), ctx, key, element) +} + +// CFInfo mocks base method. +func (m *MockCmdable) CFInfo(ctx context.Context, key string) *redis.CFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFInfo", ctx, key) + ret0, _ := ret[0].(*redis.CFInfoCmd) + return ret0 +} + +// CFInfo indicates an expected call of CFInfo. +func (mr *MockCmdableMockRecorder) CFInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockCmdable)(nil).CFInfo), ctx, key) +} + +// CFInsert mocks base method. +func (m *MockCmdable) CFInsert(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFInsert indicates an expected call of CFInsert. +func (mr *MockCmdableMockRecorder) CFInsert(ctx, key, options any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsert", reflect.TypeOf((*MockCmdable)(nil).CFInsert), varargs...) +} + +// CFInsertNX mocks base method. +func (m *MockCmdable) CFInsertNX(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsertNX", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CFInsertNX indicates an expected call of CFInsertNX. +func (mr *MockCmdableMockRecorder) CFInsertNX(ctx, key, options any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsertNX", reflect.TypeOf((*MockCmdable)(nil).CFInsertNX), varargs...) +} + +// CFLoadChunk mocks base method. +func (m *MockCmdable) CFLoadChunk(ctx context.Context, key string, iterator int64, data any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFLoadChunk", ctx, key, iterator, data) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFLoadChunk indicates an expected call of CFLoadChunk. +func (mr *MockCmdableMockRecorder) CFLoadChunk(ctx, key, iterator, data any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockCmdable)(nil).CFLoadChunk), ctx, key, iterator, data) +} + +// CFMExists mocks base method. +func (m *MockCmdable) CFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFMExists indicates an expected call of CFMExists. +func (mr *MockCmdableMockRecorder) CFMExists(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFMExists", reflect.TypeOf((*MockCmdable)(nil).CFMExists), varargs...) +} + +// CFReserve mocks base method. +func (m *MockCmdable) CFReserve(ctx context.Context, key string, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserve", ctx, key, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserve indicates an expected call of CFReserve. +func (mr *MockCmdableMockRecorder) CFReserve(ctx, key, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockCmdable)(nil).CFReserve), ctx, key, capacity) +} + +// CFReserveArgs mocks base method. +func (m *MockCmdable) CFReserveArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveArgs indicates an expected call of CFReserveArgs. +func (mr *MockCmdableMockRecorder) CFReserveArgs(ctx, key, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveArgs", reflect.TypeOf((*MockCmdable)(nil).CFReserveArgs), ctx, key, options) +} + +// CFReserveBucketSize mocks base method. +func (m *MockCmdable) CFReserveBucketSize(ctx context.Context, key string, capacity, bucketsize int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveBucketSize", ctx, key, capacity, bucketsize) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveBucketSize indicates an expected call of CFReserveBucketSize. +func (mr *MockCmdableMockRecorder) CFReserveBucketSize(ctx, key, capacity, bucketsize any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockCmdable)(nil).CFReserveBucketSize), ctx, key, capacity, bucketsize) +} + +// CFReserveExpansion mocks base method. +func (m *MockCmdable) CFReserveExpansion(ctx context.Context, key string, capacity, expansion int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveExpansion", ctx, key, capacity, expansion) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveExpansion indicates an expected call of CFReserveExpansion. +func (mr *MockCmdableMockRecorder) CFReserveExpansion(ctx, key, capacity, expansion any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockCmdable)(nil).CFReserveExpansion), ctx, key, capacity, expansion) +} + +// CFReserveMaxIterations mocks base method. +func (m *MockCmdable) CFReserveMaxIterations(ctx context.Context, key string, capacity, maxiterations int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveMaxIterations", ctx, key, capacity, maxiterations) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations. +func (mr *MockCmdableMockRecorder) CFReserveMaxIterations(ctx, key, capacity, maxiterations any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockCmdable)(nil).CFReserveMaxIterations), ctx, key, capacity, maxiterations) +} + +// CFScanDump mocks base method. +func (m *MockCmdable) CFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFScanDump", ctx, key, iterator) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// CFScanDump indicates an expected call of CFScanDump. +func (mr *MockCmdableMockRecorder) CFScanDump(ctx, key, iterator any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockCmdable)(nil).CFScanDump), ctx, key, iterator) +} + +// CMSIncrBy mocks base method. +func (m *MockCmdable) CMSIncrBy(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSIncrBy", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSIncrBy indicates an expected call of CMSIncrBy. +func (mr *MockCmdableMockRecorder) CMSIncrBy(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSIncrBy", reflect.TypeOf((*MockCmdable)(nil).CMSIncrBy), varargs...) +} + +// CMSInfo mocks base method. +func (m *MockCmdable) CMSInfo(ctx context.Context, key string) *redis.CMSInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInfo", ctx, key) + ret0, _ := ret[0].(*redis.CMSInfoCmd) + return ret0 +} + +// CMSInfo indicates an expected call of CMSInfo. +func (mr *MockCmdableMockRecorder) CMSInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockCmdable)(nil).CMSInfo), ctx, key) +} + +// CMSInitByDim mocks base method. +func (m *MockCmdable) CMSInitByDim(ctx context.Context, key string, width, height int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByDim", ctx, key, width, height) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByDim indicates an expected call of CMSInitByDim. +func (mr *MockCmdableMockRecorder) CMSInitByDim(ctx, key, width, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockCmdable)(nil).CMSInitByDim), ctx, key, width, height) +} + +// CMSInitByProb mocks base method. +func (m *MockCmdable) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByProb", ctx, key, errorRate, probability) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByProb indicates an expected call of CMSInitByProb. +func (mr *MockCmdableMockRecorder) CMSInitByProb(ctx, key, errorRate, probability any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockCmdable)(nil).CMSInitByProb), ctx, key, errorRate, probability) +} + +// CMSMerge mocks base method. +func (m *MockCmdable) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey} + for _, a := range sourceKeys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMerge indicates an expected call of CMSMerge. +func (mr *MockCmdableMockRecorder) CMSMerge(ctx, destKey any, sourceKeys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey}, sourceKeys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMerge", reflect.TypeOf((*MockCmdable)(nil).CMSMerge), varargs...) +} + +// CMSMergeWithWeight mocks base method. +func (m *MockCmdable) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSMergeWithWeight", ctx, destKey, sourceKeys) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight. +func (mr *MockCmdableMockRecorder) CMSMergeWithWeight(ctx, destKey, sourceKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockCmdable)(nil).CMSMergeWithWeight), ctx, destKey, sourceKeys) +} + +// CMSQuery mocks base method. +func (m *MockCmdable) CMSQuery(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSQuery", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSQuery indicates an expected call of CMSQuery. +func (mr *MockCmdableMockRecorder) CMSQuery(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSQuery", reflect.TypeOf((*MockCmdable)(nil).CMSQuery), varargs...) +} + +// ClientGetName mocks base method. +func (m *MockCmdable) ClientGetName(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientGetName", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientGetName indicates an expected call of ClientGetName. +func (mr *MockCmdableMockRecorder) ClientGetName(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockCmdable)(nil).ClientGetName), ctx) +} + +// ClientID mocks base method. +func (m *MockCmdable) ClientID(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientID", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientID indicates an expected call of ClientID. +func (mr *MockCmdableMockRecorder) ClientID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockCmdable)(nil).ClientID), ctx) +} + +// ClientInfo mocks base method. +func (m *MockCmdable) ClientInfo(ctx context.Context) *redis.ClientInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientInfo", ctx) + ret0, _ := ret[0].(*redis.ClientInfoCmd) + return ret0 +} + +// ClientInfo indicates an expected call of ClientInfo. +func (mr *MockCmdableMockRecorder) ClientInfo(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockCmdable)(nil).ClientInfo), ctx) +} + +// ClientKill mocks base method. +func (m *MockCmdable) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientKill", ctx, ipPort) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClientKill indicates an expected call of ClientKill. +func (mr *MockCmdableMockRecorder) ClientKill(ctx, ipPort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockCmdable)(nil).ClientKill), ctx, ipPort) +} + +// ClientKillByFilter mocks base method. +func (m *MockCmdable) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientKillByFilter indicates an expected call of ClientKillByFilter. +func (mr *MockCmdableMockRecorder) ClientKillByFilter(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockCmdable)(nil).ClientKillByFilter), varargs...) +} + +// ClientList mocks base method. +func (m *MockCmdable) ClientList(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientList", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientList indicates an expected call of ClientList. +func (mr *MockCmdableMockRecorder) ClientList(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockCmdable)(nil).ClientList), ctx) +} + +// ClientPause mocks base method. +func (m *MockCmdable) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientPause", ctx, dur) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientPause indicates an expected call of ClientPause. +func (mr *MockCmdableMockRecorder) ClientPause(ctx, dur any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockCmdable)(nil).ClientPause), ctx, dur) +} + +// ClientUnblock mocks base method. +func (m *MockCmdable) ClientUnblock(ctx context.Context, id int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblock", ctx, id) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblock indicates an expected call of ClientUnblock. +func (mr *MockCmdableMockRecorder) ClientUnblock(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockCmdable)(nil).ClientUnblock), ctx, id) +} + +// ClientUnblockWithError mocks base method. +func (m *MockCmdable) ClientUnblockWithError(ctx context.Context, id int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblockWithError", ctx, id) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblockWithError indicates an expected call of ClientUnblockWithError. +func (mr *MockCmdableMockRecorder) ClientUnblockWithError(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockCmdable)(nil).ClientUnblockWithError), ctx, id) +} + +// ClientUnpause mocks base method. +func (m *MockCmdable) ClientUnpause(ctx context.Context) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnpause", ctx) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientUnpause indicates an expected call of ClientUnpause. +func (mr *MockCmdableMockRecorder) ClientUnpause(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockCmdable)(nil).ClientUnpause), ctx) +} + +// ClusterAddSlots mocks base method. +func (m *MockCmdable) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range slots { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlots indicates an expected call of ClusterAddSlots. +func (mr *MockCmdableMockRecorder) ClusterAddSlots(ctx any, slots ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, slots...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlots), varargs...) +} + +// ClusterAddSlotsRange mocks base method. +func (m *MockCmdable) ClusterAddSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterAddSlotsRange", ctx, min, max) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange. +func (mr *MockCmdableMockRecorder) ClusterAddSlotsRange(ctx, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlotsRange), ctx, min, max) +} + +// ClusterCountFailureReports mocks base method. +func (m *MockCmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountFailureReports", ctx, nodeID) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports. +func (mr *MockCmdableMockRecorder) ClusterCountFailureReports(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockCmdable)(nil).ClusterCountFailureReports), ctx, nodeID) +} + +// ClusterCountKeysInSlot mocks base method. +func (m *MockCmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", ctx, slot) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot. +func (mr *MockCmdableMockRecorder) ClusterCountKeysInSlot(ctx, slot any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterCountKeysInSlot), ctx, slot) +} + +// ClusterDelSlots mocks base method. +func (m *MockCmdable) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range slots { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlots indicates an expected call of ClusterDelSlots. +func (mr *MockCmdableMockRecorder) ClusterDelSlots(ctx any, slots ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, slots...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlots), varargs...) +} + +// ClusterDelSlotsRange mocks base method. +func (m *MockCmdable) ClusterDelSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterDelSlotsRange", ctx, min, max) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange. +func (mr *MockCmdableMockRecorder) ClusterDelSlotsRange(ctx, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlotsRange), ctx, min, max) +} + +// ClusterFailover mocks base method. +func (m *MockCmdable) ClusterFailover(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterFailover", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterFailover indicates an expected call of ClusterFailover. +func (mr *MockCmdableMockRecorder) ClusterFailover(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockCmdable)(nil).ClusterFailover), ctx) +} + +// ClusterForget mocks base method. +func (m *MockCmdable) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterForget", ctx, nodeID) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterForget indicates an expected call of ClusterForget. +func (mr *MockCmdableMockRecorder) ClusterForget(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockCmdable)(nil).ClusterForget), ctx, nodeID) +} + +// ClusterGetKeysInSlot mocks base method. +func (m *MockCmdable) ClusterGetKeysInSlot(ctx context.Context, slot, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", ctx, slot, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot. +func (mr *MockCmdableMockRecorder) ClusterGetKeysInSlot(ctx, slot, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterGetKeysInSlot), ctx, slot, count) +} + +// ClusterInfo mocks base method. +func (m *MockCmdable) ClusterInfo(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterInfo", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterInfo indicates an expected call of ClusterInfo. +func (mr *MockCmdableMockRecorder) ClusterInfo(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockCmdable)(nil).ClusterInfo), ctx) +} + +// ClusterKeySlot mocks base method. +func (m *MockCmdable) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterKeySlot", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterKeySlot indicates an expected call of ClusterKeySlot. +func (mr *MockCmdableMockRecorder) ClusterKeySlot(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockCmdable)(nil).ClusterKeySlot), ctx, key) +} + +// ClusterLinks mocks base method. +func (m *MockCmdable) ClusterLinks(ctx context.Context) *redis.ClusterLinksCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterLinks", ctx) + ret0, _ := ret[0].(*redis.ClusterLinksCmd) + return ret0 +} + +// ClusterLinks indicates an expected call of ClusterLinks. +func (mr *MockCmdableMockRecorder) ClusterLinks(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockCmdable)(nil).ClusterLinks), ctx) +} + +// ClusterMeet mocks base method. +func (m *MockCmdable) ClusterMeet(ctx context.Context, host, port string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMeet", ctx, host, port) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterMeet indicates an expected call of ClusterMeet. +func (mr *MockCmdableMockRecorder) ClusterMeet(ctx, host, port any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockCmdable)(nil).ClusterMeet), ctx, host, port) +} + +// ClusterMyShardID mocks base method. +func (m *MockCmdable) ClusterMyShardID(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMyShardID", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterMyShardID indicates an expected call of ClusterMyShardID. +func (mr *MockCmdableMockRecorder) ClusterMyShardID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockCmdable)(nil).ClusterMyShardID), ctx) +} + +// ClusterNodes mocks base method. +func (m *MockCmdable) ClusterNodes(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterNodes", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterNodes indicates an expected call of ClusterNodes. +func (mr *MockCmdableMockRecorder) ClusterNodes(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockCmdable)(nil).ClusterNodes), ctx) +} + +// ClusterReplicate mocks base method. +func (m *MockCmdable) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterReplicate", ctx, nodeID) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterReplicate indicates an expected call of ClusterReplicate. +func (mr *MockCmdableMockRecorder) ClusterReplicate(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockCmdable)(nil).ClusterReplicate), ctx, nodeID) +} + +// ClusterResetHard mocks base method. +func (m *MockCmdable) ClusterResetHard(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetHard", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetHard indicates an expected call of ClusterResetHard. +func (mr *MockCmdableMockRecorder) ClusterResetHard(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockCmdable)(nil).ClusterResetHard), ctx) +} + +// ClusterResetSoft mocks base method. +func (m *MockCmdable) ClusterResetSoft(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetSoft", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetSoft indicates an expected call of ClusterResetSoft. +func (mr *MockCmdableMockRecorder) ClusterResetSoft(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockCmdable)(nil).ClusterResetSoft), ctx) +} + +// ClusterSaveConfig mocks base method. +func (m *MockCmdable) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSaveConfig", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterSaveConfig indicates an expected call of ClusterSaveConfig. +func (mr *MockCmdableMockRecorder) ClusterSaveConfig(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockCmdable)(nil).ClusterSaveConfig), ctx) +} + +// ClusterShards mocks base method. +func (m *MockCmdable) ClusterShards(ctx context.Context) *redis.ClusterShardsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterShards", ctx) + ret0, _ := ret[0].(*redis.ClusterShardsCmd) + return ret0 +} + +// ClusterShards indicates an expected call of ClusterShards. +func (mr *MockCmdableMockRecorder) ClusterShards(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockCmdable)(nil).ClusterShards), ctx) +} + +// ClusterSlaves mocks base method. +func (m *MockCmdable) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlaves", ctx, nodeID) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterSlaves indicates an expected call of ClusterSlaves. +func (mr *MockCmdableMockRecorder) ClusterSlaves(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockCmdable)(nil).ClusterSlaves), ctx, nodeID) +} + +// ClusterSlots mocks base method. +func (m *MockCmdable) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlots", ctx) + ret0, _ := ret[0].(*redis.ClusterSlotsCmd) + return ret0 +} + +// ClusterSlots indicates an expected call of ClusterSlots. +func (mr *MockCmdableMockRecorder) ClusterSlots(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterSlots), ctx) +} + +// Command mocks base method. +func (m *MockCmdable) Command(ctx context.Context) *redis.CommandsInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Command", ctx) + ret0, _ := ret[0].(*redis.CommandsInfoCmd) + return ret0 +} + +// Command indicates an expected call of Command. +func (mr *MockCmdableMockRecorder) Command(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockCmdable)(nil).Command), ctx) +} + +// CommandGetKeys mocks base method. +func (m *MockCmdable) CommandGetKeys(ctx context.Context, commands ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range commands { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeys", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandGetKeys indicates an expected call of CommandGetKeys. +func (mr *MockCmdableMockRecorder) CommandGetKeys(ctx any, commands ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, commands...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeys", reflect.TypeOf((*MockCmdable)(nil).CommandGetKeys), varargs...) +} + +// CommandGetKeysAndFlags mocks base method. +func (m *MockCmdable) CommandGetKeysAndFlags(ctx context.Context, commands ...any) *redis.KeyFlagsCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range commands { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...) + ret0, _ := ret[0].(*redis.KeyFlagsCmd) + return ret0 +} + +// CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags. +func (mr *MockCmdableMockRecorder) CommandGetKeysAndFlags(ctx any, commands ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, commands...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeysAndFlags", reflect.TypeOf((*MockCmdable)(nil).CommandGetKeysAndFlags), varargs...) +} + +// CommandList mocks base method. +func (m *MockCmdable) CommandList(ctx context.Context, filter *redis.FilterBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandList", ctx, filter) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandList indicates an expected call of CommandList. +func (mr *MockCmdableMockRecorder) CommandList(ctx, filter any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockCmdable)(nil).CommandList), ctx, filter) +} + +// ConfigGet mocks base method. +func (m *MockCmdable) ConfigGet(ctx context.Context, parameter string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigGet", ctx, parameter) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// ConfigGet indicates an expected call of ConfigGet. +func (mr *MockCmdableMockRecorder) ConfigGet(ctx, parameter any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockCmdable)(nil).ConfigGet), ctx, parameter) +} + +// ConfigResetStat mocks base method. +func (m *MockCmdable) ConfigResetStat(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigResetStat", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigResetStat indicates an expected call of ConfigResetStat. +func (mr *MockCmdableMockRecorder) ConfigResetStat(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockCmdable)(nil).ConfigResetStat), ctx) +} + +// ConfigRewrite mocks base method. +func (m *MockCmdable) ConfigRewrite(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigRewrite", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigRewrite indicates an expected call of ConfigRewrite. +func (mr *MockCmdableMockRecorder) ConfigRewrite(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockCmdable)(nil).ConfigRewrite), ctx) +} + +// ConfigSet mocks base method. +func (m *MockCmdable) ConfigSet(ctx context.Context, parameter, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigSet", ctx, parameter, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigSet indicates an expected call of ConfigSet. +func (mr *MockCmdableMockRecorder) ConfigSet(ctx, parameter, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockCmdable)(nil).ConfigSet), ctx, parameter, value) +} + +// Copy mocks base method. +func (m *MockCmdable) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Copy", ctx, sourceKey, destKey, db, replace) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Copy indicates an expected call of Copy. +func (mr *MockCmdableMockRecorder) Copy(ctx, sourceKey, destKey, db, replace any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockCmdable)(nil).Copy), ctx, sourceKey, destKey, db, replace) +} + +// DBSize mocks base method. +func (m *MockCmdable) DBSize(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DBSize", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DBSize indicates an expected call of DBSize. +func (mr *MockCmdableMockRecorder) DBSize(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockCmdable)(nil).DBSize), ctx) +} + +// DebugObject mocks base method. +func (m *MockCmdable) DebugObject(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugObject", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// DebugObject indicates an expected call of DebugObject. +func (mr *MockCmdableMockRecorder) DebugObject(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockCmdable)(nil).DebugObject), ctx, key) +} + +// Decr mocks base method. +func (m *MockCmdable) Decr(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Decr", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Decr indicates an expected call of Decr. +func (mr *MockCmdableMockRecorder) Decr(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockCmdable)(nil).Decr), ctx, key) +} + +// DecrBy mocks base method. +func (m *MockCmdable) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecrBy", ctx, key, decrement) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DecrBy indicates an expected call of DecrBy. +func (mr *MockCmdableMockRecorder) DecrBy(ctx, key, decrement any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockCmdable)(nil).DecrBy), ctx, key, decrement) +} + +// Del mocks base method. +func (m *MockCmdable) Del(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Del", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Del indicates an expected call of Del. +func (mr *MockCmdableMockRecorder) Del(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockCmdable)(nil).Del), varargs...) +} + +// Dump mocks base method. +func (m *MockCmdable) Dump(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Dump", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Dump indicates an expected call of Dump. +func (mr *MockCmdableMockRecorder) Dump(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockCmdable)(nil).Dump), ctx, key) +} + +// Echo mocks base method. +func (m *MockCmdable) Echo(ctx context.Context, message any) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Echo", ctx, message) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Echo indicates an expected call of Echo. +func (mr *MockCmdableMockRecorder) Echo(ctx, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockCmdable)(nil).Echo), ctx, message) +} + +// Eval mocks base method. +func (m *MockCmdable) Eval(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, script, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Eval", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// Eval indicates an expected call of Eval. +func (mr *MockCmdableMockRecorder) Eval(ctx, script, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, script, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockCmdable)(nil).Eval), varargs...) +} + +// EvalRO mocks base method. +func (m *MockCmdable) EvalRO(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, script, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalRO indicates an expected call of EvalRO. +func (mr *MockCmdableMockRecorder) EvalRO(ctx, script, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, script, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockCmdable)(nil).EvalRO), varargs...) +} + +// EvalSha mocks base method. +func (m *MockCmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, sha1, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalSha", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalSha indicates an expected call of EvalSha. +func (mr *MockCmdableMockRecorder) EvalSha(ctx, sha1, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, sha1, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockCmdable)(nil).EvalSha), varargs...) +} + +// EvalShaRO mocks base method. +func (m *MockCmdable) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, sha1, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalShaRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalShaRO indicates an expected call of EvalShaRO. +func (mr *MockCmdableMockRecorder) EvalShaRO(ctx, sha1, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, sha1, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockCmdable)(nil).EvalShaRO), varargs...) +} + +// Exists mocks base method. +func (m *MockCmdable) Exists(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Exists", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Exists indicates an expected call of Exists. +func (mr *MockCmdableMockRecorder) Exists(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockCmdable)(nil).Exists), varargs...) +} + +// Expire mocks base method. +func (m *MockCmdable) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Expire", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Expire indicates an expected call of Expire. +func (mr *MockCmdableMockRecorder) Expire(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockCmdable)(nil).Expire), ctx, key, expiration) +} + +// ExpireAt mocks base method. +func (m *MockCmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireAt", ctx, key, tm) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireAt indicates an expected call of ExpireAt. +func (mr *MockCmdableMockRecorder) ExpireAt(ctx, key, tm any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockCmdable)(nil).ExpireAt), ctx, key, tm) +} + +// ExpireGT mocks base method. +func (m *MockCmdable) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireGT", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireGT indicates an expected call of ExpireGT. +func (mr *MockCmdableMockRecorder) ExpireGT(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockCmdable)(nil).ExpireGT), ctx, key, expiration) +} + +// ExpireLT mocks base method. +func (m *MockCmdable) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireLT", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireLT indicates an expected call of ExpireLT. +func (mr *MockCmdableMockRecorder) ExpireLT(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockCmdable)(nil).ExpireLT), ctx, key, expiration) +} + +// ExpireNX mocks base method. +func (m *MockCmdable) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireNX", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireNX indicates an expected call of ExpireNX. +func (mr *MockCmdableMockRecorder) ExpireNX(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockCmdable)(nil).ExpireNX), ctx, key, expiration) +} + +// ExpireTime mocks base method. +func (m *MockCmdable) ExpireTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ExpireTime indicates an expected call of ExpireTime. +func (mr *MockCmdableMockRecorder) ExpireTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockCmdable)(nil).ExpireTime), ctx, key) +} + +// ExpireXX mocks base method. +func (m *MockCmdable) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireXX", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireXX indicates an expected call of ExpireXX. +func (mr *MockCmdableMockRecorder) ExpireXX(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockCmdable)(nil).ExpireXX), ctx, key, expiration) +} + +// FCall mocks base method. +func (m *MockCmdable) FCall(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCall", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCall indicates an expected call of FCall. +func (mr *MockCmdableMockRecorder) FCall(ctx, function, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCall", reflect.TypeOf((*MockCmdable)(nil).FCall), varargs...) +} + +// FCallRO mocks base method. +func (m *MockCmdable) FCallRO(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRO indicates an expected call of FCallRO. +func (mr *MockCmdableMockRecorder) FCallRO(ctx, function, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRO", reflect.TypeOf((*MockCmdable)(nil).FCallRO), varargs...) +} + +// FCallRo mocks base method. +func (m *MockCmdable) FCallRo(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRo", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRo indicates an expected call of FCallRo. +func (mr *MockCmdableMockRecorder) FCallRo(ctx, function, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockCmdable)(nil).FCallRo), varargs...) +} + +// FlushAll mocks base method. +func (m *MockCmdable) FlushAll(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAll", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAll indicates an expected call of FlushAll. +func (mr *MockCmdableMockRecorder) FlushAll(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockCmdable)(nil).FlushAll), ctx) +} + +// FlushAllAsync mocks base method. +func (m *MockCmdable) FlushAllAsync(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAllAsync", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAllAsync indicates an expected call of FlushAllAsync. +func (mr *MockCmdableMockRecorder) FlushAllAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockCmdable)(nil).FlushAllAsync), ctx) +} + +// FlushDB mocks base method. +func (m *MockCmdable) FlushDB(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDB", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDB indicates an expected call of FlushDB. +func (mr *MockCmdableMockRecorder) FlushDB(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockCmdable)(nil).FlushDB), ctx) +} + +// FlushDBAsync mocks base method. +func (m *MockCmdable) FlushDBAsync(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDBAsync", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDBAsync indicates an expected call of FlushDBAsync. +func (mr *MockCmdableMockRecorder) FlushDBAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockCmdable)(nil).FlushDBAsync), ctx) +} + +// FunctionDelete mocks base method. +func (m *MockCmdable) FunctionDelete(ctx context.Context, libName string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDelete indicates an expected call of FunctionDelete. +func (mr *MockCmdableMockRecorder) FunctionDelete(ctx, libName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockCmdable)(nil).FunctionDelete), ctx, libName) +} + +// FunctionDump mocks base method. +func (m *MockCmdable) FunctionDump(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDump", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDump indicates an expected call of FunctionDump. +func (mr *MockCmdableMockRecorder) FunctionDump(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockCmdable)(nil).FunctionDump), ctx) +} + +// FunctionFlush mocks base method. +func (m *MockCmdable) FunctionFlush(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlush", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlush indicates an expected call of FunctionFlush. +func (mr *MockCmdableMockRecorder) FunctionFlush(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockCmdable)(nil).FunctionFlush), ctx) +} + +// FunctionFlushAsync mocks base method. +func (m *MockCmdable) FunctionFlushAsync(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlushAsync", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlushAsync indicates an expected call of FunctionFlushAsync. +func (mr *MockCmdableMockRecorder) FunctionFlushAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockCmdable)(nil).FunctionFlushAsync), ctx) +} + +// FunctionKill mocks base method. +func (m *MockCmdable) FunctionKill(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionKill", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionKill indicates an expected call of FunctionKill. +func (mr *MockCmdableMockRecorder) FunctionKill(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockCmdable)(nil).FunctionKill), ctx) +} + +// FunctionList mocks base method. +func (m *MockCmdable) FunctionList(ctx context.Context, q redis.FunctionListQuery) *redis.FunctionListCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionList", ctx, q) + ret0, _ := ret[0].(*redis.FunctionListCmd) + return ret0 +} + +// FunctionList indicates an expected call of FunctionList. +func (mr *MockCmdableMockRecorder) FunctionList(ctx, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockCmdable)(nil).FunctionList), ctx, q) +} + +// FunctionLoad mocks base method. +func (m *MockCmdable) FunctionLoad(ctx context.Context, code string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoad", ctx, code) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoad indicates an expected call of FunctionLoad. +func (mr *MockCmdableMockRecorder) FunctionLoad(ctx, code any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockCmdable)(nil).FunctionLoad), ctx, code) +} + +// FunctionLoadReplace mocks base method. +func (m *MockCmdable) FunctionLoadReplace(ctx context.Context, code string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoadReplace", ctx, code) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoadReplace indicates an expected call of FunctionLoadReplace. +func (mr *MockCmdableMockRecorder) FunctionLoadReplace(ctx, code any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockCmdable)(nil).FunctionLoadReplace), ctx, code) +} + +// FunctionRestore mocks base method. +func (m *MockCmdable) FunctionRestore(ctx context.Context, libDump string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionRestore", ctx, libDump) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionRestore indicates an expected call of FunctionRestore. +func (mr *MockCmdableMockRecorder) FunctionRestore(ctx, libDump any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockCmdable)(nil).FunctionRestore), ctx, libDump) +} + +// FunctionStats mocks base method. +func (m *MockCmdable) FunctionStats(ctx context.Context) *redis.FunctionStatsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionStats", ctx) + ret0, _ := ret[0].(*redis.FunctionStatsCmd) + return ret0 +} + +// FunctionStats indicates an expected call of FunctionStats. +func (mr *MockCmdableMockRecorder) FunctionStats(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockCmdable)(nil).FunctionStats), ctx) +} + +// GeoAdd mocks base method. +func (m *MockCmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range geoLocation { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoAdd indicates an expected call of GeoAdd. +func (mr *MockCmdableMockRecorder) GeoAdd(ctx, key any, geoLocation ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, geoLocation...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoAdd", reflect.TypeOf((*MockCmdable)(nil).GeoAdd), varargs...) +} + +// GeoDist mocks base method. +func (m *MockCmdable) GeoDist(ctx context.Context, key, member1, member2, unit string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoDist", ctx, key, member1, member2, unit) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// GeoDist indicates an expected call of GeoDist. +func (mr *MockCmdableMockRecorder) GeoDist(ctx, key, member1, member2, unit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockCmdable)(nil).GeoDist), ctx, key, member1, member2, unit) +} + +// GeoHash mocks base method. +func (m *MockCmdable) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoHash", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoHash indicates an expected call of GeoHash. +func (mr *MockCmdableMockRecorder) GeoHash(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoHash", reflect.TypeOf((*MockCmdable)(nil).GeoHash), varargs...) +} + +// GeoPos mocks base method. +func (m *MockCmdable) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoPos", varargs...) + ret0, _ := ret[0].(*redis.GeoPosCmd) + return ret0 +} + +// GeoPos indicates an expected call of GeoPos. +func (mr *MockCmdableMockRecorder) GeoPos(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoPos", reflect.TypeOf((*MockCmdable)(nil).GeoPos), varargs...) +} + +// GeoRadius mocks base method. +func (m *MockCmdable) GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadius", ctx, key, longitude, latitude, query) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadius indicates an expected call of GeoRadius. +func (mr *MockCmdableMockRecorder) GeoRadius(ctx, key, longitude, latitude, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockCmdable)(nil).GeoRadius), ctx, key, longitude, latitude, query) +} + +// GeoRadiusByMember mocks base method. +func (m *MockCmdable) GeoRadiusByMember(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMember", ctx, key, member, query) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadiusByMember indicates an expected call of GeoRadiusByMember. +func (mr *MockCmdableMockRecorder) GeoRadiusByMember(ctx, key, member, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMember), ctx, key, member, query) +} + +// GeoRadiusByMemberStore mocks base method. +func (m *MockCmdable) GeoRadiusByMemberStore(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", ctx, key, member, query) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusByMemberStore indicates an expected call of GeoRadiusByMemberStore. +func (mr *MockCmdableMockRecorder) GeoRadiusByMemberStore(ctx, key, member, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMemberStore), ctx, key, member, query) +} + +// GeoRadiusStore mocks base method. +func (m *MockCmdable) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusStore", ctx, key, longitude, latitude, query) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusStore indicates an expected call of GeoRadiusStore. +func (mr *MockCmdableMockRecorder) GeoRadiusStore(ctx, key, longitude, latitude, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusStore), ctx, key, longitude, latitude, query) +} + +// GeoSearch mocks base method. +func (m *MockCmdable) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearch", ctx, key, q) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoSearch indicates an expected call of GeoSearch. +func (mr *MockCmdableMockRecorder) GeoSearch(ctx, key, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockCmdable)(nil).GeoSearch), ctx, key, q) +} + +// GeoSearchLocation mocks base method. +func (m *MockCmdable) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchLocation", ctx, key, q) + ret0, _ := ret[0].(*redis.GeoSearchLocationCmd) + return ret0 +} + +// GeoSearchLocation indicates an expected call of GeoSearchLocation. +func (mr *MockCmdableMockRecorder) GeoSearchLocation(ctx, key, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockCmdable)(nil).GeoSearchLocation), ctx, key, q) +} + +// GeoSearchStore mocks base method. +func (m *MockCmdable) GeoSearchStore(ctx context.Context, key, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchStore", ctx, key, store, q) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoSearchStore indicates an expected call of GeoSearchStore. +func (mr *MockCmdableMockRecorder) GeoSearchStore(ctx, key, store, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockCmdable)(nil).GeoSearchStore), ctx, key, store, q) +} + +// Get mocks base method. +func (m *MockCmdable) Get(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Get indicates an expected call of Get. +func (mr *MockCmdableMockRecorder) Get(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCmdable)(nil).Get), ctx, key) +} + +// GetBit mocks base method. +func (m *MockCmdable) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBit", ctx, key, offset) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GetBit indicates an expected call of GetBit. +func (mr *MockCmdableMockRecorder) GetBit(ctx, key, offset any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockCmdable)(nil).GetBit), ctx, key, offset) +} + +// GetDel mocks base method. +func (m *MockCmdable) GetDel(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDel", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetDel indicates an expected call of GetDel. +func (mr *MockCmdableMockRecorder) GetDel(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockCmdable)(nil).GetDel), ctx, key) +} + +// GetEx mocks base method. +func (m *MockCmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEx", ctx, key, expiration) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetEx indicates an expected call of GetEx. +func (mr *MockCmdableMockRecorder) GetEx(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockCmdable)(nil).GetEx), ctx, key, expiration) +} + +// GetRange mocks base method. +func (m *MockCmdable) GetRange(ctx context.Context, key string, start, end int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRange", ctx, key, start, end) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetRange indicates an expected call of GetRange. +func (mr *MockCmdableMockRecorder) GetRange(ctx, key, start, end any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockCmdable)(nil).GetRange), ctx, key, start, end) +} + +// GetSet mocks base method. +func (m *MockCmdable) GetSet(ctx context.Context, key string, value any) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSet", ctx, key, value) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetSet indicates an expected call of GetSet. +func (mr *MockCmdableMockRecorder) GetSet(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockCmdable)(nil).GetSet), ctx, key, value) +} + +// HDel mocks base method. +func (m *MockCmdable) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HDel indicates an expected call of HDel. +func (mr *MockCmdableMockRecorder) HDel(ctx, key any, fields ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockCmdable)(nil).HDel), varargs...) +} + +// HExists mocks base method. +func (m *MockCmdable) HExists(ctx context.Context, key, field string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HExists", ctx, key, field) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HExists indicates an expected call of HExists. +func (mr *MockCmdableMockRecorder) HExists(ctx, key, field any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockCmdable)(nil).HExists), ctx, key, field) +} + +// HGet mocks base method. +func (m *MockCmdable) HGet(ctx context.Context, key, field string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGet", ctx, key, field) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// HGet indicates an expected call of HGet. +func (mr *MockCmdableMockRecorder) HGet(ctx, key, field any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockCmdable)(nil).HGet), ctx, key, field) +} + +// HGetAll mocks base method. +func (m *MockCmdable) HGetAll(ctx context.Context, key string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGetAll", ctx, key) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// HGetAll indicates an expected call of HGetAll. +func (mr *MockCmdableMockRecorder) HGetAll(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockCmdable)(nil).HGetAll), ctx, key) +} + +// HIncrBy mocks base method. +func (m *MockCmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrBy", ctx, key, field, incr) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HIncrBy indicates an expected call of HIncrBy. +func (mr *MockCmdableMockRecorder) HIncrBy(ctx, key, field, incr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockCmdable)(nil).HIncrBy), ctx, key, field, incr) +} + +// HIncrByFloat mocks base method. +func (m *MockCmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrByFloat", ctx, key, field, incr) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// HIncrByFloat indicates an expected call of HIncrByFloat. +func (mr *MockCmdableMockRecorder) HIncrByFloat(ctx, key, field, incr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockCmdable)(nil).HIncrByFloat), ctx, key, field, incr) +} + +// HKeys mocks base method. +func (m *MockCmdable) HKeys(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HKeys", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HKeys indicates an expected call of HKeys. +func (mr *MockCmdableMockRecorder) HKeys(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockCmdable)(nil).HKeys), ctx, key) +} + +// HLen mocks base method. +func (m *MockCmdable) HLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HLen indicates an expected call of HLen. +func (mr *MockCmdableMockRecorder) HLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockCmdable)(nil).HLen), ctx, key) +} + +// HMGet mocks base method. +func (m *MockCmdable) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// HMGet indicates an expected call of HMGet. +func (mr *MockCmdableMockRecorder) HMGet(ctx, key any, fields ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMGet", reflect.TypeOf((*MockCmdable)(nil).HMGet), varargs...) +} + +// HMSet mocks base method. +func (m *MockCmdable) HMSet(ctx context.Context, key string, values ...any) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMSet", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HMSet indicates an expected call of HMSet. +func (mr *MockCmdableMockRecorder) HMSet(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockCmdable)(nil).HMSet), varargs...) +} + +// HRandField mocks base method. +func (m *MockCmdable) HRandField(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandField", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HRandField indicates an expected call of HRandField. +func (mr *MockCmdableMockRecorder) HRandField(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockCmdable)(nil).HRandField), ctx, key, count) +} + +// HRandFieldWithValues mocks base method. +func (m *MockCmdable) HRandFieldWithValues(ctx context.Context, key string, count int) *redis.KeyValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandFieldWithValues", ctx, key, count) + ret0, _ := ret[0].(*redis.KeyValueSliceCmd) + return ret0 +} + +// HRandFieldWithValues indicates an expected call of HRandFieldWithValues. +func (mr *MockCmdableMockRecorder) HRandFieldWithValues(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockCmdable)(nil).HRandFieldWithValues), ctx, key, count) +} + +// HScan mocks base method. +func (m *MockCmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// HScan indicates an expected call of HScan. +func (mr *MockCmdableMockRecorder) HScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockCmdable)(nil).HScan), ctx, key, cursor, match, count) +} + +// HSet mocks base method. +func (m *MockCmdable) HSet(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HSet", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HSet indicates an expected call of HSet. +func (mr *MockCmdableMockRecorder) HSet(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockCmdable)(nil).HSet), varargs...) +} + +// HSetNX mocks base method. +func (m *MockCmdable) HSetNX(ctx context.Context, key, field string, value any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HSetNX", ctx, key, field, value) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HSetNX indicates an expected call of HSetNX. +func (mr *MockCmdableMockRecorder) HSetNX(ctx, key, field, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockCmdable)(nil).HSetNX), ctx, key, field, value) +} + +// HVals mocks base method. +func (m *MockCmdable) HVals(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HVals", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HVals indicates an expected call of HVals. +func (mr *MockCmdableMockRecorder) HVals(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockCmdable)(nil).HVals), ctx, key) +} + +// Incr mocks base method. +func (m *MockCmdable) Incr(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Incr", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Incr indicates an expected call of Incr. +func (mr *MockCmdableMockRecorder) Incr(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockCmdable)(nil).Incr), ctx, key) +} + +// IncrBy mocks base method. +func (m *MockCmdable) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrBy", ctx, key, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// IncrBy indicates an expected call of IncrBy. +func (mr *MockCmdableMockRecorder) IncrBy(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockCmdable)(nil).IncrBy), ctx, key, value) +} + +// IncrByFloat mocks base method. +func (m *MockCmdable) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrByFloat", ctx, key, value) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// IncrByFloat indicates an expected call of IncrByFloat. +func (mr *MockCmdableMockRecorder) IncrByFloat(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockCmdable)(nil).IncrByFloat), ctx, key, value) +} + +// Info mocks base method. +func (m *MockCmdable) Info(ctx context.Context, section ...string) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range section { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Info", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Info indicates an expected call of Info. +func (mr *MockCmdableMockRecorder) Info(ctx any, section ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, section...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockCmdable)(nil).Info), varargs...) +} + +// Keys mocks base method. +func (m *MockCmdable) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Keys", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Keys indicates an expected call of Keys. +func (mr *MockCmdableMockRecorder) Keys(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockCmdable)(nil).Keys), ctx, pattern) +} + +// LCS mocks base method. +func (m *MockCmdable) LCS(ctx context.Context, q *redis.LCSQuery) *redis.LCSCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LCS", ctx, q) + ret0, _ := ret[0].(*redis.LCSCmd) + return ret0 +} + +// LCS indicates an expected call of LCS. +func (mr *MockCmdableMockRecorder) LCS(ctx, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockCmdable)(nil).LCS), ctx, q) +} + +// LIndex mocks base method. +func (m *MockCmdable) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LIndex", ctx, key, index) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LIndex indicates an expected call of LIndex. +func (mr *MockCmdableMockRecorder) LIndex(ctx, key, index any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockCmdable)(nil).LIndex), ctx, key, index) +} + +// LInsert mocks base method. +func (m *MockCmdable) LInsert(ctx context.Context, key, op string, pivot, value any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsert", ctx, key, op, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsert indicates an expected call of LInsert. +func (mr *MockCmdableMockRecorder) LInsert(ctx, key, op, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockCmdable)(nil).LInsert), ctx, key, op, pivot, value) +} + +// LInsertAfter mocks base method. +func (m *MockCmdable) LInsertAfter(ctx context.Context, key string, pivot, value any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertAfter", ctx, key, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertAfter indicates an expected call of LInsertAfter. +func (mr *MockCmdableMockRecorder) LInsertAfter(ctx, key, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockCmdable)(nil).LInsertAfter), ctx, key, pivot, value) +} + +// LInsertBefore mocks base method. +func (m *MockCmdable) LInsertBefore(ctx context.Context, key string, pivot, value any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertBefore", ctx, key, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertBefore indicates an expected call of LInsertBefore. +func (mr *MockCmdableMockRecorder) LInsertBefore(ctx, key, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockCmdable)(nil).LInsertBefore), ctx, key, pivot, value) +} + +// LLen mocks base method. +func (m *MockCmdable) LLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LLen indicates an expected call of LLen. +func (mr *MockCmdableMockRecorder) LLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockCmdable)(nil).LLen), ctx, key) +} + +// LMPop mocks base method. +func (m *MockCmdable) LMPop(ctx context.Context, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, direction, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// LMPop indicates an expected call of LMPop. +func (mr *MockCmdableMockRecorder) LMPop(ctx, direction, count any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, direction, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMPop", reflect.TypeOf((*MockCmdable)(nil).LMPop), varargs...) +} + +// LMove mocks base method. +func (m *MockCmdable) LMove(ctx context.Context, source, destination, srcpos, destpos string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LMove", ctx, source, destination, srcpos, destpos) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LMove indicates an expected call of LMove. +func (mr *MockCmdableMockRecorder) LMove(ctx, source, destination, srcpos, destpos any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockCmdable)(nil).LMove), ctx, source, destination, srcpos, destpos) +} + +// LPop mocks base method. +func (m *MockCmdable) LPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LPop indicates an expected call of LPop. +func (mr *MockCmdableMockRecorder) LPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockCmdable)(nil).LPop), ctx, key) +} + +// LPopCount mocks base method. +func (m *MockCmdable) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPopCount", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LPopCount indicates an expected call of LPopCount. +func (mr *MockCmdableMockRecorder) LPopCount(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockCmdable)(nil).LPopCount), ctx, key, count) +} + +// LPos mocks base method. +func (m *MockCmdable) LPos(ctx context.Context, key, value string, args redis.LPosArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPos", ctx, key, value, args) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPos indicates an expected call of LPos. +func (mr *MockCmdableMockRecorder) LPos(ctx, key, value, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockCmdable)(nil).LPos), ctx, key, value, args) +} + +// LPosCount mocks base method. +func (m *MockCmdable) LPosCount(ctx context.Context, key, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPosCount", ctx, key, value, count, args) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// LPosCount indicates an expected call of LPosCount. +func (mr *MockCmdableMockRecorder) LPosCount(ctx, key, value, count, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockCmdable)(nil).LPosCount), ctx, key, value, count, args) +} + +// LPush mocks base method. +func (m *MockCmdable) LPush(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPush indicates an expected call of LPush. +func (mr *MockCmdableMockRecorder) LPush(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockCmdable)(nil).LPush), varargs...) +} + +// LPushX mocks base method. +func (m *MockCmdable) LPushX(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPushX indicates an expected call of LPushX. +func (mr *MockCmdableMockRecorder) LPushX(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockCmdable)(nil).LPushX), varargs...) +} + +// LRange mocks base method. +func (m *MockCmdable) LRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LRange indicates an expected call of LRange. +func (mr *MockCmdableMockRecorder) LRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockCmdable)(nil).LRange), ctx, key, start, stop) +} + +// LRem mocks base method. +func (m *MockCmdable) LRem(ctx context.Context, key string, count int64, value any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRem", ctx, key, count, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LRem indicates an expected call of LRem. +func (mr *MockCmdableMockRecorder) LRem(ctx, key, count, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockCmdable)(nil).LRem), ctx, key, count, value) +} + +// LSet mocks base method. +func (m *MockCmdable) LSet(ctx context.Context, key string, index int64, value any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LSet", ctx, key, index, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LSet indicates an expected call of LSet. +func (mr *MockCmdableMockRecorder) LSet(ctx, key, index, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockCmdable)(nil).LSet), ctx, key, index, value) +} + +// LTrim mocks base method. +func (m *MockCmdable) LTrim(ctx context.Context, key string, start, stop int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LTrim", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LTrim indicates an expected call of LTrim. +func (mr *MockCmdableMockRecorder) LTrim(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockCmdable)(nil).LTrim), ctx, key, start, stop) +} + +// LastSave mocks base method. +func (m *MockCmdable) LastSave(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LastSave", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LastSave indicates an expected call of LastSave. +func (mr *MockCmdableMockRecorder) LastSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockCmdable)(nil).LastSave), ctx) +} + +// MGet mocks base method. +func (m *MockCmdable) MGet(ctx context.Context, keys ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// MGet indicates an expected call of MGet. +func (mr *MockCmdableMockRecorder) MGet(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockCmdable)(nil).MGet), varargs...) +} + +// MSet mocks base method. +func (m *MockCmdable) MSet(ctx context.Context, values ...any) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSet", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// MSet indicates an expected call of MSet. +func (mr *MockCmdableMockRecorder) MSet(ctx any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockCmdable)(nil).MSet), varargs...) +} + +// MSetNX mocks base method. +func (m *MockCmdable) MSetNX(ctx context.Context, values ...any) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSetNX", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// MSetNX indicates an expected call of MSetNX. +func (mr *MockCmdableMockRecorder) MSetNX(ctx any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSetNX", reflect.TypeOf((*MockCmdable)(nil).MSetNX), varargs...) +} + +// MemoryUsage mocks base method. +func (m *MockCmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range samples { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MemoryUsage", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// MemoryUsage indicates an expected call of MemoryUsage. +func (mr *MockCmdableMockRecorder) MemoryUsage(ctx, key any, samples ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, samples...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemoryUsage", reflect.TypeOf((*MockCmdable)(nil).MemoryUsage), varargs...) +} + +// Migrate mocks base method. +func (m *MockCmdable) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Migrate", ctx, host, port, key, db, timeout) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Migrate indicates an expected call of Migrate. +func (mr *MockCmdableMockRecorder) Migrate(ctx, host, port, key, db, timeout any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockCmdable)(nil).Migrate), ctx, host, port, key, db, timeout) +} + +// ModuleLoadex mocks base method. +func (m *MockCmdable) ModuleLoadex(ctx context.Context, conf *redis.ModuleLoadexConfig) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModuleLoadex", ctx, conf) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ModuleLoadex indicates an expected call of ModuleLoadex. +func (mr *MockCmdableMockRecorder) ModuleLoadex(ctx, conf any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockCmdable)(nil).ModuleLoadex), ctx, conf) +} + +// Move mocks base method. +func (m *MockCmdable) Move(ctx context.Context, key string, db int) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Move", ctx, key, db) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Move indicates an expected call of Move. +func (mr *MockCmdableMockRecorder) Move(ctx, key, db any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockCmdable)(nil).Move), ctx, key, db) +} + +// ObjectEncoding mocks base method. +func (m *MockCmdable) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectEncoding", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ObjectEncoding indicates an expected call of ObjectEncoding. +func (mr *MockCmdableMockRecorder) ObjectEncoding(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockCmdable)(nil).ObjectEncoding), ctx, key) +} + +// ObjectIdleTime mocks base method. +func (m *MockCmdable) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectIdleTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ObjectIdleTime indicates an expected call of ObjectIdleTime. +func (mr *MockCmdableMockRecorder) ObjectIdleTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockCmdable)(nil).ObjectIdleTime), ctx, key) +} + +// ObjectRefCount mocks base method. +func (m *MockCmdable) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectRefCount", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ObjectRefCount indicates an expected call of ObjectRefCount. +func (mr *MockCmdableMockRecorder) ObjectRefCount(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockCmdable)(nil).ObjectRefCount), ctx, key) +} + +// PExpire mocks base method. +func (m *MockCmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpire", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpire indicates an expected call of PExpire. +func (mr *MockCmdableMockRecorder) PExpire(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockCmdable)(nil).PExpire), ctx, key, expiration) +} + +// PExpireAt mocks base method. +func (m *MockCmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireAt", ctx, key, tm) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpireAt indicates an expected call of PExpireAt. +func (mr *MockCmdableMockRecorder) PExpireAt(ctx, key, tm any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockCmdable)(nil).PExpireAt), ctx, key, tm) +} + +// PExpireTime mocks base method. +func (m *MockCmdable) PExpireTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PExpireTime indicates an expected call of PExpireTime. +func (mr *MockCmdableMockRecorder) PExpireTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockCmdable)(nil).PExpireTime), ctx, key) +} + +// PFAdd mocks base method. +func (m *MockCmdable) PFAdd(ctx context.Context, key string, els ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range els { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFAdd indicates an expected call of PFAdd. +func (mr *MockCmdableMockRecorder) PFAdd(ctx, key any, els ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, els...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFAdd", reflect.TypeOf((*MockCmdable)(nil).PFAdd), varargs...) +} + +// PFCount mocks base method. +func (m *MockCmdable) PFCount(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFCount", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFCount indicates an expected call of PFCount. +func (mr *MockCmdableMockRecorder) PFCount(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockCmdable)(nil).PFCount), varargs...) +} + +// PFMerge mocks base method. +func (m *MockCmdable) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, dest} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// PFMerge indicates an expected call of PFMerge. +func (mr *MockCmdableMockRecorder) PFMerge(ctx, dest any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, dest}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFMerge", reflect.TypeOf((*MockCmdable)(nil).PFMerge), varargs...) +} + +// PTTL mocks base method. +func (m *MockCmdable) PTTL(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PTTL", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PTTL indicates an expected call of PTTL. +func (mr *MockCmdableMockRecorder) PTTL(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockCmdable)(nil).PTTL), ctx, key) +} + +// Persist mocks base method. +func (m *MockCmdable) Persist(ctx context.Context, key string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Persist", ctx, key) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Persist indicates an expected call of Persist. +func (mr *MockCmdableMockRecorder) Persist(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockCmdable)(nil).Persist), ctx, key) +} + +// Ping mocks base method. +func (m *MockCmdable) Ping(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Ping", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Ping indicates an expected call of Ping. +func (mr *MockCmdableMockRecorder) Ping(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockCmdable)(nil).Ping), ctx) +} + +// Pipeline mocks base method. +func (m *MockCmdable) Pipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// Pipeline indicates an expected call of Pipeline. +func (mr *MockCmdableMockRecorder) Pipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockCmdable)(nil).Pipeline)) +} + +// Pipelined mocks base method. +func (m *MockCmdable) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipelined", ctx, fn) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Pipelined indicates an expected call of Pipelined. +func (mr *MockCmdableMockRecorder) Pipelined(ctx, fn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockCmdable)(nil).Pipelined), ctx, fn) +} + +// PubSubChannels mocks base method. +func (m *MockCmdable) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubChannels", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubChannels indicates an expected call of PubSubChannels. +func (mr *MockCmdableMockRecorder) PubSubChannels(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubChannels), ctx, pattern) +} + +// PubSubNumPat mocks base method. +func (m *MockCmdable) PubSubNumPat(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubNumPat", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PubSubNumPat indicates an expected call of PubSubNumPat. +func (mr *MockCmdableMockRecorder) PubSubNumPat(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockCmdable)(nil).PubSubNumPat), ctx) +} + +// PubSubNumSub mocks base method. +func (m *MockCmdable) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubNumSub indicates an expected call of PubSubNumSub. +func (mr *MockCmdableMockRecorder) PubSubNumSub(ctx any, channels ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockCmdable)(nil).PubSubNumSub), varargs...) +} + +// PubSubShardChannels mocks base method. +func (m *MockCmdable) PubSubShardChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubShardChannels", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubShardChannels indicates an expected call of PubSubShardChannels. +func (mr *MockCmdableMockRecorder) PubSubShardChannels(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubShardChannels), ctx, pattern) +} + +// PubSubShardNumSub mocks base method. +func (m *MockCmdable) PubSubShardNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubShardNumSub indicates an expected call of PubSubShardNumSub. +func (mr *MockCmdableMockRecorder) PubSubShardNumSub(ctx any, channels ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockCmdable)(nil).PubSubShardNumSub), varargs...) +} + +// Publish mocks base method. +func (m *MockCmdable) Publish(ctx context.Context, channel string, message any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Publish", ctx, channel, message) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Publish indicates an expected call of Publish. +func (mr *MockCmdableMockRecorder) Publish(ctx, channel, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockCmdable)(nil).Publish), ctx, channel, message) +} + +// Quit mocks base method. +func (m *MockCmdable) Quit(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Quit", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Quit indicates an expected call of Quit. +func (mr *MockCmdableMockRecorder) Quit(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockCmdable)(nil).Quit), ctx) +} + +// RPop mocks base method. +func (m *MockCmdable) RPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPop indicates an expected call of RPop. +func (mr *MockCmdableMockRecorder) RPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockCmdable)(nil).RPop), ctx, key) +} + +// RPopCount mocks base method. +func (m *MockCmdable) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopCount", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// RPopCount indicates an expected call of RPopCount. +func (mr *MockCmdableMockRecorder) RPopCount(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockCmdable)(nil).RPopCount), ctx, key, count) +} + +// RPopLPush mocks base method. +func (m *MockCmdable) RPopLPush(ctx context.Context, source, destination string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopLPush", ctx, source, destination) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPopLPush indicates an expected call of RPopLPush. +func (mr *MockCmdableMockRecorder) RPopLPush(ctx, source, destination any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockCmdable)(nil).RPopLPush), ctx, source, destination) +} + +// RPush mocks base method. +func (m *MockCmdable) RPush(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPush indicates an expected call of RPush. +func (mr *MockCmdableMockRecorder) RPush(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockCmdable)(nil).RPush), varargs...) +} + +// RPushX mocks base method. +func (m *MockCmdable) RPushX(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPushX indicates an expected call of RPushX. +func (mr *MockCmdableMockRecorder) RPushX(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockCmdable)(nil).RPushX), varargs...) +} + +// RandomKey mocks base method. +func (m *MockCmdable) RandomKey(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RandomKey", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RandomKey indicates an expected call of RandomKey. +func (mr *MockCmdableMockRecorder) RandomKey(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockCmdable)(nil).RandomKey), ctx) +} + +// ReadOnly mocks base method. +func (m *MockCmdable) ReadOnly(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadOnly", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadOnly indicates an expected call of ReadOnly. +func (mr *MockCmdableMockRecorder) ReadOnly(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockCmdable)(nil).ReadOnly), ctx) +} + +// ReadWrite mocks base method. +func (m *MockCmdable) ReadWrite(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadWrite", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadWrite indicates an expected call of ReadWrite. +func (mr *MockCmdableMockRecorder) ReadWrite(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockCmdable)(nil).ReadWrite), ctx) +} + +// Rename mocks base method. +func (m *MockCmdable) Rename(ctx context.Context, key, newkey string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Rename", ctx, key, newkey) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Rename indicates an expected call of Rename. +func (mr *MockCmdableMockRecorder) Rename(ctx, key, newkey any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockCmdable)(nil).Rename), ctx, key, newkey) +} + +// RenameNX mocks base method. +func (m *MockCmdable) RenameNX(ctx context.Context, key, newkey string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RenameNX", ctx, key, newkey) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// RenameNX indicates an expected call of RenameNX. +func (mr *MockCmdableMockRecorder) RenameNX(ctx, key, newkey any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockCmdable)(nil).RenameNX), ctx, key, newkey) +} + +// Restore mocks base method. +func (m *MockCmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Restore", ctx, key, ttl, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Restore indicates an expected call of Restore. +func (mr *MockCmdableMockRecorder) Restore(ctx, key, ttl, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockCmdable)(nil).Restore), ctx, key, ttl, value) +} + +// RestoreReplace mocks base method. +func (m *MockCmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreReplace", ctx, key, ttl, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// RestoreReplace indicates an expected call of RestoreReplace. +func (mr *MockCmdableMockRecorder) RestoreReplace(ctx, key, ttl, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockCmdable)(nil).RestoreReplace), ctx, key, ttl, value) +} + +// SAdd mocks base method. +func (m *MockCmdable) SAdd(ctx context.Context, key string, members ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SAdd indicates an expected call of SAdd. +func (mr *MockCmdableMockRecorder) SAdd(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockCmdable)(nil).SAdd), varargs...) +} + +// SCard mocks base method. +func (m *MockCmdable) SCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SCard indicates an expected call of SCard. +func (mr *MockCmdableMockRecorder) SCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockCmdable)(nil).SCard), ctx, key) +} + +// SDiff mocks base method. +func (m *MockCmdable) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SDiff indicates an expected call of SDiff. +func (mr *MockCmdableMockRecorder) SDiff(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockCmdable)(nil).SDiff), varargs...) +} + +// SDiffStore mocks base method. +func (m *MockCmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SDiffStore indicates an expected call of SDiffStore. +func (mr *MockCmdableMockRecorder) SDiffStore(ctx, destination any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockCmdable)(nil).SDiffStore), varargs...) +} + +// SInter mocks base method. +func (m *MockCmdable) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInter", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SInter indicates an expected call of SInter. +func (mr *MockCmdableMockRecorder) SInter(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockCmdable)(nil).SInter), varargs...) +} + +// SInterCard mocks base method. +func (m *MockCmdable) SInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, limit} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterCard indicates an expected call of SInterCard. +func (mr *MockCmdableMockRecorder) SInterCard(ctx, limit any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, limit}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterCard", reflect.TypeOf((*MockCmdable)(nil).SInterCard), varargs...) +} + +// SInterStore mocks base method. +func (m *MockCmdable) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterStore indicates an expected call of SInterStore. +func (mr *MockCmdableMockRecorder) SInterStore(ctx, destination any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockCmdable)(nil).SInterStore), varargs...) +} + +// SIsMember mocks base method. +func (m *MockCmdable) SIsMember(ctx context.Context, key string, member any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SIsMember", ctx, key, member) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SIsMember indicates an expected call of SIsMember. +func (mr *MockCmdableMockRecorder) SIsMember(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockCmdable)(nil).SIsMember), ctx, key, member) +} + +// SMIsMember mocks base method. +func (m *MockCmdable) SMIsMember(ctx context.Context, key string, members ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SMIsMember", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// SMIsMember indicates an expected call of SMIsMember. +func (mr *MockCmdableMockRecorder) SMIsMember(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockCmdable)(nil).SMIsMember), varargs...) +} + +// SMembers mocks base method. +func (m *MockCmdable) SMembers(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembers", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SMembers indicates an expected call of SMembers. +func (mr *MockCmdableMockRecorder) SMembers(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockCmdable)(nil).SMembers), ctx, key) +} + +// SMembersMap mocks base method. +func (m *MockCmdable) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembersMap", ctx, key) + ret0, _ := ret[0].(*redis.StringStructMapCmd) + return ret0 +} + +// SMembersMap indicates an expected call of SMembersMap. +func (mr *MockCmdableMockRecorder) SMembersMap(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockCmdable)(nil).SMembersMap), ctx, key) +} + +// SMove mocks base method. +func (m *MockCmdable) SMove(ctx context.Context, source, destination string, member any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMove", ctx, source, destination, member) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SMove indicates an expected call of SMove. +func (mr *MockCmdableMockRecorder) SMove(ctx, source, destination, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockCmdable)(nil).SMove), ctx, source, destination, member) +} + +// SPop mocks base method. +func (m *MockCmdable) SPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SPop indicates an expected call of SPop. +func (mr *MockCmdableMockRecorder) SPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockCmdable)(nil).SPop), ctx, key) +} + +// SPopN mocks base method. +func (m *MockCmdable) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPopN", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SPopN indicates an expected call of SPopN. +func (mr *MockCmdableMockRecorder) SPopN(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockCmdable)(nil).SPopN), ctx, key, count) +} + +// SPublish mocks base method. +func (m *MockCmdable) SPublish(ctx context.Context, channel string, message any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPublish", ctx, channel, message) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SPublish indicates an expected call of SPublish. +func (mr *MockCmdableMockRecorder) SPublish(ctx, channel, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockCmdable)(nil).SPublish), ctx, channel, message) +} + +// SRandMember mocks base method. +func (m *MockCmdable) SRandMember(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMember", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SRandMember indicates an expected call of SRandMember. +func (mr *MockCmdableMockRecorder) SRandMember(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockCmdable)(nil).SRandMember), ctx, key) +} + +// SRandMemberN mocks base method. +func (m *MockCmdable) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMemberN", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SRandMemberN indicates an expected call of SRandMemberN. +func (mr *MockCmdableMockRecorder) SRandMemberN(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockCmdable)(nil).SRandMemberN), ctx, key, count) +} + +// SRem mocks base method. +func (m *MockCmdable) SRem(ctx context.Context, key string, members ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SRem indicates an expected call of SRem. +func (mr *MockCmdableMockRecorder) SRem(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockCmdable)(nil).SRem), varargs...) +} + +// SScan mocks base method. +func (m *MockCmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// SScan indicates an expected call of SScan. +func (mr *MockCmdableMockRecorder) SScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockCmdable)(nil).SScan), ctx, key, cursor, match, count) +} + +// SUnion mocks base method. +func (m *MockCmdable) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnion", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SUnion indicates an expected call of SUnion. +func (mr *MockCmdableMockRecorder) SUnion(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockCmdable)(nil).SUnion), varargs...) +} + +// SUnionStore mocks base method. +func (m *MockCmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnionStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SUnionStore indicates an expected call of SUnionStore. +func (mr *MockCmdableMockRecorder) SUnionStore(ctx, destination any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockCmdable)(nil).SUnionStore), varargs...) +} + +// Save mocks base method. +func (m *MockCmdable) Save(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Save indicates an expected call of Save. +func (mr *MockCmdableMockRecorder) Save(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockCmdable)(nil).Save), ctx) +} + +// Scan mocks base method. +func (m *MockCmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Scan", ctx, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// Scan indicates an expected call of Scan. +func (mr *MockCmdableMockRecorder) Scan(ctx, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockCmdable)(nil).Scan), ctx, cursor, match, count) +} + +// ScanType mocks base method. +func (m *MockCmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScanType", ctx, cursor, match, count, keyType) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ScanType indicates an expected call of ScanType. +func (mr *MockCmdableMockRecorder) ScanType(ctx, cursor, match, count, keyType any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockCmdable)(nil).ScanType), ctx, cursor, match, count, keyType) +} + +// ScriptExists mocks base method. +func (m *MockCmdable) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range hashes { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ScriptExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// ScriptExists indicates an expected call of ScriptExists. +func (mr *MockCmdableMockRecorder) ScriptExists(ctx any, hashes ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, hashes...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockCmdable)(nil).ScriptExists), varargs...) +} + +// ScriptFlush mocks base method. +func (m *MockCmdable) ScriptFlush(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptFlush", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptFlush indicates an expected call of ScriptFlush. +func (mr *MockCmdableMockRecorder) ScriptFlush(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockCmdable)(nil).ScriptFlush), ctx) +} + +// ScriptKill mocks base method. +func (m *MockCmdable) ScriptKill(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptKill", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptKill indicates an expected call of ScriptKill. +func (mr *MockCmdableMockRecorder) ScriptKill(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockCmdable)(nil).ScriptKill), ctx) +} + +// ScriptLoad mocks base method. +func (m *MockCmdable) ScriptLoad(ctx context.Context, script string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptLoad", ctx, script) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ScriptLoad indicates an expected call of ScriptLoad. +func (mr *MockCmdableMockRecorder) ScriptLoad(ctx, script any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockCmdable)(nil).ScriptLoad), ctx, script) +} + +// Set mocks base method. +func (m *MockCmdable) Set(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockCmdableMockRecorder) Set(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCmdable)(nil).Set), ctx, key, value, expiration) +} + +// SetArgs mocks base method. +func (m *MockCmdable) SetArgs(ctx context.Context, key string, value any, a redis.SetArgs) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetArgs", ctx, key, value, a) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetArgs indicates an expected call of SetArgs. +func (mr *MockCmdableMockRecorder) SetArgs(ctx, key, value, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockCmdable)(nil).SetArgs), ctx, key, value, a) +} + +// SetBit mocks base method. +func (m *MockCmdable) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetBit", ctx, key, offset, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetBit indicates an expected call of SetBit. +func (mr *MockCmdableMockRecorder) SetBit(ctx, key, offset, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockCmdable)(nil).SetBit), ctx, key, offset, value) +} + +// SetEx mocks base method. +func (m *MockCmdable) SetEx(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetEx", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetEx indicates an expected call of SetEx. +func (mr *MockCmdableMockRecorder) SetEx(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockCmdable)(nil).SetEx), ctx, key, value, expiration) +} + +// SetNX mocks base method. +func (m *MockCmdable) SetNX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNX", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetNX indicates an expected call of SetNX. +func (mr *MockCmdableMockRecorder) SetNX(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockCmdable)(nil).SetNX), ctx, key, value, expiration) +} + +// SetRange mocks base method. +func (m *MockCmdable) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRange", ctx, key, offset, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetRange indicates an expected call of SetRange. +func (mr *MockCmdableMockRecorder) SetRange(ctx, key, offset, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockCmdable)(nil).SetRange), ctx, key, offset, value) +} + +// SetXX mocks base method. +func (m *MockCmdable) SetXX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetXX", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetXX indicates an expected call of SetXX. +func (mr *MockCmdableMockRecorder) SetXX(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockCmdable)(nil).SetXX), ctx, key, value, expiration) +} + +// Shutdown mocks base method. +func (m *MockCmdable) Shutdown(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Shutdown", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Shutdown indicates an expected call of Shutdown. +func (mr *MockCmdableMockRecorder) Shutdown(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockCmdable)(nil).Shutdown), ctx) +} + +// ShutdownNoSave mocks base method. +func (m *MockCmdable) ShutdownNoSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownNoSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownNoSave indicates an expected call of ShutdownNoSave. +func (mr *MockCmdableMockRecorder) ShutdownNoSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownNoSave), ctx) +} + +// ShutdownSave mocks base method. +func (m *MockCmdable) ShutdownSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownSave indicates an expected call of ShutdownSave. +func (mr *MockCmdableMockRecorder) ShutdownSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownSave), ctx) +} + +// SlaveOf mocks base method. +func (m *MockCmdable) SlaveOf(ctx context.Context, host, port string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlaveOf", ctx, host, port) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SlaveOf indicates an expected call of SlaveOf. +func (mr *MockCmdableMockRecorder) SlaveOf(ctx, host, port any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockCmdable)(nil).SlaveOf), ctx, host, port) +} + +// SlowLogGet mocks base method. +func (m *MockCmdable) SlowLogGet(ctx context.Context, num int64) *redis.SlowLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlowLogGet", ctx, num) + ret0, _ := ret[0].(*redis.SlowLogCmd) + return ret0 +} + +// SlowLogGet indicates an expected call of SlowLogGet. +func (mr *MockCmdableMockRecorder) SlowLogGet(ctx, num any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockCmdable)(nil).SlowLogGet), ctx, num) +} + +// Sort mocks base method. +func (m *MockCmdable) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Sort", ctx, key, sort) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Sort indicates an expected call of Sort. +func (mr *MockCmdableMockRecorder) Sort(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockCmdable)(nil).Sort), ctx, key, sort) +} + +// SortInterfaces mocks base method. +func (m *MockCmdable) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortInterfaces", ctx, key, sort) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// SortInterfaces indicates an expected call of SortInterfaces. +func (mr *MockCmdableMockRecorder) SortInterfaces(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockCmdable)(nil).SortInterfaces), ctx, key, sort) +} + +// SortRO mocks base method. +func (m *MockCmdable) SortRO(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortRO", ctx, key, sort) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SortRO indicates an expected call of SortRO. +func (mr *MockCmdableMockRecorder) SortRO(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockCmdable)(nil).SortRO), ctx, key, sort) +} + +// SortStore mocks base method. +func (m *MockCmdable) SortStore(ctx context.Context, key, store string, sort *redis.Sort) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortStore", ctx, key, store, sort) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SortStore indicates an expected call of SortStore. +func (mr *MockCmdableMockRecorder) SortStore(ctx, key, store, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockCmdable)(nil).SortStore), ctx, key, store, sort) +} + +// StrLen mocks base method. +func (m *MockCmdable) StrLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StrLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// StrLen indicates an expected call of StrLen. +func (mr *MockCmdableMockRecorder) StrLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockCmdable)(nil).StrLen), ctx, key) +} + +// TDigestAdd mocks base method. +func (m *MockCmdable) TDigestAdd(ctx context.Context, key string, elements ...float64) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestAdd", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestAdd indicates an expected call of TDigestAdd. +func (mr *MockCmdableMockRecorder) TDigestAdd(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestAdd", reflect.TypeOf((*MockCmdable)(nil).TDigestAdd), varargs...) +} + +// TDigestByRank mocks base method. +func (m *MockCmdable) TDigestByRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range rank { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRank indicates an expected call of TDigestByRank. +func (mr *MockCmdableMockRecorder) TDigestByRank(ctx, key any, rank ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, rank...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRank", reflect.TypeOf((*MockCmdable)(nil).TDigestByRank), varargs...) +} + +// TDigestByRevRank mocks base method. +func (m *MockCmdable) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range rank { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRevRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRevRank indicates an expected call of TDigestByRevRank. +func (mr *MockCmdableMockRecorder) TDigestByRevRank(ctx, key any, rank ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, rank...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRevRank", reflect.TypeOf((*MockCmdable)(nil).TDigestByRevRank), varargs...) +} + +// TDigestCDF mocks base method. +func (m *MockCmdable) TDigestCDF(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestCDF", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestCDF indicates an expected call of TDigestCDF. +func (mr *MockCmdableMockRecorder) TDigestCDF(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCDF", reflect.TypeOf((*MockCmdable)(nil).TDigestCDF), varargs...) +} + +// TDigestCreate mocks base method. +func (m *MockCmdable) TDigestCreate(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreate", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreate indicates an expected call of TDigestCreate. +func (mr *MockCmdableMockRecorder) TDigestCreate(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockCmdable)(nil).TDigestCreate), ctx, key) +} + +// TDigestCreateWithCompression mocks base method. +func (m *MockCmdable) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreateWithCompression", ctx, key, compression) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression. +func (mr *MockCmdableMockRecorder) TDigestCreateWithCompression(ctx, key, compression any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockCmdable)(nil).TDigestCreateWithCompression), ctx, key, compression) +} + +// TDigestInfo mocks base method. +func (m *MockCmdable) TDigestInfo(ctx context.Context, key string) *redis.TDigestInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestInfo", ctx, key) + ret0, _ := ret[0].(*redis.TDigestInfoCmd) + return ret0 +} + +// TDigestInfo indicates an expected call of TDigestInfo. +func (mr *MockCmdableMockRecorder) TDigestInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockCmdable)(nil).TDigestInfo), ctx, key) +} + +// TDigestMax mocks base method. +func (m *MockCmdable) TDigestMax(ctx context.Context, key string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMax", ctx, key) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMax indicates an expected call of TDigestMax. +func (mr *MockCmdableMockRecorder) TDigestMax(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockCmdable)(nil).TDigestMax), ctx, key) +} + +// TDigestMerge mocks base method. +func (m *MockCmdable) TDigestMerge(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey, options} + for _, a := range sourceKeys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestMerge indicates an expected call of TDigestMerge. +func (mr *MockCmdableMockRecorder) TDigestMerge(ctx, destKey, options any, sourceKeys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey, options}, sourceKeys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMerge", reflect.TypeOf((*MockCmdable)(nil).TDigestMerge), varargs...) +} + +// TDigestMin mocks base method. +func (m *MockCmdable) TDigestMin(ctx context.Context, key string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMin", ctx, key) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMin indicates an expected call of TDigestMin. +func (mr *MockCmdableMockRecorder) TDigestMin(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockCmdable)(nil).TDigestMin), ctx, key) +} + +// TDigestQuantile mocks base method. +func (m *MockCmdable) TDigestQuantile(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestQuantile", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestQuantile indicates an expected call of TDigestQuantile. +func (mr *MockCmdableMockRecorder) TDigestQuantile(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestQuantile", reflect.TypeOf((*MockCmdable)(nil).TDigestQuantile), varargs...) +} + +// TDigestRank mocks base method. +func (m *MockCmdable) TDigestRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRank indicates an expected call of TDigestRank. +func (mr *MockCmdableMockRecorder) TDigestRank(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRank", reflect.TypeOf((*MockCmdable)(nil).TDigestRank), varargs...) +} + +// TDigestReset mocks base method. +func (m *MockCmdable) TDigestReset(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestReset", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestReset indicates an expected call of TDigestReset. +func (mr *MockCmdableMockRecorder) TDigestReset(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockCmdable)(nil).TDigestReset), ctx, key) +} + +// TDigestRevRank mocks base method. +func (m *MockCmdable) TDigestRevRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRevRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRevRank indicates an expected call of TDigestRevRank. +func (mr *MockCmdableMockRecorder) TDigestRevRank(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRevRank", reflect.TypeOf((*MockCmdable)(nil).TDigestRevRank), varargs...) +} + +// TDigestTrimmedMean mocks base method. +func (m *MockCmdable) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestTrimmedMean", ctx, key, lowCutQuantile, highCutQuantile) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestTrimmedMean indicates an expected call of TDigestTrimmedMean. +func (mr *MockCmdableMockRecorder) TDigestTrimmedMean(ctx, key, lowCutQuantile, highCutQuantile any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockCmdable)(nil).TDigestTrimmedMean), ctx, key, lowCutQuantile, highCutQuantile) +} + +// TFCall mocks base method. +func (m *MockCmdable) TFCall(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCall", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCall indicates an expected call of TFCall. +func (mr *MockCmdableMockRecorder) TFCall(ctx, libName, funcName, numKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockCmdable)(nil).TFCall), ctx, libName, funcName, numKeys) +} + +// TFCallASYNC mocks base method. +func (m *MockCmdable) TFCallASYNC(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNC", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNC indicates an expected call of TFCallASYNC. +func (mr *MockCmdableMockRecorder) TFCallASYNC(ctx, libName, funcName, numKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockCmdable)(nil).TFCallASYNC), ctx, libName, funcName, numKeys) +} + +// TFCallASYNCArgs mocks base method. +func (m *MockCmdable) TFCallASYNCArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNCArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNCArgs indicates an expected call of TFCallASYNCArgs. +func (mr *MockCmdableMockRecorder) TFCallASYNCArgs(ctx, libName, funcName, numKeys, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockCmdable)(nil).TFCallASYNCArgs), ctx, libName, funcName, numKeys, options) +} + +// TFCallArgs mocks base method. +func (m *MockCmdable) TFCallArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallArgs indicates an expected call of TFCallArgs. +func (mr *MockCmdableMockRecorder) TFCallArgs(ctx, libName, funcName, numKeys, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockCmdable)(nil).TFCallArgs), ctx, libName, funcName, numKeys, options) +} + +// TFunctionDelete mocks base method. +func (m *MockCmdable) TFunctionDelete(ctx context.Context, libName string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionDelete indicates an expected call of TFunctionDelete. +func (mr *MockCmdableMockRecorder) TFunctionDelete(ctx, libName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockCmdable)(nil).TFunctionDelete), ctx, libName) +} + +// TFunctionList mocks base method. +func (m *MockCmdable) TFunctionList(ctx context.Context) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionList", ctx) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionList indicates an expected call of TFunctionList. +func (mr *MockCmdableMockRecorder) TFunctionList(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockCmdable)(nil).TFunctionList), ctx) +} + +// TFunctionListArgs mocks base method. +func (m *MockCmdable) TFunctionListArgs(ctx context.Context, options *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionListArgs", ctx, options) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionListArgs indicates an expected call of TFunctionListArgs. +func (mr *MockCmdableMockRecorder) TFunctionListArgs(ctx, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionListArgs), ctx, options) +} + +// TFunctionLoad mocks base method. +func (m *MockCmdable) TFunctionLoad(ctx context.Context, lib string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoad", ctx, lib) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoad indicates an expected call of TFunctionLoad. +func (mr *MockCmdableMockRecorder) TFunctionLoad(ctx, lib any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoad), ctx, lib) +} + +// TFunctionLoadArgs mocks base method. +func (m *MockCmdable) TFunctionLoadArgs(ctx context.Context, lib string, options *redis.TFunctionLoadOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoadArgs", ctx, lib, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs. +func (mr *MockCmdableMockRecorder) TFunctionLoadArgs(ctx, lib, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoadArgs), ctx, lib, options) +} + +// TTL mocks base method. +func (m *MockCmdable) TTL(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TTL", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// TTL indicates an expected call of TTL. +func (mr *MockCmdableMockRecorder) TTL(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockCmdable)(nil).TTL), ctx, key) +} + +// Time mocks base method. +func (m *MockCmdable) Time(ctx context.Context) *redis.TimeCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Time", ctx) + ret0, _ := ret[0].(*redis.TimeCmd) + return ret0 +} + +// Time indicates an expected call of Time. +func (mr *MockCmdableMockRecorder) Time(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockCmdable)(nil).Time), ctx) +} + +// TopKAdd mocks base method. +func (m *MockCmdable) TopKAdd(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKAdd", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKAdd indicates an expected call of TopKAdd. +func (mr *MockCmdableMockRecorder) TopKAdd(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockCmdable)(nil).TopKAdd), varargs...) +} + +// TopKCount mocks base method. +func (m *MockCmdable) TopKCount(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKCount", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TopKCount indicates an expected call of TopKCount. +func (mr *MockCmdableMockRecorder) TopKCount(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockCmdable)(nil).TopKCount), varargs...) +} + +// TopKIncrBy mocks base method. +func (m *MockCmdable) TopKIncrBy(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKIncrBy", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKIncrBy indicates an expected call of TopKIncrBy. +func (mr *MockCmdableMockRecorder) TopKIncrBy(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockCmdable)(nil).TopKIncrBy), varargs...) +} + +// TopKInfo mocks base method. +func (m *MockCmdable) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKInfo", ctx, key) + ret0, _ := ret[0].(*redis.TopKInfoCmd) + return ret0 +} + +// TopKInfo indicates an expected call of TopKInfo. +func (mr *MockCmdableMockRecorder) TopKInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockCmdable)(nil).TopKInfo), ctx, key) +} + +// TopKList mocks base method. +func (m *MockCmdable) TopKList(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKList", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKList indicates an expected call of TopKList. +func (mr *MockCmdableMockRecorder) TopKList(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockCmdable)(nil).TopKList), ctx, key) +} + +// TopKListWithCount mocks base method. +func (m *MockCmdable) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKListWithCount", ctx, key) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// TopKListWithCount indicates an expected call of TopKListWithCount. +func (mr *MockCmdableMockRecorder) TopKListWithCount(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockCmdable)(nil).TopKListWithCount), ctx, key) +} + +// TopKQuery mocks base method. +func (m *MockCmdable) TopKQuery(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKQuery", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// TopKQuery indicates an expected call of TopKQuery. +func (mr *MockCmdableMockRecorder) TopKQuery(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockCmdable)(nil).TopKQuery), varargs...) +} + +// TopKReserve mocks base method. +func (m *MockCmdable) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserve", ctx, key, k) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserve indicates an expected call of TopKReserve. +func (mr *MockCmdableMockRecorder) TopKReserve(ctx, key, k any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockCmdable)(nil).TopKReserve), ctx, key, k) +} + +// TopKReserveWithOptions mocks base method. +func (m *MockCmdable) TopKReserveWithOptions(ctx context.Context, key string, k, width, depth int64, decay float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserveWithOptions", ctx, key, k, width, depth, decay) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserveWithOptions indicates an expected call of TopKReserveWithOptions. +func (mr *MockCmdableMockRecorder) TopKReserveWithOptions(ctx, key, k, width, depth, decay any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserveWithOptions", reflect.TypeOf((*MockCmdable)(nil).TopKReserveWithOptions), ctx, key, k, width, depth, decay) +} + +// Touch mocks base method. +func (m *MockCmdable) Touch(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Touch", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Touch indicates an expected call of Touch. +func (mr *MockCmdableMockRecorder) Touch(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockCmdable)(nil).Touch), varargs...) +} + +// TxPipeline mocks base method. +func (m *MockCmdable) TxPipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// TxPipeline indicates an expected call of TxPipeline. +func (mr *MockCmdableMockRecorder) TxPipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockCmdable)(nil).TxPipeline)) +} + +// TxPipelined mocks base method. +func (m *MockCmdable) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipelined", ctx, fn) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TxPipelined indicates an expected call of TxPipelined. +func (mr *MockCmdableMockRecorder) TxPipelined(ctx, fn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockCmdable)(nil).TxPipelined), ctx, fn) +} + +// Type mocks base method. +func (m *MockCmdable) Type(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Type", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Type indicates an expected call of Type. +func (mr *MockCmdableMockRecorder) Type(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockCmdable)(nil).Type), ctx, key) +} + +// Unlink mocks base method. +func (m *MockCmdable) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Unlink", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Unlink indicates an expected call of Unlink. +func (mr *MockCmdableMockRecorder) Unlink(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockCmdable)(nil).Unlink), varargs...) +} + +// XAck mocks base method. +func (m *MockCmdable) XAck(ctx context.Context, stream, group string, ids ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, stream, group} + for _, a := range ids { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XAck", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XAck indicates an expected call of XAck. +func (mr *MockCmdableMockRecorder) XAck(ctx, stream, group any, ids ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, stream, group}, ids...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockCmdable)(nil).XAck), varargs...) +} + +// XAdd mocks base method. +func (m *MockCmdable) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAdd", ctx, a) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// XAdd indicates an expected call of XAdd. +func (mr *MockCmdableMockRecorder) XAdd(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockCmdable)(nil).XAdd), ctx, a) +} + +// XAutoClaim mocks base method. +func (m *MockCmdable) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaim", ctx, a) + ret0, _ := ret[0].(*redis.XAutoClaimCmd) + return ret0 +} + +// XAutoClaim indicates an expected call of XAutoClaim. +func (mr *MockCmdableMockRecorder) XAutoClaim(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockCmdable)(nil).XAutoClaim), ctx, a) +} + +// XAutoClaimJustID mocks base method. +func (m *MockCmdable) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaimJustID", ctx, a) + ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd) + return ret0 +} + +// XAutoClaimJustID indicates an expected call of XAutoClaimJustID. +func (mr *MockCmdableMockRecorder) XAutoClaimJustID(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XAutoClaimJustID), ctx, a) +} + +// XClaim mocks base method. +func (m *MockCmdable) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaim", ctx, a) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XClaim indicates an expected call of XClaim. +func (mr *MockCmdableMockRecorder) XClaim(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockCmdable)(nil).XClaim), ctx, a) +} + +// XClaimJustID mocks base method. +func (m *MockCmdable) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaimJustID", ctx, a) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// XClaimJustID indicates an expected call of XClaimJustID. +func (mr *MockCmdableMockRecorder) XClaimJustID(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XClaimJustID), ctx, a) +} + +// XDel mocks base method. +func (m *MockCmdable) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, stream} + for _, a := range ids { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XDel indicates an expected call of XDel. +func (mr *MockCmdableMockRecorder) XDel(ctx, stream any, ids ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, stream}, ids...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockCmdable)(nil).XDel), varargs...) +} + +// XGroupCreate mocks base method. +func (m *MockCmdable) XGroupCreate(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreate", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreate indicates an expected call of XGroupCreate. +func (mr *MockCmdableMockRecorder) XGroupCreate(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockCmdable)(nil).XGroupCreate), ctx, stream, group, start) +} + +// XGroupCreateConsumer mocks base method. +func (m *MockCmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateConsumer", ctx, stream, group, consumer) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer. +func (mr *MockCmdableMockRecorder) XGroupCreateConsumer(ctx, stream, group, consumer any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockCmdable)(nil).XGroupCreateConsumer), ctx, stream, group, consumer) +} + +// XGroupCreateMkStream mocks base method. +func (m *MockCmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateMkStream", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream. +func (mr *MockCmdableMockRecorder) XGroupCreateMkStream(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockCmdable)(nil).XGroupCreateMkStream), ctx, stream, group, start) +} + +// XGroupDelConsumer mocks base method. +func (m *MockCmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDelConsumer", ctx, stream, group, consumer) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDelConsumer indicates an expected call of XGroupDelConsumer. +func (mr *MockCmdableMockRecorder) XGroupDelConsumer(ctx, stream, group, consumer any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockCmdable)(nil).XGroupDelConsumer), ctx, stream, group, consumer) +} + +// XGroupDestroy mocks base method. +func (m *MockCmdable) XGroupDestroy(ctx context.Context, stream, group string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDestroy", ctx, stream, group) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDestroy indicates an expected call of XGroupDestroy. +func (mr *MockCmdableMockRecorder) XGroupDestroy(ctx, stream, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockCmdable)(nil).XGroupDestroy), ctx, stream, group) +} + +// XGroupSetID mocks base method. +func (m *MockCmdable) XGroupSetID(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupSetID", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupSetID indicates an expected call of XGroupSetID. +func (mr *MockCmdableMockRecorder) XGroupSetID(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockCmdable)(nil).XGroupSetID), ctx, stream, group, start) +} + +// XInfoConsumers mocks base method. +func (m *MockCmdable) XInfoConsumers(ctx context.Context, key, group string) *redis.XInfoConsumersCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoConsumers", ctx, key, group) + ret0, _ := ret[0].(*redis.XInfoConsumersCmd) + return ret0 +} + +// XInfoConsumers indicates an expected call of XInfoConsumers. +func (mr *MockCmdableMockRecorder) XInfoConsumers(ctx, key, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockCmdable)(nil).XInfoConsumers), ctx, key, group) +} + +// XInfoGroups mocks base method. +func (m *MockCmdable) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoGroups", ctx, key) + ret0, _ := ret[0].(*redis.XInfoGroupsCmd) + return ret0 +} + +// XInfoGroups indicates an expected call of XInfoGroups. +func (mr *MockCmdableMockRecorder) XInfoGroups(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockCmdable)(nil).XInfoGroups), ctx, key) +} + +// XInfoStream mocks base method. +func (m *MockCmdable) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStream", ctx, key) + ret0, _ := ret[0].(*redis.XInfoStreamCmd) + return ret0 +} + +// XInfoStream indicates an expected call of XInfoStream. +func (mr *MockCmdableMockRecorder) XInfoStream(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockCmdable)(nil).XInfoStream), ctx, key) +} + +// XInfoStreamFull mocks base method. +func (m *MockCmdable) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStreamFull", ctx, key, count) + ret0, _ := ret[0].(*redis.XInfoStreamFullCmd) + return ret0 +} + +// XInfoStreamFull indicates an expected call of XInfoStreamFull. +func (mr *MockCmdableMockRecorder) XInfoStreamFull(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockCmdable)(nil).XInfoStreamFull), ctx, key, count) +} + +// XLen mocks base method. +func (m *MockCmdable) XLen(ctx context.Context, stream string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XLen", ctx, stream) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XLen indicates an expected call of XLen. +func (mr *MockCmdableMockRecorder) XLen(ctx, stream any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockCmdable)(nil).XLen), ctx, stream) +} + +// XPending mocks base method. +func (m *MockCmdable) XPending(ctx context.Context, stream, group string) *redis.XPendingCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPending", ctx, stream, group) + ret0, _ := ret[0].(*redis.XPendingCmd) + return ret0 +} + +// XPending indicates an expected call of XPending. +func (mr *MockCmdableMockRecorder) XPending(ctx, stream, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockCmdable)(nil).XPending), ctx, stream, group) +} + +// XPendingExt mocks base method. +func (m *MockCmdable) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPendingExt", ctx, a) + ret0, _ := ret[0].(*redis.XPendingExtCmd) + return ret0 +} + +// XPendingExt indicates an expected call of XPendingExt. +func (mr *MockCmdableMockRecorder) XPendingExt(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockCmdable)(nil).XPendingExt), ctx, a) +} + +// XRange mocks base method. +func (m *MockCmdable) XRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRange", ctx, stream, start, stop) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRange indicates an expected call of XRange. +func (mr *MockCmdableMockRecorder) XRange(ctx, stream, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockCmdable)(nil).XRange), ctx, stream, start, stop) +} + +// XRangeN mocks base method. +func (m *MockCmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRangeN", ctx, stream, start, stop, count) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRangeN indicates an expected call of XRangeN. +func (mr *MockCmdableMockRecorder) XRangeN(ctx, stream, start, stop, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockCmdable)(nil).XRangeN), ctx, stream, start, stop, count) +} + +// XRead mocks base method. +func (m *MockCmdable) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRead", ctx, a) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XRead indicates an expected call of XRead. +func (mr *MockCmdableMockRecorder) XRead(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockCmdable)(nil).XRead), ctx, a) +} + +// XReadGroup mocks base method. +func (m *MockCmdable) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XReadGroup", ctx, a) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadGroup indicates an expected call of XReadGroup. +func (mr *MockCmdableMockRecorder) XReadGroup(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockCmdable)(nil).XReadGroup), ctx, a) +} + +// XReadStreams mocks base method. +func (m *MockCmdable) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range streams { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XReadStreams", varargs...) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadStreams indicates an expected call of XReadStreams. +func (mr *MockCmdableMockRecorder) XReadStreams(ctx any, streams ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, streams...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockCmdable)(nil).XReadStreams), varargs...) +} + +// XRevRange mocks base method. +func (m *MockCmdable) XRevRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRange", ctx, stream, start, stop) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRange indicates an expected call of XRevRange. +func (mr *MockCmdableMockRecorder) XRevRange(ctx, stream, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockCmdable)(nil).XRevRange), ctx, stream, start, stop) +} + +// XRevRangeN mocks base method. +func (m *MockCmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRangeN", ctx, stream, start, stop, count) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRangeN indicates an expected call of XRevRangeN. +func (mr *MockCmdableMockRecorder) XRevRangeN(ctx, stream, start, stop, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockCmdable)(nil).XRevRangeN), ctx, stream, start, stop, count) +} + +// XTrimMaxLen mocks base method. +func (m *MockCmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLen", ctx, key, maxLen) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLen indicates an expected call of XTrimMaxLen. +func (mr *MockCmdableMockRecorder) XTrimMaxLen(ctx, key, maxLen any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLen), ctx, key, maxLen) +} + +// XTrimMaxLenApprox mocks base method. +func (m *MockCmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLenApprox", ctx, key, maxLen, limit) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLenApprox indicates an expected call of XTrimMaxLenApprox. +func (mr *MockCmdableMockRecorder) XTrimMaxLenApprox(ctx, key, maxLen, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLenApprox), ctx, key, maxLen, limit) +} + +// XTrimMinID mocks base method. +func (m *MockCmdable) XTrimMinID(ctx context.Context, key, minID string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinID", ctx, key, minID) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinID indicates an expected call of XTrimMinID. +func (mr *MockCmdableMockRecorder) XTrimMinID(ctx, key, minID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockCmdable)(nil).XTrimMinID), ctx, key, minID) +} + +// XTrimMinIDApprox mocks base method. +func (m *MockCmdable) XTrimMinIDApprox(ctx context.Context, key, minID string, limit int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinIDApprox", ctx, key, minID, limit) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinIDApprox indicates an expected call of XTrimMinIDApprox. +func (mr *MockCmdableMockRecorder) XTrimMinIDApprox(ctx, key, minID, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockCmdable)(nil).XTrimMinIDApprox), ctx, key, minID, limit) +} + +// ZAdd mocks base method. +func (m *MockCmdable) ZAdd(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAdd indicates an expected call of ZAdd. +func (mr *MockCmdableMockRecorder) ZAdd(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockCmdable)(nil).ZAdd), varargs...) +} + +// ZAddArgs mocks base method. +func (m *MockCmdable) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgs", ctx, key, args) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddArgs indicates an expected call of ZAddArgs. +func (mr *MockCmdableMockRecorder) ZAddArgs(ctx, key, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockCmdable)(nil).ZAddArgs), ctx, key, args) +} + +// ZAddArgsIncr mocks base method. +func (m *MockCmdable) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgsIncr", ctx, key, args) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZAddArgsIncr indicates an expected call of ZAddArgsIncr. +func (mr *MockCmdableMockRecorder) ZAddArgsIncr(ctx, key, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockCmdable)(nil).ZAddArgsIncr), ctx, key, args) +} + +// ZAddGT mocks base method. +func (m *MockCmdable) ZAddGT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddGT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddGT indicates an expected call of ZAddGT. +func (mr *MockCmdableMockRecorder) ZAddGT(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddGT", reflect.TypeOf((*MockCmdable)(nil).ZAddGT), varargs...) +} + +// ZAddLT mocks base method. +func (m *MockCmdable) ZAddLT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddLT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddLT indicates an expected call of ZAddLT. +func (mr *MockCmdableMockRecorder) ZAddLT(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddLT", reflect.TypeOf((*MockCmdable)(nil).ZAddLT), varargs...) +} + +// ZAddNX mocks base method. +func (m *MockCmdable) ZAddNX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddNX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddNX indicates an expected call of ZAddNX. +func (mr *MockCmdableMockRecorder) ZAddNX(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockCmdable)(nil).ZAddNX), varargs...) +} + +// ZAddXX mocks base method. +func (m *MockCmdable) ZAddXX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddXX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddXX indicates an expected call of ZAddXX. +func (mr *MockCmdableMockRecorder) ZAddXX(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockCmdable)(nil).ZAddXX), varargs...) +} + +// ZCard mocks base method. +func (m *MockCmdable) ZCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCard indicates an expected call of ZCard. +func (mr *MockCmdableMockRecorder) ZCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockCmdable)(nil).ZCard), ctx, key) +} + +// ZCount mocks base method. +func (m *MockCmdable) ZCount(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCount", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCount indicates an expected call of ZCount. +func (mr *MockCmdableMockRecorder) ZCount(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockCmdable)(nil).ZCount), ctx, key, min, max) +} + +// ZDiff mocks base method. +func (m *MockCmdable) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZDiff indicates an expected call of ZDiff. +func (mr *MockCmdableMockRecorder) ZDiff(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockCmdable)(nil).ZDiff), varargs...) +} + +// ZDiffStore mocks base method. +func (m *MockCmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZDiffStore indicates an expected call of ZDiffStore. +func (mr *MockCmdableMockRecorder) ZDiffStore(ctx, destination any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockCmdable)(nil).ZDiffStore), varargs...) +} + +// ZDiffWithScores mocks base method. +func (m *MockCmdable) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffWithScores", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZDiffWithScores indicates an expected call of ZDiffWithScores. +func (mr *MockCmdableMockRecorder) ZDiffWithScores(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockCmdable)(nil).ZDiffWithScores), varargs...) +} + +// ZIncrBy mocks base method. +func (m *MockCmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZIncrBy", ctx, key, increment, member) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZIncrBy indicates an expected call of ZIncrBy. +func (mr *MockCmdableMockRecorder) ZIncrBy(ctx, key, increment, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockCmdable)(nil).ZIncrBy), ctx, key, increment, member) +} + +// ZInter mocks base method. +func (m *MockCmdable) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInter", ctx, store) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZInter indicates an expected call of ZInter. +func (mr *MockCmdableMockRecorder) ZInter(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockCmdable)(nil).ZInter), ctx, store) +} + +// ZInterCard mocks base method. +func (m *MockCmdable) ZInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, limit} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterCard indicates an expected call of ZInterCard. +func (mr *MockCmdableMockRecorder) ZInterCard(ctx, limit any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, limit}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterCard", reflect.TypeOf((*MockCmdable)(nil).ZInterCard), varargs...) +} + +// ZInterStore mocks base method. +func (m *MockCmdable) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterStore", ctx, destination, store) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterStore indicates an expected call of ZInterStore. +func (mr *MockCmdableMockRecorder) ZInterStore(ctx, destination, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockCmdable)(nil).ZInterStore), ctx, destination, store) +} + +// ZInterWithScores mocks base method. +func (m *MockCmdable) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterWithScores", ctx, store) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZInterWithScores indicates an expected call of ZInterWithScores. +func (mr *MockCmdableMockRecorder) ZInterWithScores(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockCmdable)(nil).ZInterWithScores), ctx, store) +} + +// ZLexCount mocks base method. +func (m *MockCmdable) ZLexCount(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZLexCount", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZLexCount indicates an expected call of ZLexCount. +func (mr *MockCmdableMockRecorder) ZLexCount(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockCmdable)(nil).ZLexCount), ctx, key, min, max) +} + +// ZMPop mocks base method. +func (m *MockCmdable) ZMPop(ctx context.Context, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, order, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// ZMPop indicates an expected call of ZMPop. +func (mr *MockCmdableMockRecorder) ZMPop(ctx, order, count any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, order, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMPop", reflect.TypeOf((*MockCmdable)(nil).ZMPop), varargs...) +} + +// ZMScore mocks base method. +func (m *MockCmdable) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMScore", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// ZMScore indicates an expected call of ZMScore. +func (mr *MockCmdableMockRecorder) ZMScore(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockCmdable)(nil).ZMScore), varargs...) +} + +// ZPopMax mocks base method. +func (m *MockCmdable) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range count { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMax indicates an expected call of ZPopMax. +func (mr *MockCmdableMockRecorder) ZPopMax(ctx, key any, count ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, count...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockCmdable)(nil).ZPopMax), varargs...) +} + +// ZPopMin mocks base method. +func (m *MockCmdable) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range count { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMin indicates an expected call of ZPopMin. +func (mr *MockCmdableMockRecorder) ZPopMin(ctx, key any, count ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, count...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockCmdable)(nil).ZPopMin), varargs...) +} + +// ZRandMember mocks base method. +func (m *MockCmdable) ZRandMember(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMember", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRandMember indicates an expected call of ZRandMember. +func (mr *MockCmdableMockRecorder) ZRandMember(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockCmdable)(nil).ZRandMember), ctx, key, count) +} + +// ZRandMemberWithScores mocks base method. +func (m *MockCmdable) ZRandMemberWithScores(ctx context.Context, key string, count int) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMemberWithScores", ctx, key, count) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores. +func (mr *MockCmdableMockRecorder) ZRandMemberWithScores(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRandMemberWithScores), ctx, key, count) +} + +// ZRange mocks base method. +func (m *MockCmdable) ZRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRange indicates an expected call of ZRange. +func (mr *MockCmdableMockRecorder) ZRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockCmdable)(nil).ZRange), ctx, key, start, stop) +} + +// ZRangeArgs mocks base method. +func (m *MockCmdable) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgs", ctx, z) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeArgs indicates an expected call of ZRangeArgs. +func (mr *MockCmdableMockRecorder) ZRangeArgs(ctx, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockCmdable)(nil).ZRangeArgs), ctx, z) +} + +// ZRangeArgsWithScores mocks base method. +func (m *MockCmdable) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgsWithScores", ctx, z) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores. +func (mr *MockCmdableMockRecorder) ZRangeArgsWithScores(ctx, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeArgsWithScores), ctx, z) +} + +// ZRangeByLex mocks base method. +func (m *MockCmdable) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByLex", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByLex indicates an expected call of ZRangeByLex. +func (mr *MockCmdableMockRecorder) ZRangeByLex(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRangeByLex), ctx, key, opt) +} + +// ZRangeByScore mocks base method. +func (m *MockCmdable) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScore", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByScore indicates an expected call of ZRangeByScore. +func (mr *MockCmdableMockRecorder) ZRangeByScore(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRangeByScore), ctx, key, opt) +} + +// ZRangeByScoreWithScores mocks base method. +func (m *MockCmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", ctx, key, opt) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores. +func (mr *MockCmdableMockRecorder) ZRangeByScoreWithScores(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeByScoreWithScores), ctx, key, opt) +} + +// ZRangeStore mocks base method. +func (m *MockCmdable) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeStore", ctx, dst, z) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRangeStore indicates an expected call of ZRangeStore. +func (mr *MockCmdableMockRecorder) ZRangeStore(ctx, dst, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockCmdable)(nil).ZRangeStore), ctx, dst, z) +} + +// ZRangeWithScores mocks base method. +func (m *MockCmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeWithScores", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeWithScores indicates an expected call of ZRangeWithScores. +func (mr *MockCmdableMockRecorder) ZRangeWithScores(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeWithScores), ctx, key, start, stop) +} + +// ZRank mocks base method. +func (m *MockCmdable) ZRank(ctx context.Context, key, member string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRank", ctx, key, member) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRank indicates an expected call of ZRank. +func (mr *MockCmdableMockRecorder) ZRank(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockCmdable)(nil).ZRank), ctx, key, member) +} + +// ZRankWithScore mocks base method. +func (m *MockCmdable) ZRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRankWithScore", ctx, key, member) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRankWithScore indicates an expected call of ZRankWithScore. +func (mr *MockCmdableMockRecorder) ZRankWithScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockCmdable)(nil).ZRankWithScore), ctx, key, member) +} + +// ZRem mocks base method. +func (m *MockCmdable) ZRem(ctx context.Context, key string, members ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRem indicates an expected call of ZRem. +func (mr *MockCmdableMockRecorder) ZRem(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockCmdable)(nil).ZRem), varargs...) +} + +// ZRemRangeByLex mocks base method. +func (m *MockCmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByLex", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByLex indicates an expected call of ZRemRangeByLex. +func (mr *MockCmdableMockRecorder) ZRemRangeByLex(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByLex), ctx, key, min, max) +} + +// ZRemRangeByRank mocks base method. +func (m *MockCmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByRank", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByRank indicates an expected call of ZRemRangeByRank. +func (mr *MockCmdableMockRecorder) ZRemRangeByRank(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByRank), ctx, key, start, stop) +} + +// ZRemRangeByScore mocks base method. +func (m *MockCmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByScore", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByScore indicates an expected call of ZRemRangeByScore. +func (mr *MockCmdableMockRecorder) ZRemRangeByScore(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByScore), ctx, key, min, max) +} + +// ZRevRange mocks base method. +func (m *MockCmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRange indicates an expected call of ZRevRange. +func (mr *MockCmdableMockRecorder) ZRevRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockCmdable)(nil).ZRevRange), ctx, key, start, stop) +} + +// ZRevRangeByLex mocks base method. +func (m *MockCmdable) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByLex", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByLex indicates an expected call of ZRevRangeByLex. +func (mr *MockCmdableMockRecorder) ZRevRangeByLex(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByLex), ctx, key, opt) +} + +// ZRevRangeByScore mocks base method. +func (m *MockCmdable) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScore", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByScore indicates an expected call of ZRevRangeByScore. +func (mr *MockCmdableMockRecorder) ZRevRangeByScore(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByScore), ctx, key, opt) +} + +// ZRevRangeByScoreWithScores mocks base method. +func (m *MockCmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", ctx, key, opt) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores. +func (mr *MockCmdableMockRecorder) ZRevRangeByScoreWithScores(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByScoreWithScores), ctx, key, opt) +} + +// ZRevRangeWithScores mocks base method. +func (m *MockCmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeWithScores", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeWithScores indicates an expected call of ZRevRangeWithScores. +func (mr *MockCmdableMockRecorder) ZRevRangeWithScores(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeWithScores), ctx, key, start, stop) +} + +// ZRevRank mocks base method. +func (m *MockCmdable) ZRevRank(ctx context.Context, key, member string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRank", ctx, key, member) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRevRank indicates an expected call of ZRevRank. +func (mr *MockCmdableMockRecorder) ZRevRank(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockCmdable)(nil).ZRevRank), ctx, key, member) +} + +// ZRevRankWithScore mocks base method. +func (m *MockCmdable) ZRevRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRankWithScore", ctx, key, member) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRevRankWithScore indicates an expected call of ZRevRankWithScore. +func (mr *MockCmdableMockRecorder) ZRevRankWithScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockCmdable)(nil).ZRevRankWithScore), ctx, key, member) +} + +// ZScan mocks base method. +func (m *MockCmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ZScan indicates an expected call of ZScan. +func (mr *MockCmdableMockRecorder) ZScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockCmdable)(nil).ZScan), ctx, key, cursor, match, count) +} + +// ZScore mocks base method. +func (m *MockCmdable) ZScore(ctx context.Context, key, member string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScore", ctx, key, member) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZScore indicates an expected call of ZScore. +func (mr *MockCmdableMockRecorder) ZScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockCmdable)(nil).ZScore), ctx, key, member) +} + +// ZUnion mocks base method. +func (m *MockCmdable) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnion", ctx, store) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZUnion indicates an expected call of ZUnion. +func (mr *MockCmdableMockRecorder) ZUnion(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockCmdable)(nil).ZUnion), ctx, store) +} + +// ZUnionStore mocks base method. +func (m *MockCmdable) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionStore", ctx, dest, store) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZUnionStore indicates an expected call of ZUnionStore. +func (mr *MockCmdableMockRecorder) ZUnionStore(ctx, dest, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockCmdable)(nil).ZUnionStore), ctx, dest, store) +} + +// ZUnionWithScores mocks base method. +func (m *MockCmdable) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionWithScores", ctx, store) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZUnionWithScores indicates an expected call of ZUnionWithScores. +func (mr *MockCmdableMockRecorder) ZUnionWithScores(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockCmdable)(nil).ZUnionWithScores), ctx, store) +} + +// MockStatefulCmdable is a mock of StatefulCmdable interface. +type MockStatefulCmdable struct { + ctrl *gomock.Controller + recorder *MockStatefulCmdableMockRecorder +} + +// MockStatefulCmdableMockRecorder is the mock recorder for MockStatefulCmdable. +type MockStatefulCmdableMockRecorder struct { + mock *MockStatefulCmdable +} + +// NewMockStatefulCmdable creates a new mock instance. +func NewMockStatefulCmdable(ctrl *gomock.Controller) *MockStatefulCmdable { + mock := &MockStatefulCmdable{ctrl: ctrl} + mock.recorder = &MockStatefulCmdableMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStatefulCmdable) EXPECT() *MockStatefulCmdableMockRecorder { + return m.recorder +} + +// ACLDryRun mocks base method. +func (m *MockStatefulCmdable) ACLDryRun(ctx context.Context, username string, command ...any) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, username} + for _, a := range command { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ACLDryRun", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ACLDryRun indicates an expected call of ACLDryRun. +func (mr *MockStatefulCmdableMockRecorder) ACLDryRun(ctx, username any, command ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, username}, command...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDryRun", reflect.TypeOf((*MockStatefulCmdable)(nil).ACLDryRun), varargs...) +} + +// ACLLog mocks base method. +func (m *MockStatefulCmdable) ACLLog(ctx context.Context, count int64) *redis.ACLLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLog", ctx, count) + ret0, _ := ret[0].(*redis.ACLLogCmd) + return ret0 +} + +// ACLLog indicates an expected call of ACLLog. +func (mr *MockStatefulCmdableMockRecorder) ACLLog(ctx, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockStatefulCmdable)(nil).ACLLog), ctx, count) +} + +// ACLLogReset mocks base method. +func (m *MockStatefulCmdable) ACLLogReset(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLogReset", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ACLLogReset indicates an expected call of ACLLogReset. +func (mr *MockStatefulCmdableMockRecorder) ACLLogReset(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockStatefulCmdable)(nil).ACLLogReset), ctx) +} + +// Append mocks base method. +func (m *MockStatefulCmdable) Append(ctx context.Context, key, value string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Append", ctx, key, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Append indicates an expected call of Append. +func (mr *MockStatefulCmdableMockRecorder) Append(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockStatefulCmdable)(nil).Append), ctx, key, value) +} + +// Auth mocks base method. +func (m *MockStatefulCmdable) Auth(ctx context.Context, password string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Auth", ctx, password) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Auth indicates an expected call of Auth. +func (mr *MockStatefulCmdableMockRecorder) Auth(ctx, password any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Auth", reflect.TypeOf((*MockStatefulCmdable)(nil).Auth), ctx, password) +} + +// AuthACL mocks base method. +func (m *MockStatefulCmdable) AuthACL(ctx context.Context, username, password string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthACL", ctx, username, password) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// AuthACL indicates an expected call of AuthACL. +func (mr *MockStatefulCmdableMockRecorder) AuthACL(ctx, username, password any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthACL", reflect.TypeOf((*MockStatefulCmdable)(nil).AuthACL), ctx, username, password) +} + +// BFAdd mocks base method. +func (m *MockStatefulCmdable) BFAdd(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFAdd", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFAdd indicates an expected call of BFAdd. +func (mr *MockStatefulCmdableMockRecorder) BFAdd(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).BFAdd), ctx, key, element) +} + +// BFCard mocks base method. +func (m *MockStatefulCmdable) BFCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BFCard indicates an expected call of BFCard. +func (mr *MockStatefulCmdableMockRecorder) BFCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockStatefulCmdable)(nil).BFCard), ctx, key) +} + +// BFExists mocks base method. +func (m *MockStatefulCmdable) BFExists(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFExists", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFExists indicates an expected call of BFExists. +func (mr *MockStatefulCmdableMockRecorder) BFExists(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockStatefulCmdable)(nil).BFExists), ctx, key, element) +} + +// BFInfo mocks base method. +func (m *MockStatefulCmdable) BFInfo(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfo", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfo indicates an expected call of BFInfo. +func (mr *MockStatefulCmdableMockRecorder) BFInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfo), ctx, key) +} + +// BFInfoArg mocks base method. +func (m *MockStatefulCmdable) BFInfoArg(ctx context.Context, key, option string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoArg", ctx, key, option) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoArg indicates an expected call of BFInfoArg. +func (mr *MockStatefulCmdableMockRecorder) BFInfoArg(ctx, key, option any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoArg), ctx, key, option) +} + +// BFInfoCapacity mocks base method. +func (m *MockStatefulCmdable) BFInfoCapacity(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoCapacity", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoCapacity indicates an expected call of BFInfoCapacity. +func (mr *MockStatefulCmdableMockRecorder) BFInfoCapacity(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoCapacity), ctx, key) +} + +// BFInfoExpansion mocks base method. +func (m *MockStatefulCmdable) BFInfoExpansion(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoExpansion", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoExpansion indicates an expected call of BFInfoExpansion. +func (mr *MockStatefulCmdableMockRecorder) BFInfoExpansion(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoExpansion), ctx, key) +} + +// BFInfoFilters mocks base method. +func (m *MockStatefulCmdable) BFInfoFilters(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoFilters", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoFilters indicates an expected call of BFInfoFilters. +func (mr *MockStatefulCmdableMockRecorder) BFInfoFilters(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoFilters), ctx, key) +} + +// BFInfoItems mocks base method. +func (m *MockStatefulCmdable) BFInfoItems(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoItems", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoItems indicates an expected call of BFInfoItems. +func (mr *MockStatefulCmdableMockRecorder) BFInfoItems(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoItems), ctx, key) +} + +// BFInfoSize mocks base method. +func (m *MockStatefulCmdable) BFInfoSize(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoSize", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoSize indicates an expected call of BFInfoSize. +func (mr *MockStatefulCmdableMockRecorder) BFInfoSize(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoSize), ctx, key) +} + +// BFInsert mocks base method. +func (m *MockStatefulCmdable) BFInsert(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFInsert indicates an expected call of BFInsert. +func (mr *MockStatefulCmdableMockRecorder) BFInsert(ctx, key, options any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInsert", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInsert), varargs...) +} + +// BFLoadChunk mocks base method. +func (m *MockStatefulCmdable) BFLoadChunk(ctx context.Context, key string, iterator int64, data any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFLoadChunk", ctx, key, iterator, data) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFLoadChunk indicates an expected call of BFLoadChunk. +func (mr *MockStatefulCmdableMockRecorder) BFLoadChunk(ctx, key, iterator, data any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockStatefulCmdable)(nil).BFLoadChunk), ctx, key, iterator, data) +} + +// BFMAdd mocks base method. +func (m *MockStatefulCmdable) BFMAdd(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMAdd", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMAdd indicates an expected call of BFMAdd. +func (mr *MockStatefulCmdableMockRecorder) BFMAdd(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).BFMAdd), varargs...) +} + +// BFMExists mocks base method. +func (m *MockStatefulCmdable) BFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMExists indicates an expected call of BFMExists. +func (mr *MockStatefulCmdableMockRecorder) BFMExists(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMExists", reflect.TypeOf((*MockStatefulCmdable)(nil).BFMExists), varargs...) +} + +// BFReserve mocks base method. +func (m *MockStatefulCmdable) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserve", ctx, key, errorRate, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserve indicates an expected call of BFReserve. +func (mr *MockStatefulCmdableMockRecorder) BFReserve(ctx, key, errorRate, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockStatefulCmdable)(nil).BFReserve), ctx, key, errorRate, capacity) +} + +// BFReserveArgs mocks base method. +func (m *MockStatefulCmdable) BFReserveArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveArgs indicates an expected call of BFReserveArgs. +func (mr *MockStatefulCmdableMockRecorder) BFReserveArgs(ctx, key, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).BFReserveArgs), ctx, key, options) +} + +// BFReserveExpansion mocks base method. +func (m *MockStatefulCmdable) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveExpansion", ctx, key, errorRate, capacity, expansion) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveExpansion indicates an expected call of BFReserveExpansion. +func (mr *MockStatefulCmdableMockRecorder) BFReserveExpansion(ctx, key, errorRate, capacity, expansion any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockStatefulCmdable)(nil).BFReserveExpansion), ctx, key, errorRate, capacity, expansion) +} + +// BFReserveNonScaling mocks base method. +func (m *MockStatefulCmdable) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveNonScaling", ctx, key, errorRate, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveNonScaling indicates an expected call of BFReserveNonScaling. +func (mr *MockStatefulCmdableMockRecorder) BFReserveNonScaling(ctx, key, errorRate, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockStatefulCmdable)(nil).BFReserveNonScaling), ctx, key, errorRate, capacity) +} + +// BFScanDump mocks base method. +func (m *MockStatefulCmdable) BFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFScanDump", ctx, key, iterator) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// BFScanDump indicates an expected call of BFScanDump. +func (mr *MockStatefulCmdableMockRecorder) BFScanDump(ctx, key, iterator any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockStatefulCmdable)(nil).BFScanDump), ctx, key, iterator) +} + +// BLMPop mocks base method. +func (m *MockStatefulCmdable) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout, direction, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// BLMPop indicates an expected call of BLMPop. +func (mr *MockStatefulCmdableMockRecorder) BLMPop(ctx, timeout, direction, count any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout, direction, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMPop", reflect.TypeOf((*MockStatefulCmdable)(nil).BLMPop), varargs...) +} + +// BLMove mocks base method. +func (m *MockStatefulCmdable) BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BLMove", ctx, source, destination, srcpos, destpos, timeout) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BLMove indicates an expected call of BLMove. +func (mr *MockStatefulCmdableMockRecorder) BLMove(ctx, source, destination, srcpos, destpos, timeout any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMove", reflect.TypeOf((*MockStatefulCmdable)(nil).BLMove), ctx, source, destination, srcpos, destpos, timeout) +} + +// BLPop mocks base method. +func (m *MockStatefulCmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BLPop indicates an expected call of BLPop. +func (mr *MockStatefulCmdableMockRecorder) BLPop(ctx, timeout any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLPop", reflect.TypeOf((*MockStatefulCmdable)(nil).BLPop), varargs...) +} + +// BRPop mocks base method. +func (m *MockStatefulCmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BRPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BRPop indicates an expected call of BRPop. +func (mr *MockStatefulCmdableMockRecorder) BRPop(ctx, timeout any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPop", reflect.TypeOf((*MockStatefulCmdable)(nil).BRPop), varargs...) +} + +// BRPopLPush mocks base method. +func (m *MockStatefulCmdable) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BRPopLPush", ctx, source, destination, timeout) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BRPopLPush indicates an expected call of BRPopLPush. +func (mr *MockStatefulCmdableMockRecorder) BRPopLPush(ctx, source, destination, timeout any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockStatefulCmdable)(nil).BRPopLPush), ctx, source, destination, timeout) +} + +// BZMPop mocks base method. +func (m *MockStatefulCmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout, order, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// BZMPop indicates an expected call of BZMPop. +func (mr *MockStatefulCmdableMockRecorder) BZMPop(ctx, timeout, order, count any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout, order, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZMPop", reflect.TypeOf((*MockStatefulCmdable)(nil).BZMPop), varargs...) +} + +// BZPopMax mocks base method. +func (m *MockStatefulCmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMax indicates an expected call of BZPopMax. +func (mr *MockStatefulCmdableMockRecorder) BZPopMax(ctx, timeout any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMax", reflect.TypeOf((*MockStatefulCmdable)(nil).BZPopMax), varargs...) +} + +// BZPopMin mocks base method. +func (m *MockStatefulCmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMin indicates an expected call of BZPopMin. +func (mr *MockStatefulCmdableMockRecorder) BZPopMin(ctx, timeout any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMin", reflect.TypeOf((*MockStatefulCmdable)(nil).BZPopMin), varargs...) +} + +// BgRewriteAOF mocks base method. +func (m *MockStatefulCmdable) BgRewriteAOF(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgRewriteAOF", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgRewriteAOF indicates an expected call of BgRewriteAOF. +func (mr *MockStatefulCmdableMockRecorder) BgRewriteAOF(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockStatefulCmdable)(nil).BgRewriteAOF), ctx) +} + +// BgSave mocks base method. +func (m *MockStatefulCmdable) BgSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgSave indicates an expected call of BgSave. +func (mr *MockStatefulCmdableMockRecorder) BgSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockStatefulCmdable)(nil).BgSave), ctx) +} + +// BitCount mocks base method. +func (m *MockStatefulCmdable) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitCount", ctx, key, bitCount) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitCount indicates an expected call of BitCount. +func (mr *MockStatefulCmdableMockRecorder) BitCount(ctx, key, bitCount any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockStatefulCmdable)(nil).BitCount), ctx, key, bitCount) +} + +// BitField mocks base method. +func (m *MockStatefulCmdable) BitField(ctx context.Context, key string, args ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitField", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// BitField indicates an expected call of BitField. +func (mr *MockStatefulCmdableMockRecorder) BitField(ctx, key any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockStatefulCmdable)(nil).BitField), varargs...) +} + +// BitOpAnd mocks base method. +func (m *MockStatefulCmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpAnd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpAnd indicates an expected call of BitOpAnd. +func (mr *MockStatefulCmdableMockRecorder) BitOpAnd(ctx, destKey any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAnd", reflect.TypeOf((*MockStatefulCmdable)(nil).BitOpAnd), varargs...) +} + +// BitOpNot mocks base method. +func (m *MockStatefulCmdable) BitOpNot(ctx context.Context, destKey, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitOpNot", ctx, destKey, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpNot indicates an expected call of BitOpNot. +func (mr *MockStatefulCmdableMockRecorder) BitOpNot(ctx, destKey, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockStatefulCmdable)(nil).BitOpNot), ctx, destKey, key) +} + +// BitOpOr mocks base method. +func (m *MockStatefulCmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpOr", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpOr indicates an expected call of BitOpOr. +func (mr *MockStatefulCmdableMockRecorder) BitOpOr(ctx, destKey any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOr", reflect.TypeOf((*MockStatefulCmdable)(nil).BitOpOr), varargs...) +} + +// BitOpXor mocks base method. +func (m *MockStatefulCmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpXor", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpXor indicates an expected call of BitOpXor. +func (mr *MockStatefulCmdableMockRecorder) BitOpXor(ctx, destKey any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpXor", reflect.TypeOf((*MockStatefulCmdable)(nil).BitOpXor), varargs...) +} + +// BitPos mocks base method. +func (m *MockStatefulCmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key, bit} + for _, a := range pos { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitPos", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPos indicates an expected call of BitPos. +func (mr *MockStatefulCmdableMockRecorder) BitPos(ctx, key, bit any, pos ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key, bit}, pos...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPos", reflect.TypeOf((*MockStatefulCmdable)(nil).BitPos), varargs...) +} + +// BitPosSpan mocks base method. +func (m *MockStatefulCmdable) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitPosSpan", ctx, key, bit, start, end, span) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPosSpan indicates an expected call of BitPosSpan. +func (mr *MockStatefulCmdableMockRecorder) BitPosSpan(ctx, key, bit, start, end, span any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPosSpan", reflect.TypeOf((*MockStatefulCmdable)(nil).BitPosSpan), ctx, key, bit, start, end, span) +} + +// CFAdd mocks base method. +func (m *MockStatefulCmdable) CFAdd(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAdd", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAdd indicates an expected call of CFAdd. +func (mr *MockStatefulCmdableMockRecorder) CFAdd(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).CFAdd), ctx, key, element) +} + +// CFAddNX mocks base method. +func (m *MockStatefulCmdable) CFAddNX(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAddNX", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAddNX indicates an expected call of CFAddNX. +func (mr *MockStatefulCmdableMockRecorder) CFAddNX(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockStatefulCmdable)(nil).CFAddNX), ctx, key, element) +} + +// CFCount mocks base method. +func (m *MockStatefulCmdable) CFCount(ctx context.Context, key string, element any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFCount", ctx, key, element) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// CFCount indicates an expected call of CFCount. +func (mr *MockStatefulCmdableMockRecorder) CFCount(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockStatefulCmdable)(nil).CFCount), ctx, key, element) +} + +// CFDel mocks base method. +func (m *MockStatefulCmdable) CFDel(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFDel", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFDel indicates an expected call of CFDel. +func (mr *MockStatefulCmdableMockRecorder) CFDel(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockStatefulCmdable)(nil).CFDel), ctx, key, element) +} + +// CFExists mocks base method. +func (m *MockStatefulCmdable) CFExists(ctx context.Context, key string, element any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFExists", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFExists indicates an expected call of CFExists. +func (mr *MockStatefulCmdableMockRecorder) CFExists(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockStatefulCmdable)(nil).CFExists), ctx, key, element) +} + +// CFInfo mocks base method. +func (m *MockStatefulCmdable) CFInfo(ctx context.Context, key string) *redis.CFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFInfo", ctx, key) + ret0, _ := ret[0].(*redis.CFInfoCmd) + return ret0 +} + +// CFInfo indicates an expected call of CFInfo. +func (mr *MockStatefulCmdableMockRecorder) CFInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).CFInfo), ctx, key) +} + +// CFInsert mocks base method. +func (m *MockStatefulCmdable) CFInsert(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFInsert indicates an expected call of CFInsert. +func (mr *MockStatefulCmdableMockRecorder) CFInsert(ctx, key, options any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsert", reflect.TypeOf((*MockStatefulCmdable)(nil).CFInsert), varargs...) +} + +// CFInsertNX mocks base method. +func (m *MockStatefulCmdable) CFInsertNX(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsertNX", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CFInsertNX indicates an expected call of CFInsertNX. +func (mr *MockStatefulCmdableMockRecorder) CFInsertNX(ctx, key, options any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsertNX", reflect.TypeOf((*MockStatefulCmdable)(nil).CFInsertNX), varargs...) +} + +// CFLoadChunk mocks base method. +func (m *MockStatefulCmdable) CFLoadChunk(ctx context.Context, key string, iterator int64, data any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFLoadChunk", ctx, key, iterator, data) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFLoadChunk indicates an expected call of CFLoadChunk. +func (mr *MockStatefulCmdableMockRecorder) CFLoadChunk(ctx, key, iterator, data any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockStatefulCmdable)(nil).CFLoadChunk), ctx, key, iterator, data) +} + +// CFMExists mocks base method. +func (m *MockStatefulCmdable) CFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFMExists indicates an expected call of CFMExists. +func (mr *MockStatefulCmdableMockRecorder) CFMExists(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFMExists", reflect.TypeOf((*MockStatefulCmdable)(nil).CFMExists), varargs...) +} + +// CFReserve mocks base method. +func (m *MockStatefulCmdable) CFReserve(ctx context.Context, key string, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserve", ctx, key, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserve indicates an expected call of CFReserve. +func (mr *MockStatefulCmdableMockRecorder) CFReserve(ctx, key, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserve), ctx, key, capacity) +} + +// CFReserveArgs mocks base method. +func (m *MockStatefulCmdable) CFReserveArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveArgs indicates an expected call of CFReserveArgs. +func (mr *MockStatefulCmdableMockRecorder) CFReserveArgs(ctx, key, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserveArgs), ctx, key, options) +} + +// CFReserveBucketSize mocks base method. +func (m *MockStatefulCmdable) CFReserveBucketSize(ctx context.Context, key string, capacity, bucketsize int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveBucketSize", ctx, key, capacity, bucketsize) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveBucketSize indicates an expected call of CFReserveBucketSize. +func (mr *MockStatefulCmdableMockRecorder) CFReserveBucketSize(ctx, key, capacity, bucketsize any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserveBucketSize), ctx, key, capacity, bucketsize) +} + +// CFReserveExpansion mocks base method. +func (m *MockStatefulCmdable) CFReserveExpansion(ctx context.Context, key string, capacity, expansion int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveExpansion", ctx, key, capacity, expansion) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveExpansion indicates an expected call of CFReserveExpansion. +func (mr *MockStatefulCmdableMockRecorder) CFReserveExpansion(ctx, key, capacity, expansion any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserveExpansion), ctx, key, capacity, expansion) +} + +// CFReserveMaxIterations mocks base method. +func (m *MockStatefulCmdable) CFReserveMaxIterations(ctx context.Context, key string, capacity, maxiterations int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveMaxIterations", ctx, key, capacity, maxiterations) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations. +func (mr *MockStatefulCmdableMockRecorder) CFReserveMaxIterations(ctx, key, capacity, maxiterations any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserveMaxIterations), ctx, key, capacity, maxiterations) +} + +// CFScanDump mocks base method. +func (m *MockStatefulCmdable) CFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFScanDump", ctx, key, iterator) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// CFScanDump indicates an expected call of CFScanDump. +func (mr *MockStatefulCmdableMockRecorder) CFScanDump(ctx, key, iterator any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockStatefulCmdable)(nil).CFScanDump), ctx, key, iterator) +} + +// CMSIncrBy mocks base method. +func (m *MockStatefulCmdable) CMSIncrBy(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSIncrBy", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSIncrBy indicates an expected call of CMSIncrBy. +func (mr *MockStatefulCmdableMockRecorder) CMSIncrBy(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSIncrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSIncrBy), varargs...) +} + +// CMSInfo mocks base method. +func (m *MockStatefulCmdable) CMSInfo(ctx context.Context, key string) *redis.CMSInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInfo", ctx, key) + ret0, _ := ret[0].(*redis.CMSInfoCmd) + return ret0 +} + +// CMSInfo indicates an expected call of CMSInfo. +func (mr *MockStatefulCmdableMockRecorder) CMSInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSInfo), ctx, key) +} + +// CMSInitByDim mocks base method. +func (m *MockStatefulCmdable) CMSInitByDim(ctx context.Context, key string, width, height int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByDim", ctx, key, width, height) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByDim indicates an expected call of CMSInitByDim. +func (mr *MockStatefulCmdableMockRecorder) CMSInitByDim(ctx, key, width, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSInitByDim), ctx, key, width, height) +} + +// CMSInitByProb mocks base method. +func (m *MockStatefulCmdable) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByProb", ctx, key, errorRate, probability) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByProb indicates an expected call of CMSInitByProb. +func (mr *MockStatefulCmdableMockRecorder) CMSInitByProb(ctx, key, errorRate, probability any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSInitByProb), ctx, key, errorRate, probability) +} + +// CMSMerge mocks base method. +func (m *MockStatefulCmdable) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey} + for _, a := range sourceKeys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMerge indicates an expected call of CMSMerge. +func (mr *MockStatefulCmdableMockRecorder) CMSMerge(ctx, destKey any, sourceKeys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey}, sourceKeys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMerge", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSMerge), varargs...) +} + +// CMSMergeWithWeight mocks base method. +func (m *MockStatefulCmdable) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSMergeWithWeight", ctx, destKey, sourceKeys) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight. +func (mr *MockStatefulCmdableMockRecorder) CMSMergeWithWeight(ctx, destKey, sourceKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSMergeWithWeight), ctx, destKey, sourceKeys) +} + +// CMSQuery mocks base method. +func (m *MockStatefulCmdable) CMSQuery(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSQuery", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSQuery indicates an expected call of CMSQuery. +func (mr *MockStatefulCmdableMockRecorder) CMSQuery(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSQuery", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSQuery), varargs...) +} + +// ClientGetName mocks base method. +func (m *MockStatefulCmdable) ClientGetName(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientGetName", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientGetName indicates an expected call of ClientGetName. +func (mr *MockStatefulCmdableMockRecorder) ClientGetName(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientGetName), ctx) +} + +// ClientID mocks base method. +func (m *MockStatefulCmdable) ClientID(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientID", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientID indicates an expected call of ClientID. +func (mr *MockStatefulCmdableMockRecorder) ClientID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientID), ctx) +} + +// ClientInfo mocks base method. +func (m *MockStatefulCmdable) ClientInfo(ctx context.Context) *redis.ClientInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientInfo", ctx) + ret0, _ := ret[0].(*redis.ClientInfoCmd) + return ret0 +} + +// ClientInfo indicates an expected call of ClientInfo. +func (mr *MockStatefulCmdableMockRecorder) ClientInfo(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientInfo), ctx) +} + +// ClientKill mocks base method. +func (m *MockStatefulCmdable) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientKill", ctx, ipPort) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClientKill indicates an expected call of ClientKill. +func (mr *MockStatefulCmdableMockRecorder) ClientKill(ctx, ipPort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientKill), ctx, ipPort) +} + +// ClientKillByFilter mocks base method. +func (m *MockStatefulCmdable) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientKillByFilter indicates an expected call of ClientKillByFilter. +func (mr *MockStatefulCmdableMockRecorder) ClientKillByFilter(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientKillByFilter), varargs...) +} + +// ClientList mocks base method. +func (m *MockStatefulCmdable) ClientList(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientList", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientList indicates an expected call of ClientList. +func (mr *MockStatefulCmdableMockRecorder) ClientList(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientList), ctx) +} + +// ClientPause mocks base method. +func (m *MockStatefulCmdable) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientPause", ctx, dur) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientPause indicates an expected call of ClientPause. +func (mr *MockStatefulCmdableMockRecorder) ClientPause(ctx, dur any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientPause), ctx, dur) +} + +// ClientSetName mocks base method. +func (m *MockStatefulCmdable) ClientSetName(ctx context.Context, name string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientSetName", ctx, name) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientSetName indicates an expected call of ClientSetName. +func (mr *MockStatefulCmdableMockRecorder) ClientSetName(ctx, name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientSetName", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientSetName), ctx, name) +} + +// ClientUnblock mocks base method. +func (m *MockStatefulCmdable) ClientUnblock(ctx context.Context, id int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblock", ctx, id) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblock indicates an expected call of ClientUnblock. +func (mr *MockStatefulCmdableMockRecorder) ClientUnblock(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientUnblock), ctx, id) +} + +// ClientUnblockWithError mocks base method. +func (m *MockStatefulCmdable) ClientUnblockWithError(ctx context.Context, id int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblockWithError", ctx, id) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblockWithError indicates an expected call of ClientUnblockWithError. +func (mr *MockStatefulCmdableMockRecorder) ClientUnblockWithError(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientUnblockWithError), ctx, id) +} + +// ClientUnpause mocks base method. +func (m *MockStatefulCmdable) ClientUnpause(ctx context.Context) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnpause", ctx) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientUnpause indicates an expected call of ClientUnpause. +func (mr *MockStatefulCmdableMockRecorder) ClientUnpause(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientUnpause), ctx) +} + +// ClusterAddSlots mocks base method. +func (m *MockStatefulCmdable) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range slots { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlots indicates an expected call of ClusterAddSlots. +func (mr *MockStatefulCmdableMockRecorder) ClusterAddSlots(ctx any, slots ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, slots...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterAddSlots), varargs...) +} + +// ClusterAddSlotsRange mocks base method. +func (m *MockStatefulCmdable) ClusterAddSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterAddSlotsRange", ctx, min, max) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange. +func (mr *MockStatefulCmdableMockRecorder) ClusterAddSlotsRange(ctx, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterAddSlotsRange), ctx, min, max) +} + +// ClusterCountFailureReports mocks base method. +func (m *MockStatefulCmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountFailureReports", ctx, nodeID) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports. +func (mr *MockStatefulCmdableMockRecorder) ClusterCountFailureReports(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterCountFailureReports), ctx, nodeID) +} + +// ClusterCountKeysInSlot mocks base method. +func (m *MockStatefulCmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", ctx, slot) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot. +func (mr *MockStatefulCmdableMockRecorder) ClusterCountKeysInSlot(ctx, slot any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterCountKeysInSlot), ctx, slot) +} + +// ClusterDelSlots mocks base method. +func (m *MockStatefulCmdable) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range slots { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlots indicates an expected call of ClusterDelSlots. +func (mr *MockStatefulCmdableMockRecorder) ClusterDelSlots(ctx any, slots ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, slots...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterDelSlots), varargs...) +} + +// ClusterDelSlotsRange mocks base method. +func (m *MockStatefulCmdable) ClusterDelSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterDelSlotsRange", ctx, min, max) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange. +func (mr *MockStatefulCmdableMockRecorder) ClusterDelSlotsRange(ctx, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterDelSlotsRange), ctx, min, max) +} + +// ClusterFailover mocks base method. +func (m *MockStatefulCmdable) ClusterFailover(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterFailover", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterFailover indicates an expected call of ClusterFailover. +func (mr *MockStatefulCmdableMockRecorder) ClusterFailover(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterFailover), ctx) +} + +// ClusterForget mocks base method. +func (m *MockStatefulCmdable) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterForget", ctx, nodeID) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterForget indicates an expected call of ClusterForget. +func (mr *MockStatefulCmdableMockRecorder) ClusterForget(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterForget), ctx, nodeID) +} + +// ClusterGetKeysInSlot mocks base method. +func (m *MockStatefulCmdable) ClusterGetKeysInSlot(ctx context.Context, slot, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", ctx, slot, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot. +func (mr *MockStatefulCmdableMockRecorder) ClusterGetKeysInSlot(ctx, slot, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterGetKeysInSlot), ctx, slot, count) +} + +// ClusterInfo mocks base method. +func (m *MockStatefulCmdable) ClusterInfo(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterInfo", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterInfo indicates an expected call of ClusterInfo. +func (mr *MockStatefulCmdableMockRecorder) ClusterInfo(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterInfo), ctx) +} + +// ClusterKeySlot mocks base method. +func (m *MockStatefulCmdable) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterKeySlot", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterKeySlot indicates an expected call of ClusterKeySlot. +func (mr *MockStatefulCmdableMockRecorder) ClusterKeySlot(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterKeySlot), ctx, key) +} + +// ClusterLinks mocks base method. +func (m *MockStatefulCmdable) ClusterLinks(ctx context.Context) *redis.ClusterLinksCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterLinks", ctx) + ret0, _ := ret[0].(*redis.ClusterLinksCmd) + return ret0 +} + +// ClusterLinks indicates an expected call of ClusterLinks. +func (mr *MockStatefulCmdableMockRecorder) ClusterLinks(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterLinks), ctx) +} + +// ClusterMeet mocks base method. +func (m *MockStatefulCmdable) ClusterMeet(ctx context.Context, host, port string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMeet", ctx, host, port) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterMeet indicates an expected call of ClusterMeet. +func (mr *MockStatefulCmdableMockRecorder) ClusterMeet(ctx, host, port any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterMeet), ctx, host, port) +} + +// ClusterMyShardID mocks base method. +func (m *MockStatefulCmdable) ClusterMyShardID(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMyShardID", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterMyShardID indicates an expected call of ClusterMyShardID. +func (mr *MockStatefulCmdableMockRecorder) ClusterMyShardID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterMyShardID), ctx) +} + +// ClusterNodes mocks base method. +func (m *MockStatefulCmdable) ClusterNodes(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterNodes", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterNodes indicates an expected call of ClusterNodes. +func (mr *MockStatefulCmdableMockRecorder) ClusterNodes(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterNodes), ctx) +} + +// ClusterReplicate mocks base method. +func (m *MockStatefulCmdable) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterReplicate", ctx, nodeID) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterReplicate indicates an expected call of ClusterReplicate. +func (mr *MockStatefulCmdableMockRecorder) ClusterReplicate(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterReplicate), ctx, nodeID) +} + +// ClusterResetHard mocks base method. +func (m *MockStatefulCmdable) ClusterResetHard(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetHard", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetHard indicates an expected call of ClusterResetHard. +func (mr *MockStatefulCmdableMockRecorder) ClusterResetHard(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterResetHard), ctx) +} + +// ClusterResetSoft mocks base method. +func (m *MockStatefulCmdable) ClusterResetSoft(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetSoft", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetSoft indicates an expected call of ClusterResetSoft. +func (mr *MockStatefulCmdableMockRecorder) ClusterResetSoft(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterResetSoft), ctx) +} + +// ClusterSaveConfig mocks base method. +func (m *MockStatefulCmdable) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSaveConfig", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterSaveConfig indicates an expected call of ClusterSaveConfig. +func (mr *MockStatefulCmdableMockRecorder) ClusterSaveConfig(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterSaveConfig), ctx) +} + +// ClusterShards mocks base method. +func (m *MockStatefulCmdable) ClusterShards(ctx context.Context) *redis.ClusterShardsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterShards", ctx) + ret0, _ := ret[0].(*redis.ClusterShardsCmd) + return ret0 +} + +// ClusterShards indicates an expected call of ClusterShards. +func (mr *MockStatefulCmdableMockRecorder) ClusterShards(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterShards), ctx) +} + +// ClusterSlaves mocks base method. +func (m *MockStatefulCmdable) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlaves", ctx, nodeID) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterSlaves indicates an expected call of ClusterSlaves. +func (mr *MockStatefulCmdableMockRecorder) ClusterSlaves(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterSlaves), ctx, nodeID) +} + +// ClusterSlots mocks base method. +func (m *MockStatefulCmdable) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlots", ctx) + ret0, _ := ret[0].(*redis.ClusterSlotsCmd) + return ret0 +} + +// ClusterSlots indicates an expected call of ClusterSlots. +func (mr *MockStatefulCmdableMockRecorder) ClusterSlots(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterSlots), ctx) +} + +// Command mocks base method. +func (m *MockStatefulCmdable) Command(ctx context.Context) *redis.CommandsInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Command", ctx) + ret0, _ := ret[0].(*redis.CommandsInfoCmd) + return ret0 +} + +// Command indicates an expected call of Command. +func (mr *MockStatefulCmdableMockRecorder) Command(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockStatefulCmdable)(nil).Command), ctx) +} + +// CommandGetKeys mocks base method. +func (m *MockStatefulCmdable) CommandGetKeys(ctx context.Context, commands ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range commands { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeys", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandGetKeys indicates an expected call of CommandGetKeys. +func (mr *MockStatefulCmdableMockRecorder) CommandGetKeys(ctx any, commands ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, commands...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeys", reflect.TypeOf((*MockStatefulCmdable)(nil).CommandGetKeys), varargs...) +} + +// CommandGetKeysAndFlags mocks base method. +func (m *MockStatefulCmdable) CommandGetKeysAndFlags(ctx context.Context, commands ...any) *redis.KeyFlagsCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range commands { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...) + ret0, _ := ret[0].(*redis.KeyFlagsCmd) + return ret0 +} + +// CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags. +func (mr *MockStatefulCmdableMockRecorder) CommandGetKeysAndFlags(ctx any, commands ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, commands...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeysAndFlags", reflect.TypeOf((*MockStatefulCmdable)(nil).CommandGetKeysAndFlags), varargs...) +} + +// CommandList mocks base method. +func (m *MockStatefulCmdable) CommandList(ctx context.Context, filter *redis.FilterBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandList", ctx, filter) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandList indicates an expected call of CommandList. +func (mr *MockStatefulCmdableMockRecorder) CommandList(ctx, filter any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockStatefulCmdable)(nil).CommandList), ctx, filter) +} + +// ConfigGet mocks base method. +func (m *MockStatefulCmdable) ConfigGet(ctx context.Context, parameter string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigGet", ctx, parameter) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// ConfigGet indicates an expected call of ConfigGet. +func (mr *MockStatefulCmdableMockRecorder) ConfigGet(ctx, parameter any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockStatefulCmdable)(nil).ConfigGet), ctx, parameter) +} + +// ConfigResetStat mocks base method. +func (m *MockStatefulCmdable) ConfigResetStat(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigResetStat", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigResetStat indicates an expected call of ConfigResetStat. +func (mr *MockStatefulCmdableMockRecorder) ConfigResetStat(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockStatefulCmdable)(nil).ConfigResetStat), ctx) +} + +// ConfigRewrite mocks base method. +func (m *MockStatefulCmdable) ConfigRewrite(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigRewrite", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigRewrite indicates an expected call of ConfigRewrite. +func (mr *MockStatefulCmdableMockRecorder) ConfigRewrite(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockStatefulCmdable)(nil).ConfigRewrite), ctx) +} + +// ConfigSet mocks base method. +func (m *MockStatefulCmdable) ConfigSet(ctx context.Context, parameter, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigSet", ctx, parameter, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigSet indicates an expected call of ConfigSet. +func (mr *MockStatefulCmdableMockRecorder) ConfigSet(ctx, parameter, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockStatefulCmdable)(nil).ConfigSet), ctx, parameter, value) +} + +// Copy mocks base method. +func (m *MockStatefulCmdable) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Copy", ctx, sourceKey, destKey, db, replace) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Copy indicates an expected call of Copy. +func (mr *MockStatefulCmdableMockRecorder) Copy(ctx, sourceKey, destKey, db, replace any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockStatefulCmdable)(nil).Copy), ctx, sourceKey, destKey, db, replace) +} + +// DBSize mocks base method. +func (m *MockStatefulCmdable) DBSize(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DBSize", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DBSize indicates an expected call of DBSize. +func (mr *MockStatefulCmdableMockRecorder) DBSize(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockStatefulCmdable)(nil).DBSize), ctx) +} + +// DebugObject mocks base method. +func (m *MockStatefulCmdable) DebugObject(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugObject", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// DebugObject indicates an expected call of DebugObject. +func (mr *MockStatefulCmdableMockRecorder) DebugObject(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockStatefulCmdable)(nil).DebugObject), ctx, key) +} + +// Decr mocks base method. +func (m *MockStatefulCmdable) Decr(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Decr", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Decr indicates an expected call of Decr. +func (mr *MockStatefulCmdableMockRecorder) Decr(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockStatefulCmdable)(nil).Decr), ctx, key) +} + +// DecrBy mocks base method. +func (m *MockStatefulCmdable) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecrBy", ctx, key, decrement) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DecrBy indicates an expected call of DecrBy. +func (mr *MockStatefulCmdableMockRecorder) DecrBy(ctx, key, decrement any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).DecrBy), ctx, key, decrement) +} + +// Del mocks base method. +func (m *MockStatefulCmdable) Del(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Del", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Del indicates an expected call of Del. +func (mr *MockStatefulCmdableMockRecorder) Del(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockStatefulCmdable)(nil).Del), varargs...) +} + +// Dump mocks base method. +func (m *MockStatefulCmdable) Dump(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Dump", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Dump indicates an expected call of Dump. +func (mr *MockStatefulCmdableMockRecorder) Dump(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockStatefulCmdable)(nil).Dump), ctx, key) +} + +// Echo mocks base method. +func (m *MockStatefulCmdable) Echo(ctx context.Context, message any) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Echo", ctx, message) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Echo indicates an expected call of Echo. +func (mr *MockStatefulCmdableMockRecorder) Echo(ctx, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockStatefulCmdable)(nil).Echo), ctx, message) +} + +// Eval mocks base method. +func (m *MockStatefulCmdable) Eval(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, script, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Eval", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// Eval indicates an expected call of Eval. +func (mr *MockStatefulCmdableMockRecorder) Eval(ctx, script, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, script, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockStatefulCmdable)(nil).Eval), varargs...) +} + +// EvalRO mocks base method. +func (m *MockStatefulCmdable) EvalRO(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, script, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalRO indicates an expected call of EvalRO. +func (mr *MockStatefulCmdableMockRecorder) EvalRO(ctx, script, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, script, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockStatefulCmdable)(nil).EvalRO), varargs...) +} + +// EvalSha mocks base method. +func (m *MockStatefulCmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, sha1, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalSha", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalSha indicates an expected call of EvalSha. +func (mr *MockStatefulCmdableMockRecorder) EvalSha(ctx, sha1, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, sha1, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockStatefulCmdable)(nil).EvalSha), varargs...) +} + +// EvalShaRO mocks base method. +func (m *MockStatefulCmdable) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, sha1, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalShaRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalShaRO indicates an expected call of EvalShaRO. +func (mr *MockStatefulCmdableMockRecorder) EvalShaRO(ctx, sha1, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, sha1, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockStatefulCmdable)(nil).EvalShaRO), varargs...) +} + +// Exists mocks base method. +func (m *MockStatefulCmdable) Exists(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Exists", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Exists indicates an expected call of Exists. +func (mr *MockStatefulCmdableMockRecorder) Exists(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockStatefulCmdable)(nil).Exists), varargs...) +} + +// Expire mocks base method. +func (m *MockStatefulCmdable) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Expire", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Expire indicates an expected call of Expire. +func (mr *MockStatefulCmdableMockRecorder) Expire(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockStatefulCmdable)(nil).Expire), ctx, key, expiration) +} + +// ExpireAt mocks base method. +func (m *MockStatefulCmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireAt", ctx, key, tm) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireAt indicates an expected call of ExpireAt. +func (mr *MockStatefulCmdableMockRecorder) ExpireAt(ctx, key, tm any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireAt), ctx, key, tm) +} + +// ExpireGT mocks base method. +func (m *MockStatefulCmdable) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireGT", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireGT indicates an expected call of ExpireGT. +func (mr *MockStatefulCmdableMockRecorder) ExpireGT(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireGT), ctx, key, expiration) +} + +// ExpireLT mocks base method. +func (m *MockStatefulCmdable) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireLT", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireLT indicates an expected call of ExpireLT. +func (mr *MockStatefulCmdableMockRecorder) ExpireLT(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireLT), ctx, key, expiration) +} + +// ExpireNX mocks base method. +func (m *MockStatefulCmdable) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireNX", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireNX indicates an expected call of ExpireNX. +func (mr *MockStatefulCmdableMockRecorder) ExpireNX(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireNX), ctx, key, expiration) +} + +// ExpireTime mocks base method. +func (m *MockStatefulCmdable) ExpireTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ExpireTime indicates an expected call of ExpireTime. +func (mr *MockStatefulCmdableMockRecorder) ExpireTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireTime), ctx, key) +} + +// ExpireXX mocks base method. +func (m *MockStatefulCmdable) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireXX", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireXX indicates an expected call of ExpireXX. +func (mr *MockStatefulCmdableMockRecorder) ExpireXX(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireXX), ctx, key, expiration) +} + +// FCall mocks base method. +func (m *MockStatefulCmdable) FCall(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCall", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCall indicates an expected call of FCall. +func (mr *MockStatefulCmdableMockRecorder) FCall(ctx, function, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCall", reflect.TypeOf((*MockStatefulCmdable)(nil).FCall), varargs...) +} + +// FCallRO mocks base method. +func (m *MockStatefulCmdable) FCallRO(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRO indicates an expected call of FCallRO. +func (mr *MockStatefulCmdableMockRecorder) FCallRO(ctx, function, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRO", reflect.TypeOf((*MockStatefulCmdable)(nil).FCallRO), varargs...) +} + +// FCallRo mocks base method. +func (m *MockStatefulCmdable) FCallRo(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRo", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRo indicates an expected call of FCallRo. +func (mr *MockStatefulCmdableMockRecorder) FCallRo(ctx, function, keys any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockStatefulCmdable)(nil).FCallRo), varargs...) +} + +// FlushAll mocks base method. +func (m *MockStatefulCmdable) FlushAll(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAll", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAll indicates an expected call of FlushAll. +func (mr *MockStatefulCmdableMockRecorder) FlushAll(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockStatefulCmdable)(nil).FlushAll), ctx) +} + +// FlushAllAsync mocks base method. +func (m *MockStatefulCmdable) FlushAllAsync(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAllAsync", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAllAsync indicates an expected call of FlushAllAsync. +func (mr *MockStatefulCmdableMockRecorder) FlushAllAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockStatefulCmdable)(nil).FlushAllAsync), ctx) +} + +// FlushDB mocks base method. +func (m *MockStatefulCmdable) FlushDB(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDB", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDB indicates an expected call of FlushDB. +func (mr *MockStatefulCmdableMockRecorder) FlushDB(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockStatefulCmdable)(nil).FlushDB), ctx) +} + +// FlushDBAsync mocks base method. +func (m *MockStatefulCmdable) FlushDBAsync(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDBAsync", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDBAsync indicates an expected call of FlushDBAsync. +func (mr *MockStatefulCmdableMockRecorder) FlushDBAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockStatefulCmdable)(nil).FlushDBAsync), ctx) +} + +// FunctionDelete mocks base method. +func (m *MockStatefulCmdable) FunctionDelete(ctx context.Context, libName string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDelete indicates an expected call of FunctionDelete. +func (mr *MockStatefulCmdableMockRecorder) FunctionDelete(ctx, libName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionDelete), ctx, libName) +} + +// FunctionDump mocks base method. +func (m *MockStatefulCmdable) FunctionDump(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDump", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDump indicates an expected call of FunctionDump. +func (mr *MockStatefulCmdableMockRecorder) FunctionDump(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionDump), ctx) +} + +// FunctionFlush mocks base method. +func (m *MockStatefulCmdable) FunctionFlush(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlush", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlush indicates an expected call of FunctionFlush. +func (mr *MockStatefulCmdableMockRecorder) FunctionFlush(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionFlush), ctx) +} + +// FunctionFlushAsync mocks base method. +func (m *MockStatefulCmdable) FunctionFlushAsync(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlushAsync", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlushAsync indicates an expected call of FunctionFlushAsync. +func (mr *MockStatefulCmdableMockRecorder) FunctionFlushAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionFlushAsync), ctx) +} + +// FunctionKill mocks base method. +func (m *MockStatefulCmdable) FunctionKill(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionKill", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionKill indicates an expected call of FunctionKill. +func (mr *MockStatefulCmdableMockRecorder) FunctionKill(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionKill), ctx) +} + +// FunctionList mocks base method. +func (m *MockStatefulCmdable) FunctionList(ctx context.Context, q redis.FunctionListQuery) *redis.FunctionListCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionList", ctx, q) + ret0, _ := ret[0].(*redis.FunctionListCmd) + return ret0 +} + +// FunctionList indicates an expected call of FunctionList. +func (mr *MockStatefulCmdableMockRecorder) FunctionList(ctx, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionList), ctx, q) +} + +// FunctionLoad mocks base method. +func (m *MockStatefulCmdable) FunctionLoad(ctx context.Context, code string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoad", ctx, code) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoad indicates an expected call of FunctionLoad. +func (mr *MockStatefulCmdableMockRecorder) FunctionLoad(ctx, code any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionLoad), ctx, code) +} + +// FunctionLoadReplace mocks base method. +func (m *MockStatefulCmdable) FunctionLoadReplace(ctx context.Context, code string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoadReplace", ctx, code) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoadReplace indicates an expected call of FunctionLoadReplace. +func (mr *MockStatefulCmdableMockRecorder) FunctionLoadReplace(ctx, code any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionLoadReplace), ctx, code) +} + +// FunctionRestore mocks base method. +func (m *MockStatefulCmdable) FunctionRestore(ctx context.Context, libDump string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionRestore", ctx, libDump) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionRestore indicates an expected call of FunctionRestore. +func (mr *MockStatefulCmdableMockRecorder) FunctionRestore(ctx, libDump any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionRestore), ctx, libDump) +} + +// FunctionStats mocks base method. +func (m *MockStatefulCmdable) FunctionStats(ctx context.Context) *redis.FunctionStatsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionStats", ctx) + ret0, _ := ret[0].(*redis.FunctionStatsCmd) + return ret0 +} + +// FunctionStats indicates an expected call of FunctionStats. +func (mr *MockStatefulCmdableMockRecorder) FunctionStats(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionStats), ctx) +} + +// GeoAdd mocks base method. +func (m *MockStatefulCmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range geoLocation { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoAdd indicates an expected call of GeoAdd. +func (mr *MockStatefulCmdableMockRecorder) GeoAdd(ctx, key any, geoLocation ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, geoLocation...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoAdd), varargs...) +} + +// GeoDist mocks base method. +func (m *MockStatefulCmdable) GeoDist(ctx context.Context, key, member1, member2, unit string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoDist", ctx, key, member1, member2, unit) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// GeoDist indicates an expected call of GeoDist. +func (mr *MockStatefulCmdableMockRecorder) GeoDist(ctx, key, member1, member2, unit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoDist), ctx, key, member1, member2, unit) +} + +// GeoHash mocks base method. +func (m *MockStatefulCmdable) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoHash", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoHash indicates an expected call of GeoHash. +func (mr *MockStatefulCmdableMockRecorder) GeoHash(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoHash", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoHash), varargs...) +} + +// GeoPos mocks base method. +func (m *MockStatefulCmdable) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoPos", varargs...) + ret0, _ := ret[0].(*redis.GeoPosCmd) + return ret0 +} + +// GeoPos indicates an expected call of GeoPos. +func (mr *MockStatefulCmdableMockRecorder) GeoPos(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoPos", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoPos), varargs...) +} + +// GeoRadius mocks base method. +func (m *MockStatefulCmdable) GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadius", ctx, key, longitude, latitude, query) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadius indicates an expected call of GeoRadius. +func (mr *MockStatefulCmdableMockRecorder) GeoRadius(ctx, key, longitude, latitude, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoRadius), ctx, key, longitude, latitude, query) +} + +// GeoRadiusByMember mocks base method. +func (m *MockStatefulCmdable) GeoRadiusByMember(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMember", ctx, key, member, query) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadiusByMember indicates an expected call of GeoRadiusByMember. +func (mr *MockStatefulCmdableMockRecorder) GeoRadiusByMember(ctx, key, member, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoRadiusByMember), ctx, key, member, query) +} + +// GeoRadiusByMemberStore mocks base method. +func (m *MockStatefulCmdable) GeoRadiusByMemberStore(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", ctx, key, member, query) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusByMemberStore indicates an expected call of GeoRadiusByMemberStore. +func (mr *MockStatefulCmdableMockRecorder) GeoRadiusByMemberStore(ctx, key, member, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoRadiusByMemberStore), ctx, key, member, query) +} + +// GeoRadiusStore mocks base method. +func (m *MockStatefulCmdable) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusStore", ctx, key, longitude, latitude, query) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusStore indicates an expected call of GeoRadiusStore. +func (mr *MockStatefulCmdableMockRecorder) GeoRadiusStore(ctx, key, longitude, latitude, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoRadiusStore), ctx, key, longitude, latitude, query) +} + +// GeoSearch mocks base method. +func (m *MockStatefulCmdable) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearch", ctx, key, q) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoSearch indicates an expected call of GeoSearch. +func (mr *MockStatefulCmdableMockRecorder) GeoSearch(ctx, key, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoSearch), ctx, key, q) +} + +// GeoSearchLocation mocks base method. +func (m *MockStatefulCmdable) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchLocation", ctx, key, q) + ret0, _ := ret[0].(*redis.GeoSearchLocationCmd) + return ret0 +} + +// GeoSearchLocation indicates an expected call of GeoSearchLocation. +func (mr *MockStatefulCmdableMockRecorder) GeoSearchLocation(ctx, key, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoSearchLocation), ctx, key, q) +} + +// GeoSearchStore mocks base method. +func (m *MockStatefulCmdable) GeoSearchStore(ctx context.Context, key, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchStore", ctx, key, store, q) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoSearchStore indicates an expected call of GeoSearchStore. +func (mr *MockStatefulCmdableMockRecorder) GeoSearchStore(ctx, key, store, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoSearchStore), ctx, key, store, q) +} + +// Get mocks base method. +func (m *MockStatefulCmdable) Get(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Get indicates an expected call of Get. +func (mr *MockStatefulCmdableMockRecorder) Get(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStatefulCmdable)(nil).Get), ctx, key) +} + +// GetBit mocks base method. +func (m *MockStatefulCmdable) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBit", ctx, key, offset) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GetBit indicates an expected call of GetBit. +func (mr *MockStatefulCmdableMockRecorder) GetBit(ctx, key, offset any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockStatefulCmdable)(nil).GetBit), ctx, key, offset) +} + +// GetDel mocks base method. +func (m *MockStatefulCmdable) GetDel(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDel", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetDel indicates an expected call of GetDel. +func (mr *MockStatefulCmdableMockRecorder) GetDel(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockStatefulCmdable)(nil).GetDel), ctx, key) +} + +// GetEx mocks base method. +func (m *MockStatefulCmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEx", ctx, key, expiration) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetEx indicates an expected call of GetEx. +func (mr *MockStatefulCmdableMockRecorder) GetEx(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockStatefulCmdable)(nil).GetEx), ctx, key, expiration) +} + +// GetRange mocks base method. +func (m *MockStatefulCmdable) GetRange(ctx context.Context, key string, start, end int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRange", ctx, key, start, end) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetRange indicates an expected call of GetRange. +func (mr *MockStatefulCmdableMockRecorder) GetRange(ctx, key, start, end any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockStatefulCmdable)(nil).GetRange), ctx, key, start, end) +} + +// GetSet mocks base method. +func (m *MockStatefulCmdable) GetSet(ctx context.Context, key string, value any) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSet", ctx, key, value) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetSet indicates an expected call of GetSet. +func (mr *MockStatefulCmdableMockRecorder) GetSet(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockStatefulCmdable)(nil).GetSet), ctx, key, value) +} + +// HDel mocks base method. +func (m *MockStatefulCmdable) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HDel indicates an expected call of HDel. +func (mr *MockStatefulCmdableMockRecorder) HDel(ctx, key any, fields ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockStatefulCmdable)(nil).HDel), varargs...) +} + +// HExists mocks base method. +func (m *MockStatefulCmdable) HExists(ctx context.Context, key, field string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HExists", ctx, key, field) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HExists indicates an expected call of HExists. +func (mr *MockStatefulCmdableMockRecorder) HExists(ctx, key, field any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockStatefulCmdable)(nil).HExists), ctx, key, field) +} + +// HGet mocks base method. +func (m *MockStatefulCmdable) HGet(ctx context.Context, key, field string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGet", ctx, key, field) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// HGet indicates an expected call of HGet. +func (mr *MockStatefulCmdableMockRecorder) HGet(ctx, key, field any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockStatefulCmdable)(nil).HGet), ctx, key, field) +} + +// HGetAll mocks base method. +func (m *MockStatefulCmdable) HGetAll(ctx context.Context, key string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGetAll", ctx, key) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// HGetAll indicates an expected call of HGetAll. +func (mr *MockStatefulCmdableMockRecorder) HGetAll(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockStatefulCmdable)(nil).HGetAll), ctx, key) +} + +// HIncrBy mocks base method. +func (m *MockStatefulCmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrBy", ctx, key, field, incr) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HIncrBy indicates an expected call of HIncrBy. +func (mr *MockStatefulCmdableMockRecorder) HIncrBy(ctx, key, field, incr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).HIncrBy), ctx, key, field, incr) +} + +// HIncrByFloat mocks base method. +func (m *MockStatefulCmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrByFloat", ctx, key, field, incr) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// HIncrByFloat indicates an expected call of HIncrByFloat. +func (mr *MockStatefulCmdableMockRecorder) HIncrByFloat(ctx, key, field, incr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockStatefulCmdable)(nil).HIncrByFloat), ctx, key, field, incr) +} + +// HKeys mocks base method. +func (m *MockStatefulCmdable) HKeys(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HKeys", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HKeys indicates an expected call of HKeys. +func (mr *MockStatefulCmdableMockRecorder) HKeys(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockStatefulCmdable)(nil).HKeys), ctx, key) +} + +// HLen mocks base method. +func (m *MockStatefulCmdable) HLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HLen indicates an expected call of HLen. +func (mr *MockStatefulCmdableMockRecorder) HLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockStatefulCmdable)(nil).HLen), ctx, key) +} + +// HMGet mocks base method. +func (m *MockStatefulCmdable) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// HMGet indicates an expected call of HMGet. +func (mr *MockStatefulCmdableMockRecorder) HMGet(ctx, key any, fields ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMGet", reflect.TypeOf((*MockStatefulCmdable)(nil).HMGet), varargs...) +} + +// HMSet mocks base method. +func (m *MockStatefulCmdable) HMSet(ctx context.Context, key string, values ...any) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMSet", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HMSet indicates an expected call of HMSet. +func (mr *MockStatefulCmdableMockRecorder) HMSet(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockStatefulCmdable)(nil).HMSet), varargs...) +} + +// HRandField mocks base method. +func (m *MockStatefulCmdable) HRandField(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandField", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HRandField indicates an expected call of HRandField. +func (mr *MockStatefulCmdableMockRecorder) HRandField(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockStatefulCmdable)(nil).HRandField), ctx, key, count) +} + +// HRandFieldWithValues mocks base method. +func (m *MockStatefulCmdable) HRandFieldWithValues(ctx context.Context, key string, count int) *redis.KeyValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandFieldWithValues", ctx, key, count) + ret0, _ := ret[0].(*redis.KeyValueSliceCmd) + return ret0 +} + +// HRandFieldWithValues indicates an expected call of HRandFieldWithValues. +func (mr *MockStatefulCmdableMockRecorder) HRandFieldWithValues(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockStatefulCmdable)(nil).HRandFieldWithValues), ctx, key, count) +} + +// HScan mocks base method. +func (m *MockStatefulCmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// HScan indicates an expected call of HScan. +func (mr *MockStatefulCmdableMockRecorder) HScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockStatefulCmdable)(nil).HScan), ctx, key, cursor, match, count) +} + +// HSet mocks base method. +func (m *MockStatefulCmdable) HSet(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HSet", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HSet indicates an expected call of HSet. +func (mr *MockStatefulCmdableMockRecorder) HSet(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockStatefulCmdable)(nil).HSet), varargs...) +} + +// HSetNX mocks base method. +func (m *MockStatefulCmdable) HSetNX(ctx context.Context, key, field string, value any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HSetNX", ctx, key, field, value) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HSetNX indicates an expected call of HSetNX. +func (mr *MockStatefulCmdableMockRecorder) HSetNX(ctx, key, field, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockStatefulCmdable)(nil).HSetNX), ctx, key, field, value) +} + +// HVals mocks base method. +func (m *MockStatefulCmdable) HVals(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HVals", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HVals indicates an expected call of HVals. +func (mr *MockStatefulCmdableMockRecorder) HVals(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockStatefulCmdable)(nil).HVals), ctx, key) +} + +// Hello mocks base method. +func (m *MockStatefulCmdable) Hello(ctx context.Context, ver int, username, password, clientName string) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Hello", ctx, ver, username, password, clientName) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// Hello indicates an expected call of Hello. +func (mr *MockStatefulCmdableMockRecorder) Hello(ctx, ver, username, password, clientName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hello", reflect.TypeOf((*MockStatefulCmdable)(nil).Hello), ctx, ver, username, password, clientName) +} + +// Incr mocks base method. +func (m *MockStatefulCmdable) Incr(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Incr", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Incr indicates an expected call of Incr. +func (mr *MockStatefulCmdableMockRecorder) Incr(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockStatefulCmdable)(nil).Incr), ctx, key) +} + +// IncrBy mocks base method. +func (m *MockStatefulCmdable) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrBy", ctx, key, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// IncrBy indicates an expected call of IncrBy. +func (mr *MockStatefulCmdableMockRecorder) IncrBy(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).IncrBy), ctx, key, value) +} + +// IncrByFloat mocks base method. +func (m *MockStatefulCmdable) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrByFloat", ctx, key, value) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// IncrByFloat indicates an expected call of IncrByFloat. +func (mr *MockStatefulCmdableMockRecorder) IncrByFloat(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockStatefulCmdable)(nil).IncrByFloat), ctx, key, value) +} + +// Info mocks base method. +func (m *MockStatefulCmdable) Info(ctx context.Context, section ...string) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range section { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Info", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Info indicates an expected call of Info. +func (mr *MockStatefulCmdableMockRecorder) Info(ctx any, section ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, section...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockStatefulCmdable)(nil).Info), varargs...) +} + +// Keys mocks base method. +func (m *MockStatefulCmdable) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Keys", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Keys indicates an expected call of Keys. +func (mr *MockStatefulCmdableMockRecorder) Keys(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockStatefulCmdable)(nil).Keys), ctx, pattern) +} + +// LCS mocks base method. +func (m *MockStatefulCmdable) LCS(ctx context.Context, q *redis.LCSQuery) *redis.LCSCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LCS", ctx, q) + ret0, _ := ret[0].(*redis.LCSCmd) + return ret0 +} + +// LCS indicates an expected call of LCS. +func (mr *MockStatefulCmdableMockRecorder) LCS(ctx, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockStatefulCmdable)(nil).LCS), ctx, q) +} + +// LIndex mocks base method. +func (m *MockStatefulCmdable) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LIndex", ctx, key, index) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LIndex indicates an expected call of LIndex. +func (mr *MockStatefulCmdableMockRecorder) LIndex(ctx, key, index any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockStatefulCmdable)(nil).LIndex), ctx, key, index) +} + +// LInsert mocks base method. +func (m *MockStatefulCmdable) LInsert(ctx context.Context, key, op string, pivot, value any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsert", ctx, key, op, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsert indicates an expected call of LInsert. +func (mr *MockStatefulCmdableMockRecorder) LInsert(ctx, key, op, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockStatefulCmdable)(nil).LInsert), ctx, key, op, pivot, value) +} + +// LInsertAfter mocks base method. +func (m *MockStatefulCmdable) LInsertAfter(ctx context.Context, key string, pivot, value any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertAfter", ctx, key, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertAfter indicates an expected call of LInsertAfter. +func (mr *MockStatefulCmdableMockRecorder) LInsertAfter(ctx, key, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockStatefulCmdable)(nil).LInsertAfter), ctx, key, pivot, value) +} + +// LInsertBefore mocks base method. +func (m *MockStatefulCmdable) LInsertBefore(ctx context.Context, key string, pivot, value any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertBefore", ctx, key, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertBefore indicates an expected call of LInsertBefore. +func (mr *MockStatefulCmdableMockRecorder) LInsertBefore(ctx, key, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockStatefulCmdable)(nil).LInsertBefore), ctx, key, pivot, value) +} + +// LLen mocks base method. +func (m *MockStatefulCmdable) LLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LLen indicates an expected call of LLen. +func (mr *MockStatefulCmdableMockRecorder) LLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockStatefulCmdable)(nil).LLen), ctx, key) +} + +// LMPop mocks base method. +func (m *MockStatefulCmdable) LMPop(ctx context.Context, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, direction, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// LMPop indicates an expected call of LMPop. +func (mr *MockStatefulCmdableMockRecorder) LMPop(ctx, direction, count any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, direction, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMPop", reflect.TypeOf((*MockStatefulCmdable)(nil).LMPop), varargs...) +} + +// LMove mocks base method. +func (m *MockStatefulCmdable) LMove(ctx context.Context, source, destination, srcpos, destpos string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LMove", ctx, source, destination, srcpos, destpos) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LMove indicates an expected call of LMove. +func (mr *MockStatefulCmdableMockRecorder) LMove(ctx, source, destination, srcpos, destpos any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockStatefulCmdable)(nil).LMove), ctx, source, destination, srcpos, destpos) +} + +// LPop mocks base method. +func (m *MockStatefulCmdable) LPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LPop indicates an expected call of LPop. +func (mr *MockStatefulCmdableMockRecorder) LPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockStatefulCmdable)(nil).LPop), ctx, key) +} + +// LPopCount mocks base method. +func (m *MockStatefulCmdable) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPopCount", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LPopCount indicates an expected call of LPopCount. +func (mr *MockStatefulCmdableMockRecorder) LPopCount(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockStatefulCmdable)(nil).LPopCount), ctx, key, count) +} + +// LPos mocks base method. +func (m *MockStatefulCmdable) LPos(ctx context.Context, key, value string, args redis.LPosArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPos", ctx, key, value, args) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPos indicates an expected call of LPos. +func (mr *MockStatefulCmdableMockRecorder) LPos(ctx, key, value, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockStatefulCmdable)(nil).LPos), ctx, key, value, args) +} + +// LPosCount mocks base method. +func (m *MockStatefulCmdable) LPosCount(ctx context.Context, key, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPosCount", ctx, key, value, count, args) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// LPosCount indicates an expected call of LPosCount. +func (mr *MockStatefulCmdableMockRecorder) LPosCount(ctx, key, value, count, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockStatefulCmdable)(nil).LPosCount), ctx, key, value, count, args) +} + +// LPush mocks base method. +func (m *MockStatefulCmdable) LPush(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPush indicates an expected call of LPush. +func (mr *MockStatefulCmdableMockRecorder) LPush(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockStatefulCmdable)(nil).LPush), varargs...) +} + +// LPushX mocks base method. +func (m *MockStatefulCmdable) LPushX(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPushX indicates an expected call of LPushX. +func (mr *MockStatefulCmdableMockRecorder) LPushX(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockStatefulCmdable)(nil).LPushX), varargs...) +} + +// LRange mocks base method. +func (m *MockStatefulCmdable) LRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LRange indicates an expected call of LRange. +func (mr *MockStatefulCmdableMockRecorder) LRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockStatefulCmdable)(nil).LRange), ctx, key, start, stop) +} + +// LRem mocks base method. +func (m *MockStatefulCmdable) LRem(ctx context.Context, key string, count int64, value any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRem", ctx, key, count, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LRem indicates an expected call of LRem. +func (mr *MockStatefulCmdableMockRecorder) LRem(ctx, key, count, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockStatefulCmdable)(nil).LRem), ctx, key, count, value) +} + +// LSet mocks base method. +func (m *MockStatefulCmdable) LSet(ctx context.Context, key string, index int64, value any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LSet", ctx, key, index, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LSet indicates an expected call of LSet. +func (mr *MockStatefulCmdableMockRecorder) LSet(ctx, key, index, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockStatefulCmdable)(nil).LSet), ctx, key, index, value) +} + +// LTrim mocks base method. +func (m *MockStatefulCmdable) LTrim(ctx context.Context, key string, start, stop int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LTrim", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LTrim indicates an expected call of LTrim. +func (mr *MockStatefulCmdableMockRecorder) LTrim(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockStatefulCmdable)(nil).LTrim), ctx, key, start, stop) +} + +// LastSave mocks base method. +func (m *MockStatefulCmdable) LastSave(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LastSave", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LastSave indicates an expected call of LastSave. +func (mr *MockStatefulCmdableMockRecorder) LastSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockStatefulCmdable)(nil).LastSave), ctx) +} + +// MGet mocks base method. +func (m *MockStatefulCmdable) MGet(ctx context.Context, keys ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// MGet indicates an expected call of MGet. +func (mr *MockStatefulCmdableMockRecorder) MGet(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockStatefulCmdable)(nil).MGet), varargs...) +} + +// MSet mocks base method. +func (m *MockStatefulCmdable) MSet(ctx context.Context, values ...any) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSet", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// MSet indicates an expected call of MSet. +func (mr *MockStatefulCmdableMockRecorder) MSet(ctx any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockStatefulCmdable)(nil).MSet), varargs...) +} + +// MSetNX mocks base method. +func (m *MockStatefulCmdable) MSetNX(ctx context.Context, values ...any) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSetNX", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// MSetNX indicates an expected call of MSetNX. +func (mr *MockStatefulCmdableMockRecorder) MSetNX(ctx any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSetNX", reflect.TypeOf((*MockStatefulCmdable)(nil).MSetNX), varargs...) +} + +// MemoryUsage mocks base method. +func (m *MockStatefulCmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range samples { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MemoryUsage", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// MemoryUsage indicates an expected call of MemoryUsage. +func (mr *MockStatefulCmdableMockRecorder) MemoryUsage(ctx, key any, samples ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, samples...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemoryUsage", reflect.TypeOf((*MockStatefulCmdable)(nil).MemoryUsage), varargs...) +} + +// Migrate mocks base method. +func (m *MockStatefulCmdable) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Migrate", ctx, host, port, key, db, timeout) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Migrate indicates an expected call of Migrate. +func (mr *MockStatefulCmdableMockRecorder) Migrate(ctx, host, port, key, db, timeout any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockStatefulCmdable)(nil).Migrate), ctx, host, port, key, db, timeout) +} + +// ModuleLoadex mocks base method. +func (m *MockStatefulCmdable) ModuleLoadex(ctx context.Context, conf *redis.ModuleLoadexConfig) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModuleLoadex", ctx, conf) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ModuleLoadex indicates an expected call of ModuleLoadex. +func (mr *MockStatefulCmdableMockRecorder) ModuleLoadex(ctx, conf any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockStatefulCmdable)(nil).ModuleLoadex), ctx, conf) +} + +// Move mocks base method. +func (m *MockStatefulCmdable) Move(ctx context.Context, key string, db int) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Move", ctx, key, db) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Move indicates an expected call of Move. +func (mr *MockStatefulCmdableMockRecorder) Move(ctx, key, db any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockStatefulCmdable)(nil).Move), ctx, key, db) +} + +// ObjectEncoding mocks base method. +func (m *MockStatefulCmdable) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectEncoding", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ObjectEncoding indicates an expected call of ObjectEncoding. +func (mr *MockStatefulCmdableMockRecorder) ObjectEncoding(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockStatefulCmdable)(nil).ObjectEncoding), ctx, key) +} + +// ObjectIdleTime mocks base method. +func (m *MockStatefulCmdable) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectIdleTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ObjectIdleTime indicates an expected call of ObjectIdleTime. +func (mr *MockStatefulCmdableMockRecorder) ObjectIdleTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockStatefulCmdable)(nil).ObjectIdleTime), ctx, key) +} + +// ObjectRefCount mocks base method. +func (m *MockStatefulCmdable) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectRefCount", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ObjectRefCount indicates an expected call of ObjectRefCount. +func (mr *MockStatefulCmdableMockRecorder) ObjectRefCount(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockStatefulCmdable)(nil).ObjectRefCount), ctx, key) +} + +// PExpire mocks base method. +func (m *MockStatefulCmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpire", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpire indicates an expected call of PExpire. +func (mr *MockStatefulCmdableMockRecorder) PExpire(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockStatefulCmdable)(nil).PExpire), ctx, key, expiration) +} + +// PExpireAt mocks base method. +func (m *MockStatefulCmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireAt", ctx, key, tm) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpireAt indicates an expected call of PExpireAt. +func (mr *MockStatefulCmdableMockRecorder) PExpireAt(ctx, key, tm any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockStatefulCmdable)(nil).PExpireAt), ctx, key, tm) +} + +// PExpireTime mocks base method. +func (m *MockStatefulCmdable) PExpireTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PExpireTime indicates an expected call of PExpireTime. +func (mr *MockStatefulCmdableMockRecorder) PExpireTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockStatefulCmdable)(nil).PExpireTime), ctx, key) +} + +// PFAdd mocks base method. +func (m *MockStatefulCmdable) PFAdd(ctx context.Context, key string, els ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range els { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFAdd indicates an expected call of PFAdd. +func (mr *MockStatefulCmdableMockRecorder) PFAdd(ctx, key any, els ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, els...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).PFAdd), varargs...) +} + +// PFCount mocks base method. +func (m *MockStatefulCmdable) PFCount(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFCount", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFCount indicates an expected call of PFCount. +func (mr *MockStatefulCmdableMockRecorder) PFCount(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockStatefulCmdable)(nil).PFCount), varargs...) +} + +// PFMerge mocks base method. +func (m *MockStatefulCmdable) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, dest} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// PFMerge indicates an expected call of PFMerge. +func (mr *MockStatefulCmdableMockRecorder) PFMerge(ctx, dest any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, dest}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFMerge", reflect.TypeOf((*MockStatefulCmdable)(nil).PFMerge), varargs...) +} + +// PTTL mocks base method. +func (m *MockStatefulCmdable) PTTL(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PTTL", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PTTL indicates an expected call of PTTL. +func (mr *MockStatefulCmdableMockRecorder) PTTL(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockStatefulCmdable)(nil).PTTL), ctx, key) +} + +// Persist mocks base method. +func (m *MockStatefulCmdable) Persist(ctx context.Context, key string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Persist", ctx, key) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Persist indicates an expected call of Persist. +func (mr *MockStatefulCmdableMockRecorder) Persist(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockStatefulCmdable)(nil).Persist), ctx, key) +} + +// Ping mocks base method. +func (m *MockStatefulCmdable) Ping(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Ping", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Ping indicates an expected call of Ping. +func (mr *MockStatefulCmdableMockRecorder) Ping(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockStatefulCmdable)(nil).Ping), ctx) +} + +// Pipeline mocks base method. +func (m *MockStatefulCmdable) Pipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// Pipeline indicates an expected call of Pipeline. +func (mr *MockStatefulCmdableMockRecorder) Pipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockStatefulCmdable)(nil).Pipeline)) +} + +// Pipelined mocks base method. +func (m *MockStatefulCmdable) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipelined", ctx, fn) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Pipelined indicates an expected call of Pipelined. +func (mr *MockStatefulCmdableMockRecorder) Pipelined(ctx, fn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockStatefulCmdable)(nil).Pipelined), ctx, fn) +} + +// PubSubChannels mocks base method. +func (m *MockStatefulCmdable) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubChannels", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubChannels indicates an expected call of PubSubChannels. +func (mr *MockStatefulCmdableMockRecorder) PubSubChannels(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockStatefulCmdable)(nil).PubSubChannels), ctx, pattern) +} + +// PubSubNumPat mocks base method. +func (m *MockStatefulCmdable) PubSubNumPat(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubNumPat", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PubSubNumPat indicates an expected call of PubSubNumPat. +func (mr *MockStatefulCmdableMockRecorder) PubSubNumPat(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockStatefulCmdable)(nil).PubSubNumPat), ctx) +} + +// PubSubNumSub mocks base method. +func (m *MockStatefulCmdable) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubNumSub indicates an expected call of PubSubNumSub. +func (mr *MockStatefulCmdableMockRecorder) PubSubNumSub(ctx any, channels ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockStatefulCmdable)(nil).PubSubNumSub), varargs...) +} + +// PubSubShardChannels mocks base method. +func (m *MockStatefulCmdable) PubSubShardChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubShardChannels", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubShardChannels indicates an expected call of PubSubShardChannels. +func (mr *MockStatefulCmdableMockRecorder) PubSubShardChannels(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockStatefulCmdable)(nil).PubSubShardChannels), ctx, pattern) +} + +// PubSubShardNumSub mocks base method. +func (m *MockStatefulCmdable) PubSubShardNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubShardNumSub indicates an expected call of PubSubShardNumSub. +func (mr *MockStatefulCmdableMockRecorder) PubSubShardNumSub(ctx any, channels ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockStatefulCmdable)(nil).PubSubShardNumSub), varargs...) +} + +// Publish mocks base method. +func (m *MockStatefulCmdable) Publish(ctx context.Context, channel string, message any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Publish", ctx, channel, message) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Publish indicates an expected call of Publish. +func (mr *MockStatefulCmdableMockRecorder) Publish(ctx, channel, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockStatefulCmdable)(nil).Publish), ctx, channel, message) +} + +// Quit mocks base method. +func (m *MockStatefulCmdable) Quit(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Quit", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Quit indicates an expected call of Quit. +func (mr *MockStatefulCmdableMockRecorder) Quit(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockStatefulCmdable)(nil).Quit), ctx) +} + +// RPop mocks base method. +func (m *MockStatefulCmdable) RPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPop indicates an expected call of RPop. +func (mr *MockStatefulCmdableMockRecorder) RPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockStatefulCmdable)(nil).RPop), ctx, key) +} + +// RPopCount mocks base method. +func (m *MockStatefulCmdable) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopCount", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// RPopCount indicates an expected call of RPopCount. +func (mr *MockStatefulCmdableMockRecorder) RPopCount(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockStatefulCmdable)(nil).RPopCount), ctx, key, count) +} + +// RPopLPush mocks base method. +func (m *MockStatefulCmdable) RPopLPush(ctx context.Context, source, destination string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopLPush", ctx, source, destination) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPopLPush indicates an expected call of RPopLPush. +func (mr *MockStatefulCmdableMockRecorder) RPopLPush(ctx, source, destination any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockStatefulCmdable)(nil).RPopLPush), ctx, source, destination) +} + +// RPush mocks base method. +func (m *MockStatefulCmdable) RPush(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPush indicates an expected call of RPush. +func (mr *MockStatefulCmdableMockRecorder) RPush(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockStatefulCmdable)(nil).RPush), varargs...) +} + +// RPushX mocks base method. +func (m *MockStatefulCmdable) RPushX(ctx context.Context, key string, values ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPushX indicates an expected call of RPushX. +func (mr *MockStatefulCmdableMockRecorder) RPushX(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockStatefulCmdable)(nil).RPushX), varargs...) +} + +// RandomKey mocks base method. +func (m *MockStatefulCmdable) RandomKey(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RandomKey", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RandomKey indicates an expected call of RandomKey. +func (mr *MockStatefulCmdableMockRecorder) RandomKey(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockStatefulCmdable)(nil).RandomKey), ctx) +} + +// ReadOnly mocks base method. +func (m *MockStatefulCmdable) ReadOnly(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadOnly", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadOnly indicates an expected call of ReadOnly. +func (mr *MockStatefulCmdableMockRecorder) ReadOnly(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockStatefulCmdable)(nil).ReadOnly), ctx) +} + +// ReadWrite mocks base method. +func (m *MockStatefulCmdable) ReadWrite(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadWrite", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadWrite indicates an expected call of ReadWrite. +func (mr *MockStatefulCmdableMockRecorder) ReadWrite(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockStatefulCmdable)(nil).ReadWrite), ctx) +} + +// Rename mocks base method. +func (m *MockStatefulCmdable) Rename(ctx context.Context, key, newkey string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Rename", ctx, key, newkey) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Rename indicates an expected call of Rename. +func (mr *MockStatefulCmdableMockRecorder) Rename(ctx, key, newkey any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockStatefulCmdable)(nil).Rename), ctx, key, newkey) +} + +// RenameNX mocks base method. +func (m *MockStatefulCmdable) RenameNX(ctx context.Context, key, newkey string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RenameNX", ctx, key, newkey) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// RenameNX indicates an expected call of RenameNX. +func (mr *MockStatefulCmdableMockRecorder) RenameNX(ctx, key, newkey any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockStatefulCmdable)(nil).RenameNX), ctx, key, newkey) +} + +// Restore mocks base method. +func (m *MockStatefulCmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Restore", ctx, key, ttl, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Restore indicates an expected call of Restore. +func (mr *MockStatefulCmdableMockRecorder) Restore(ctx, key, ttl, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockStatefulCmdable)(nil).Restore), ctx, key, ttl, value) +} + +// RestoreReplace mocks base method. +func (m *MockStatefulCmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreReplace", ctx, key, ttl, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// RestoreReplace indicates an expected call of RestoreReplace. +func (mr *MockStatefulCmdableMockRecorder) RestoreReplace(ctx, key, ttl, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockStatefulCmdable)(nil).RestoreReplace), ctx, key, ttl, value) +} + +// SAdd mocks base method. +func (m *MockStatefulCmdable) SAdd(ctx context.Context, key string, members ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SAdd indicates an expected call of SAdd. +func (mr *MockStatefulCmdableMockRecorder) SAdd(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).SAdd), varargs...) +} + +// SCard mocks base method. +func (m *MockStatefulCmdable) SCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SCard indicates an expected call of SCard. +func (mr *MockStatefulCmdableMockRecorder) SCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockStatefulCmdable)(nil).SCard), ctx, key) +} + +// SDiff mocks base method. +func (m *MockStatefulCmdable) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SDiff indicates an expected call of SDiff. +func (mr *MockStatefulCmdableMockRecorder) SDiff(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockStatefulCmdable)(nil).SDiff), varargs...) +} + +// SDiffStore mocks base method. +func (m *MockStatefulCmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SDiffStore indicates an expected call of SDiffStore. +func (mr *MockStatefulCmdableMockRecorder) SDiffStore(ctx, destination any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockStatefulCmdable)(nil).SDiffStore), varargs...) +} + +// SInter mocks base method. +func (m *MockStatefulCmdable) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInter", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SInter indicates an expected call of SInter. +func (mr *MockStatefulCmdableMockRecorder) SInter(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockStatefulCmdable)(nil).SInter), varargs...) +} + +// SInterCard mocks base method. +func (m *MockStatefulCmdable) SInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, limit} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterCard indicates an expected call of SInterCard. +func (mr *MockStatefulCmdableMockRecorder) SInterCard(ctx, limit any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, limit}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterCard", reflect.TypeOf((*MockStatefulCmdable)(nil).SInterCard), varargs...) +} + +// SInterStore mocks base method. +func (m *MockStatefulCmdable) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterStore indicates an expected call of SInterStore. +func (mr *MockStatefulCmdableMockRecorder) SInterStore(ctx, destination any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockStatefulCmdable)(nil).SInterStore), varargs...) +} + +// SIsMember mocks base method. +func (m *MockStatefulCmdable) SIsMember(ctx context.Context, key string, member any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SIsMember", ctx, key, member) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SIsMember indicates an expected call of SIsMember. +func (mr *MockStatefulCmdableMockRecorder) SIsMember(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockStatefulCmdable)(nil).SIsMember), ctx, key, member) +} + +// SMIsMember mocks base method. +func (m *MockStatefulCmdable) SMIsMember(ctx context.Context, key string, members ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SMIsMember", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// SMIsMember indicates an expected call of SMIsMember. +func (mr *MockStatefulCmdableMockRecorder) SMIsMember(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockStatefulCmdable)(nil).SMIsMember), varargs...) +} + +// SMembers mocks base method. +func (m *MockStatefulCmdable) SMembers(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembers", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SMembers indicates an expected call of SMembers. +func (mr *MockStatefulCmdableMockRecorder) SMembers(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockStatefulCmdable)(nil).SMembers), ctx, key) +} + +// SMembersMap mocks base method. +func (m *MockStatefulCmdable) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembersMap", ctx, key) + ret0, _ := ret[0].(*redis.StringStructMapCmd) + return ret0 +} + +// SMembersMap indicates an expected call of SMembersMap. +func (mr *MockStatefulCmdableMockRecorder) SMembersMap(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockStatefulCmdable)(nil).SMembersMap), ctx, key) +} + +// SMove mocks base method. +func (m *MockStatefulCmdable) SMove(ctx context.Context, source, destination string, member any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMove", ctx, source, destination, member) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SMove indicates an expected call of SMove. +func (mr *MockStatefulCmdableMockRecorder) SMove(ctx, source, destination, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockStatefulCmdable)(nil).SMove), ctx, source, destination, member) +} + +// SPop mocks base method. +func (m *MockStatefulCmdable) SPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SPop indicates an expected call of SPop. +func (mr *MockStatefulCmdableMockRecorder) SPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockStatefulCmdable)(nil).SPop), ctx, key) +} + +// SPopN mocks base method. +func (m *MockStatefulCmdable) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPopN", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SPopN indicates an expected call of SPopN. +func (mr *MockStatefulCmdableMockRecorder) SPopN(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockStatefulCmdable)(nil).SPopN), ctx, key, count) +} + +// SPublish mocks base method. +func (m *MockStatefulCmdable) SPublish(ctx context.Context, channel string, message any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPublish", ctx, channel, message) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SPublish indicates an expected call of SPublish. +func (mr *MockStatefulCmdableMockRecorder) SPublish(ctx, channel, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockStatefulCmdable)(nil).SPublish), ctx, channel, message) +} + +// SRandMember mocks base method. +func (m *MockStatefulCmdable) SRandMember(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMember", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SRandMember indicates an expected call of SRandMember. +func (mr *MockStatefulCmdableMockRecorder) SRandMember(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockStatefulCmdable)(nil).SRandMember), ctx, key) +} + +// SRandMemberN mocks base method. +func (m *MockStatefulCmdable) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMemberN", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SRandMemberN indicates an expected call of SRandMemberN. +func (mr *MockStatefulCmdableMockRecorder) SRandMemberN(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockStatefulCmdable)(nil).SRandMemberN), ctx, key, count) +} + +// SRem mocks base method. +func (m *MockStatefulCmdable) SRem(ctx context.Context, key string, members ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SRem indicates an expected call of SRem. +func (mr *MockStatefulCmdableMockRecorder) SRem(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockStatefulCmdable)(nil).SRem), varargs...) +} + +// SScan mocks base method. +func (m *MockStatefulCmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// SScan indicates an expected call of SScan. +func (mr *MockStatefulCmdableMockRecorder) SScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockStatefulCmdable)(nil).SScan), ctx, key, cursor, match, count) +} + +// SUnion mocks base method. +func (m *MockStatefulCmdable) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnion", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SUnion indicates an expected call of SUnion. +func (mr *MockStatefulCmdableMockRecorder) SUnion(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockStatefulCmdable)(nil).SUnion), varargs...) +} + +// SUnionStore mocks base method. +func (m *MockStatefulCmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnionStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SUnionStore indicates an expected call of SUnionStore. +func (mr *MockStatefulCmdableMockRecorder) SUnionStore(ctx, destination any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockStatefulCmdable)(nil).SUnionStore), varargs...) +} + +// Save mocks base method. +func (m *MockStatefulCmdable) Save(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Save indicates an expected call of Save. +func (mr *MockStatefulCmdableMockRecorder) Save(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStatefulCmdable)(nil).Save), ctx) +} + +// Scan mocks base method. +func (m *MockStatefulCmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Scan", ctx, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// Scan indicates an expected call of Scan. +func (mr *MockStatefulCmdableMockRecorder) Scan(ctx, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockStatefulCmdable)(nil).Scan), ctx, cursor, match, count) +} + +// ScanType mocks base method. +func (m *MockStatefulCmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScanType", ctx, cursor, match, count, keyType) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ScanType indicates an expected call of ScanType. +func (mr *MockStatefulCmdableMockRecorder) ScanType(ctx, cursor, match, count, keyType any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockStatefulCmdable)(nil).ScanType), ctx, cursor, match, count, keyType) +} + +// ScriptExists mocks base method. +func (m *MockStatefulCmdable) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range hashes { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ScriptExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// ScriptExists indicates an expected call of ScriptExists. +func (mr *MockStatefulCmdableMockRecorder) ScriptExists(ctx any, hashes ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, hashes...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockStatefulCmdable)(nil).ScriptExists), varargs...) +} + +// ScriptFlush mocks base method. +func (m *MockStatefulCmdable) ScriptFlush(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptFlush", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptFlush indicates an expected call of ScriptFlush. +func (mr *MockStatefulCmdableMockRecorder) ScriptFlush(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockStatefulCmdable)(nil).ScriptFlush), ctx) +} + +// ScriptKill mocks base method. +func (m *MockStatefulCmdable) ScriptKill(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptKill", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptKill indicates an expected call of ScriptKill. +func (mr *MockStatefulCmdableMockRecorder) ScriptKill(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockStatefulCmdable)(nil).ScriptKill), ctx) +} + +// ScriptLoad mocks base method. +func (m *MockStatefulCmdable) ScriptLoad(ctx context.Context, script string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptLoad", ctx, script) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ScriptLoad indicates an expected call of ScriptLoad. +func (mr *MockStatefulCmdableMockRecorder) ScriptLoad(ctx, script any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockStatefulCmdable)(nil).ScriptLoad), ctx, script) +} + +// Select mocks base method. +func (m *MockStatefulCmdable) Select(ctx context.Context, index int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Select", ctx, index) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Select indicates an expected call of Select. +func (mr *MockStatefulCmdableMockRecorder) Select(ctx, index any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Select", reflect.TypeOf((*MockStatefulCmdable)(nil).Select), ctx, index) +} + +// Set mocks base method. +func (m *MockStatefulCmdable) Set(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockStatefulCmdableMockRecorder) Set(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStatefulCmdable)(nil).Set), ctx, key, value, expiration) +} + +// SetArgs mocks base method. +func (m *MockStatefulCmdable) SetArgs(ctx context.Context, key string, value any, a redis.SetArgs) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetArgs", ctx, key, value, a) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetArgs indicates an expected call of SetArgs. +func (mr *MockStatefulCmdableMockRecorder) SetArgs(ctx, key, value, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).SetArgs), ctx, key, value, a) +} + +// SetBit mocks base method. +func (m *MockStatefulCmdable) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetBit", ctx, key, offset, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetBit indicates an expected call of SetBit. +func (mr *MockStatefulCmdableMockRecorder) SetBit(ctx, key, offset, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockStatefulCmdable)(nil).SetBit), ctx, key, offset, value) +} + +// SetEx mocks base method. +func (m *MockStatefulCmdable) SetEx(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetEx", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetEx indicates an expected call of SetEx. +func (mr *MockStatefulCmdableMockRecorder) SetEx(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockStatefulCmdable)(nil).SetEx), ctx, key, value, expiration) +} + +// SetNX mocks base method. +func (m *MockStatefulCmdable) SetNX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNX", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetNX indicates an expected call of SetNX. +func (mr *MockStatefulCmdableMockRecorder) SetNX(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockStatefulCmdable)(nil).SetNX), ctx, key, value, expiration) +} + +// SetRange mocks base method. +func (m *MockStatefulCmdable) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRange", ctx, key, offset, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetRange indicates an expected call of SetRange. +func (mr *MockStatefulCmdableMockRecorder) SetRange(ctx, key, offset, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockStatefulCmdable)(nil).SetRange), ctx, key, offset, value) +} + +// SetXX mocks base method. +func (m *MockStatefulCmdable) SetXX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetXX", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetXX indicates an expected call of SetXX. +func (mr *MockStatefulCmdableMockRecorder) SetXX(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockStatefulCmdable)(nil).SetXX), ctx, key, value, expiration) +} + +// Shutdown mocks base method. +func (m *MockStatefulCmdable) Shutdown(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Shutdown", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Shutdown indicates an expected call of Shutdown. +func (mr *MockStatefulCmdableMockRecorder) Shutdown(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockStatefulCmdable)(nil).Shutdown), ctx) +} + +// ShutdownNoSave mocks base method. +func (m *MockStatefulCmdable) ShutdownNoSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownNoSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownNoSave indicates an expected call of ShutdownNoSave. +func (mr *MockStatefulCmdableMockRecorder) ShutdownNoSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockStatefulCmdable)(nil).ShutdownNoSave), ctx) +} + +// ShutdownSave mocks base method. +func (m *MockStatefulCmdable) ShutdownSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownSave indicates an expected call of ShutdownSave. +func (mr *MockStatefulCmdableMockRecorder) ShutdownSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockStatefulCmdable)(nil).ShutdownSave), ctx) +} + +// SlaveOf mocks base method. +func (m *MockStatefulCmdable) SlaveOf(ctx context.Context, host, port string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlaveOf", ctx, host, port) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SlaveOf indicates an expected call of SlaveOf. +func (mr *MockStatefulCmdableMockRecorder) SlaveOf(ctx, host, port any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockStatefulCmdable)(nil).SlaveOf), ctx, host, port) +} + +// SlowLogGet mocks base method. +func (m *MockStatefulCmdable) SlowLogGet(ctx context.Context, num int64) *redis.SlowLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlowLogGet", ctx, num) + ret0, _ := ret[0].(*redis.SlowLogCmd) + return ret0 +} + +// SlowLogGet indicates an expected call of SlowLogGet. +func (mr *MockStatefulCmdableMockRecorder) SlowLogGet(ctx, num any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockStatefulCmdable)(nil).SlowLogGet), ctx, num) +} + +// Sort mocks base method. +func (m *MockStatefulCmdable) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Sort", ctx, key, sort) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Sort indicates an expected call of Sort. +func (mr *MockStatefulCmdableMockRecorder) Sort(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockStatefulCmdable)(nil).Sort), ctx, key, sort) +} + +// SortInterfaces mocks base method. +func (m *MockStatefulCmdable) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortInterfaces", ctx, key, sort) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// SortInterfaces indicates an expected call of SortInterfaces. +func (mr *MockStatefulCmdableMockRecorder) SortInterfaces(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockStatefulCmdable)(nil).SortInterfaces), ctx, key, sort) +} + +// SortRO mocks base method. +func (m *MockStatefulCmdable) SortRO(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortRO", ctx, key, sort) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SortRO indicates an expected call of SortRO. +func (mr *MockStatefulCmdableMockRecorder) SortRO(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockStatefulCmdable)(nil).SortRO), ctx, key, sort) +} + +// SortStore mocks base method. +func (m *MockStatefulCmdable) SortStore(ctx context.Context, key, store string, sort *redis.Sort) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortStore", ctx, key, store, sort) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SortStore indicates an expected call of SortStore. +func (mr *MockStatefulCmdableMockRecorder) SortStore(ctx, key, store, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockStatefulCmdable)(nil).SortStore), ctx, key, store, sort) +} + +// StrLen mocks base method. +func (m *MockStatefulCmdable) StrLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StrLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// StrLen indicates an expected call of StrLen. +func (mr *MockStatefulCmdableMockRecorder) StrLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockStatefulCmdable)(nil).StrLen), ctx, key) +} + +// SwapDB mocks base method. +func (m *MockStatefulCmdable) SwapDB(ctx context.Context, index1, index2 int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SwapDB", ctx, index1, index2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SwapDB indicates an expected call of SwapDB. +func (mr *MockStatefulCmdableMockRecorder) SwapDB(ctx, index1, index2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapDB", reflect.TypeOf((*MockStatefulCmdable)(nil).SwapDB), ctx, index1, index2) +} + +// TDigestAdd mocks base method. +func (m *MockStatefulCmdable) TDigestAdd(ctx context.Context, key string, elements ...float64) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestAdd", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestAdd indicates an expected call of TDigestAdd. +func (mr *MockStatefulCmdableMockRecorder) TDigestAdd(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestAdd), varargs...) +} + +// TDigestByRank mocks base method. +func (m *MockStatefulCmdable) TDigestByRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range rank { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRank indicates an expected call of TDigestByRank. +func (mr *MockStatefulCmdableMockRecorder) TDigestByRank(ctx, key any, rank ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, rank...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRank", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestByRank), varargs...) +} + +// TDigestByRevRank mocks base method. +func (m *MockStatefulCmdable) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range rank { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRevRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRevRank indicates an expected call of TDigestByRevRank. +func (mr *MockStatefulCmdableMockRecorder) TDigestByRevRank(ctx, key any, rank ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, rank...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRevRank", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestByRevRank), varargs...) +} + +// TDigestCDF mocks base method. +func (m *MockStatefulCmdable) TDigestCDF(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestCDF", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestCDF indicates an expected call of TDigestCDF. +func (mr *MockStatefulCmdableMockRecorder) TDigestCDF(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCDF", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestCDF), varargs...) +} + +// TDigestCreate mocks base method. +func (m *MockStatefulCmdable) TDigestCreate(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreate", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreate indicates an expected call of TDigestCreate. +func (mr *MockStatefulCmdableMockRecorder) TDigestCreate(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestCreate), ctx, key) +} + +// TDigestCreateWithCompression mocks base method. +func (m *MockStatefulCmdable) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreateWithCompression", ctx, key, compression) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression. +func (mr *MockStatefulCmdableMockRecorder) TDigestCreateWithCompression(ctx, key, compression any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestCreateWithCompression), ctx, key, compression) +} + +// TDigestInfo mocks base method. +func (m *MockStatefulCmdable) TDigestInfo(ctx context.Context, key string) *redis.TDigestInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestInfo", ctx, key) + ret0, _ := ret[0].(*redis.TDigestInfoCmd) + return ret0 +} + +// TDigestInfo indicates an expected call of TDigestInfo. +func (mr *MockStatefulCmdableMockRecorder) TDigestInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestInfo), ctx, key) +} + +// TDigestMax mocks base method. +func (m *MockStatefulCmdable) TDigestMax(ctx context.Context, key string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMax", ctx, key) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMax indicates an expected call of TDigestMax. +func (mr *MockStatefulCmdableMockRecorder) TDigestMax(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestMax), ctx, key) +} + +// TDigestMerge mocks base method. +func (m *MockStatefulCmdable) TDigestMerge(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destKey, options} + for _, a := range sourceKeys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestMerge indicates an expected call of TDigestMerge. +func (mr *MockStatefulCmdableMockRecorder) TDigestMerge(ctx, destKey, options any, sourceKeys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destKey, options}, sourceKeys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMerge", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestMerge), varargs...) +} + +// TDigestMin mocks base method. +func (m *MockStatefulCmdable) TDigestMin(ctx context.Context, key string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMin", ctx, key) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMin indicates an expected call of TDigestMin. +func (mr *MockStatefulCmdableMockRecorder) TDigestMin(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestMin), ctx, key) +} + +// TDigestQuantile mocks base method. +func (m *MockStatefulCmdable) TDigestQuantile(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestQuantile", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestQuantile indicates an expected call of TDigestQuantile. +func (mr *MockStatefulCmdableMockRecorder) TDigestQuantile(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestQuantile", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestQuantile), varargs...) +} + +// TDigestRank mocks base method. +func (m *MockStatefulCmdable) TDigestRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRank indicates an expected call of TDigestRank. +func (mr *MockStatefulCmdableMockRecorder) TDigestRank(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRank", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestRank), varargs...) +} + +// TDigestReset mocks base method. +func (m *MockStatefulCmdable) TDigestReset(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestReset", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestReset indicates an expected call of TDigestReset. +func (mr *MockStatefulCmdableMockRecorder) TDigestReset(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestReset), ctx, key) +} + +// TDigestRevRank mocks base method. +func (m *MockStatefulCmdable) TDigestRevRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRevRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRevRank indicates an expected call of TDigestRevRank. +func (mr *MockStatefulCmdableMockRecorder) TDigestRevRank(ctx, key any, values ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRevRank", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestRevRank), varargs...) +} + +// TDigestTrimmedMean mocks base method. +func (m *MockStatefulCmdable) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestTrimmedMean", ctx, key, lowCutQuantile, highCutQuantile) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestTrimmedMean indicates an expected call of TDigestTrimmedMean. +func (mr *MockStatefulCmdableMockRecorder) TDigestTrimmedMean(ctx, key, lowCutQuantile, highCutQuantile any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestTrimmedMean), ctx, key, lowCutQuantile, highCutQuantile) +} + +// TFCall mocks base method. +func (m *MockStatefulCmdable) TFCall(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCall", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCall indicates an expected call of TFCall. +func (mr *MockStatefulCmdableMockRecorder) TFCall(ctx, libName, funcName, numKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockStatefulCmdable)(nil).TFCall), ctx, libName, funcName, numKeys) +} + +// TFCallASYNC mocks base method. +func (m *MockStatefulCmdable) TFCallASYNC(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNC", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNC indicates an expected call of TFCallASYNC. +func (mr *MockStatefulCmdableMockRecorder) TFCallASYNC(ctx, libName, funcName, numKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockStatefulCmdable)(nil).TFCallASYNC), ctx, libName, funcName, numKeys) +} + +// TFCallASYNCArgs mocks base method. +func (m *MockStatefulCmdable) TFCallASYNCArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNCArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNCArgs indicates an expected call of TFCallASYNCArgs. +func (mr *MockStatefulCmdableMockRecorder) TFCallASYNCArgs(ctx, libName, funcName, numKeys, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).TFCallASYNCArgs), ctx, libName, funcName, numKeys, options) +} + +// TFCallArgs mocks base method. +func (m *MockStatefulCmdable) TFCallArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallArgs indicates an expected call of TFCallArgs. +func (mr *MockStatefulCmdableMockRecorder) TFCallArgs(ctx, libName, funcName, numKeys, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).TFCallArgs), ctx, libName, funcName, numKeys, options) +} + +// TFunctionDelete mocks base method. +func (m *MockStatefulCmdable) TFunctionDelete(ctx context.Context, libName string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionDelete indicates an expected call of TFunctionDelete. +func (mr *MockStatefulCmdableMockRecorder) TFunctionDelete(ctx, libName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionDelete), ctx, libName) +} + +// TFunctionList mocks base method. +func (m *MockStatefulCmdable) TFunctionList(ctx context.Context) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionList", ctx) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionList indicates an expected call of TFunctionList. +func (mr *MockStatefulCmdableMockRecorder) TFunctionList(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionList), ctx) +} + +// TFunctionListArgs mocks base method. +func (m *MockStatefulCmdable) TFunctionListArgs(ctx context.Context, options *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionListArgs", ctx, options) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionListArgs indicates an expected call of TFunctionListArgs. +func (mr *MockStatefulCmdableMockRecorder) TFunctionListArgs(ctx, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionListArgs), ctx, options) +} + +// TFunctionLoad mocks base method. +func (m *MockStatefulCmdable) TFunctionLoad(ctx context.Context, lib string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoad", ctx, lib) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoad indicates an expected call of TFunctionLoad. +func (mr *MockStatefulCmdableMockRecorder) TFunctionLoad(ctx, lib any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionLoad), ctx, lib) +} + +// TFunctionLoadArgs mocks base method. +func (m *MockStatefulCmdable) TFunctionLoadArgs(ctx context.Context, lib string, options *redis.TFunctionLoadOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoadArgs", ctx, lib, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs. +func (mr *MockStatefulCmdableMockRecorder) TFunctionLoadArgs(ctx, lib, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionLoadArgs), ctx, lib, options) +} + +// TTL mocks base method. +func (m *MockStatefulCmdable) TTL(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TTL", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// TTL indicates an expected call of TTL. +func (mr *MockStatefulCmdableMockRecorder) TTL(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockStatefulCmdable)(nil).TTL), ctx, key) +} + +// Time mocks base method. +func (m *MockStatefulCmdable) Time(ctx context.Context) *redis.TimeCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Time", ctx) + ret0, _ := ret[0].(*redis.TimeCmd) + return ret0 +} + +// Time indicates an expected call of Time. +func (mr *MockStatefulCmdableMockRecorder) Time(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockStatefulCmdable)(nil).Time), ctx) +} + +// TopKAdd mocks base method. +func (m *MockStatefulCmdable) TopKAdd(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKAdd", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKAdd indicates an expected call of TopKAdd. +func (mr *MockStatefulCmdableMockRecorder) TopKAdd(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKAdd), varargs...) +} + +// TopKCount mocks base method. +func (m *MockStatefulCmdable) TopKCount(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKCount", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TopKCount indicates an expected call of TopKCount. +func (mr *MockStatefulCmdableMockRecorder) TopKCount(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKCount), varargs...) +} + +// TopKIncrBy mocks base method. +func (m *MockStatefulCmdable) TopKIncrBy(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKIncrBy", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKIncrBy indicates an expected call of TopKIncrBy. +func (mr *MockStatefulCmdableMockRecorder) TopKIncrBy(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKIncrBy), varargs...) +} + +// TopKInfo mocks base method. +func (m *MockStatefulCmdable) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKInfo", ctx, key) + ret0, _ := ret[0].(*redis.TopKInfoCmd) + return ret0 +} + +// TopKInfo indicates an expected call of TopKInfo. +func (mr *MockStatefulCmdableMockRecorder) TopKInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKInfo), ctx, key) +} + +// TopKList mocks base method. +func (m *MockStatefulCmdable) TopKList(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKList", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKList indicates an expected call of TopKList. +func (mr *MockStatefulCmdableMockRecorder) TopKList(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKList), ctx, key) +} + +// TopKListWithCount mocks base method. +func (m *MockStatefulCmdable) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKListWithCount", ctx, key) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// TopKListWithCount indicates an expected call of TopKListWithCount. +func (mr *MockStatefulCmdableMockRecorder) TopKListWithCount(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKListWithCount), ctx, key) +} + +// TopKQuery mocks base method. +func (m *MockStatefulCmdable) TopKQuery(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKQuery", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// TopKQuery indicates an expected call of TopKQuery. +func (mr *MockStatefulCmdableMockRecorder) TopKQuery(ctx, key any, elements ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKQuery), varargs...) +} + +// TopKReserve mocks base method. +func (m *MockStatefulCmdable) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserve", ctx, key, k) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserve indicates an expected call of TopKReserve. +func (mr *MockStatefulCmdableMockRecorder) TopKReserve(ctx, key, k any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKReserve), ctx, key, k) +} + +// TopKReserveWithOptions mocks base method. +func (m *MockStatefulCmdable) TopKReserveWithOptions(ctx context.Context, key string, k, width, depth int64, decay float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserveWithOptions", ctx, key, k, width, depth, decay) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserveWithOptions indicates an expected call of TopKReserveWithOptions. +func (mr *MockStatefulCmdableMockRecorder) TopKReserveWithOptions(ctx, key, k, width, depth, decay any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserveWithOptions", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKReserveWithOptions), ctx, key, k, width, depth, decay) +} + +// Touch mocks base method. +func (m *MockStatefulCmdable) Touch(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Touch", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Touch indicates an expected call of Touch. +func (mr *MockStatefulCmdableMockRecorder) Touch(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockStatefulCmdable)(nil).Touch), varargs...) +} + +// TxPipeline mocks base method. +func (m *MockStatefulCmdable) TxPipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// TxPipeline indicates an expected call of TxPipeline. +func (mr *MockStatefulCmdableMockRecorder) TxPipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockStatefulCmdable)(nil).TxPipeline)) +} + +// TxPipelined mocks base method. +func (m *MockStatefulCmdable) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipelined", ctx, fn) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TxPipelined indicates an expected call of TxPipelined. +func (mr *MockStatefulCmdableMockRecorder) TxPipelined(ctx, fn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockStatefulCmdable)(nil).TxPipelined), ctx, fn) +} + +// Type mocks base method. +func (m *MockStatefulCmdable) Type(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Type", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Type indicates an expected call of Type. +func (mr *MockStatefulCmdableMockRecorder) Type(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockStatefulCmdable)(nil).Type), ctx, key) +} + +// Unlink mocks base method. +func (m *MockStatefulCmdable) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Unlink", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Unlink indicates an expected call of Unlink. +func (mr *MockStatefulCmdableMockRecorder) Unlink(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockStatefulCmdable)(nil).Unlink), varargs...) +} + +// XAck mocks base method. +func (m *MockStatefulCmdable) XAck(ctx context.Context, stream, group string, ids ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, stream, group} + for _, a := range ids { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XAck", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XAck indicates an expected call of XAck. +func (mr *MockStatefulCmdableMockRecorder) XAck(ctx, stream, group any, ids ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, stream, group}, ids...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockStatefulCmdable)(nil).XAck), varargs...) +} + +// XAdd mocks base method. +func (m *MockStatefulCmdable) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAdd", ctx, a) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// XAdd indicates an expected call of XAdd. +func (mr *MockStatefulCmdableMockRecorder) XAdd(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).XAdd), ctx, a) +} + +// XAutoClaim mocks base method. +func (m *MockStatefulCmdable) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaim", ctx, a) + ret0, _ := ret[0].(*redis.XAutoClaimCmd) + return ret0 +} + +// XAutoClaim indicates an expected call of XAutoClaim. +func (mr *MockStatefulCmdableMockRecorder) XAutoClaim(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockStatefulCmdable)(nil).XAutoClaim), ctx, a) +} + +// XAutoClaimJustID mocks base method. +func (m *MockStatefulCmdable) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaimJustID", ctx, a) + ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd) + return ret0 +} + +// XAutoClaimJustID indicates an expected call of XAutoClaimJustID. +func (mr *MockStatefulCmdableMockRecorder) XAutoClaimJustID(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockStatefulCmdable)(nil).XAutoClaimJustID), ctx, a) +} + +// XClaim mocks base method. +func (m *MockStatefulCmdable) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaim", ctx, a) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XClaim indicates an expected call of XClaim. +func (mr *MockStatefulCmdableMockRecorder) XClaim(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockStatefulCmdable)(nil).XClaim), ctx, a) +} + +// XClaimJustID mocks base method. +func (m *MockStatefulCmdable) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaimJustID", ctx, a) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// XClaimJustID indicates an expected call of XClaimJustID. +func (mr *MockStatefulCmdableMockRecorder) XClaimJustID(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockStatefulCmdable)(nil).XClaimJustID), ctx, a) +} + +// XDel mocks base method. +func (m *MockStatefulCmdable) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, stream} + for _, a := range ids { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XDel indicates an expected call of XDel. +func (mr *MockStatefulCmdableMockRecorder) XDel(ctx, stream any, ids ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, stream}, ids...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockStatefulCmdable)(nil).XDel), varargs...) +} + +// XGroupCreate mocks base method. +func (m *MockStatefulCmdable) XGroupCreate(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreate", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreate indicates an expected call of XGroupCreate. +func (mr *MockStatefulCmdableMockRecorder) XGroupCreate(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupCreate), ctx, stream, group, start) +} + +// XGroupCreateConsumer mocks base method. +func (m *MockStatefulCmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateConsumer", ctx, stream, group, consumer) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer. +func (mr *MockStatefulCmdableMockRecorder) XGroupCreateConsumer(ctx, stream, group, consumer any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupCreateConsumer), ctx, stream, group, consumer) +} + +// XGroupCreateMkStream mocks base method. +func (m *MockStatefulCmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateMkStream", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream. +func (mr *MockStatefulCmdableMockRecorder) XGroupCreateMkStream(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupCreateMkStream), ctx, stream, group, start) +} + +// XGroupDelConsumer mocks base method. +func (m *MockStatefulCmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDelConsumer", ctx, stream, group, consumer) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDelConsumer indicates an expected call of XGroupDelConsumer. +func (mr *MockStatefulCmdableMockRecorder) XGroupDelConsumer(ctx, stream, group, consumer any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupDelConsumer), ctx, stream, group, consumer) +} + +// XGroupDestroy mocks base method. +func (m *MockStatefulCmdable) XGroupDestroy(ctx context.Context, stream, group string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDestroy", ctx, stream, group) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDestroy indicates an expected call of XGroupDestroy. +func (mr *MockStatefulCmdableMockRecorder) XGroupDestroy(ctx, stream, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupDestroy), ctx, stream, group) +} + +// XGroupSetID mocks base method. +func (m *MockStatefulCmdable) XGroupSetID(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupSetID", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupSetID indicates an expected call of XGroupSetID. +func (mr *MockStatefulCmdableMockRecorder) XGroupSetID(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupSetID), ctx, stream, group, start) +} + +// XInfoConsumers mocks base method. +func (m *MockStatefulCmdable) XInfoConsumers(ctx context.Context, key, group string) *redis.XInfoConsumersCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoConsumers", ctx, key, group) + ret0, _ := ret[0].(*redis.XInfoConsumersCmd) + return ret0 +} + +// XInfoConsumers indicates an expected call of XInfoConsumers. +func (mr *MockStatefulCmdableMockRecorder) XInfoConsumers(ctx, key, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoConsumers), ctx, key, group) +} + +// XInfoGroups mocks base method. +func (m *MockStatefulCmdable) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoGroups", ctx, key) + ret0, _ := ret[0].(*redis.XInfoGroupsCmd) + return ret0 +} + +// XInfoGroups indicates an expected call of XInfoGroups. +func (mr *MockStatefulCmdableMockRecorder) XInfoGroups(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoGroups), ctx, key) +} + +// XInfoStream mocks base method. +func (m *MockStatefulCmdable) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStream", ctx, key) + ret0, _ := ret[0].(*redis.XInfoStreamCmd) + return ret0 +} + +// XInfoStream indicates an expected call of XInfoStream. +func (mr *MockStatefulCmdableMockRecorder) XInfoStream(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoStream), ctx, key) +} + +// XInfoStreamFull mocks base method. +func (m *MockStatefulCmdable) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStreamFull", ctx, key, count) + ret0, _ := ret[0].(*redis.XInfoStreamFullCmd) + return ret0 +} + +// XInfoStreamFull indicates an expected call of XInfoStreamFull. +func (mr *MockStatefulCmdableMockRecorder) XInfoStreamFull(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoStreamFull), ctx, key, count) +} + +// XLen mocks base method. +func (m *MockStatefulCmdable) XLen(ctx context.Context, stream string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XLen", ctx, stream) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XLen indicates an expected call of XLen. +func (mr *MockStatefulCmdableMockRecorder) XLen(ctx, stream any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockStatefulCmdable)(nil).XLen), ctx, stream) +} + +// XPending mocks base method. +func (m *MockStatefulCmdable) XPending(ctx context.Context, stream, group string) *redis.XPendingCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPending", ctx, stream, group) + ret0, _ := ret[0].(*redis.XPendingCmd) + return ret0 +} + +// XPending indicates an expected call of XPending. +func (mr *MockStatefulCmdableMockRecorder) XPending(ctx, stream, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockStatefulCmdable)(nil).XPending), ctx, stream, group) +} + +// XPendingExt mocks base method. +func (m *MockStatefulCmdable) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPendingExt", ctx, a) + ret0, _ := ret[0].(*redis.XPendingExtCmd) + return ret0 +} + +// XPendingExt indicates an expected call of XPendingExt. +func (mr *MockStatefulCmdableMockRecorder) XPendingExt(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockStatefulCmdable)(nil).XPendingExt), ctx, a) +} + +// XRange mocks base method. +func (m *MockStatefulCmdable) XRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRange", ctx, stream, start, stop) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRange indicates an expected call of XRange. +func (mr *MockStatefulCmdableMockRecorder) XRange(ctx, stream, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockStatefulCmdable)(nil).XRange), ctx, stream, start, stop) +} + +// XRangeN mocks base method. +func (m *MockStatefulCmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRangeN", ctx, stream, start, stop, count) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRangeN indicates an expected call of XRangeN. +func (mr *MockStatefulCmdableMockRecorder) XRangeN(ctx, stream, start, stop, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockStatefulCmdable)(nil).XRangeN), ctx, stream, start, stop, count) +} + +// XRead mocks base method. +func (m *MockStatefulCmdable) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRead", ctx, a) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XRead indicates an expected call of XRead. +func (mr *MockStatefulCmdableMockRecorder) XRead(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockStatefulCmdable)(nil).XRead), ctx, a) +} + +// XReadGroup mocks base method. +func (m *MockStatefulCmdable) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XReadGroup", ctx, a) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadGroup indicates an expected call of XReadGroup. +func (mr *MockStatefulCmdableMockRecorder) XReadGroup(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockStatefulCmdable)(nil).XReadGroup), ctx, a) +} + +// XReadStreams mocks base method. +func (m *MockStatefulCmdable) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range streams { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XReadStreams", varargs...) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadStreams indicates an expected call of XReadStreams. +func (mr *MockStatefulCmdableMockRecorder) XReadStreams(ctx any, streams ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, streams...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockStatefulCmdable)(nil).XReadStreams), varargs...) +} + +// XRevRange mocks base method. +func (m *MockStatefulCmdable) XRevRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRange", ctx, stream, start, stop) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRange indicates an expected call of XRevRange. +func (mr *MockStatefulCmdableMockRecorder) XRevRange(ctx, stream, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockStatefulCmdable)(nil).XRevRange), ctx, stream, start, stop) +} + +// XRevRangeN mocks base method. +func (m *MockStatefulCmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRangeN", ctx, stream, start, stop, count) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRangeN indicates an expected call of XRevRangeN. +func (mr *MockStatefulCmdableMockRecorder) XRevRangeN(ctx, stream, start, stop, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockStatefulCmdable)(nil).XRevRangeN), ctx, stream, start, stop, count) +} + +// XTrimMaxLen mocks base method. +func (m *MockStatefulCmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLen", ctx, key, maxLen) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLen indicates an expected call of XTrimMaxLen. +func (mr *MockStatefulCmdableMockRecorder) XTrimMaxLen(ctx, key, maxLen any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMaxLen), ctx, key, maxLen) +} + +// XTrimMaxLenApprox mocks base method. +func (m *MockStatefulCmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLenApprox", ctx, key, maxLen, limit) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLenApprox indicates an expected call of XTrimMaxLenApprox. +func (mr *MockStatefulCmdableMockRecorder) XTrimMaxLenApprox(ctx, key, maxLen, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMaxLenApprox), ctx, key, maxLen, limit) +} + +// XTrimMinID mocks base method. +func (m *MockStatefulCmdable) XTrimMinID(ctx context.Context, key, minID string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinID", ctx, key, minID) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinID indicates an expected call of XTrimMinID. +func (mr *MockStatefulCmdableMockRecorder) XTrimMinID(ctx, key, minID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMinID), ctx, key, minID) +} + +// XTrimMinIDApprox mocks base method. +func (m *MockStatefulCmdable) XTrimMinIDApprox(ctx context.Context, key, minID string, limit int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinIDApprox", ctx, key, minID, limit) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinIDApprox indicates an expected call of XTrimMinIDApprox. +func (mr *MockStatefulCmdableMockRecorder) XTrimMinIDApprox(ctx, key, minID, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMinIDApprox), ctx, key, minID, limit) +} + +// ZAdd mocks base method. +func (m *MockStatefulCmdable) ZAdd(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAdd indicates an expected call of ZAdd. +func (mr *MockStatefulCmdableMockRecorder) ZAdd(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAdd), varargs...) +} + +// ZAddArgs mocks base method. +func (m *MockStatefulCmdable) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgs", ctx, key, args) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddArgs indicates an expected call of ZAddArgs. +func (mr *MockStatefulCmdableMockRecorder) ZAddArgs(ctx, key, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddArgs), ctx, key, args) +} + +// ZAddArgsIncr mocks base method. +func (m *MockStatefulCmdable) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgsIncr", ctx, key, args) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZAddArgsIncr indicates an expected call of ZAddArgsIncr. +func (mr *MockStatefulCmdableMockRecorder) ZAddArgsIncr(ctx, key, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddArgsIncr), ctx, key, args) +} + +// ZAddGT mocks base method. +func (m *MockStatefulCmdable) ZAddGT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddGT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddGT indicates an expected call of ZAddGT. +func (mr *MockStatefulCmdableMockRecorder) ZAddGT(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddGT", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddGT), varargs...) +} + +// ZAddLT mocks base method. +func (m *MockStatefulCmdable) ZAddLT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddLT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddLT indicates an expected call of ZAddLT. +func (mr *MockStatefulCmdableMockRecorder) ZAddLT(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddLT", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddLT), varargs...) +} + +// ZAddNX mocks base method. +func (m *MockStatefulCmdable) ZAddNX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddNX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddNX indicates an expected call of ZAddNX. +func (mr *MockStatefulCmdableMockRecorder) ZAddNX(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddNX), varargs...) +} + +// ZAddXX mocks base method. +func (m *MockStatefulCmdable) ZAddXX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddXX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddXX indicates an expected call of ZAddXX. +func (mr *MockStatefulCmdableMockRecorder) ZAddXX(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddXX), varargs...) +} + +// ZCard mocks base method. +func (m *MockStatefulCmdable) ZCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCard indicates an expected call of ZCard. +func (mr *MockStatefulCmdableMockRecorder) ZCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockStatefulCmdable)(nil).ZCard), ctx, key) +} + +// ZCount mocks base method. +func (m *MockStatefulCmdable) ZCount(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCount", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCount indicates an expected call of ZCount. +func (mr *MockStatefulCmdableMockRecorder) ZCount(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockStatefulCmdable)(nil).ZCount), ctx, key, min, max) +} + +// ZDiff mocks base method. +func (m *MockStatefulCmdable) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZDiff indicates an expected call of ZDiff. +func (mr *MockStatefulCmdableMockRecorder) ZDiff(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockStatefulCmdable)(nil).ZDiff), varargs...) +} + +// ZDiffStore mocks base method. +func (m *MockStatefulCmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZDiffStore indicates an expected call of ZDiffStore. +func (mr *MockStatefulCmdableMockRecorder) ZDiffStore(ctx, destination any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZDiffStore), varargs...) +} + +// ZDiffWithScores mocks base method. +func (m *MockStatefulCmdable) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffWithScores", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZDiffWithScores indicates an expected call of ZDiffWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZDiffWithScores(ctx any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZDiffWithScores), varargs...) +} + +// ZIncrBy mocks base method. +func (m *MockStatefulCmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZIncrBy", ctx, key, increment, member) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZIncrBy indicates an expected call of ZIncrBy. +func (mr *MockStatefulCmdableMockRecorder) ZIncrBy(ctx, key, increment, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).ZIncrBy), ctx, key, increment, member) +} + +// ZInter mocks base method. +func (m *MockStatefulCmdable) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInter", ctx, store) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZInter indicates an expected call of ZInter. +func (mr *MockStatefulCmdableMockRecorder) ZInter(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInter), ctx, store) +} + +// ZInterCard mocks base method. +func (m *MockStatefulCmdable) ZInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, limit} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterCard indicates an expected call of ZInterCard. +func (mr *MockStatefulCmdableMockRecorder) ZInterCard(ctx, limit any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, limit}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterCard", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInterCard), varargs...) +} + +// ZInterStore mocks base method. +func (m *MockStatefulCmdable) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterStore", ctx, destination, store) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterStore indicates an expected call of ZInterStore. +func (mr *MockStatefulCmdableMockRecorder) ZInterStore(ctx, destination, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInterStore), ctx, destination, store) +} + +// ZInterWithScores mocks base method. +func (m *MockStatefulCmdable) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterWithScores", ctx, store) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZInterWithScores indicates an expected call of ZInterWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZInterWithScores(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInterWithScores), ctx, store) +} + +// ZLexCount mocks base method. +func (m *MockStatefulCmdable) ZLexCount(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZLexCount", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZLexCount indicates an expected call of ZLexCount. +func (mr *MockStatefulCmdableMockRecorder) ZLexCount(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockStatefulCmdable)(nil).ZLexCount), ctx, key, min, max) +} + +// ZMPop mocks base method. +func (m *MockStatefulCmdable) ZMPop(ctx context.Context, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, order, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// ZMPop indicates an expected call of ZMPop. +func (mr *MockStatefulCmdableMockRecorder) ZMPop(ctx, order, count any, keys ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, order, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMPop", reflect.TypeOf((*MockStatefulCmdable)(nil).ZMPop), varargs...) +} + +// ZMScore mocks base method. +func (m *MockStatefulCmdable) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMScore", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// ZMScore indicates an expected call of ZMScore. +func (mr *MockStatefulCmdableMockRecorder) ZMScore(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZMScore), varargs...) +} + +// ZPopMax mocks base method. +func (m *MockStatefulCmdable) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range count { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMax indicates an expected call of ZPopMax. +func (mr *MockStatefulCmdableMockRecorder) ZPopMax(ctx, key any, count ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, count...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockStatefulCmdable)(nil).ZPopMax), varargs...) +} + +// ZPopMin mocks base method. +func (m *MockStatefulCmdable) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range count { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMin indicates an expected call of ZPopMin. +func (mr *MockStatefulCmdableMockRecorder) ZPopMin(ctx, key any, count ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, count...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockStatefulCmdable)(nil).ZPopMin), varargs...) +} + +// ZRandMember mocks base method. +func (m *MockStatefulCmdable) ZRandMember(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMember", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRandMember indicates an expected call of ZRandMember. +func (mr *MockStatefulCmdableMockRecorder) ZRandMember(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRandMember), ctx, key, count) +} + +// ZRandMemberWithScores mocks base method. +func (m *MockStatefulCmdable) ZRandMemberWithScores(ctx context.Context, key string, count int) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMemberWithScores", ctx, key, count) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZRandMemberWithScores(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRandMemberWithScores), ctx, key, count) +} + +// ZRange mocks base method. +func (m *MockStatefulCmdable) ZRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRange indicates an expected call of ZRange. +func (mr *MockStatefulCmdableMockRecorder) ZRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRange), ctx, key, start, stop) +} + +// ZRangeArgs mocks base method. +func (m *MockStatefulCmdable) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgs", ctx, z) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeArgs indicates an expected call of ZRangeArgs. +func (mr *MockStatefulCmdableMockRecorder) ZRangeArgs(ctx, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeArgs), ctx, z) +} + +// ZRangeArgsWithScores mocks base method. +func (m *MockStatefulCmdable) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgsWithScores", ctx, z) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZRangeArgsWithScores(ctx, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeArgsWithScores), ctx, z) +} + +// ZRangeByLex mocks base method. +func (m *MockStatefulCmdable) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByLex", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByLex indicates an expected call of ZRangeByLex. +func (mr *MockStatefulCmdableMockRecorder) ZRangeByLex(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByLex), ctx, key, opt) +} + +// ZRangeByScore mocks base method. +func (m *MockStatefulCmdable) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScore", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByScore indicates an expected call of ZRangeByScore. +func (mr *MockStatefulCmdableMockRecorder) ZRangeByScore(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByScore), ctx, key, opt) +} + +// ZRangeByScoreWithScores mocks base method. +func (m *MockStatefulCmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", ctx, key, opt) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZRangeByScoreWithScores(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByScoreWithScores), ctx, key, opt) +} + +// ZRangeStore mocks base method. +func (m *MockStatefulCmdable) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeStore", ctx, dst, z) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRangeStore indicates an expected call of ZRangeStore. +func (mr *MockStatefulCmdableMockRecorder) ZRangeStore(ctx, dst, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeStore), ctx, dst, z) +} + +// ZRangeWithScores mocks base method. +func (m *MockStatefulCmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeWithScores", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeWithScores indicates an expected call of ZRangeWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZRangeWithScores(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeWithScores), ctx, key, start, stop) +} + +// ZRank mocks base method. +func (m *MockStatefulCmdable) ZRank(ctx context.Context, key, member string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRank", ctx, key, member) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRank indicates an expected call of ZRank. +func (mr *MockStatefulCmdableMockRecorder) ZRank(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRank), ctx, key, member) +} + +// ZRankWithScore mocks base method. +func (m *MockStatefulCmdable) ZRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRankWithScore", ctx, key, member) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRankWithScore indicates an expected call of ZRankWithScore. +func (mr *MockStatefulCmdableMockRecorder) ZRankWithScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRankWithScore), ctx, key, member) +} + +// ZRem mocks base method. +func (m *MockStatefulCmdable) ZRem(ctx context.Context, key string, members ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRem indicates an expected call of ZRem. +func (mr *MockStatefulCmdableMockRecorder) ZRem(ctx, key any, members ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRem), varargs...) +} + +// ZRemRangeByLex mocks base method. +func (m *MockStatefulCmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByLex", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByLex indicates an expected call of ZRemRangeByLex. +func (mr *MockStatefulCmdableMockRecorder) ZRemRangeByLex(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRemRangeByLex), ctx, key, min, max) +} + +// ZRemRangeByRank mocks base method. +func (m *MockStatefulCmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByRank", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByRank indicates an expected call of ZRemRangeByRank. +func (mr *MockStatefulCmdableMockRecorder) ZRemRangeByRank(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRemRangeByRank), ctx, key, start, stop) +} + +// ZRemRangeByScore mocks base method. +func (m *MockStatefulCmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByScore", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByScore indicates an expected call of ZRemRangeByScore. +func (mr *MockStatefulCmdableMockRecorder) ZRemRangeByScore(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRemRangeByScore), ctx, key, min, max) +} + +// ZRevRange mocks base method. +func (m *MockStatefulCmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRange indicates an expected call of ZRevRange. +func (mr *MockStatefulCmdableMockRecorder) ZRevRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRange), ctx, key, start, stop) +} + +// ZRevRangeByLex mocks base method. +func (m *MockStatefulCmdable) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByLex", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByLex indicates an expected call of ZRevRangeByLex. +func (mr *MockStatefulCmdableMockRecorder) ZRevRangeByLex(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByLex), ctx, key, opt) +} + +// ZRevRangeByScore mocks base method. +func (m *MockStatefulCmdable) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScore", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByScore indicates an expected call of ZRevRangeByScore. +func (mr *MockStatefulCmdableMockRecorder) ZRevRangeByScore(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByScore), ctx, key, opt) +} + +// ZRevRangeByScoreWithScores mocks base method. +func (m *MockStatefulCmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", ctx, key, opt) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZRevRangeByScoreWithScores(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByScoreWithScores), ctx, key, opt) +} + +// ZRevRangeWithScores mocks base method. +func (m *MockStatefulCmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeWithScores", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeWithScores indicates an expected call of ZRevRangeWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZRevRangeWithScores(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeWithScores), ctx, key, start, stop) +} + +// ZRevRank mocks base method. +func (m *MockStatefulCmdable) ZRevRank(ctx context.Context, key, member string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRank", ctx, key, member) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRevRank indicates an expected call of ZRevRank. +func (mr *MockStatefulCmdableMockRecorder) ZRevRank(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRank), ctx, key, member) +} + +// ZRevRankWithScore mocks base method. +func (m *MockStatefulCmdable) ZRevRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRankWithScore", ctx, key, member) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRevRankWithScore indicates an expected call of ZRevRankWithScore. +func (mr *MockStatefulCmdableMockRecorder) ZRevRankWithScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRankWithScore), ctx, key, member) +} + +// ZScan mocks base method. +func (m *MockStatefulCmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ZScan indicates an expected call of ZScan. +func (mr *MockStatefulCmdableMockRecorder) ZScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockStatefulCmdable)(nil).ZScan), ctx, key, cursor, match, count) +} + +// ZScore mocks base method. +func (m *MockStatefulCmdable) ZScore(ctx context.Context, key, member string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScore", ctx, key, member) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZScore indicates an expected call of ZScore. +func (mr *MockStatefulCmdableMockRecorder) ZScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZScore), ctx, key, member) +} + +// ZUnion mocks base method. +func (m *MockStatefulCmdable) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnion", ctx, store) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZUnion indicates an expected call of ZUnion. +func (mr *MockStatefulCmdableMockRecorder) ZUnion(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnion), ctx, store) +} + +// ZUnionStore mocks base method. +func (m *MockStatefulCmdable) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionStore", ctx, dest, store) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZUnionStore indicates an expected call of ZUnionStore. +func (mr *MockStatefulCmdableMockRecorder) ZUnionStore(ctx, dest, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnionStore), ctx, dest, store) +} + +// ZUnionWithScores mocks base method. +func (m *MockStatefulCmdable) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionWithScores", ctx, store) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZUnionWithScores indicates an expected call of ZUnionWithScores. +func (mr *MockStatefulCmdableMockRecorder) ZUnionWithScores(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnionWithScores), ctx, store) +} diff --git a/internal/integration/activelimit_test.go b/internal/integration/activelimit_test.go index 83da1c4..32331ff 100644 --- a/internal/integration/activelimit_test.go +++ b/internal/integration/activelimit_test.go @@ -24,7 +24,7 @@ func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { name string maxCount int64 getReq func() *http.Request - createMiddleware func() gin.HandlerFunc + createMiddleware func(maxActive int64) gin.HandlerFunc before func(server *gin.Engine) after func() @@ -36,8 +36,8 @@ func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { { name: "开启限流,LocalLimit正常操作", - createMiddleware: func() gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(1).SetStatue(true).Build() + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(maxActive).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) @@ -57,8 +57,8 @@ func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { { name: "开启限流,LocalLimit 有一个人很久没出来,新请求被限流", - createMiddleware: func() gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(1).SetStatue(true).Build() + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(maxActive).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) @@ -82,8 +82,8 @@ func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { { name: "开启限流,LocalLimit 有一个人很久没出来,等待前面的请求退出后,成功通过", - createMiddleware: func() gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(1).SetStatue(true).Build() + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return locallimit.NewLocalActiveLimit(maxActive).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) @@ -95,7 +95,6 @@ func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { require.NoError(t, err) resp := httptest.NewRecorder() server.ServeHTTP(resp, req) - fmt.Println("阻塞的人出来了...") assert.Equal(t, 200, resp.Code) }, after: func() { @@ -105,81 +104,13 @@ func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { maxCount: 1, wantCode: http.StatusOK, }, - { - name: "关闭限流,请求正常执行", - createMiddleware: func() gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(1).SetStatue(false).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - before: func(server *gin.Engine) { - - }, - after: func() { - - }, - - maxCount: 1, - wantCode: 200, - }, - { - name: "关闭限流,LocalLimit 有一个人很久没出来,新请求正常返回", - createMiddleware: func() gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(1).SetStatue(false).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - before: func(server *gin.Engine) { - req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) - require.NoError(t, err) - resp := httptest.NewRecorder() - server.ServeHTTP(resp, req) - assert.Equal(t, 200, resp.Code) - }, - after: func() { - - }, - - maxCount: 1, - wantCode: 200, - }, - { - name: "关闭限流,LocalLimit 有一个人很久没出来,新请求正常返回", - createMiddleware: func() gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(1).SetStatue(false).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - before: func(server *gin.Engine) { - req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) - require.NoError(t, err) - resp := httptest.NewRecorder() - server.ServeHTTP(resp, req) - assert.Equal(t, 200, resp.Code) - }, - after: func() { - - }, - - maxCount: 1, - wantCode: 200, - }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { server := gin.Default() - server.Use(tc.createMiddleware()) + server.Use(tc.createMiddleware(tc.maxCount)) server.GET("/activelimit", func(ctx *gin.Context) { ctx.Status(http.StatusOK) }) @@ -226,7 +157,7 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { maxCount int64 key string getReq func() *http.Request - createMiddleware func() gin.HandlerFunc + createMiddleware func(maxActive int64, key string) gin.HandlerFunc before func(server *gin.Engine, key string) interval time.Duration @@ -242,8 +173,8 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { { name: "开启限流,RedisLimit正常操作", - createMiddleware: func() gin.HandlerFunc { - return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(true).Build() + createMiddleware: func(maxActive int64, key string) gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, maxActive, key).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) @@ -269,8 +200,8 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { { name: "开启限流,RedisLimit,有一个人长时间没退出,导致限流", - createMiddleware: func() gin.HandlerFunc { - return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(true).Build() + createMiddleware: func(maxActive int64, key string) gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, maxActive, key).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) @@ -300,8 +231,8 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { { name: "开启限流,RedisLimit,有一个人长时间没退出,等待前面退出后,正常请求....", - createMiddleware: func() gin.HandlerFunc { - return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(true).Build() + createMiddleware: func(maxActive int64, key string) gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, maxActive, key).Build() }, getReq: func() *http.Request { req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) @@ -326,58 +257,6 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { afterCount: 0, afterErr: nil, }, - { - name: "关闭限流,RedisLimit, 请求正常退出", - - createMiddleware: func() gin.HandlerFunc { - return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(false).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - before: func(server *gin.Engine, key string) { - - req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) - require.NoError(t, err) - resp := httptest.NewRecorder() - server.ServeHTTP(resp, req) - assert.Equal(t, 200, resp.Code) - }, - after: func(key string) (int64, error) { - return 0, nil - }, - maxCount: 1, - key: "test", - wantCode: http.StatusOK, - }, - { - name: "关闭限流,RedisLimit,,有一个人长时间没退出,不会限流", - - createMiddleware: func() gin.HandlerFunc { - return redislimit.NewRedisActiveLimit(redisClient, 1, "test").SetStatue(false).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - before: func(server *gin.Engine, key string) { - - req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) - require.NoError(t, err) - resp := httptest.NewRecorder() - server.ServeHTTP(resp, req) - assert.Equal(t, 200, resp.Code) - }, - after: func(key string) (int64, error) { - return 0, nil - }, - maxCount: 1, - key: "test", - wantCode: http.StatusOK, - }, } for _, tc := range testCases { @@ -388,7 +267,7 @@ func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { t.Run(tc.name, func(t *testing.T) { server := gin.Default() - server.Use(tc.createMiddleware()) + server.Use(tc.createMiddleware(tc.maxCount, tc.key)) server.GET("/activelimit", func(ctx *gin.Context) { ctx.Status(http.StatusOK) }) diff --git a/middlewares/activelimit/locallimit/builder.go b/middlewares/activelimit/locallimit/builder.go index 077259d..3486c43 100644 --- a/middlewares/activelimit/locallimit/builder.go +++ b/middlewares/activelimit/locallimit/builder.go @@ -1,7 +1,6 @@ package locallimit import ( - "fmt" "github.com/gin-gonic/gin" "go.uber.org/atomic" "net/http" @@ -12,8 +11,6 @@ type LocalActiveLimit struct { MaxActive *atomic.Int64 //当前活跃个数 countActive *atomic.Int64 - //是否开启限流 - Statue *atomic.Bool } // NewLocalActiveLimit 全局限流 @@ -21,15 +18,9 @@ func NewLocalActiveLimit(maxActive int64) *LocalActiveLimit { return &LocalActiveLimit{ MaxActive: atomic.NewInt64(maxActive), countActive: atomic.NewInt64(0), - Statue: atomic.NewBool(true), } } -func (a *LocalActiveLimit) SetStatue(statue bool) *LocalActiveLimit { - a.Statue.Store(statue) - return a -} - func (a *LocalActiveLimit) SetMaxActive(maxActive int64) *LocalActiveLimit { a.MaxActive.Store(maxActive) return a @@ -37,22 +28,17 @@ func (a *LocalActiveLimit) SetMaxActive(maxActive int64) *LocalActiveLimit { func (a *LocalActiveLimit) Build() gin.HandlerFunc { return func(ctx *gin.Context) { - //开启限流 - if a.Statue.Load() { - //直接减一操作 下面必加一成功 - defer func() { - fmt.Println("简易操作....:") - a.countActive.Sub(1) - }() - // 并直接占坑成功 - if a.countActive.Add(1) <= a.MaxActive.Load() { - ctx.Next() - } else { - ctx.AbortWithStatus(http.StatusTooManyRequests) - } - return - + //直接减一操作 下面必加一成功 + defer func() { + a.countActive.Sub(1) + }() + // 并直接占坑成功 + if a.countActive.Add(1) <= a.MaxActive.Load() { + ctx.Next() + } else { + ctx.AbortWithStatus(http.StatusTooManyRequests) } - ctx.Next() + return + } } diff --git a/middlewares/activelimit/redislimit/builder.go b/middlewares/activelimit/redislimit/builder.go index 1bfc895..e23910b 100644 --- a/middlewares/activelimit/redislimit/builder.go +++ b/middlewares/activelimit/redislimit/builder.go @@ -11,8 +11,6 @@ type RedisActiveLimit struct { //最大限制个数 MaxActive *atomic.Int64 - //是否开启限流 - Statue *atomic.Bool //用来记录连接数的key key string cmd redis.Cmdable @@ -22,17 +20,11 @@ type RedisActiveLimit struct { func NewRedisActiveLimit(cmd redis.Cmdable, maxActive int64, key string) *RedisActiveLimit { return &RedisActiveLimit{ MaxActive: atomic.NewInt64(maxActive), - Statue: atomic.NewBool(true), key: key, cmd: cmd, } } -func (a *RedisActiveLimit) SetStatue(statue bool) *RedisActiveLimit { - a.Statue.Store(statue) - return a -} - func (a *RedisActiveLimit) SetMaxActive(maxActive int64) *RedisActiveLimit { a.MaxActive.Store(maxActive) return a @@ -40,25 +32,20 @@ func (a *RedisActiveLimit) SetMaxActive(maxActive int64) *RedisActiveLimit { func (a *RedisActiveLimit) Build() gin.HandlerFunc { return func(ctx *gin.Context) { - //开启限流 - if a.Statue.Load() { - currentCount, err := a.cmd.Incr(ctx, a.key).Result() - if err != nil { - //为了安全性 直接返回异常 - ctx.AbortWithStatus(http.StatusInternalServerError) - return - } - defer func() { - _ = a.cmd.Decr(ctx, a.key).Err() - }() - if currentCount <= a.MaxActive.Load() { - ctx.Next() - } else { - ctx.AbortWithStatus(http.StatusTooManyRequests) - } + currentCount, err := a.cmd.Incr(ctx, a.key).Result() + if err != nil { + //为了安全性 直接返回异常 + ctx.AbortWithStatus(http.StatusInternalServerError) return - } - ctx.Next() + defer func() { + _ = a.cmd.Decr(ctx, a.key).Err() + }() + if currentCount <= a.MaxActive.Load() { + ctx.Next() + } else { + ctx.AbortWithStatus(http.StatusTooManyRequests) + } + return } } diff --git a/middlewares/activelimit/redislimit/builder_test.go b/middlewares/activelimit/redislimit/builder_test.go new file mode 100644 index 0000000..1f37bb7 --- /dev/null +++ b/middlewares/activelimit/redislimit/builder_test.go @@ -0,0 +1,224 @@ +package redislimit + +import ( + "context" + "errors" + redismocks "github.com/ecodeclub/ginx/internal/activelimit/mocks" + "github.com/gin-gonic/gin" + "github.com/redis/go-redis/v9" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + "net/http" + "net/http/httptest" + "testing" + "time" +) + +func TestRedisActiveLimit_Build(t *testing.T) { + testCases := []struct { + name string + maxCount int64 + key string + mock func(ctrl *gomock.Controller, key string) redis.Cmdable + getReq func() *http.Request + createMiddleware func(redisClient redis.Cmdable) gin.HandlerFunc + before func(server *gin.Engine, key string) + + interval time.Duration + after func(string2 string) (int64, error) + + //响应的code + wantCode int + + //检查退出的时候redis 状态 + afterCount int64 + afterErr error + }{ + { + name: "开启限流,RedisLimit正常操作", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(nil) + res1.SetVal(int64(1)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + + res2 := redis.NewIntCmd(context.Background()) + res2.SetErr(nil) + res2.SetVal(int64(0)) + redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2) + return redisClient + + }, + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + }, + after: func(string2 string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + }, + { + name: "开启限流,RedisLimit,有一个人长时间没退出,导致限流", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + //第一个进来的 + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(nil) + res1.SetVal(int64(1)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + + //第二个进来的 + res := redis.NewIntCmd(context.Background()) + res.SetErr(nil) + res.SetVal(int64(2)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res) + + //第二个人出去,还有一个处理中 + res2 := redis.NewIntCmd(context.Background()) + res2.SetErr(nil) + res2.SetVal(int64(1)) + redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2).AnyTimes() + + //res3 := redis.NewIntCmd(context.Background()) + //res3.SetErr(nil) + //res3.SetVal(int64(0)) + //redisClient.EXPECT().Decr(gomock.Any(), key).Return(res3) + + return redisClient + + }, + + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + + interval: time.Millisecond * 20, + after: func(key string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusTooManyRequests, + }, + { + name: "开启限流,RedisLimit,有一个人长时间没退出,等待前面退出后,正常请求....", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + //第一个进来的 + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(nil) + res1.SetVal(int64(1)) + redisClient.EXPECT().Incr(gomock.Any(), key).Times(2).Return(res1) + //第一个人出去 + res2 := redis.NewIntCmd(context.Background()) + res2.SetErr(nil) + res2.SetVal(int64(0)) + redisClient.EXPECT().Decr(gomock.Any(), key).Times(2).Return(res2) + + return redisClient + }, + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + interval: time.Millisecond * 300, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + }, + { + name: "系统异常", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + //第一个进来的 + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(errors.New("redis 异常")) + res1.SetVal(int64(0)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + + return redisClient + + }, + + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + }, + + interval: time.Millisecond * 20, + after: func(key string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusInternalServerError, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + ctl := gomock.NewController(t) + defer ctl.Finish() + server := gin.Default() + server.Use(tc.createMiddleware(tc.mock(ctl, tc.key))) + server.GET("/activelimit", func(ctx *gin.Context) { + ctx.Status(http.StatusOK) + }) + server.GET("/activelimit3", func(ctx *gin.Context) { + time.Sleep(time.Millisecond * 100) + ctx.Status(http.StatusOK) + }) + resp := httptest.NewRecorder() + go func() { + tc.before(server, tc.key) + }() + time.Sleep(tc.interval) + server.ServeHTTP(resp, tc.getReq()) + assert.Equal(t, tc.wantCode, resp.Code) + + }) + } +} From b8d8699cd8245492663537de13ff4a1a06f0429b Mon Sep 17 00:00:00 2001 From: Pyxy Date: Mon, 2 Oct 2023 07:42:00 +0800 Subject: [PATCH 04/10] =?UTF-8?q?=E6=8A=8Alocal=20=E4=B8=AD=E7=9A=84?= =?UTF-8?q?=E9=9B=86=E6=88=90=E6=B5=8B=E8=AF=95=E6=94=BE=E5=88=B0=E5=8D=95?= =?UTF-8?q?=E5=85=83=E6=B5=8B=E8=AF=95=E4=B8=AD,redis=20=E6=B7=BB=E5=8A=A0?= =?UTF-8?q?=E6=97=A5=E5=BF=97=E6=89=93=E5=8D=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/integration/activelimit_test.go | 119 ---------------- middlewares/activelimit/locallimit/builder.go | 5 +- .../activelimit/locallimit/builder_test.go | 129 ++++++++++++++++++ middlewares/activelimit/redislimit/builder.go | 20 ++- .../activelimit/redislimit/builder_test.go | 34 +++++ 5 files changed, 182 insertions(+), 125 deletions(-) create mode 100644 middlewares/activelimit/locallimit/builder_test.go diff --git a/internal/integration/activelimit_test.go b/internal/integration/activelimit_test.go index 32331ff..3edf207 100644 --- a/internal/integration/activelimit_test.go +++ b/internal/integration/activelimit_test.go @@ -5,7 +5,6 @@ package integration import ( "context" "fmt" - "github.com/ecodeclub/ginx/middlewares/activelimit/locallimit" "github.com/ecodeclub/ginx/middlewares/activelimit/redislimit" "github.com/redis/go-redis/v9" "net/http" @@ -18,124 +17,6 @@ import ( "github.com/stretchr/testify/require" ) -func TestBuilder_e2e_ActiveLocalLimit(t *testing.T) { - - testCases := []struct { - name string - maxCount int64 - getReq func() *http.Request - createMiddleware func(maxActive int64) gin.HandlerFunc - before func(server *gin.Engine) - - after func() - //响应的code - wantCode int - // - interval time.Duration - }{ - { - name: "开启限流,LocalLimit正常操作", - - createMiddleware: func(maxActive int64) gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(maxActive).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - before: func(server *gin.Engine) { - - }, - after: func() { - - }, - - maxCount: 1, - wantCode: 200, - }, - { - name: "开启限流,LocalLimit 有一个人很久没出来,新请求被限流", - - createMiddleware: func(maxActive int64) gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(maxActive).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - before: func(server *gin.Engine) { - req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) - require.NoError(t, err) - resp := httptest.NewRecorder() - server.ServeHTTP(resp, req) - assert.Equal(t, 200, resp.Code) - }, - after: func() { - - }, - - maxCount: 1, - wantCode: http.StatusTooManyRequests, - }, - { - name: "开启限流,LocalLimit 有一个人很久没出来,等待前面的请求退出后,成功通过", - - createMiddleware: func(maxActive int64) gin.HandlerFunc { - return locallimit.NewLocalActiveLimit(maxActive).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) - require.NoError(t, err) - return req - }, - before: func(server *gin.Engine) { - req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) - require.NoError(t, err) - resp := httptest.NewRecorder() - server.ServeHTTP(resp, req) - assert.Equal(t, 200, resp.Code) - }, - after: func() { - - }, - interval: time.Millisecond * 600, - maxCount: 1, - wantCode: http.StatusOK, - }, - } - - for _, tc := range testCases { - t.Run(tc.name, func(t *testing.T) { - - server := gin.Default() - server.Use(tc.createMiddleware(tc.maxCount)) - server.GET("/activelimit", func(ctx *gin.Context) { - ctx.Status(http.StatusOK) - }) - server.GET("/activelimit3", func(ctx *gin.Context) { - time.Sleep(time.Millisecond * 300) - ctx.Status(http.StatusOK) - }) - resp := httptest.NewRecorder() - go func() { - tc.before(server) - }() - //加延时保证 tc.before 执行 - time.Sleep(time.Millisecond * 10) - - time.Sleep(tc.interval) - server.ServeHTTP(resp, tc.getReq()) - assert.Equal(t, tc.wantCode, resp.Code) - - tc.after() - - }) - } - -} - func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { redisClient := redis.NewClient(&redis.Options{ Addr: "localhost:16379", diff --git a/middlewares/activelimit/locallimit/builder.go b/middlewares/activelimit/locallimit/builder.go index 3486c43..3517915 100644 --- a/middlewares/activelimit/locallimit/builder.go +++ b/middlewares/activelimit/locallimit/builder.go @@ -28,12 +28,11 @@ func (a *LocalActiveLimit) SetMaxActive(maxActive int64) *LocalActiveLimit { func (a *LocalActiveLimit) Build() gin.HandlerFunc { return func(ctx *gin.Context) { - //直接减一操作 下面必加一成功 + current := a.countActive.Add(1) defer func() { a.countActive.Sub(1) }() - // 并直接占坑成功 - if a.countActive.Add(1) <= a.MaxActive.Load() { + if current <= a.MaxActive.Load() { ctx.Next() } else { ctx.AbortWithStatus(http.StatusTooManyRequests) diff --git a/middlewares/activelimit/locallimit/builder_test.go b/middlewares/activelimit/locallimit/builder_test.go new file mode 100644 index 0000000..0d6518b --- /dev/null +++ b/middlewares/activelimit/locallimit/builder_test.go @@ -0,0 +1,129 @@ +package locallimit + +import ( + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "net/http" + "net/http/httptest" + "testing" + "time" +) + +func TestLocalActiveLimit_Build(t *testing.T) { + + testCases := []struct { + name string + maxCount int64 + getReq func() *http.Request + createMiddleware func(maxActive int64) gin.HandlerFunc + before func(server *gin.Engine) + + after func() + //响应的code + wantCode int + // + interval time.Duration + }{ + { + name: "开启限流,LocalLimit正常操作", + + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return NewLocalActiveLimit(maxActive).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + + }, + after: func() { + + }, + + maxCount: 1, + wantCode: 200, + }, + { + name: "开启限流,LocalLimit 有一个人很久没出来,新请求被限流", + + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return NewLocalActiveLimit(maxActive).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + after: func() { + + }, + + maxCount: 1, + wantCode: http.StatusTooManyRequests, + }, + { + name: "开启限流,LocalLimit 有一个人很久没出来,等待前面的请求退出后,成功通过", + + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return NewLocalActiveLimit(maxActive).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + after: func() { + + }, + interval: time.Millisecond * 600, + maxCount: 1, + wantCode: http.StatusOK, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + + server := gin.Default() + server.Use(tc.createMiddleware(tc.maxCount)) + server.GET("/activelimit", func(ctx *gin.Context) { + ctx.Status(http.StatusOK) + }) + server.GET("/activelimit3", func(ctx *gin.Context) { + time.Sleep(time.Millisecond * 300) + ctx.Status(http.StatusOK) + }) + resp := httptest.NewRecorder() + go func() { + tc.before(server) + }() + //加延时保证 tc.before 执行 + time.Sleep(time.Millisecond * 10) + + time.Sleep(tc.interval) + server.ServeHTTP(resp, tc.getReq()) + assert.Equal(t, tc.wantCode, resp.Code) + + tc.after() + + }) + } + +} diff --git a/middlewares/activelimit/redislimit/builder.go b/middlewares/activelimit/redislimit/builder.go index e23910b..9d44fd2 100644 --- a/middlewares/activelimit/redislimit/builder.go +++ b/middlewares/activelimit/redislimit/builder.go @@ -1,6 +1,7 @@ package redislimit import ( + "fmt" "github.com/gin-gonic/gin" "github.com/redis/go-redis/v9" "go.uber.org/atomic" @@ -12,8 +13,9 @@ type RedisActiveLimit struct { MaxActive *atomic.Int64 //用来记录连接数的key - key string - cmd redis.Cmdable + key string + cmd redis.Cmdable + logFn func(msg any, args ...any) } // NewRedisActiveLimit 全局限流 @@ -22,6 +24,9 @@ func NewRedisActiveLimit(cmd redis.Cmdable, maxActive int64, key string) *RedisA MaxActive: atomic.NewInt64(maxActive), key: key, cmd: cmd, + logFn: func(msg any, args ...any) { + fmt.Println(fmt.Sprintf("%v 详细信息: %v", msg, args)) + }, } } @@ -30,20 +35,29 @@ func (a *RedisActiveLimit) SetMaxActive(maxActive int64) *RedisActiveLimit { return a } +func (a *RedisActiveLimit) SetLogFunc(fun func(msg any, args ...any)) *RedisActiveLimit { + a.logFn = fun + return a +} + func (a *RedisActiveLimit) Build() gin.HandlerFunc { return func(ctx *gin.Context) { currentCount, err := a.cmd.Incr(ctx, a.key).Result() if err != nil { //为了安全性 直接返回异常 + a.logFn("redis 加一操作", err) ctx.AbortWithStatus(http.StatusInternalServerError) return } defer func() { - _ = a.cmd.Decr(ctx, a.key).Err() + if err = a.cmd.Decr(ctx, a.key).Err(); err != nil { + a.logFn("redis 减一操作", err) + } }() if currentCount <= a.MaxActive.Load() { ctx.Next() } else { + a.logFn("web server ", "限流中..") ctx.AbortWithStatus(http.StatusTooManyRequests) } return diff --git a/middlewares/activelimit/redislimit/builder_test.go b/middlewares/activelimit/redislimit/builder_test.go index 1f37bb7..574edf8 100644 --- a/middlewares/activelimit/redislimit/builder_test.go +++ b/middlewares/activelimit/redislimit/builder_test.go @@ -69,6 +69,40 @@ func TestRedisActiveLimit_Build(t *testing.T) { key: "test", wantCode: http.StatusOK, }, + { + name: "开启限流,RedisLimit正常操作,但是减一操作异常", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(nil) + res1.SetVal(int64(1)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + + res2 := redis.NewIntCmd(context.Background()) + res2.SetErr(errors.New("减一操作异常")) + res2.SetVal(int64(0)) + redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2) + return redisClient + + }, + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + }, + after: func(string2 string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + }, { name: "开启限流,RedisLimit,有一个人长时间没退出,导致限流", mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { From a2c71c33fb59bdc595079bb234cf59466dee2ae4 Mon Sep 17 00:00:00 2001 From: Pyxy Date: Mon, 2 Oct 2023 10:00:09 +0800 Subject: [PATCH 05/10] =?UTF-8?q?maxActive=20=E5=8F=98=E9=87=8F=E7=A7=81?= =?UTF-8?q?=E6=9C=89=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- middlewares/activelimit/locallimit/builder.go | 8 ++++---- middlewares/activelimit/redislimit/builder.go | 8 ++++---- middlewares/ratelimit/redis_slide_window.go | 6 +++--- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/middlewares/activelimit/locallimit/builder.go b/middlewares/activelimit/locallimit/builder.go index 3517915..9784d2d 100644 --- a/middlewares/activelimit/locallimit/builder.go +++ b/middlewares/activelimit/locallimit/builder.go @@ -8,7 +8,7 @@ import ( type LocalActiveLimit struct { //最大限制个数 - MaxActive *atomic.Int64 + maxActive *atomic.Int64 //当前活跃个数 countActive *atomic.Int64 } @@ -16,13 +16,13 @@ type LocalActiveLimit struct { // NewLocalActiveLimit 全局限流 func NewLocalActiveLimit(maxActive int64) *LocalActiveLimit { return &LocalActiveLimit{ - MaxActive: atomic.NewInt64(maxActive), + maxActive: atomic.NewInt64(maxActive), countActive: atomic.NewInt64(0), } } func (a *LocalActiveLimit) SetMaxActive(maxActive int64) *LocalActiveLimit { - a.MaxActive.Store(maxActive) + a.maxActive.Store(maxActive) return a } @@ -32,7 +32,7 @@ func (a *LocalActiveLimit) Build() gin.HandlerFunc { defer func() { a.countActive.Sub(1) }() - if current <= a.MaxActive.Load() { + if current <= a.maxActive.Load() { ctx.Next() } else { ctx.AbortWithStatus(http.StatusTooManyRequests) diff --git a/middlewares/activelimit/redislimit/builder.go b/middlewares/activelimit/redislimit/builder.go index 9d44fd2..f3da2e2 100644 --- a/middlewares/activelimit/redislimit/builder.go +++ b/middlewares/activelimit/redislimit/builder.go @@ -10,7 +10,7 @@ import ( type RedisActiveLimit struct { //最大限制个数 - MaxActive *atomic.Int64 + maxActive *atomic.Int64 //用来记录连接数的key key string @@ -21,7 +21,7 @@ type RedisActiveLimit struct { // NewRedisActiveLimit 全局限流 func NewRedisActiveLimit(cmd redis.Cmdable, maxActive int64, key string) *RedisActiveLimit { return &RedisActiveLimit{ - MaxActive: atomic.NewInt64(maxActive), + maxActive: atomic.NewInt64(maxActive), key: key, cmd: cmd, logFn: func(msg any, args ...any) { @@ -31,7 +31,7 @@ func NewRedisActiveLimit(cmd redis.Cmdable, maxActive int64, key string) *RedisA } func (a *RedisActiveLimit) SetMaxActive(maxActive int64) *RedisActiveLimit { - a.MaxActive.Store(maxActive) + a.maxActive.Store(maxActive) return a } @@ -54,7 +54,7 @@ func (a *RedisActiveLimit) Build() gin.HandlerFunc { a.logFn("redis 减一操作", err) } }() - if currentCount <= a.MaxActive.Load() { + if currentCount <= a.maxActive.Load() { ctx.Next() } else { a.logFn("web server ", "限流中..") diff --git a/middlewares/ratelimit/redis_slide_window.go b/middlewares/ratelimit/redis_slide_window.go index 51e6ba7..429d47b 100644 --- a/middlewares/ratelimit/redis_slide_window.go +++ b/middlewares/ratelimit/redis_slide_window.go @@ -8,11 +8,11 @@ import ( "github.com/ecodeclub/ginx/internal/ratelimit" ) -// NewRedisSlidingWindowLimiter 创建一个基于 redislimit 的滑动窗口限流器. -// cmd: 可传入 redislimit 的客户端 +// NewRedisSlidingWindowLimiter 创建一个基于 redis 的滑动窗口限流器. +// cmd: 可传入 redis 的客户端 // interval: 窗口大小 // rate: 阈值 -// 表示: 在 interval 内允许 rate 个请求 +// 表示: 在 interval 内允许 rate 个请求W // 示例: 1s 内允许 3000 个请求 func NewRedisSlidingWindowLimiter(cmd redis.Cmdable, interval time.Duration, rate int) ratelimit.Limiter { From 1b83c652446dc0d337593ddc1ec51b1b19e8d88c Mon Sep 17 00:00:00 2001 From: Pyxy Date: Mon, 2 Oct 2023 10:04:55 +0800 Subject: [PATCH 06/10] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- middlewares/ratelimit/redis_slide_window.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/middlewares/ratelimit/redis_slide_window.go b/middlewares/ratelimit/redis_slide_window.go index 429d47b..b90f488 100644 --- a/middlewares/ratelimit/redis_slide_window.go +++ b/middlewares/ratelimit/redis_slide_window.go @@ -12,7 +12,7 @@ import ( // cmd: 可传入 redis 的客户端 // interval: 窗口大小 // rate: 阈值 -// 表示: 在 interval 内允许 rate 个请求W +// 表示: 在 interval 内允许 rate 个请求 // 示例: 1s 内允许 3000 个请求 func NewRedisSlidingWindowLimiter(cmd redis.Cmdable, interval time.Duration, rate int) ratelimit.Limiter { From f808f1c7e4e1e8f3f0740e9b26f4841c331ef71a Mon Sep 17 00:00:00 2001 From: Pyxy Date: Mon, 2 Oct 2023 14:23:58 +0800 Subject: [PATCH 07/10] =?UTF-8?q?license=20=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LICENSE | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/LICENSE b/LICENSE index d57e925..f49a4e1 100644 --- a/LICENSE +++ b/LICENSE @@ -94,7 +94,7 @@ (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and - (a) You must cause any modified files to carry prominent notices + (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works @@ -198,4 +198,4 @@ distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and - limitations under the License. + limitations under the License. \ No newline at end of file From 2e46b53533b490f4e07abaac7bcfd3fe5d474b8b Mon Sep 17 00:00:00 2001 From: Pyxy Date: Mon, 2 Oct 2023 14:28:11 +0800 Subject: [PATCH 08/10] =?UTF-8?q?license=20=E4=BF=AE=E6=94=B92?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LICENSE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LICENSE b/LICENSE index f49a4e1..261eeb9 100644 --- a/LICENSE +++ b/LICENSE @@ -198,4 +198,4 @@ distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file + limitations under the License. From 9a60a8cd458f3cff58605f28819e81b517f43022 Mon Sep 17 00:00:00 2001 From: Pyxy Date: Mon, 2 Oct 2023 21:23:45 +0800 Subject: [PATCH 09/10] =?UTF-8?q?mocks=E5=8C=85=E4=BD=8D=E7=BD=AE=E8=B0=83?= =?UTF-8?q?=E6=95=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/{activelimit => }/mocks/redis_mock.go | 6 +++--- middlewares/activelimit/redislimit/builder_test.go | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) rename internal/{activelimit => }/mocks/redis_mock.go (99%) diff --git a/internal/activelimit/mocks/redis_mock.go b/internal/mocks/redis_mock.go similarity index 99% rename from internal/activelimit/mocks/redis_mock.go rename to internal/mocks/redis_mock.go index 2bd8266..927216b 100644 --- a/internal/activelimit/mocks/redis_mock.go +++ b/internal/mocks/redis_mock.go @@ -3,10 +3,10 @@ // // Generated by this command: // -// mockgen.exe -source=G:\go-up\pkg\mod\github.com\redis\go-redis\v9@v9.1.0\commands.go -package=redismocks -destination=G:\go-up\src\ginx\internal\activelimit\mocks\redis_mock.go +// mockgen.exe -source=G:\go-up\pkg\mod\github.com\redis\go-redis\v9@v9.1.0\commands.go -package=mocks -destination=G:\go-up\src\ginx\internal\mocks\redis_mock.go // -// Package redismocks is a generated GoMock package. -package redismocks +// Package mocks is a generated GoMock package. +package mocks import ( context "context" diff --git a/middlewares/activelimit/redislimit/builder_test.go b/middlewares/activelimit/redislimit/builder_test.go index 574edf8..e6f8f13 100644 --- a/middlewares/activelimit/redislimit/builder_test.go +++ b/middlewares/activelimit/redislimit/builder_test.go @@ -3,7 +3,7 @@ package redislimit import ( "context" "errors" - redismocks "github.com/ecodeclub/ginx/internal/activelimit/mocks" + redismocks "github.com/ecodeclub/ginx/internal/mocks" "github.com/gin-gonic/gin" "github.com/redis/go-redis/v9" "github.com/stretchr/testify/assert" From 98b246ac1db451a0da3d6a90f03cc41770966e9a Mon Sep 17 00:00:00 2001 From: PYxy Date: Sun, 8 Oct 2023 17:43:21 +0800 Subject: [PATCH 10/10] accesslog middleware --- middlewares/accesslog/builder.go | 135 ++++++++++++++ middlewares/accesslog/builder_test.go | 249 ++++++++++++++++++++++++++ 2 files changed, 384 insertions(+) create mode 100644 middlewares/accesslog/builder.go create mode 100644 middlewares/accesslog/builder_test.go diff --git a/middlewares/accesslog/builder.go b/middlewares/accesslog/builder.go new file mode 100644 index 0000000..c3ab0ac --- /dev/null +++ b/middlewares/accesslog/builder.go @@ -0,0 +1,135 @@ +package accesslog + +import ( + "bytes" + "context" + "io" + "time" + + "github.com/gin-gonic/gin" + "go.uber.org/atomic" +) + +type AccessLog struct { + //http 请求类型 + Method string + //url 整个请求的url + Url string + //请求体 + ReqBody string + //响应体 + RespBody string + //处理时间 + Duration string + //状态码 + Status int +} + +type Builder struct { + allowReqBody *atomic.Bool + allowRespBody *atomic.Bool + //logger logger.LoggerV1 //这里要自己确认用什么日志级别 + // + loggerFunc func(ctx context.Context, al *AccessLog) + maxLength *atomic.Int64 +} + +func NewBuilder(fn func(ctx context.Context, al *AccessLog)) *Builder { + return &Builder{ + allowReqBody: atomic.NewBool(false), + allowRespBody: atomic.NewBool(false), + loggerFunc: fn, + maxLength: atomic.NewInt64(1024), + } +} + +// AllowReqBody 是否打印请求体 +func (b *Builder) AllowReqBody() *Builder { + b.allowReqBody.Store(true) + return b +} + +// AllowRespBody 是否打印响应体 +func (b *Builder) AllowRespBody() *Builder { + b.allowRespBody.Store(true) + return b +} + +// MaxLength 打印的最大长度 +func (b *Builder) MaxLength(maxLength int64) *Builder { + b.maxLength.Store(maxLength) + return b +} + +func (b *Builder) Builder() gin.HandlerFunc { + return func(ctx *gin.Context) { + var ( + //请求处理开始时间 + start = time.Now() + //url + url = ctx.Request.URL.String() + //url 长度 + curLen = int64(len(url)) + //运行打印的最大长度 + maxLength = b.maxLength.Load() + //是否打印请求体 + allowReqBody = b.allowReqBody.Load() + //是否打印响应体 + allowRespBody = b.allowRespBody.Load() + ) + + if curLen >= maxLength { + url = url[:maxLength] + } + + accessLog := &AccessLog{ + Method: ctx.Request.Method, + Url: url, + } + if ctx.Request.Body != nil && allowReqBody { + body, _ := ctx.GetRawData() + ctx.Request.Body = io.NopCloser(bytes.NewReader(body)) + if int64(len(body)) >= maxLength { + body = body[:maxLength] + } + //注意资源的消耗 + accessLog.ReqBody = string(body) + } + + if allowRespBody { + ctx.Writer = responseWriter{ + ResponseWriter: ctx.Writer, + al: accessLog, + maxLength: maxLength, + } + } + + defer func() { + accessLog.Duration = time.Now().Sub(start).String() + //日志打印 + b.loggerFunc(ctx, accessLog) + }() + ctx.Next() + } +} + +type responseWriter struct { + gin.ResponseWriter + al *AccessLog + maxLength int64 +} + +func (r responseWriter) WriteHeader(statusCode int) { + + r.al.Status = statusCode + r.ResponseWriter.WriteHeader(statusCode) +} + +func (r responseWriter) Write(data []byte) (int, error) { + curLen := int64(len(data)) + if curLen >= r.maxLength { + data = data[:r.maxLength] + } + r.al.RespBody = string(data) + return r.ResponseWriter.Write(data) +} diff --git a/middlewares/accesslog/builder_test.go b/middlewares/accesslog/builder_test.go new file mode 100644 index 0000000..30ecd4f --- /dev/null +++ b/middlewares/accesslog/builder_test.go @@ -0,0 +1,249 @@ +package accesslog + +import ( + "context" + "fmt" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestBuilder_Builder(t *testing.T) { + testCases := []struct { + name string + getReq func() *http.Request + accesslog *AccessLog + logfunc func(accesslog *AccessLog) func(ctx context.Context, al *AccessLog) + middleWarebuilder func(func(ctx context.Context, al *AccessLog)) gin.HandlerFunc + setStatus int + setRsp string + resultAccessLog *AccessLog + }{ + { + name: "不打印请求体,响应体", + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/accesslog", nil) + require.NoError(t, err) + return req + }, + accesslog: &AccessLog{}, + logfunc: func(accesslog *AccessLog) func(ctx context.Context, al *AccessLog) { + + return func(ctx context.Context, al *AccessLog) { + // + //accesslog.Status = al.Status + //accesslog.Method = al.Method + ////url 整个请求的u + //accesslog.Url = al.Url + ////请求体 + //accesslog.ReqBody = al.ReqBody + ////响应体 + //accesslog.RespBody = al.RespBody + ////处理时间 + //accesslog.Duration = al.Duration + ////状态码 + //accesslog.Status = al.Status + copy(accesslog, al) + fmt.Printf("请求类型: %s \n请求url:%s \n请求体:%s \n响应体:%s \n状态码:%d \n消耗时间:%s \n", al.Method, al.Url, al.ReqBody, al.RespBody, al.Status, al.Duration) + } + }, + middleWarebuilder: func(f func(ctx context.Context, al *AccessLog)) gin.HandlerFunc { + return NewBuilder(f).Builder() + }, + resultAccessLog: &AccessLog{ + Method: "GET", + Url: "/accesslog", + }, + }, + { + name: "不打印请求体,打印响应体", + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/accesslog", nil) + require.NoError(t, err) + return req + }, + accesslog: &AccessLog{}, + logfunc: func(accesslog *AccessLog) func(ctx context.Context, al *AccessLog) { + + return func(ctx context.Context, al *AccessLog) { + + copy(accesslog, al) + + fmt.Printf("请求类型: %s \n请求url:%s \n请求体:%s \n响应体:%s \n状态码:%d \n消耗时间:%s \n", al.Method, al.Url, al.ReqBody, al.RespBody, al.Status, al.Duration) + } + }, + middleWarebuilder: func(f func(ctx context.Context, al *AccessLog)) gin.HandlerFunc { + return NewBuilder(f).AllowRespBody().Builder() + }, + resultAccessLog: &AccessLog{ + Method: "GET", + Url: "/accesslog", + RespBody: `{"msg":"aa22"}`, + Status: http.StatusOK, + }, + }, + { + name: "打印请求体,不打印响应体", + getReq: func() *http.Request { + read := strings.NewReader(`{"msg":"aa11"}`) + + req, err := http.NewRequest(http.MethodGet, "/accesslog", read) + require.NoError(t, err) + return req + }, + accesslog: &AccessLog{}, + logfunc: func(accesslog *AccessLog) func(ctx context.Context, al *AccessLog) { + + return func(ctx context.Context, al *AccessLog) { + + copy(accesslog, al) + + fmt.Printf("请求类型: %s \n请求url:%s \n请求体:%s \n响应体:%s \n状态码:%d \n消耗时间:%s \n", al.Method, al.Url, al.ReqBody, al.RespBody, al.Status, al.Duration) + } + }, + middleWarebuilder: func(f func(ctx context.Context, al *AccessLog)) gin.HandlerFunc { + return NewBuilder(f).AllowReqBody().Builder() + }, + resultAccessLog: &AccessLog{ + Method: "GET", + Url: "/accesslog", + ReqBody: `{"msg":"aa11"}`, + }, + }, + { + name: "打印请求体,打印响应体", + getReq: func() *http.Request { + read := strings.NewReader(`{"msg":"aa11"}`) + + req, err := http.NewRequest(http.MethodGet, "/accesslog", read) + require.NoError(t, err) + return req + }, + accesslog: &AccessLog{}, + logfunc: func(accesslog *AccessLog) func(ctx context.Context, al *AccessLog) { + + return func(ctx context.Context, al *AccessLog) { + + copy(accesslog, al) + + fmt.Printf("请求类型: %s \n请求url:%s \n请求体:%s \n响应体:%s \n状态码:%d \n消耗时间:%s \n", al.Method, al.Url, al.ReqBody, al.RespBody, al.Status, al.Duration) + } + }, + middleWarebuilder: func(f func(ctx context.Context, al *AccessLog)) gin.HandlerFunc { + return NewBuilder(f).AllowReqBody().AllowRespBody().Builder() + }, + resultAccessLog: &AccessLog{ + Method: "GET", + Url: "/accesslog", + ReqBody: `{"msg":"aa11"}`, + RespBody: `{"msg":"aa22"}`, + Status: http.StatusOK, + }, + }, + { + name: "打印请求体超标,不打印响应体,限制长度为10", + getReq: func() *http.Request { + read := strings.NewReader(`{"msg":"aa11"}`) + + req, err := http.NewRequest(http.MethodGet, "/accesslog", read) + require.NoError(t, err) + return req + }, + accesslog: &AccessLog{}, + logfunc: func(accesslog *AccessLog) func(ctx context.Context, al *AccessLog) { + + return func(ctx context.Context, al *AccessLog) { + + copy(accesslog, al) + + fmt.Printf("请求类型: %s \n请求url:%s \n请求体:%s \n响应体:%s \n状态码:%d \n消耗时间:%s \n", al.Method, al.Url, al.ReqBody, al.RespBody, al.Status, al.Duration) + } + }, + middleWarebuilder: func(f func(ctx context.Context, al *AccessLog)) gin.HandlerFunc { + return NewBuilder(f).AllowReqBody().MaxLength(10).Builder() + }, + resultAccessLog: &AccessLog{ + Method: "GET", + Url: "/accesslog", + ReqBody: `{"msg":"aa`, + }, + }, + { + name: "不打印请求体,打印响应体超标,限制长度为10", + getReq: func() *http.Request { + read := strings.NewReader(`{"msg":"aa11"}`) + + req, err := http.NewRequest(http.MethodGet, "/accesslog", read) + require.NoError(t, err) + return req + }, + accesslog: &AccessLog{}, + logfunc: func(accesslog *AccessLog) func(ctx context.Context, al *AccessLog) { + + return func(ctx context.Context, al *AccessLog) { + + copy(accesslog, al) + + fmt.Printf("请求类型: %s \n请求url:%s \n请求体:%s \n响应体:%s \n状态码:%d \n消耗时间:%s \n", al.Method, al.Url, al.ReqBody, al.RespBody, al.Status, al.Duration) + } + }, + middleWarebuilder: func(f func(ctx context.Context, al *AccessLog)) gin.HandlerFunc { + return NewBuilder(f).AllowRespBody().MaxLength(10).Builder() + }, + resultAccessLog: &AccessLog{ + Method: "GET", + Url: "/accesslog", + RespBody: `{"msg":"aa`, + Status: http.StatusOK, + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + server := gin.Default() + server.Use(tc.middleWarebuilder(tc.logfunc(tc.accesslog))) + server.GET("/accesslog", func(ctx *gin.Context) { + ctx.JSON(http.StatusOK, map[string]any{ + "msg": "aa22", + }) + }) + resp := httptest.NewRecorder() + + server.ServeHTTP(resp, tc.getReq()) + //中间件使用的defer 所有这里要给点时间 + time.Sleep(time.Millisecond * 100) + assert.Equal(t, tc.accesslog.Method, tc.resultAccessLog.Method) + assert.Equal(t, tc.accesslog.Url, tc.resultAccessLog.Url) + assert.Equal(t, tc.accesslog.ReqBody, tc.resultAccessLog.ReqBody) + assert.Equal(t, tc.accesslog.RespBody, tc.resultAccessLog.RespBody) + //时间不好判断 + //assert.Equal(t, tc.accesslog.Duration, tc.resultAccessLog.Duration) + + assert.Equal(t, tc.accesslog.Status, tc.resultAccessLog.Status) + + }) + + } +} + +func copy(source, target *AccessLog) { + source.Status = target.Status + source.Method = target.Method + //url 整个请求的u + source.Url = target.Url + //请求体 + source.ReqBody = target.ReqBody + //响应体 + source.RespBody = target.RespBody + //处理时间 + source.Duration = target.Duration + //状态码 + source.Status = target.Status +}