From fd72a4660a067f430d521b56e1c06ca323710bf2 Mon Sep 17 00:00:00 2001 From: joil Date: Thu, 12 Oct 2023 18:13:23 +0800 Subject: [PATCH 01/12] =?UTF-8?q?refactor:=20=E4=BC=98=E5=8C=96=E5=B9=B6?= =?UTF-8?q?=E6=95=B4=E7=90=86=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- jwt/management_test.go | 17 +--- jwt/middleware_builder.go | 12 ++- jwt/middleware_builder_test.go | 57 ++++++++----- middlewares/activelimit/locallimit/builder.go | 12 +-- .../activelimit/locallimit/builder_test.go | 28 ++----- middlewares/activelimit/redislimit/builder.go | 14 ++-- .../activelimit/redislimit/builder_test.go | 79 ++++++------------- 7 files changed, 87 insertions(+), 132 deletions(-) diff --git a/jwt/management_test.go b/jwt/management_test.go index 638f4cf..28f7004 100644 --- a/jwt/management_test.go +++ b/jwt/management_test.go @@ -26,18 +26,9 @@ var ( IssuedAt: jwt.NewNumericDate(nowTime), }, } - encryptionKey = "sign key" - nowTime = time.UnixMilli(1695571200000) - defaultOption = NewOptions(defaultExpire, encryptionKey) - defaultIgnorePaths = func(path string) bool { - ignorePaths := []string{"/login", "/signup"} - for _, ignorePath := range ignorePaths { - if path == ignorePath { - return true - } - } - return false - } + encryptionKey = "sign key" + nowTime = time.UnixMilli(1695571200000) + defaultOption = NewOptions(defaultExpire, encryptionKey) defaultManagement = NewManagement[data](defaultOption, WithNowFunc[data](func() time.Time { return nowTime @@ -801,5 +792,5 @@ func (m *Management[T]) registerRoutes(server *gin.Engine) { server.GET("/login", func(ctx *gin.Context) { ctx.Status(http.StatusOK) }) - server.GET("refresh", m.Refresh) + server.GET("/refresh", m.Refresh) } diff --git a/jwt/middleware_builder.go b/jwt/middleware_builder.go index 35995b8..e98fec1 100644 --- a/jwt/middleware_builder.go +++ b/jwt/middleware_builder.go @@ -1,12 +1,13 @@ package jwt import ( - "github.com/ecodeclub/ekit/set" - "github.com/gin-gonic/gin" - "github.com/golang-jwt/jwt/v5" "log/slog" "net/http" "time" + + "github.com/ecodeclub/ekit/set" + "github.com/gin-gonic/gin" + "github.com/golang-jwt/jwt/v5" ) // MiddlewareBuilder 创建一个校验登录的 middleware @@ -73,9 +74,6 @@ func staticIgnorePaths(paths ...string) func(path string) bool { s.Add(path) } return func(path string) bool { - if s.Exist(path) { - return true - } - return false + return s.Exist(path) } } diff --git a/jwt/middleware_builder_test.go b/jwt/middleware_builder_test.go index 2e72151..46efe34 100644 --- a/jwt/middleware_builder_test.go +++ b/jwt/middleware_builder_test.go @@ -1,20 +1,22 @@ package jwt import ( - "github.com/gin-gonic/gin" - "github.com/stretchr/testify/assert" "net/http" "net/http/httptest" "testing" "time" + + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" ) func TestMiddlewareBuilder_Build(t *testing.T) { type testCase[T any] struct { - name string - m *Management[T] - reqBuilder func(t *testing.T) *http.Request - wantCode int + name string + m *Management[T] + reqBuilder func(t *testing.T) *http.Request + isUseIgnore bool + wantCode int } tests := []testCase[data]{ { @@ -45,6 +47,24 @@ func TestMiddlewareBuilder_Build(t *testing.T) { }, wantCode: http.StatusUnauthorized, }, + { + // 验证通过 + name: "pass_the_verification", + m: NewManagement[data](defaultOption, + WithNowFunc[data](func() time.Time { + return time.UnixMilli(1695571500000) + }), + ), + reqBuilder: func(t *testing.T) *http.Request { + req, err := http.NewRequest(http.MethodGet, "/", nil) + if err != nil { + t.Fatal(err) + } + req.Header.Add("authorization", "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjp7ImZvbyI6IjEifSwiZXhwIjoxNjk1NTcxODAwLCJpYXQiOjE2OTU1NzEyMDB9.RMpM5YNgxl9OtCy4lt_JRxv6k8s6plCkthnAV-vbXEQ") + return req + }, + wantCode: http.StatusOK, + }, { // 无需认证直接通过 name: "pass_without_authentication", @@ -56,32 +76,31 @@ func TestMiddlewareBuilder_Build(t *testing.T) { } return req }, - wantCode: http.StatusOK, + isUseIgnore: true, + wantCode: http.StatusOK, }, { - // 验证通过 - name: "pass_the_verification", - m: NewManagement[data](defaultOption, - WithNowFunc[data](func() time.Time { - return time.UnixMilli(1695571500000) - }), - ), + // 未使用忽略选项则进行拦截 + name: "intercept_if_ignore_opt_is_not_used", + m: NewManagement[data](defaultOption), reqBuilder: func(t *testing.T) *http.Request { - req, err := http.NewRequest(http.MethodGet, "/", nil) + req, err := http.NewRequest(http.MethodGet, "/login", nil) if err != nil { t.Fatal(err) } - req.Header.Add("authorization", "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjp7ImZvbyI6IjEifSwiZXhwIjoxNjk1NTcxODAwLCJpYXQiOjE2OTU1NzEyMDB9.RMpM5YNgxl9OtCy4lt_JRxv6k8s6plCkthnAV-vbXEQ") return req }, - wantCode: http.StatusOK, + wantCode: http.StatusUnauthorized, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { server := gin.Default() - server.Use(tt.m.MiddlewareBuilder(). - IgnorePath("/login").Build()) + m := tt.m.MiddlewareBuilder() + if tt.isUseIgnore { + m = m.IgnorePath("/login") + } + server.Use(m.Build()) tt.m.registerRoutes(server) req := tt.reqBuilder(t) diff --git a/middlewares/activelimit/locallimit/builder.go b/middlewares/activelimit/locallimit/builder.go index b09d25d..98ed393 100644 --- a/middlewares/activelimit/locallimit/builder.go +++ b/middlewares/activelimit/locallimit/builder.go @@ -15,15 +15,16 @@ package locallimit import ( + "net/http" + "github.com/gin-gonic/gin" "go.uber.org/atomic" - "net/http" ) type LocalActiveLimit struct { - //最大限制个数 + // 最大限制个数 maxActive *atomic.Int64 - //当前活跃个数 + // 当前活跃个数 countActive *atomic.Int64 } @@ -35,11 +36,6 @@ func NewLocalActiveLimit(maxActive int64) *LocalActiveLimit { } } -func (a *LocalActiveLimit) SetMaxActive(maxActive int64) *LocalActiveLimit { - a.maxActive.Store(maxActive) - return a -} - func (a *LocalActiveLimit) Build() gin.HandlerFunc { return func(ctx *gin.Context) { current := a.countActive.Add(1) diff --git a/middlewares/activelimit/locallimit/builder_test.go b/middlewares/activelimit/locallimit/builder_test.go index af897be..ddaf5cb 100644 --- a/middlewares/activelimit/locallimit/builder_test.go +++ b/middlewares/activelimit/locallimit/builder_test.go @@ -15,13 +15,14 @@ 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" + + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestLocalActiveLimit_Build(t *testing.T) { @@ -33,10 +34,8 @@ func TestLocalActiveLimit_Build(t *testing.T) { createMiddleware func(maxActive int64) gin.HandlerFunc before func(server *gin.Engine) - after func() - //响应的code + // 响应的code wantCode int - // interval time.Duration }{ { @@ -50,12 +49,7 @@ func TestLocalActiveLimit_Build(t *testing.T) { require.NoError(t, err) return req }, - before: func(server *gin.Engine) { - - }, - after: func() { - - }, + before: func(server *gin.Engine) {}, maxCount: 1, wantCode: 200, @@ -78,9 +72,6 @@ func TestLocalActiveLimit_Build(t *testing.T) { server.ServeHTTP(resp, req) assert.Equal(t, 200, resp.Code) }, - after: func() { - - }, maxCount: 1, wantCode: http.StatusTooManyRequests, @@ -103,9 +94,7 @@ func TestLocalActiveLimit_Build(t *testing.T) { server.ServeHTTP(resp, req) assert.Equal(t, 200, resp.Code) }, - after: func() { - }, interval: time.Millisecond * 600, maxCount: 1, wantCode: http.StatusOK, @@ -128,15 +117,12 @@ func TestLocalActiveLimit_Build(t *testing.T) { go func() { tc.before(server) }() - //加延时保证 tc.before 执行 + // 加延时保证 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 9d295f8..e952ccc 100644 --- a/middlewares/activelimit/redislimit/builder.go +++ b/middlewares/activelimit/redislimit/builder.go @@ -16,17 +16,18 @@ package redislimit import ( "fmt" + "net/http" + "github.com/gin-gonic/gin" "github.com/redis/go-redis/v9" "go.uber.org/atomic" - "net/http" ) type RedisActiveLimit struct { - //最大限制个数 + // 最大限制个数 maxActive *atomic.Int64 - //用来记录连接数的key + // 用来记录连接数的key key string cmd redis.Cmdable logFn func(msg any, args ...any) @@ -44,11 +45,6 @@ func NewRedisActiveLimit(cmd redis.Cmdable, maxActive int64, key string) *RedisA } } -func (a *RedisActiveLimit) SetMaxActive(maxActive int64) *RedisActiveLimit { - a.maxActive.Store(maxActive) - return a -} - func (a *RedisActiveLimit) SetLogFunc(fun func(msg any, args ...any)) *RedisActiveLimit { a.logFn = fun return a @@ -58,7 +54,7 @@ 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 diff --git a/middlewares/activelimit/redislimit/builder_test.go b/middlewares/activelimit/redislimit/builder_test.go index 4277521..0e07abb 100644 --- a/middlewares/activelimit/redislimit/builder_test.go +++ b/middlewares/activelimit/redislimit/builder_test.go @@ -17,22 +17,23 @@ package redislimit import ( "context" "errors" - redismocks "github.com/ecodeclub/ginx/internal/mocks" + "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" "go.uber.org/mock/gomock" - "net/http" - "net/http/httptest" - "testing" - "time" + + redismocks "github.com/ecodeclub/ginx/internal/mocks" ) 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 @@ -40,14 +41,9 @@ func TestRedisActiveLimit_Build(t *testing.T) { before func(server *gin.Engine, key string) interval time.Duration - after func(string2 string) (int64, error) - //响应的code + // 响应的code wantCode int - - //检查退出的时候redis 状态 - afterCount int64 - afterErr error }{ { name: "开启限流,RedisLimit正常操作", @@ -73,13 +69,7 @@ func TestRedisActiveLimit_Build(t *testing.T) { require.NoError(t, err) return req }, - before: func(server *gin.Engine, key string) { - - }, - after: func(string2 string) (int64, error) { - return 0, nil - }, - maxCount: 1, + before: func(server *gin.Engine, key string) {}, key: "test", wantCode: http.StatusOK, }, @@ -107,45 +97,33 @@ func TestRedisActiveLimit_Build(t *testing.T) { require.NoError(t, err) return req }, - before: func(server *gin.Engine, key string) { - - }, - after: func(string2 string) (int64, error) { - return 0, nil - }, - maxCount: 1, + before: func(server *gin.Engine, key string) {}, 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 { @@ -157,7 +135,6 @@ func TestRedisActiveLimit_Build(t *testing.T) { return req }, before: func(server *gin.Engine, key string) { - req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) require.NoError(t, err) resp := httptest.NewRecorder() @@ -166,27 +143,28 @@ func TestRedisActiveLimit_Build(t *testing.T) { }, 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 { - //第一个进来的 + // 第1个请求开始 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) - //第一个人出去 + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + // 第1个请求结束 res2 := redis.NewIntCmd(context.Background()) res2.SetErr(nil) res2.SetVal(int64(0)) - redisClient.EXPECT().Decr(gomock.Any(), key).Times(2).Return(res2) + redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2) + + // 第2个请求开始 + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + // 第2个请求结束 + redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2) return redisClient }, @@ -206,14 +184,13 @@ func TestRedisActiveLimit_Build(t *testing.T) { 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 异常")) @@ -221,7 +198,6 @@ func TestRedisActiveLimit_Build(t *testing.T) { redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) return redisClient - }, createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { @@ -232,15 +208,9 @@ func TestRedisActiveLimit_Build(t *testing.T) { require.NoError(t, err) return req }, - before: func(server *gin.Engine, key string) { - - }, + 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, }, @@ -266,7 +236,6 @@ func TestRedisActiveLimit_Build(t *testing.T) { time.Sleep(tc.interval) server.ServeHTTP(resp, tc.getReq()) assert.Equal(t, tc.wantCode, resp.Code) - }) } } From 764568e265c901a859d99002acee27950036d3d7 Mon Sep 17 00:00:00 2001 From: joil Date: Thu, 12 Oct 2023 22:20:35 +0800 Subject: [PATCH 02/12] fix: actions --- go.mod | 4 +--- go.sum | 4 ---- internal/integration/activelimit_test.go | 5 +++-- middlewares/ratelimit/builder_test.go | 2 +- 4 files changed, 5 insertions(+), 10 deletions(-) diff --git a/go.mod b/go.mod index 1dcba70..2f0db3b 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/ecodeclub/ginx -go 1.21.1 +go 1.21 require ( github.com/ecodeclub/ekit v0.0.8 @@ -36,11 +36,9 @@ 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 7dc4bff..1cc58e3 100644 --- a/go.sum +++ b/go.sum @@ -87,8 +87,6 @@ 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= @@ -97,8 +95,6 @@ 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/integration/activelimit_test.go b/internal/integration/activelimit_test.go index c64aa37..0f0f280 100644 --- a/internal/integration/activelimit_test.go +++ b/internal/integration/activelimit_test.go @@ -19,13 +19,14 @@ package integration import ( "context" "fmt" - "github.com/ecodeclub/ginx/middlewares/activelimit/redislimit" - "github.com/redis/go-redis/v9" "net/http" "net/http/httptest" "testing" "time" + "github.com/ecodeclub/ginx/middlewares/activelimit/redislimit" + "github.com/redis/go-redis/v9" + "github.com/gin-gonic/gin" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" diff --git a/middlewares/ratelimit/builder_test.go b/middlewares/ratelimit/builder_test.go index c0fa288..1ddc4ec 100644 --- a/middlewares/ratelimit/builder_test.go +++ b/middlewares/ratelimit/builder_test.go @@ -25,7 +25,7 @@ import ( "go.uber.org/mock/gomock" "github.com/ecodeclub/ginx/internal/ratelimit" - "github.com/ecodeclub/ginx/internal/ratelimit/mocks" + limitmocks "github.com/ecodeclub/ginx/internal/ratelimit/mocks" ) func TestBuilder_SetKeyGenFunc(t *testing.T) { From 891e32033090799612a25d068da13018f75a3d95 Mon Sep 17 00:00:00 2001 From: joil Date: Thu, 12 Oct 2023 22:45:22 +0800 Subject: [PATCH 03/12] fix: actions --- .github/workflows/go-fmt.yml | 2 +- .github/workflows/go.yml | 2 +- .github/workflows/golangci-lint.yml | 2 +- go.mod | 4 ++-- go.sum | 15 ++++++++------- 5 files changed, 13 insertions(+), 12 deletions(-) diff --git a/.github/workflows/go-fmt.yml b/.github/workflows/go-fmt.yml index 230c442..a012f15 100644 --- a/.github/workflows/go-fmt.yml +++ b/.github/workflows/go-fmt.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: ">=1.20.0" + go-version: ">=1.21.0" - name: Install goimports run: go install golang.org/x/tools/cmd/goimports@latest diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 1e00067..1676b3a 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: 1.20.0 + go-version: 1.21.0 - name: Build run: go build -v ./... diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml index 7e4c788..caf8e13 100644 --- a/.github/workflows/golangci-lint.yml +++ b/.github/workflows/golangci-lint.yml @@ -33,7 +33,7 @@ jobs: steps: - uses: actions/setup-go@v3 with: - go-version: 1.20.0 + go-version: 1.21.0 - uses: actions/checkout@v3 - name: golangci-lint uses: golangci/golangci-lint-action@v3 diff --git a/go.mod b/go.mod index 2f0db3b..804b295 100644 --- a/go.mod +++ b/go.mod @@ -6,8 +6,8 @@ require ( github.com/ecodeclub/ekit v0.0.8 github.com/gin-gonic/gin v1.9.1 github.com/golang-jwt/jwt/v5 v5.0.0 - github.com/redis/go-redis/v9 v9.1.0 - github.com/stretchr/testify v1.8.3 + github.com/redis/go-redis/v9 v9.2.1 + github.com/stretchr/testify v1.8.4 go.uber.org/atomic v1.11.0 go.uber.org/mock v0.3.0 ) diff --git a/go.sum b/go.sum index 1cc58e3..c7371fa 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,7 @@ -github.com/bsm/ginkgo/v2 v2.9.5 h1:rtVBYPs3+TC5iLUVOis1B9tjLTup7Cj5IfzosKtvTJ0= -github.com/bsm/ginkgo/v2 v2.9.5/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= -github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y= -github.com/bsm/gomega v1.26.0/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM= github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s= github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U= @@ -61,8 +61,8 @@ github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZ github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/redis/go-redis/v9 v9.1.0 h1:137FnGdk+EQdCbye1FW+qOEcY5S+SpY9T0NiuqvtfMY= -github.com/redis/go-redis/v9 v9.1.0/go.mod h1:urWj3He21Dj5k4TK1y59xH8Uj6ATueP8AH1cY3lZl4c= +github.com/redis/go-redis/v9 v9.2.1 h1:WlYJg71ODF0dVspZZCpYmoF1+U1Jjk9Rwd7pq6QmlCg= +github.com/redis/go-redis/v9 v9.2.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= @@ -72,8 +72,9 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY= github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= 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= From d3d54b576d5d79a43b7681e17ff2daf778645502 Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 00:10:48 +0800 Subject: [PATCH 04/12] fix: actions --- .github/workflows/integration_test.yml | 34 +++++++++ Makefile | 69 +++++++++++-------- internal/mocks/redis_mock.go | 24 +++++-- internal/ratelimit/mocks/ratelimit.mock.go | 14 ++++ internal/ratelimit/redis_slide_window.go | 2 +- internal/ratelimit/redis_slide_window_test.go | 2 +- internal/ratelimit/types.go | 14 ++++ jwt/claims_option.go | 14 ++++ jwt/claims_option_test.go | 14 ++++ jwt/management.go | 14 ++++ jwt/management_test.go | 14 ++++ jwt/middleware_builder.go | 14 ++++ jwt/middleware_builder_test.go | 14 ++++ jwt/types.go | 14 ++++ script/integrate_test.sh | 7 ++ script/integration_test_compose.yml | 8 +++ 16 files changed, 237 insertions(+), 35 deletions(-) create mode 100644 .github/workflows/integration_test.yml create mode 100644 script/integrate_test.sh create mode 100644 script/integration_test_compose.yml diff --git a/.github/workflows/integration_test.yml b/.github/workflows/integration_test.yml new file mode 100644 index 0000000..def9e2c --- /dev/null +++ b/.github/workflows/integration_test.yml @@ -0,0 +1,34 @@ +# Copyright 2023 ecodeclub +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# 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. + +name: Integration Test + +on: + push: + branches: [ main, dev] + pull_request: + branches: [ main, dev] + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - name: Set up Go + uses: actions/setup-go@v3 + with: + go-version: '1.21' + + - name: Test + run: sudo sh ./script/integrate_test.sh \ No newline at end of file diff --git a/Makefile b/Makefile index c7e6056..c9a98db 100644 --- a/Makefile +++ b/Makefile @@ -1,28 +1,41 @@ -.PHONY: bench -bench: - @go test -bench=. -benchmem ./... - -.PHONY: ut -ut: - @go test -tags=goexperiment.arenas -race ./... - -.PHONY: setup -setup: - @sh ./script/setup.sh - -.PHONY: fmt -fmt: - @sh ./script/goimports.sh - -.PHONY: lint -lint: - @golangci-lint run -c .golangci.yml - -.PHONY: tidy -tidy: - @go mod tidy -v - -.PHONY: check -check: - @$(MAKE) fmt - @$(MAKE) tidy \ No newline at end of file +.PHONY: bench +bench: + @go test -bench=. -benchmem ./... + +.PHONY: ut +ut: + @go test -tags=goexperiment.arenas -race ./... + +.PHONY: setup +setup: + @sh ./script/setup.sh + +.PHONY: fmt +fmt: + @sh ./script/goimports.sh + +.PHONY: lint +lint: + @golangci-lint run -c .golangci.yml + +.PHONY: tidy +tidy: + @go mod tidy -v + +.PHONY: check +check: + @$(MAKE) fmt + @$(MAKE) tidy + +# e2e 测试 +.PHONY: e2e +e2e: + sh ./script/integrate_test.sh + +.PHONY: e2e_up +e2e_up: + docker compose -f script/integration_test_compose.yml up -d + +.PHONY: e2e_down +e2e_down: + docker compose -f script/integration_test_compose.yml down \ No newline at end of file diff --git a/internal/mocks/redis_mock.go b/internal/mocks/redis_mock.go index 927216b..e6fddeb 100644 --- a/internal/mocks/redis_mock.go +++ b/internal/mocks/redis_mock.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + // Code generated by MockGen. DO NOT EDIT. // Source: G:\go-up\pkg\mod\github.com\redis\go-redis\v9@v9.1.0\commands.go // @@ -9,12 +23,12 @@ package mocks import ( - context "context" - reflect "reflect" - time "time" + "context" + "reflect" + "time" - redis "github.com/redis/go-redis/v9" - gomock "go.uber.org/mock/gomock" + "github.com/redis/go-redis/v9" + "go.uber.org/mock/gomock" ) // MockCmdable is a mock of Cmdable interface. diff --git a/internal/ratelimit/mocks/ratelimit.mock.go b/internal/ratelimit/mocks/ratelimit.mock.go index 01883ae..063b1f2 100644 --- a/internal/ratelimit/mocks/ratelimit.mock.go +++ b/internal/ratelimit/mocks/ratelimit.mock.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + // Code generated by MockGen. DO NOT EDIT. // Source: types.go diff --git a/internal/ratelimit/redis_slide_window.go b/internal/ratelimit/redis_slide_window.go index a383c9d..2e06ae9 100644 --- a/internal/ratelimit/redis_slide_window.go +++ b/internal/ratelimit/redis_slide_window.go @@ -1,4 +1,4 @@ -// Copyright 2021 ecodeclub +// Copyright 2023 ecodeclub // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. diff --git a/internal/ratelimit/redis_slide_window_test.go b/internal/ratelimit/redis_slide_window_test.go index 0e5be10..c7afd1b 100644 --- a/internal/ratelimit/redis_slide_window_test.go +++ b/internal/ratelimit/redis_slide_window_test.go @@ -1,4 +1,4 @@ -// Copyright 2021 ecodeclub +// Copyright 2023 ecodeclub // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. diff --git a/internal/ratelimit/types.go b/internal/ratelimit/types.go index e603695..ae84687 100644 --- a/internal/ratelimit/types.go +++ b/internal/ratelimit/types.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + package ratelimit import "context" diff --git a/jwt/claims_option.go b/jwt/claims_option.go index 0dc7f28..ec62b82 100644 --- a/jwt/claims_option.go +++ b/jwt/claims_option.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + package jwt import ( diff --git a/jwt/claims_option_test.go b/jwt/claims_option_test.go index df6d7a0..45d2c69 100644 --- a/jwt/claims_option_test.go +++ b/jwt/claims_option_test.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + package jwt import ( diff --git a/jwt/management.go b/jwt/management.go index 4e1f464..dc8465b 100644 --- a/jwt/management.go +++ b/jwt/management.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + package jwt import ( diff --git a/jwt/management_test.go b/jwt/management_test.go index 28f7004..e1beb45 100644 --- a/jwt/management_test.go +++ b/jwt/management_test.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + package jwt import ( diff --git a/jwt/middleware_builder.go b/jwt/middleware_builder.go index e98fec1..a12911b 100644 --- a/jwt/middleware_builder.go +++ b/jwt/middleware_builder.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + package jwt import ( diff --git a/jwt/middleware_builder_test.go b/jwt/middleware_builder_test.go index 46efe34..23e94cd 100644 --- a/jwt/middleware_builder_test.go +++ b/jwt/middleware_builder_test.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + package jwt import ( diff --git a/jwt/types.go b/jwt/types.go index d6f104e..5ae25e8 100644 --- a/jwt/types.go +++ b/jwt/types.go @@ -1,3 +1,17 @@ +// Copyright 2023 ecodeclub +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// 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. + package jwt import ( diff --git a/script/integrate_test.sh b/script/integrate_test.sh new file mode 100644 index 0000000..c14633b --- /dev/null +++ b/script/integrate_test.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash + +set -e +docker compose -f script/integration_test_compose.yml down +docker compose -f script/integration_test_compose.yml up -d +go test ./... -tags=e2e +docker compose -f script/integration_test_compose.yml down \ No newline at end of file diff --git a/script/integration_test_compose.yml b/script/integration_test_compose.yml new file mode 100644 index 0000000..b9112c8 --- /dev/null +++ b/script/integration_test_compose.yml @@ -0,0 +1,8 @@ +version: '3.0' +services: + redis: + image: 'bitnami/redis:7.2' + environment: + - ALLOW_EMPTY_PASSWORD=yes + ports: + - '16379:6379' \ No newline at end of file From d9427f0943e7ea47a9a794c0028a4efa06528283 Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 00:18:43 +0800 Subject: [PATCH 05/12] fix: actions --- .github/workflows/go-fmt.yml | 2 +- .github/workflows/go.yml | 2 +- .github/workflows/golangci-lint.yml | 2 +- .github/workflows/integration_test.yml | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/go-fmt.yml b/.github/workflows/go-fmt.yml index a012f15..0f1506a 100644 --- a/.github/workflows/go-fmt.yml +++ b/.github/workflows/go-fmt.yml @@ -24,7 +24,7 @@ jobs: build: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Go uses: actions/setup-go@v3 with: diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 1676b3a..ed96142 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -24,7 +24,7 @@ jobs: build: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Go uses: actions/setup-go@v3 with: diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml index caf8e13..2a7ab19 100644 --- a/.github/workflows/golangci-lint.yml +++ b/.github/workflows/golangci-lint.yml @@ -34,7 +34,7 @@ jobs: - uses: actions/setup-go@v3 with: go-version: 1.21.0 - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: golangci-lint uses: golangci/golangci-lint-action@v3 with: diff --git a/.github/workflows/integration_test.yml b/.github/workflows/integration_test.yml index def9e2c..07bafdf 100644 --- a/.github/workflows/integration_test.yml +++ b/.github/workflows/integration_test.yml @@ -24,9 +24,9 @@ jobs: build: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Go - uses: actions/setup-go@v3 + uses: actions/setup-go@v2 with: go-version: '1.21' From aab7743ce4e1f0bdaa92c68bc5e80062450e0c9b Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 11:17:56 +0800 Subject: [PATCH 06/12] fix: test --- .github/workflows/integration_test.yml | 4 +- internal/mocks/redis_mock.go | 9847 ++++------------- .../activelimit/redislimit/builder_test.go | 250 +- 3 files changed, 1990 insertions(+), 8111 deletions(-) diff --git a/.github/workflows/integration_test.yml b/.github/workflows/integration_test.yml index 07bafdf..e13cbcc 100644 --- a/.github/workflows/integration_test.yml +++ b/.github/workflows/integration_test.yml @@ -26,9 +26,9 @@ jobs: steps: - uses: actions/checkout@v4 - name: Set up Go - uses: actions/setup-go@v2 + uses: actions/setup-go@v3 with: - go-version: '1.21' + go-version: 1.21.0 - name: Test run: sudo sh ./script/integrate_test.sh \ No newline at end of file diff --git a/internal/mocks/redis_mock.go b/internal/mocks/redis_mock.go index e6fddeb..dc5180a 100644 --- a/internal/mocks/redis_mock.go +++ b/internal/mocks/redis_mock.go @@ -13,22 +13,22 @@ // limitations under the License. // Code generated by MockGen. DO NOT EDIT. -// Source: G:\go-up\pkg\mod\github.com\redis\go-redis\v9@v9.1.0\commands.go +// Source: github.com/redis/go-redis/v9 (interfaces: Cmdable) // // Generated by this command: // -// 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 +// mockgen -package=mocks -destination=internal/mocks/redis_mock.go github.com/redis/go-redis/v9 Cmdable // // Package mocks is a generated GoMock package. package mocks import ( - "context" - "reflect" - "time" + context "context" + reflect "reflect" + time "time" - "github.com/redis/go-redis/v9" - "go.uber.org/mock/gomock" + redis "github.com/redis/go-redis/v9" + gomock "go.uber.org/mock/gomock" ) // MockCmdable is a mock of Cmdable interface. @@ -55,10 +55,10 @@ func (m *MockCmdable) EXPECT() *MockCmdableMockRecorder { } // ACLDryRun mocks base method. -func (m *MockCmdable) ACLDryRun(ctx context.Context, username string, command ...any) *redis.StringCmd { +func (m *MockCmdable) ACLDryRun(arg0 context.Context, arg1 string, arg2 ...any) *redis.StringCmd { m.ctrl.T.Helper() - varargs := []any{ctx, username} - for _, a := range command { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ACLDryRun", varargs...) @@ -67,199 +67,199 @@ func (m *MockCmdable) ACLDryRun(ctx context.Context, username string, command .. } // ACLDryRun indicates an expected call of ACLDryRun. -func (mr *MockCmdableMockRecorder) ACLDryRun(ctx, username any, command ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ACLDryRun(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, username}, command...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) ACLLog(arg0 context.Context, arg1 int64) *redis.ACLLogCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ACLLog", ctx, count) + ret := m.ctrl.Call(m, "ACLLog", arg0, arg1) ret0, _ := ret[0].(*redis.ACLLogCmd) return ret0 } // ACLLog indicates an expected call of ACLLog. -func (mr *MockCmdableMockRecorder) ACLLog(ctx, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ACLLog(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockCmdable)(nil).ACLLog), ctx, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockCmdable)(nil).ACLLog), arg0, arg1) } // ACLLogReset mocks base method. -func (m *MockCmdable) ACLLogReset(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ACLLogReset(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ACLLogReset", ctx) + ret := m.ctrl.Call(m, "ACLLogReset", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ACLLogReset indicates an expected call of ACLLogReset. -func (mr *MockCmdableMockRecorder) ACLLogReset(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ACLLogReset(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockCmdable)(nil).ACLLogReset), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockCmdable)(nil).ACLLogReset), arg0) } // Append mocks base method. -func (m *MockCmdable) Append(ctx context.Context, key, value string) *redis.IntCmd { +func (m *MockCmdable) Append(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Append", ctx, key, value) + ret := m.ctrl.Call(m, "Append", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // Append indicates an expected call of Append. -func (mr *MockCmdableMockRecorder) Append(ctx, key, value any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Append(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockCmdable)(nil).Append), ctx, key, value) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockCmdable)(nil).Append), arg0, arg1, arg2) } // BFAdd mocks base method. -func (m *MockCmdable) BFAdd(ctx context.Context, key string, element any) *redis.BoolCmd { +func (m *MockCmdable) BFAdd(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFAdd", ctx, key, element) + ret := m.ctrl.Call(m, "BFAdd", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // BFAdd indicates an expected call of BFAdd. -func (mr *MockCmdableMockRecorder) BFAdd(ctx, key, element any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFAdd(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockCmdable)(nil).BFAdd), ctx, key, element) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockCmdable)(nil).BFAdd), arg0, arg1, arg2) } // BFCard mocks base method. -func (m *MockCmdable) BFCard(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) BFCard(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFCard", ctx, key) + ret := m.ctrl.Call(m, "BFCard", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // BFCard indicates an expected call of BFCard. -func (mr *MockCmdableMockRecorder) BFCard(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFCard(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockCmdable)(nil).BFCard), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockCmdable)(nil).BFCard), arg0, arg1) } // BFExists mocks base method. -func (m *MockCmdable) BFExists(ctx context.Context, key string, element any) *redis.BoolCmd { +func (m *MockCmdable) BFExists(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFExists", ctx, key, element) + ret := m.ctrl.Call(m, "BFExists", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // BFExists indicates an expected call of BFExists. -func (mr *MockCmdableMockRecorder) BFExists(ctx, key, element any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFExists(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockCmdable)(nil).BFExists), ctx, key, element) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockCmdable)(nil).BFExists), arg0, arg1, arg2) } // BFInfo mocks base method. -func (m *MockCmdable) BFInfo(ctx context.Context, key string) *redis.BFInfoCmd { +func (m *MockCmdable) BFInfo(arg0 context.Context, arg1 string) *redis.BFInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFInfo", ctx, key) + ret := m.ctrl.Call(m, "BFInfo", arg0, arg1) ret0, _ := ret[0].(*redis.BFInfoCmd) return ret0 } // BFInfo indicates an expected call of BFInfo. -func (mr *MockCmdableMockRecorder) BFInfo(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFInfo(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockCmdable)(nil).BFInfo), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockCmdable)(nil).BFInfo), arg0, arg1) } // BFInfoArg mocks base method. -func (m *MockCmdable) BFInfoArg(ctx context.Context, key, option string) *redis.BFInfoCmd { +func (m *MockCmdable) BFInfoArg(arg0 context.Context, arg1, arg2 string) *redis.BFInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFInfoArg", ctx, key, option) + ret := m.ctrl.Call(m, "BFInfoArg", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BFInfoCmd) return ret0 } // BFInfoArg indicates an expected call of BFInfoArg. -func (mr *MockCmdableMockRecorder) BFInfoArg(ctx, key, option any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFInfoArg(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockCmdable)(nil).BFInfoArg), ctx, key, option) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockCmdable)(nil).BFInfoArg), arg0, arg1, arg2) } // BFInfoCapacity mocks base method. -func (m *MockCmdable) BFInfoCapacity(ctx context.Context, key string) *redis.BFInfoCmd { +func (m *MockCmdable) BFInfoCapacity(arg0 context.Context, arg1 string) *redis.BFInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFInfoCapacity", ctx, key) + ret := m.ctrl.Call(m, "BFInfoCapacity", arg0, arg1) ret0, _ := ret[0].(*redis.BFInfoCmd) return ret0 } // BFInfoCapacity indicates an expected call of BFInfoCapacity. -func (mr *MockCmdableMockRecorder) BFInfoCapacity(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFInfoCapacity(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockCmdable)(nil).BFInfoCapacity), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockCmdable)(nil).BFInfoCapacity), arg0, arg1) } // BFInfoExpansion mocks base method. -func (m *MockCmdable) BFInfoExpansion(ctx context.Context, key string) *redis.BFInfoCmd { +func (m *MockCmdable) BFInfoExpansion(arg0 context.Context, arg1 string) *redis.BFInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFInfoExpansion", ctx, key) + ret := m.ctrl.Call(m, "BFInfoExpansion", arg0, arg1) ret0, _ := ret[0].(*redis.BFInfoCmd) return ret0 } // BFInfoExpansion indicates an expected call of BFInfoExpansion. -func (mr *MockCmdableMockRecorder) BFInfoExpansion(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFInfoExpansion(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockCmdable)(nil).BFInfoExpansion), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockCmdable)(nil).BFInfoExpansion), arg0, arg1) } // BFInfoFilters mocks base method. -func (m *MockCmdable) BFInfoFilters(ctx context.Context, key string) *redis.BFInfoCmd { +func (m *MockCmdable) BFInfoFilters(arg0 context.Context, arg1 string) *redis.BFInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFInfoFilters", ctx, key) + ret := m.ctrl.Call(m, "BFInfoFilters", arg0, arg1) ret0, _ := ret[0].(*redis.BFInfoCmd) return ret0 } // BFInfoFilters indicates an expected call of BFInfoFilters. -func (mr *MockCmdableMockRecorder) BFInfoFilters(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFInfoFilters(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockCmdable)(nil).BFInfoFilters), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockCmdable)(nil).BFInfoFilters), arg0, arg1) } // BFInfoItems mocks base method. -func (m *MockCmdable) BFInfoItems(ctx context.Context, key string) *redis.BFInfoCmd { +func (m *MockCmdable) BFInfoItems(arg0 context.Context, arg1 string) *redis.BFInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFInfoItems", ctx, key) + ret := m.ctrl.Call(m, "BFInfoItems", arg0, arg1) ret0, _ := ret[0].(*redis.BFInfoCmd) return ret0 } // BFInfoItems indicates an expected call of BFInfoItems. -func (mr *MockCmdableMockRecorder) BFInfoItems(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFInfoItems(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockCmdable)(nil).BFInfoItems), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockCmdable)(nil).BFInfoItems), arg0, arg1) } // BFInfoSize mocks base method. -func (m *MockCmdable) BFInfoSize(ctx context.Context, key string) *redis.BFInfoCmd { +func (m *MockCmdable) BFInfoSize(arg0 context.Context, arg1 string) *redis.BFInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFInfoSize", ctx, key) + ret := m.ctrl.Call(m, "BFInfoSize", arg0, arg1) ret0, _ := ret[0].(*redis.BFInfoCmd) return ret0 } // BFInfoSize indicates an expected call of BFInfoSize. -func (mr *MockCmdableMockRecorder) BFInfoSize(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFInfoSize(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockCmdable)(nil).BFInfoSize), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockCmdable)(nil).BFInfoSize), arg0, arg1) } // BFInsert mocks base method. -func (m *MockCmdable) BFInsert(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...any) *redis.BoolSliceCmd { +func (m *MockCmdable) BFInsert(arg0 context.Context, arg1 string, arg2 *redis.BFInsertOptions, arg3 ...any) *redis.BoolSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key, options} - for _, a := range elements { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BFInsert", varargs...) @@ -268,31 +268,31 @@ func (m *MockCmdable) BFInsert(ctx context.Context, key string, options *redis.B } // BFInsert indicates an expected call of BFInsert. -func (mr *MockCmdableMockRecorder) BFInsert(ctx, key, options any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFInsert(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key, options}, elements...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) BFLoadChunk(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFLoadChunk", ctx, key, iterator, data) + ret := m.ctrl.Call(m, "BFLoadChunk", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) BFLoadChunk(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockCmdable)(nil).BFLoadChunk), arg0, arg1, arg2, arg3) } // BFMAdd mocks base method. -func (m *MockCmdable) BFMAdd(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { +func (m *MockCmdable) BFMAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BFMAdd", varargs...) @@ -301,17 +301,17 @@ func (m *MockCmdable) BFMAdd(ctx context.Context, key string, elements ...any) * } // BFMAdd indicates an expected call of BFMAdd. -func (mr *MockCmdableMockRecorder) BFMAdd(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFMAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, elements...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) BFMExists(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BFMExists", varargs...) @@ -320,87 +320,87 @@ func (m *MockCmdable) BFMExists(ctx context.Context, key string, elements ...any } // BFMExists indicates an expected call of BFMExists. -func (mr *MockCmdableMockRecorder) BFMExists(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFMExists(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, elements...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) BFReserve(arg0 context.Context, arg1 string, arg2 float64, arg3 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFReserve", ctx, key, errorRate, capacity) + ret := m.ctrl.Call(m, "BFReserve", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) BFReserve(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockCmdable)(nil).BFReserve), arg0, arg1, arg2, arg3) } -// BFReserveArgs mocks base method. -func (m *MockCmdable) BFReserveArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd { +// BFReserveExpansion mocks base method. +func (m *MockCmdable) BFReserveExpansion(arg0 context.Context, arg1 string, arg2 float64, arg3, arg4 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFReserveArgs", ctx, key, options) + ret := m.ctrl.Call(m, "BFReserveExpansion", arg0, arg1, arg2, arg3, arg4) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } -// BFReserveArgs indicates an expected call of BFReserveArgs. -func (mr *MockCmdableMockRecorder) BFReserveArgs(ctx, key, options any) *gomock.Call { +// BFReserveExpansion indicates an expected call of BFReserveExpansion. +func (mr *MockCmdableMockRecorder) BFReserveExpansion(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveArgs", reflect.TypeOf((*MockCmdable)(nil).BFReserveArgs), ctx, key, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockCmdable)(nil).BFReserveExpansion), arg0, arg1, arg2, arg3, arg4) } -// BFReserveExpansion mocks base method. -func (m *MockCmdable) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *redis.StatusCmd { +// BFReserveNonScaling mocks base method. +func (m *MockCmdable) BFReserveNonScaling(arg0 context.Context, arg1 string, arg2 float64, arg3 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFReserveExpansion", ctx, key, errorRate, capacity, expansion) + ret := m.ctrl.Call(m, "BFReserveNonScaling", arg0, arg1, arg2, arg3) 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 { +// BFReserveNonScaling indicates an expected call of BFReserveNonScaling. +func (mr *MockCmdableMockRecorder) BFReserveNonScaling(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockCmdable)(nil).BFReserveNonScaling), arg0, arg1, arg2, arg3) } -// BFReserveNonScaling mocks base method. -func (m *MockCmdable) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { +// BFReserveWithArgs mocks base method. +func (m *MockCmdable) BFReserveWithArgs(arg0 context.Context, arg1 string, arg2 *redis.BFReserveOptions) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFReserveNonScaling", ctx, key, errorRate, capacity) + ret := m.ctrl.Call(m, "BFReserveWithArgs", arg0, arg1, arg2) 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 { +// BFReserveWithArgs indicates an expected call of BFReserveWithArgs. +func (mr *MockCmdableMockRecorder) BFReserveWithArgs(arg0, arg1, arg2 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveWithArgs", reflect.TypeOf((*MockCmdable)(nil).BFReserveWithArgs), arg0, arg1, arg2) } // BFScanDump mocks base method. -func (m *MockCmdable) BFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { +func (m *MockCmdable) BFScanDump(arg0 context.Context, arg1 string, arg2 int64) *redis.ScanDumpCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BFScanDump", ctx, key, iterator) + ret := m.ctrl.Call(m, "BFScanDump", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.ScanDumpCmd) return ret0 } // BFScanDump indicates an expected call of BFScanDump. -func (mr *MockCmdableMockRecorder) BFScanDump(ctx, key, iterator any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BFScanDump(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockCmdable)(nil).BFScanDump), ctx, key, iterator) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockCmdable)(nil).BFScanDump), arg0, arg1, arg2) } // BLMPop mocks base method. -func (m *MockCmdable) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *redis.KeyValuesCmd { +func (m *MockCmdable) BLMPop(arg0 context.Context, arg1 time.Duration, arg2 string, arg3 int64, arg4 ...string) *redis.KeyValuesCmd { m.ctrl.T.Helper() - varargs := []any{ctx, timeout, direction, count} - for _, a := range keys { + varargs := []any{arg0, arg1, arg2, arg3} + for _, a := range arg4 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BLMPop", varargs...) @@ -409,31 +409,31 @@ func (m *MockCmdable) BLMPop(ctx context.Context, timeout time.Duration, directi } // BLMPop indicates an expected call of BLMPop. -func (mr *MockCmdableMockRecorder) BLMPop(ctx, timeout, direction, count any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BLMPop(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, timeout, direction, count}, keys...) + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) 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 { +func (m *MockCmdable) BLMove(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 time.Duration) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BLMove", ctx, source, destination, srcpos, destpos, timeout) + ret := m.ctrl.Call(m, "BLMove", arg0, arg1, arg2, arg3, arg4, arg5) 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 { +func (mr *MockCmdableMockRecorder) BLMove(arg0, arg1, arg2, arg3, arg4, arg5 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMove", reflect.TypeOf((*MockCmdable)(nil).BLMove), arg0, arg1, arg2, arg3, arg4, arg5) } // BLPop mocks base method. -func (m *MockCmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { +func (m *MockCmdable) BLPop(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, timeout} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BLPop", varargs...) @@ -442,17 +442,17 @@ func (m *MockCmdable) BLPop(ctx context.Context, timeout time.Duration, keys ... } // BLPop indicates an expected call of BLPop. -func (mr *MockCmdableMockRecorder) BLPop(ctx, timeout any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BLPop(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, timeout}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) BRPop(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, timeout} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BRPop", varargs...) @@ -461,31 +461,31 @@ func (m *MockCmdable) BRPop(ctx context.Context, timeout time.Duration, keys ... } // BRPop indicates an expected call of BRPop. -func (mr *MockCmdableMockRecorder) BRPop(ctx, timeout any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BRPop(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, timeout}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) BRPopLPush(arg0 context.Context, arg1, arg2 string, arg3 time.Duration) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BRPopLPush", ctx, source, destination, timeout) + ret := m.ctrl.Call(m, "BRPopLPush", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) BRPopLPush(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockCmdable)(nil).BRPopLPush), arg0, arg1, arg2, arg3) } // BZMPop mocks base method. -func (m *MockCmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { +func (m *MockCmdable) BZMPop(arg0 context.Context, arg1 time.Duration, arg2 string, arg3 int64, arg4 ...string) *redis.ZSliceWithKeyCmd { m.ctrl.T.Helper() - varargs := []any{ctx, timeout, order, count} - for _, a := range keys { + varargs := []any{arg0, arg1, arg2, arg3} + for _, a := range arg4 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BZMPop", varargs...) @@ -494,17 +494,17 @@ func (m *MockCmdable) BZMPop(ctx context.Context, timeout time.Duration, order s } // BZMPop indicates an expected call of BZMPop. -func (mr *MockCmdableMockRecorder) BZMPop(ctx, timeout, order, count any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BZMPop(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, timeout, order, count}, keys...) + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) 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 { +func (m *MockCmdable) BZPopMax(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.ZWithKeyCmd { m.ctrl.T.Helper() - varargs := []any{ctx, timeout} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BZPopMax", varargs...) @@ -513,17 +513,17 @@ func (m *MockCmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys } // BZPopMax indicates an expected call of BZPopMax. -func (mr *MockCmdableMockRecorder) BZPopMax(ctx, timeout any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BZPopMax(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, timeout}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) BZPopMin(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.ZWithKeyCmd { m.ctrl.T.Helper() - varargs := []any{ctx, timeout} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "BZPopMin", varargs...) @@ -532,266 +532,129 @@ func (m *MockCmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys } // BZPopMin indicates an expected call of BZPopMin. -func (mr *MockCmdableMockRecorder) BZPopMin(ctx, timeout any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BZPopMin(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, timeout}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) BgRewriteAOF(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BgRewriteAOF", ctx) + ret := m.ctrl.Call(m, "BgRewriteAOF", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // BgRewriteAOF indicates an expected call of BgRewriteAOF. -func (mr *MockCmdableMockRecorder) BgRewriteAOF(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) BgRewriteAOF(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockCmdable)(nil).BgRewriteAOF), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockCmdable)(nil).BgRewriteAOF), arg0) } // BgSave mocks base method. -func (m *MockCmdable) BgSave(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) BgSave(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BgSave", ctx) + ret := m.ctrl.Call(m, "BgSave", arg0) 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 { +func (mr *MockCmdableMockRecorder) BgSave(arg0 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockCmdable)(nil).BgSave), arg0) } // CFAdd mocks base method. -func (m *MockCmdable) CFAdd(ctx context.Context, key string, element any) *redis.BoolCmd { +func (m *MockCmdable) CFAdd(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFAdd", ctx, key, element) + ret := m.ctrl.Call(m, "CFAdd", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // CFAdd indicates an expected call of CFAdd. -func (mr *MockCmdableMockRecorder) CFAdd(ctx, key, element any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFAdd(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockCmdable)(nil).CFAdd), ctx, key, element) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockCmdable)(nil).CFAdd), arg0, arg1, arg2) } // CFAddNX mocks base method. -func (m *MockCmdable) CFAddNX(ctx context.Context, key string, element any) *redis.BoolCmd { +func (m *MockCmdable) CFAddNX(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFAddNX", ctx, key, element) + ret := m.ctrl.Call(m, "CFAddNX", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // CFAddNX indicates an expected call of CFAddNX. -func (mr *MockCmdableMockRecorder) CFAddNX(ctx, key, element any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFAddNX(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockCmdable)(nil).CFAddNX), ctx, key, element) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockCmdable)(nil).CFAddNX), arg0, arg1, arg2) } // CFCount mocks base method. -func (m *MockCmdable) CFCount(ctx context.Context, key string, element any) *redis.IntCmd { +func (m *MockCmdable) CFCount(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFCount", ctx, key, element) + ret := m.ctrl.Call(m, "CFCount", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // CFCount indicates an expected call of CFCount. -func (mr *MockCmdableMockRecorder) CFCount(ctx, key, element any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFCount(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockCmdable)(nil).CFCount), ctx, key, element) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockCmdable)(nil).CFCount), arg0, arg1, arg2) } // CFDel mocks base method. -func (m *MockCmdable) CFDel(ctx context.Context, key string, element any) *redis.BoolCmd { +func (m *MockCmdable) CFDel(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFDel", ctx, key, element) + ret := m.ctrl.Call(m, "CFDel", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // CFDel indicates an expected call of CFDel. -func (mr *MockCmdableMockRecorder) CFDel(ctx, key, element any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFDel(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockCmdable)(nil).CFDel), ctx, key, element) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockCmdable)(nil).CFDel), arg0, arg1, arg2) } // CFExists mocks base method. -func (m *MockCmdable) CFExists(ctx context.Context, key string, element any) *redis.BoolCmd { +func (m *MockCmdable) CFExists(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFExists", ctx, key, element) + ret := m.ctrl.Call(m, "CFExists", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // CFExists indicates an expected call of CFExists. -func (mr *MockCmdableMockRecorder) CFExists(ctx, key, element any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFExists(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockCmdable)(nil).CFExists), ctx, key, element) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockCmdable)(nil).CFExists), arg0, arg1, arg2) } // CFInfo mocks base method. -func (m *MockCmdable) CFInfo(ctx context.Context, key string) *redis.CFInfoCmd { +func (m *MockCmdable) CFInfo(arg0 context.Context, arg1 string) *redis.CFInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFInfo", ctx, key) + ret := m.ctrl.Call(m, "CFInfo", arg0, arg1) ret0, _ := ret[0].(*redis.CFInfoCmd) return ret0 } // CFInfo indicates an expected call of CFInfo. -func (mr *MockCmdableMockRecorder) CFInfo(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFInfo(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockCmdable)(nil).CFInfo), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockCmdable)(nil).CFInfo), arg0, arg1) } // CFInsert mocks base method. -func (m *MockCmdable) CFInsert(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.BoolSliceCmd { +func (m *MockCmdable) CFInsert(arg0 context.Context, arg1 string, arg2 *redis.CFInsertOptions, arg3 ...any) *redis.BoolSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key, options} - for _, a := range elements { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CFInsert", varargs...) @@ -800,17 +663,17 @@ func (m *MockCmdable) CFInsert(ctx context.Context, key string, options *redis.C } // CFInsert indicates an expected call of CFInsert. -func (mr *MockCmdableMockRecorder) CFInsert(ctx, key, options any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFInsert(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key, options}, elements...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) CFInsertNX(arg0 context.Context, arg1 string, arg2 *redis.CFInsertOptions, arg3 ...any) *redis.IntSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key, options} - for _, a := range elements { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CFInsertNX", varargs...) @@ -819,31 +682,31 @@ func (m *MockCmdable) CFInsertNX(ctx context.Context, key string, options *redis } // CFInsertNX indicates an expected call of CFInsertNX. -func (mr *MockCmdableMockRecorder) CFInsertNX(ctx, key, options any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFInsertNX(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key, options}, elements...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) CFLoadChunk(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFLoadChunk", ctx, key, iterator, data) + ret := m.ctrl.Call(m, "CFLoadChunk", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) CFLoadChunk(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockCmdable)(nil).CFLoadChunk), arg0, arg1, arg2, arg3) } // CFMExists mocks base method. -func (m *MockCmdable) CFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { +func (m *MockCmdable) CFMExists(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CFMExists", varargs...) @@ -852,101 +715,101 @@ func (m *MockCmdable) CFMExists(ctx context.Context, key string, elements ...any } // CFMExists indicates an expected call of CFMExists. -func (mr *MockCmdableMockRecorder) CFMExists(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFMExists(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, elements...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) CFReserve(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFReserve", ctx, key, capacity) + ret := m.ctrl.Call(m, "CFReserve", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // CFReserve indicates an expected call of CFReserve. -func (mr *MockCmdableMockRecorder) CFReserve(ctx, key, capacity any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFReserve(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockCmdable)(nil).CFReserve), ctx, key, capacity) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockCmdable)(nil).CFReserve), arg0, arg1, arg2) } -// CFReserveArgs mocks base method. -func (m *MockCmdable) CFReserveArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd { +// CFReserveBucketSize mocks base method. +func (m *MockCmdable) CFReserveBucketSize(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFReserveArgs", ctx, key, options) + ret := m.ctrl.Call(m, "CFReserveBucketSize", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } -// CFReserveArgs indicates an expected call of CFReserveArgs. -func (mr *MockCmdableMockRecorder) CFReserveArgs(ctx, key, options any) *gomock.Call { +// CFReserveBucketSize indicates an expected call of CFReserveBucketSize. +func (mr *MockCmdableMockRecorder) CFReserveBucketSize(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveArgs", reflect.TypeOf((*MockCmdable)(nil).CFReserveArgs), ctx, key, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockCmdable)(nil).CFReserveBucketSize), arg0, arg1, arg2, arg3) } -// CFReserveBucketSize mocks base method. -func (m *MockCmdable) CFReserveBucketSize(ctx context.Context, key string, capacity, bucketsize int64) *redis.StatusCmd { +// CFReserveExpansion mocks base method. +func (m *MockCmdable) CFReserveExpansion(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFReserveBucketSize", ctx, key, capacity, bucketsize) + ret := m.ctrl.Call(m, "CFReserveExpansion", arg0, arg1, arg2, arg3) 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 { +// CFReserveExpansion indicates an expected call of CFReserveExpansion. +func (mr *MockCmdableMockRecorder) CFReserveExpansion(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockCmdable)(nil).CFReserveExpansion), arg0, arg1, arg2, arg3) } -// CFReserveExpansion mocks base method. -func (m *MockCmdable) CFReserveExpansion(ctx context.Context, key string, capacity, expansion int64) *redis.StatusCmd { +// CFReserveMaxIterations mocks base method. +func (m *MockCmdable) CFReserveMaxIterations(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFReserveExpansion", ctx, key, capacity, expansion) + ret := m.ctrl.Call(m, "CFReserveMaxIterations", arg0, arg1, arg2, arg3) 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 { +// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations. +func (mr *MockCmdableMockRecorder) CFReserveMaxIterations(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockCmdable)(nil).CFReserveMaxIterations), arg0, arg1, arg2, arg3) } -// CFReserveMaxIterations mocks base method. -func (m *MockCmdable) CFReserveMaxIterations(ctx context.Context, key string, capacity, maxiterations int64) *redis.StatusCmd { +// CFReserveWithArgs mocks base method. +func (m *MockCmdable) CFReserveWithArgs(arg0 context.Context, arg1 string, arg2 *redis.CFReserveOptions) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFReserveMaxIterations", ctx, key, capacity, maxiterations) + ret := m.ctrl.Call(m, "CFReserveWithArgs", arg0, arg1, arg2) 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 { +// CFReserveWithArgs indicates an expected call of CFReserveWithArgs. +func (mr *MockCmdableMockRecorder) CFReserveWithArgs(arg0, arg1, arg2 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveWithArgs", reflect.TypeOf((*MockCmdable)(nil).CFReserveWithArgs), arg0, arg1, arg2) } // CFScanDump mocks base method. -func (m *MockCmdable) CFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { +func (m *MockCmdable) CFScanDump(arg0 context.Context, arg1 string, arg2 int64) *redis.ScanDumpCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CFScanDump", ctx, key, iterator) + ret := m.ctrl.Call(m, "CFScanDump", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.ScanDumpCmd) return ret0 } // CFScanDump indicates an expected call of CFScanDump. -func (mr *MockCmdableMockRecorder) CFScanDump(ctx, key, iterator any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CFScanDump(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockCmdable)(nil).CFScanDump), ctx, key, iterator) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockCmdable)(nil).CFScanDump), arg0, arg1, arg2) } // CMSIncrBy mocks base method. -func (m *MockCmdable) CMSIncrBy(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { +func (m *MockCmdable) CMSIncrBy(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CMSIncrBy", varargs...) @@ -955,59 +818,59 @@ func (m *MockCmdable) CMSIncrBy(ctx context.Context, key string, elements ...any } // CMSIncrBy indicates an expected call of CMSIncrBy. -func (mr *MockCmdableMockRecorder) CMSIncrBy(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CMSIncrBy(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, elements...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) CMSInfo(arg0 context.Context, arg1 string) *redis.CMSInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CMSInfo", ctx, key) + ret := m.ctrl.Call(m, "CMSInfo", arg0, arg1) ret0, _ := ret[0].(*redis.CMSInfoCmd) return ret0 } // CMSInfo indicates an expected call of CMSInfo. -func (mr *MockCmdableMockRecorder) CMSInfo(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CMSInfo(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockCmdable)(nil).CMSInfo), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockCmdable)(nil).CMSInfo), arg0, arg1) } // CMSInitByDim mocks base method. -func (m *MockCmdable) CMSInitByDim(ctx context.Context, key string, width, height int64) *redis.StatusCmd { +func (m *MockCmdable) CMSInitByDim(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CMSInitByDim", ctx, key, width, height) + ret := m.ctrl.Call(m, "CMSInitByDim", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) CMSInitByDim(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockCmdable)(nil).CMSInitByDim), arg0, arg1, arg2, arg3) } // CMSInitByProb mocks base method. -func (m *MockCmdable) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *redis.StatusCmd { +func (m *MockCmdable) CMSInitByProb(arg0 context.Context, arg1 string, arg2, arg3 float64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CMSInitByProb", ctx, key, errorRate, probability) + ret := m.ctrl.Call(m, "CMSInitByProb", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) CMSInitByProb(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockCmdable)(nil).CMSInitByProb), arg0, arg1, arg2, arg3) } // CMSMerge mocks base method. -func (m *MockCmdable) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *redis.StatusCmd { +func (m *MockCmdable) CMSMerge(arg0 context.Context, arg1 string, arg2 ...string) *redis.StatusCmd { m.ctrl.T.Helper() - varargs := []any{ctx, destKey} - for _, a := range sourceKeys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CMSMerge", varargs...) @@ -1016,31 +879,31 @@ func (m *MockCmdable) CMSMerge(ctx context.Context, destKey string, sourceKeys . } // CMSMerge indicates an expected call of CMSMerge. -func (mr *MockCmdableMockRecorder) CMSMerge(ctx, destKey any, sourceKeys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CMSMerge(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, destKey}, sourceKeys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) CMSMergeWithWeight(arg0 context.Context, arg1 string, arg2 map[string]int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CMSMergeWithWeight", ctx, destKey, sourceKeys) + ret := m.ctrl.Call(m, "CMSMergeWithWeight", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight. -func (mr *MockCmdableMockRecorder) CMSMergeWithWeight(ctx, destKey, sourceKeys any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CMSMergeWithWeight(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockCmdable)(nil).CMSMergeWithWeight), ctx, destKey, sourceKeys) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockCmdable)(nil).CMSMergeWithWeight), arg0, arg1, arg2) } // CMSQuery mocks base method. -func (m *MockCmdable) CMSQuery(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { +func (m *MockCmdable) CMSQuery(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CMSQuery", varargs...) @@ -1049,73 +912,73 @@ func (m *MockCmdable) CMSQuery(ctx context.Context, key string, elements ...any) } // CMSQuery indicates an expected call of CMSQuery. -func (mr *MockCmdableMockRecorder) CMSQuery(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CMSQuery(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, elements...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) ClientGetName(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientGetName", ctx) + ret := m.ctrl.Call(m, "ClientGetName", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // ClientGetName indicates an expected call of ClientGetName. -func (mr *MockCmdableMockRecorder) ClientGetName(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientGetName(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockCmdable)(nil).ClientGetName), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockCmdable)(nil).ClientGetName), arg0) } // ClientID mocks base method. -func (m *MockCmdable) ClientID(ctx context.Context) *redis.IntCmd { +func (m *MockCmdable) ClientID(arg0 context.Context) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientID", ctx) + ret := m.ctrl.Call(m, "ClientID", arg0) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ClientID indicates an expected call of ClientID. -func (mr *MockCmdableMockRecorder) ClientID(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockCmdable)(nil).ClientID), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockCmdable)(nil).ClientID), arg0) } // ClientInfo mocks base method. -func (m *MockCmdable) ClientInfo(ctx context.Context) *redis.ClientInfoCmd { +func (m *MockCmdable) ClientInfo(arg0 context.Context) *redis.ClientInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientInfo", ctx) + ret := m.ctrl.Call(m, "ClientInfo", arg0) ret0, _ := ret[0].(*redis.ClientInfoCmd) return ret0 } // ClientInfo indicates an expected call of ClientInfo. -func (mr *MockCmdableMockRecorder) ClientInfo(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockCmdable)(nil).ClientInfo), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockCmdable)(nil).ClientInfo), arg0) } // ClientKill mocks base method. -func (m *MockCmdable) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd { +func (m *MockCmdable) ClientKill(arg0 context.Context, arg1 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientKill", ctx, ipPort) + ret := m.ctrl.Call(m, "ClientKill", arg0, arg1) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClientKill indicates an expected call of ClientKill. -func (mr *MockCmdableMockRecorder) ClientKill(ctx, ipPort any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientKill(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockCmdable)(nil).ClientKill), ctx, ipPort) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockCmdable)(nil).ClientKill), arg0, arg1) } // ClientKillByFilter mocks base method. -func (m *MockCmdable) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd { +func (m *MockCmdable) ClientKillByFilter(arg0 context.Context, arg1 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...) @@ -1124,87 +987,87 @@ func (m *MockCmdable) ClientKillByFilter(ctx context.Context, keys ...string) *r } // ClientKillByFilter indicates an expected call of ClientKillByFilter. -func (mr *MockCmdableMockRecorder) ClientKillByFilter(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientKillByFilter(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, keys...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) ClientList(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientList", ctx) + ret := m.ctrl.Call(m, "ClientList", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // ClientList indicates an expected call of ClientList. -func (mr *MockCmdableMockRecorder) ClientList(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientList(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockCmdable)(nil).ClientList), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockCmdable)(nil).ClientList), arg0) } // ClientPause mocks base method. -func (m *MockCmdable) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd { +func (m *MockCmdable) ClientPause(arg0 context.Context, arg1 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientPause", ctx, dur) + ret := m.ctrl.Call(m, "ClientPause", arg0, arg1) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // ClientPause indicates an expected call of ClientPause. -func (mr *MockCmdableMockRecorder) ClientPause(ctx, dur any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientPause(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockCmdable)(nil).ClientPause), ctx, dur) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockCmdable)(nil).ClientPause), arg0, arg1) } // ClientUnblock mocks base method. -func (m *MockCmdable) ClientUnblock(ctx context.Context, id int64) *redis.IntCmd { +func (m *MockCmdable) ClientUnblock(arg0 context.Context, arg1 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientUnblock", ctx, id) + ret := m.ctrl.Call(m, "ClientUnblock", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ClientUnblock indicates an expected call of ClientUnblock. -func (mr *MockCmdableMockRecorder) ClientUnblock(ctx, id any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientUnblock(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockCmdable)(nil).ClientUnblock), ctx, id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockCmdable)(nil).ClientUnblock), arg0, arg1) } // ClientUnblockWithError mocks base method. -func (m *MockCmdable) ClientUnblockWithError(ctx context.Context, id int64) *redis.IntCmd { +func (m *MockCmdable) ClientUnblockWithError(arg0 context.Context, arg1 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientUnblockWithError", ctx, id) + ret := m.ctrl.Call(m, "ClientUnblockWithError", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ClientUnblockWithError indicates an expected call of ClientUnblockWithError. -func (mr *MockCmdableMockRecorder) ClientUnblockWithError(ctx, id any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientUnblockWithError(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockCmdable)(nil).ClientUnblockWithError), ctx, id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockCmdable)(nil).ClientUnblockWithError), arg0, arg1) } // ClientUnpause mocks base method. -func (m *MockCmdable) ClientUnpause(ctx context.Context) *redis.BoolCmd { +func (m *MockCmdable) ClientUnpause(arg0 context.Context) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientUnpause", ctx) + ret := m.ctrl.Call(m, "ClientUnpause", arg0) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // ClientUnpause indicates an expected call of ClientUnpause. -func (mr *MockCmdableMockRecorder) ClientUnpause(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClientUnpause(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockCmdable)(nil).ClientUnpause), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockCmdable)(nil).ClientUnpause), arg0) } // ClusterAddSlots mocks base method. -func (m *MockCmdable) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd { +func (m *MockCmdable) ClusterAddSlots(arg0 context.Context, arg1 ...int) *redis.StatusCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range slots { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...) @@ -1213,59 +1076,59 @@ func (m *MockCmdable) ClusterAddSlots(ctx context.Context, slots ...int) *redis. } // ClusterAddSlots indicates an expected call of ClusterAddSlots. -func (mr *MockCmdableMockRecorder) ClusterAddSlots(ctx any, slots ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterAddSlots(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, slots...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) ClusterAddSlotsRange(arg0 context.Context, arg1, arg2 int) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterAddSlotsRange", ctx, min, max) + ret := m.ctrl.Call(m, "ClusterAddSlotsRange", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange. -func (mr *MockCmdableMockRecorder) ClusterAddSlotsRange(ctx, min, max any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterAddSlotsRange(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlotsRange), ctx, min, max) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlotsRange), arg0, arg1, arg2) } // ClusterCountFailureReports mocks base method. -func (m *MockCmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd { +func (m *MockCmdable) ClusterCountFailureReports(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterCountFailureReports", ctx, nodeID) + ret := m.ctrl.Call(m, "ClusterCountFailureReports", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports. -func (mr *MockCmdableMockRecorder) ClusterCountFailureReports(ctx, nodeID any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterCountFailureReports(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockCmdable)(nil).ClusterCountFailureReports), ctx, nodeID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockCmdable)(nil).ClusterCountFailureReports), arg0, arg1) } // ClusterCountKeysInSlot mocks base method. -func (m *MockCmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd { +func (m *MockCmdable) ClusterCountKeysInSlot(arg0 context.Context, arg1 int) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", ctx, slot) + ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot. -func (mr *MockCmdableMockRecorder) ClusterCountKeysInSlot(ctx, slot any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterCountKeysInSlot(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterCountKeysInSlot), ctx, slot) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterCountKeysInSlot), arg0, arg1) } // ClusterDelSlots mocks base method. -func (m *MockCmdable) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd { +func (m *MockCmdable) ClusterDelSlots(arg0 context.Context, arg1 ...int) *redis.StatusCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range slots { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...) @@ -1274,269 +1137,269 @@ func (m *MockCmdable) ClusterDelSlots(ctx context.Context, slots ...int) *redis. } // ClusterDelSlots indicates an expected call of ClusterDelSlots. -func (mr *MockCmdableMockRecorder) ClusterDelSlots(ctx any, slots ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterDelSlots(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, slots...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) ClusterDelSlotsRange(arg0 context.Context, arg1, arg2 int) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterDelSlotsRange", ctx, min, max) + ret := m.ctrl.Call(m, "ClusterDelSlotsRange", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange. -func (mr *MockCmdableMockRecorder) ClusterDelSlotsRange(ctx, min, max any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterDelSlotsRange(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlotsRange), ctx, min, max) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlotsRange), arg0, arg1, arg2) } // ClusterFailover mocks base method. -func (m *MockCmdable) ClusterFailover(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ClusterFailover(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterFailover", ctx) + ret := m.ctrl.Call(m, "ClusterFailover", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterFailover indicates an expected call of ClusterFailover. -func (mr *MockCmdableMockRecorder) ClusterFailover(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterFailover(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockCmdable)(nil).ClusterFailover), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockCmdable)(nil).ClusterFailover), arg0) } // ClusterForget mocks base method. -func (m *MockCmdable) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd { +func (m *MockCmdable) ClusterForget(arg0 context.Context, arg1 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterForget", ctx, nodeID) + ret := m.ctrl.Call(m, "ClusterForget", arg0, arg1) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterForget indicates an expected call of ClusterForget. -func (mr *MockCmdableMockRecorder) ClusterForget(ctx, nodeID any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterForget(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockCmdable)(nil).ClusterForget), ctx, nodeID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockCmdable)(nil).ClusterForget), arg0, arg1) } // ClusterGetKeysInSlot mocks base method. -func (m *MockCmdable) ClusterGetKeysInSlot(ctx context.Context, slot, count int) *redis.StringSliceCmd { +func (m *MockCmdable) ClusterGetKeysInSlot(arg0 context.Context, arg1, arg2 int) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", ctx, slot, count) + ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot. -func (mr *MockCmdableMockRecorder) ClusterGetKeysInSlot(ctx, slot, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterGetKeysInSlot(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterGetKeysInSlot), ctx, slot, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterGetKeysInSlot), arg0, arg1, arg2) } // ClusterInfo mocks base method. -func (m *MockCmdable) ClusterInfo(ctx context.Context) *redis.StringCmd { +func (m *MockCmdable) ClusterInfo(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterInfo", ctx) + ret := m.ctrl.Call(m, "ClusterInfo", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // ClusterInfo indicates an expected call of ClusterInfo. -func (mr *MockCmdableMockRecorder) ClusterInfo(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterInfo(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockCmdable)(nil).ClusterInfo), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockCmdable)(nil).ClusterInfo), arg0) } // ClusterKeySlot mocks base method. -func (m *MockCmdable) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) ClusterKeySlot(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterKeySlot", ctx, key) + ret := m.ctrl.Call(m, "ClusterKeySlot", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ClusterKeySlot indicates an expected call of ClusterKeySlot. -func (mr *MockCmdableMockRecorder) ClusterKeySlot(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterKeySlot(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockCmdable)(nil).ClusterKeySlot), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockCmdable)(nil).ClusterKeySlot), arg0, arg1) } // ClusterLinks mocks base method. -func (m *MockCmdable) ClusterLinks(ctx context.Context) *redis.ClusterLinksCmd { +func (m *MockCmdable) ClusterLinks(arg0 context.Context) *redis.ClusterLinksCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterLinks", ctx) + ret := m.ctrl.Call(m, "ClusterLinks", arg0) ret0, _ := ret[0].(*redis.ClusterLinksCmd) return ret0 } // ClusterLinks indicates an expected call of ClusterLinks. -func (mr *MockCmdableMockRecorder) ClusterLinks(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterLinks(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockCmdable)(nil).ClusterLinks), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockCmdable)(nil).ClusterLinks), arg0) } // ClusterMeet mocks base method. -func (m *MockCmdable) ClusterMeet(ctx context.Context, host, port string) *redis.StatusCmd { +func (m *MockCmdable) ClusterMeet(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterMeet", ctx, host, port) + ret := m.ctrl.Call(m, "ClusterMeet", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterMeet indicates an expected call of ClusterMeet. -func (mr *MockCmdableMockRecorder) ClusterMeet(ctx, host, port any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterMeet(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockCmdable)(nil).ClusterMeet), ctx, host, port) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockCmdable)(nil).ClusterMeet), arg0, arg1, arg2) } // ClusterMyShardID mocks base method. -func (m *MockCmdable) ClusterMyShardID(ctx context.Context) *redis.StringCmd { +func (m *MockCmdable) ClusterMyShardID(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterMyShardID", ctx) + ret := m.ctrl.Call(m, "ClusterMyShardID", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // ClusterMyShardID indicates an expected call of ClusterMyShardID. -func (mr *MockCmdableMockRecorder) ClusterMyShardID(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterMyShardID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockCmdable)(nil).ClusterMyShardID), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockCmdable)(nil).ClusterMyShardID), arg0) } // ClusterNodes mocks base method. -func (m *MockCmdable) ClusterNodes(ctx context.Context) *redis.StringCmd { +func (m *MockCmdable) ClusterNodes(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterNodes", ctx) + ret := m.ctrl.Call(m, "ClusterNodes", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // ClusterNodes indicates an expected call of ClusterNodes. -func (mr *MockCmdableMockRecorder) ClusterNodes(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterNodes(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockCmdable)(nil).ClusterNodes), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockCmdable)(nil).ClusterNodes), arg0) } // ClusterReplicate mocks base method. -func (m *MockCmdable) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd { +func (m *MockCmdable) ClusterReplicate(arg0 context.Context, arg1 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterReplicate", ctx, nodeID) + ret := m.ctrl.Call(m, "ClusterReplicate", arg0, arg1) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterReplicate indicates an expected call of ClusterReplicate. -func (mr *MockCmdableMockRecorder) ClusterReplicate(ctx, nodeID any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterReplicate(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockCmdable)(nil).ClusterReplicate), ctx, nodeID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockCmdable)(nil).ClusterReplicate), arg0, arg1) } // ClusterResetHard mocks base method. -func (m *MockCmdable) ClusterResetHard(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ClusterResetHard(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterResetHard", ctx) + ret := m.ctrl.Call(m, "ClusterResetHard", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterResetHard indicates an expected call of ClusterResetHard. -func (mr *MockCmdableMockRecorder) ClusterResetHard(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterResetHard(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockCmdable)(nil).ClusterResetHard), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockCmdable)(nil).ClusterResetHard), arg0) } // ClusterResetSoft mocks base method. -func (m *MockCmdable) ClusterResetSoft(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ClusterResetSoft(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterResetSoft", ctx) + ret := m.ctrl.Call(m, "ClusterResetSoft", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterResetSoft indicates an expected call of ClusterResetSoft. -func (mr *MockCmdableMockRecorder) ClusterResetSoft(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterResetSoft(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockCmdable)(nil).ClusterResetSoft), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockCmdable)(nil).ClusterResetSoft), arg0) } // ClusterSaveConfig mocks base method. -func (m *MockCmdable) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ClusterSaveConfig(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterSaveConfig", ctx) + ret := m.ctrl.Call(m, "ClusterSaveConfig", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ClusterSaveConfig indicates an expected call of ClusterSaveConfig. -func (mr *MockCmdableMockRecorder) ClusterSaveConfig(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterSaveConfig(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockCmdable)(nil).ClusterSaveConfig), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockCmdable)(nil).ClusterSaveConfig), arg0) } // ClusterShards mocks base method. -func (m *MockCmdable) ClusterShards(ctx context.Context) *redis.ClusterShardsCmd { +func (m *MockCmdable) ClusterShards(arg0 context.Context) *redis.ClusterShardsCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterShards", ctx) + ret := m.ctrl.Call(m, "ClusterShards", arg0) ret0, _ := ret[0].(*redis.ClusterShardsCmd) return ret0 } // ClusterShards indicates an expected call of ClusterShards. -func (mr *MockCmdableMockRecorder) ClusterShards(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterShards(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockCmdable)(nil).ClusterShards), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockCmdable)(nil).ClusterShards), arg0) } // ClusterSlaves mocks base method. -func (m *MockCmdable) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd { +func (m *MockCmdable) ClusterSlaves(arg0 context.Context, arg1 string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterSlaves", ctx, nodeID) + ret := m.ctrl.Call(m, "ClusterSlaves", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ClusterSlaves indicates an expected call of ClusterSlaves. -func (mr *MockCmdableMockRecorder) ClusterSlaves(ctx, nodeID any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterSlaves(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockCmdable)(nil).ClusterSlaves), ctx, nodeID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockCmdable)(nil).ClusterSlaves), arg0, arg1) } // ClusterSlots mocks base method. -func (m *MockCmdable) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd { +func (m *MockCmdable) ClusterSlots(arg0 context.Context) *redis.ClusterSlotsCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClusterSlots", ctx) + ret := m.ctrl.Call(m, "ClusterSlots", arg0) ret0, _ := ret[0].(*redis.ClusterSlotsCmd) return ret0 } // ClusterSlots indicates an expected call of ClusterSlots. -func (mr *MockCmdableMockRecorder) ClusterSlots(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ClusterSlots(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterSlots), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterSlots), arg0) } // Command mocks base method. -func (m *MockCmdable) Command(ctx context.Context) *redis.CommandsInfoCmd { +func (m *MockCmdable) Command(arg0 context.Context) *redis.CommandsInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Command", ctx) + ret := m.ctrl.Call(m, "Command", arg0) ret0, _ := ret[0].(*redis.CommandsInfoCmd) return ret0 } // Command indicates an expected call of Command. -func (mr *MockCmdableMockRecorder) Command(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Command(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockCmdable)(nil).Command), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockCmdable)(nil).Command), arg0) } // CommandGetKeys mocks base method. -func (m *MockCmdable) CommandGetKeys(ctx context.Context, commands ...any) *redis.StringSliceCmd { +func (m *MockCmdable) CommandGetKeys(arg0 context.Context, arg1 ...any) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range commands { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CommandGetKeys", varargs...) @@ -1545,17 +1408,17 @@ func (m *MockCmdable) CommandGetKeys(ctx context.Context, commands ...any) *redi } // CommandGetKeys indicates an expected call of CommandGetKeys. -func (mr *MockCmdableMockRecorder) CommandGetKeys(ctx any, commands ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CommandGetKeys(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, commands...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) CommandGetKeysAndFlags(arg0 context.Context, arg1 ...any) *redis.KeyFlagsCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range commands { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...) @@ -1564,157 +1427,157 @@ func (m *MockCmdable) CommandGetKeysAndFlags(ctx context.Context, commands ...an } // CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags. -func (mr *MockCmdableMockRecorder) CommandGetKeysAndFlags(ctx any, commands ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CommandGetKeysAndFlags(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, commands...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) CommandList(arg0 context.Context, arg1 *redis.FilterBy) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CommandList", ctx, filter) + ret := m.ctrl.Call(m, "CommandList", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // CommandList indicates an expected call of CommandList. -func (mr *MockCmdableMockRecorder) CommandList(ctx, filter any) *gomock.Call { +func (mr *MockCmdableMockRecorder) CommandList(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockCmdable)(nil).CommandList), ctx, filter) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockCmdable)(nil).CommandList), arg0, arg1) } // ConfigGet mocks base method. -func (m *MockCmdable) ConfigGet(ctx context.Context, parameter string) *redis.MapStringStringCmd { +func (m *MockCmdable) ConfigGet(arg0 context.Context, arg1 string) *redis.MapStringStringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConfigGet", ctx, parameter) + ret := m.ctrl.Call(m, "ConfigGet", arg0, arg1) ret0, _ := ret[0].(*redis.MapStringStringCmd) return ret0 } // ConfigGet indicates an expected call of ConfigGet. -func (mr *MockCmdableMockRecorder) ConfigGet(ctx, parameter any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ConfigGet(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockCmdable)(nil).ConfigGet), ctx, parameter) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockCmdable)(nil).ConfigGet), arg0, arg1) } // ConfigResetStat mocks base method. -func (m *MockCmdable) ConfigResetStat(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ConfigResetStat(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConfigResetStat", ctx) + ret := m.ctrl.Call(m, "ConfigResetStat", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ConfigResetStat indicates an expected call of ConfigResetStat. -func (mr *MockCmdableMockRecorder) ConfigResetStat(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ConfigResetStat(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockCmdable)(nil).ConfigResetStat), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockCmdable)(nil).ConfigResetStat), arg0) } // ConfigRewrite mocks base method. -func (m *MockCmdable) ConfigRewrite(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ConfigRewrite(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConfigRewrite", ctx) + ret := m.ctrl.Call(m, "ConfigRewrite", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ConfigRewrite indicates an expected call of ConfigRewrite. -func (mr *MockCmdableMockRecorder) ConfigRewrite(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ConfigRewrite(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockCmdable)(nil).ConfigRewrite), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockCmdable)(nil).ConfigRewrite), arg0) } // ConfigSet mocks base method. -func (m *MockCmdable) ConfigSet(ctx context.Context, parameter, value string) *redis.StatusCmd { +func (m *MockCmdable) ConfigSet(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConfigSet", ctx, parameter, value) + ret := m.ctrl.Call(m, "ConfigSet", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ConfigSet indicates an expected call of ConfigSet. -func (mr *MockCmdableMockRecorder) ConfigSet(ctx, parameter, value any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ConfigSet(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockCmdable)(nil).ConfigSet), ctx, parameter, value) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockCmdable)(nil).ConfigSet), arg0, arg1, arg2) } // Copy mocks base method. -func (m *MockCmdable) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *redis.IntCmd { +func (m *MockCmdable) Copy(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 bool) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Copy", ctx, sourceKey, destKey, db, replace) + ret := m.ctrl.Call(m, "Copy", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) Copy(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockCmdable)(nil).Copy), arg0, arg1, arg2, arg3, arg4) } // DBSize mocks base method. -func (m *MockCmdable) DBSize(ctx context.Context) *redis.IntCmd { +func (m *MockCmdable) DBSize(arg0 context.Context) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DBSize", ctx) + ret := m.ctrl.Call(m, "DBSize", arg0) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // DBSize indicates an expected call of DBSize. -func (mr *MockCmdableMockRecorder) DBSize(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) DBSize(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockCmdable)(nil).DBSize), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockCmdable)(nil).DBSize), arg0) } // DebugObject mocks base method. -func (m *MockCmdable) DebugObject(ctx context.Context, key string) *redis.StringCmd { +func (m *MockCmdable) DebugObject(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DebugObject", ctx, key) + ret := m.ctrl.Call(m, "DebugObject", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // DebugObject indicates an expected call of DebugObject. -func (mr *MockCmdableMockRecorder) DebugObject(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) DebugObject(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockCmdable)(nil).DebugObject), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockCmdable)(nil).DebugObject), arg0, arg1) } // Decr mocks base method. -func (m *MockCmdable) Decr(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) Decr(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Decr", ctx, key) + ret := m.ctrl.Call(m, "Decr", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // Decr indicates an expected call of Decr. -func (mr *MockCmdableMockRecorder) Decr(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Decr(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockCmdable)(nil).Decr), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockCmdable)(nil).Decr), arg0, arg1) } // DecrBy mocks base method. -func (m *MockCmdable) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd { +func (m *MockCmdable) DecrBy(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DecrBy", ctx, key, decrement) + ret := m.ctrl.Call(m, "DecrBy", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // DecrBy indicates an expected call of DecrBy. -func (mr *MockCmdableMockRecorder) DecrBy(ctx, key, decrement any) *gomock.Call { +func (mr *MockCmdableMockRecorder) DecrBy(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockCmdable)(nil).DecrBy), ctx, key, decrement) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockCmdable)(nil).DecrBy), arg0, arg1, arg2) } // Del mocks base method. -func (m *MockCmdable) Del(ctx context.Context, keys ...string) *redis.IntCmd { +func (m *MockCmdable) Del(arg0 context.Context, arg1 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Del", varargs...) @@ -1723,45 +1586,45 @@ func (m *MockCmdable) Del(ctx context.Context, keys ...string) *redis.IntCmd { } // Del indicates an expected call of Del. -func (mr *MockCmdableMockRecorder) Del(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Del(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, keys...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) Dump(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Dump", ctx, key) + ret := m.ctrl.Call(m, "Dump", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // Dump indicates an expected call of Dump. -func (mr *MockCmdableMockRecorder) Dump(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Dump(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockCmdable)(nil).Dump), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockCmdable)(nil).Dump), arg0, arg1) } // Echo mocks base method. -func (m *MockCmdable) Echo(ctx context.Context, message any) *redis.StringCmd { +func (m *MockCmdable) Echo(arg0 context.Context, arg1 any) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Echo", ctx, message) + ret := m.ctrl.Call(m, "Echo", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // Echo indicates an expected call of Echo. -func (mr *MockCmdableMockRecorder) Echo(ctx, message any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Echo(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockCmdable)(nil).Echo), ctx, message) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockCmdable)(nil).Echo), arg0, arg1) } // Eval mocks base method. -func (m *MockCmdable) Eval(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd { +func (m *MockCmdable) Eval(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { m.ctrl.T.Helper() - varargs := []any{ctx, script, keys} - for _, a := range args { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Eval", varargs...) @@ -1770,17 +1633,17 @@ func (m *MockCmdable) Eval(ctx context.Context, script string, keys []string, ar } // Eval indicates an expected call of Eval. -func (mr *MockCmdableMockRecorder) Eval(ctx, script, keys any, args ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Eval(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, script, keys}, args...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) EvalRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { m.ctrl.T.Helper() - varargs := []any{ctx, script, keys} - for _, a := range args { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "EvalRO", varargs...) @@ -1789,17 +1652,17 @@ func (m *MockCmdable) EvalRO(ctx context.Context, script string, keys []string, } // EvalRO indicates an expected call of EvalRO. -func (mr *MockCmdableMockRecorder) EvalRO(ctx, script, keys any, args ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) EvalRO(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, script, keys}, args...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) EvalSha(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { m.ctrl.T.Helper() - varargs := []any{ctx, sha1, keys} - for _, a := range args { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "EvalSha", varargs...) @@ -1808,17 +1671,17 @@ func (m *MockCmdable) EvalSha(ctx context.Context, sha1 string, keys []string, a } // EvalSha indicates an expected call of EvalSha. -func (mr *MockCmdableMockRecorder) EvalSha(ctx, sha1, keys any, args ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) EvalSha(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, sha1, keys}, args...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) EvalShaRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { m.ctrl.T.Helper() - varargs := []any{ctx, sha1, keys} - for _, a := range args { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "EvalShaRO", varargs...) @@ -1827,17 +1690,17 @@ func (m *MockCmdable) EvalShaRO(ctx context.Context, sha1 string, keys []string, } // EvalShaRO indicates an expected call of EvalShaRO. -func (mr *MockCmdableMockRecorder) EvalShaRO(ctx, sha1, keys any, args ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) EvalShaRO(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, sha1, keys}, args...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) Exists(arg0 context.Context, arg1 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Exists", varargs...) @@ -1846,115 +1709,115 @@ func (m *MockCmdable) Exists(ctx context.Context, keys ...string) *redis.IntCmd } // Exists indicates an expected call of Exists. -func (mr *MockCmdableMockRecorder) Exists(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Exists(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, keys...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) Expire(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Expire", ctx, key, expiration) + ret := m.ctrl.Call(m, "Expire", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // Expire indicates an expected call of Expire. -func (mr *MockCmdableMockRecorder) Expire(ctx, key, expiration any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Expire(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockCmdable)(nil).Expire), ctx, key, expiration) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockCmdable)(nil).Expire), arg0, arg1, arg2) } // ExpireAt mocks base method. -func (m *MockCmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { +func (m *MockCmdable) ExpireAt(arg0 context.Context, arg1 string, arg2 time.Time) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExpireAt", ctx, key, tm) + ret := m.ctrl.Call(m, "ExpireAt", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // ExpireAt indicates an expected call of ExpireAt. -func (mr *MockCmdableMockRecorder) ExpireAt(ctx, key, tm any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ExpireAt(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockCmdable)(nil).ExpireAt), ctx, key, tm) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockCmdable)(nil).ExpireAt), arg0, arg1, arg2) } // ExpireGT mocks base method. -func (m *MockCmdable) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { +func (m *MockCmdable) ExpireGT(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExpireGT", ctx, key, expiration) + ret := m.ctrl.Call(m, "ExpireGT", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // ExpireGT indicates an expected call of ExpireGT. -func (mr *MockCmdableMockRecorder) ExpireGT(ctx, key, expiration any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ExpireGT(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockCmdable)(nil).ExpireGT), ctx, key, expiration) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockCmdable)(nil).ExpireGT), arg0, arg1, arg2) } // ExpireLT mocks base method. -func (m *MockCmdable) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { +func (m *MockCmdable) ExpireLT(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExpireLT", ctx, key, expiration) + ret := m.ctrl.Call(m, "ExpireLT", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // ExpireLT indicates an expected call of ExpireLT. -func (mr *MockCmdableMockRecorder) ExpireLT(ctx, key, expiration any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ExpireLT(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockCmdable)(nil).ExpireLT), ctx, key, expiration) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockCmdable)(nil).ExpireLT), arg0, arg1, arg2) } // ExpireNX mocks base method. -func (m *MockCmdable) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { +func (m *MockCmdable) ExpireNX(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExpireNX", ctx, key, expiration) + ret := m.ctrl.Call(m, "ExpireNX", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // ExpireNX indicates an expected call of ExpireNX. -func (mr *MockCmdableMockRecorder) ExpireNX(ctx, key, expiration any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ExpireNX(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockCmdable)(nil).ExpireNX), ctx, key, expiration) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockCmdable)(nil).ExpireNX), arg0, arg1, arg2) } // ExpireTime mocks base method. -func (m *MockCmdable) ExpireTime(ctx context.Context, key string) *redis.DurationCmd { +func (m *MockCmdable) ExpireTime(arg0 context.Context, arg1 string) *redis.DurationCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExpireTime", ctx, key) + ret := m.ctrl.Call(m, "ExpireTime", arg0, arg1) ret0, _ := ret[0].(*redis.DurationCmd) return ret0 } // ExpireTime indicates an expected call of ExpireTime. -func (mr *MockCmdableMockRecorder) ExpireTime(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ExpireTime(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockCmdable)(nil).ExpireTime), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockCmdable)(nil).ExpireTime), arg0, arg1) } // ExpireXX mocks base method. -func (m *MockCmdable) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { +func (m *MockCmdable) ExpireXX(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExpireXX", ctx, key, expiration) + ret := m.ctrl.Call(m, "ExpireXX", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // ExpireXX indicates an expected call of ExpireXX. -func (mr *MockCmdableMockRecorder) ExpireXX(ctx, key, expiration any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ExpireXX(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockCmdable)(nil).ExpireXX), ctx, key, expiration) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockCmdable)(nil).ExpireXX), arg0, arg1, arg2) } // FCall mocks base method. -func (m *MockCmdable) FCall(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd { +func (m *MockCmdable) FCall(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { m.ctrl.T.Helper() - varargs := []any{ctx, function, keys} - for _, a := range args { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "FCall", varargs...) @@ -1963,17 +1826,17 @@ func (m *MockCmdable) FCall(ctx context.Context, function string, keys []string, } // FCall indicates an expected call of FCall. -func (mr *MockCmdableMockRecorder) FCall(ctx, function, keys any, args ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FCall(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, function, keys}, args...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) FCallRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { m.ctrl.T.Helper() - varargs := []any{ctx, function, keys} - for _, a := range args { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "FCallRO", varargs...) @@ -1982,17 +1845,17 @@ func (m *MockCmdable) FCallRO(ctx context.Context, function string, keys []strin } // FCallRO indicates an expected call of FCallRO. -func (mr *MockCmdableMockRecorder) FCallRO(ctx, function, keys any, args ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FCallRO(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, function, keys}, args...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) FCallRo(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { m.ctrl.T.Helper() - varargs := []any{ctx, function, keys} - for _, a := range args { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "FCallRo", varargs...) @@ -2001,213 +1864,213 @@ func (m *MockCmdable) FCallRo(ctx context.Context, function string, keys []strin } // FCallRo indicates an expected call of FCallRo. -func (mr *MockCmdableMockRecorder) FCallRo(ctx, function, keys any, args ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FCallRo(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, function, keys}, args...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) FlushAll(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FlushAll", ctx) + ret := m.ctrl.Call(m, "FlushAll", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // FlushAll indicates an expected call of FlushAll. -func (mr *MockCmdableMockRecorder) FlushAll(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FlushAll(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockCmdable)(nil).FlushAll), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockCmdable)(nil).FlushAll), arg0) } // FlushAllAsync mocks base method. -func (m *MockCmdable) FlushAllAsync(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) FlushAllAsync(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FlushAllAsync", ctx) + ret := m.ctrl.Call(m, "FlushAllAsync", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // FlushAllAsync indicates an expected call of FlushAllAsync. -func (mr *MockCmdableMockRecorder) FlushAllAsync(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FlushAllAsync(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockCmdable)(nil).FlushAllAsync), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockCmdable)(nil).FlushAllAsync), arg0) } // FlushDB mocks base method. -func (m *MockCmdable) FlushDB(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) FlushDB(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FlushDB", ctx) + ret := m.ctrl.Call(m, "FlushDB", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // FlushDB indicates an expected call of FlushDB. -func (mr *MockCmdableMockRecorder) FlushDB(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FlushDB(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockCmdable)(nil).FlushDB), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockCmdable)(nil).FlushDB), arg0) } // FlushDBAsync mocks base method. -func (m *MockCmdable) FlushDBAsync(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) FlushDBAsync(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FlushDBAsync", ctx) + ret := m.ctrl.Call(m, "FlushDBAsync", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // FlushDBAsync indicates an expected call of FlushDBAsync. -func (mr *MockCmdableMockRecorder) FlushDBAsync(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FlushDBAsync(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockCmdable)(nil).FlushDBAsync), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockCmdable)(nil).FlushDBAsync), arg0) } // FunctionDelete mocks base method. -func (m *MockCmdable) FunctionDelete(ctx context.Context, libName string) *redis.StringCmd { +func (m *MockCmdable) FunctionDelete(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionDelete", ctx, libName) + ret := m.ctrl.Call(m, "FunctionDelete", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // FunctionDelete indicates an expected call of FunctionDelete. -func (mr *MockCmdableMockRecorder) FunctionDelete(ctx, libName any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionDelete(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockCmdable)(nil).FunctionDelete), ctx, libName) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockCmdable)(nil).FunctionDelete), arg0, arg1) } // FunctionDump mocks base method. -func (m *MockCmdable) FunctionDump(ctx context.Context) *redis.StringCmd { +func (m *MockCmdable) FunctionDump(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionDump", ctx) + ret := m.ctrl.Call(m, "FunctionDump", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // FunctionDump indicates an expected call of FunctionDump. -func (mr *MockCmdableMockRecorder) FunctionDump(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionDump(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockCmdable)(nil).FunctionDump), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockCmdable)(nil).FunctionDump), arg0) } // FunctionFlush mocks base method. -func (m *MockCmdable) FunctionFlush(ctx context.Context) *redis.StringCmd { +func (m *MockCmdable) FunctionFlush(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionFlush", ctx) + ret := m.ctrl.Call(m, "FunctionFlush", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // FunctionFlush indicates an expected call of FunctionFlush. -func (mr *MockCmdableMockRecorder) FunctionFlush(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionFlush(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockCmdable)(nil).FunctionFlush), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockCmdable)(nil).FunctionFlush), arg0) } // FunctionFlushAsync mocks base method. -func (m *MockCmdable) FunctionFlushAsync(ctx context.Context) *redis.StringCmd { +func (m *MockCmdable) FunctionFlushAsync(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionFlushAsync", ctx) + ret := m.ctrl.Call(m, "FunctionFlushAsync", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // FunctionFlushAsync indicates an expected call of FunctionFlushAsync. -func (mr *MockCmdableMockRecorder) FunctionFlushAsync(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionFlushAsync(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockCmdable)(nil).FunctionFlushAsync), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockCmdable)(nil).FunctionFlushAsync), arg0) } // FunctionKill mocks base method. -func (m *MockCmdable) FunctionKill(ctx context.Context) *redis.StringCmd { +func (m *MockCmdable) FunctionKill(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionKill", ctx) + ret := m.ctrl.Call(m, "FunctionKill", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // FunctionKill indicates an expected call of FunctionKill. -func (mr *MockCmdableMockRecorder) FunctionKill(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionKill(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockCmdable)(nil).FunctionKill), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockCmdable)(nil).FunctionKill), arg0) } // FunctionList mocks base method. -func (m *MockCmdable) FunctionList(ctx context.Context, q redis.FunctionListQuery) *redis.FunctionListCmd { +func (m *MockCmdable) FunctionList(arg0 context.Context, arg1 redis.FunctionListQuery) *redis.FunctionListCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionList", ctx, q) + ret := m.ctrl.Call(m, "FunctionList", arg0, arg1) ret0, _ := ret[0].(*redis.FunctionListCmd) return ret0 } // FunctionList indicates an expected call of FunctionList. -func (mr *MockCmdableMockRecorder) FunctionList(ctx, q any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionList(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockCmdable)(nil).FunctionList), ctx, q) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockCmdable)(nil).FunctionList), arg0, arg1) } // FunctionLoad mocks base method. -func (m *MockCmdable) FunctionLoad(ctx context.Context, code string) *redis.StringCmd { +func (m *MockCmdable) FunctionLoad(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionLoad", ctx, code) + ret := m.ctrl.Call(m, "FunctionLoad", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // FunctionLoad indicates an expected call of FunctionLoad. -func (mr *MockCmdableMockRecorder) FunctionLoad(ctx, code any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionLoad(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockCmdable)(nil).FunctionLoad), ctx, code) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockCmdable)(nil).FunctionLoad), arg0, arg1) } // FunctionLoadReplace mocks base method. -func (m *MockCmdable) FunctionLoadReplace(ctx context.Context, code string) *redis.StringCmd { +func (m *MockCmdable) FunctionLoadReplace(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionLoadReplace", ctx, code) + ret := m.ctrl.Call(m, "FunctionLoadReplace", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // FunctionLoadReplace indicates an expected call of FunctionLoadReplace. -func (mr *MockCmdableMockRecorder) FunctionLoadReplace(ctx, code any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionLoadReplace(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockCmdable)(nil).FunctionLoadReplace), ctx, code) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockCmdable)(nil).FunctionLoadReplace), arg0, arg1) } // FunctionRestore mocks base method. -func (m *MockCmdable) FunctionRestore(ctx context.Context, libDump string) *redis.StringCmd { +func (m *MockCmdable) FunctionRestore(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionRestore", ctx, libDump) + ret := m.ctrl.Call(m, "FunctionRestore", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // FunctionRestore indicates an expected call of FunctionRestore. -func (mr *MockCmdableMockRecorder) FunctionRestore(ctx, libDump any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionRestore(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockCmdable)(nil).FunctionRestore), ctx, libDump) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockCmdable)(nil).FunctionRestore), arg0, arg1) } // FunctionStats mocks base method. -func (m *MockCmdable) FunctionStats(ctx context.Context) *redis.FunctionStatsCmd { +func (m *MockCmdable) FunctionStats(arg0 context.Context) *redis.FunctionStatsCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FunctionStats", ctx) + ret := m.ctrl.Call(m, "FunctionStats", arg0) ret0, _ := ret[0].(*redis.FunctionStatsCmd) return ret0 } // FunctionStats indicates an expected call of FunctionStats. -func (mr *MockCmdableMockRecorder) FunctionStats(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) FunctionStats(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockCmdable)(nil).FunctionStats), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockCmdable)(nil).FunctionStats), arg0) } // GeoAdd mocks base method. -func (m *MockCmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd { +func (m *MockCmdable) GeoAdd(arg0 context.Context, arg1 string, arg2 ...*redis.GeoLocation) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range geoLocation { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GeoAdd", varargs...) @@ -2216,31 +2079,31 @@ func (m *MockCmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*re } // GeoAdd indicates an expected call of GeoAdd. -func (mr *MockCmdableMockRecorder) GeoAdd(ctx, key any, geoLocation ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) GeoAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, geoLocation...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) GeoDist(arg0 context.Context, arg1, arg2, arg3, arg4 string) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GeoDist", ctx, key, member1, member2, unit) + ret := m.ctrl.Call(m, "GeoDist", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) GeoDist(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockCmdable)(nil).GeoDist), arg0, arg1, arg2, arg3, arg4) } // GeoHash mocks base method. -func (m *MockCmdable) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd { +func (m *MockCmdable) GeoHash(arg0 context.Context, arg1 string, arg2 ...string) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GeoHash", varargs...) @@ -2249,17 +2112,17 @@ func (m *MockCmdable) GeoHash(ctx context.Context, key string, members ...string } // GeoHash indicates an expected call of GeoHash. -func (mr *MockCmdableMockRecorder) GeoHash(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) GeoHash(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, members...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) GeoPos(arg0 context.Context, arg1 string, arg2 ...string) *redis.GeoPosCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GeoPos", varargs...) @@ -2268,199 +2131,185 @@ func (m *MockCmdable) GeoPos(ctx context.Context, key string, members ...string) } // GeoPos indicates an expected call of GeoPos. -func (mr *MockCmdableMockRecorder) GeoPos(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) GeoPos(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, members...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) GeoRadius(arg0 context.Context, arg1 string, arg2, arg3 float64, arg4 *redis.GeoRadiusQuery) *redis.GeoLocationCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GeoRadius", ctx, key, longitude, latitude, query) + ret := m.ctrl.Call(m, "GeoRadius", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) GeoRadius(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockCmdable)(nil).GeoRadius), arg0, arg1, arg2, arg3, arg4) } // GeoRadiusByMember mocks base method. -func (m *MockCmdable) GeoRadiusByMember(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { +func (m *MockCmdable) GeoRadiusByMember(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoRadiusQuery) *redis.GeoLocationCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GeoRadiusByMember", ctx, key, member, query) + ret := m.ctrl.Call(m, "GeoRadiusByMember", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) GeoRadiusByMember(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMember), arg0, arg1, arg2, arg3) } // GeoRadiusByMemberStore mocks base method. -func (m *MockCmdable) GeoRadiusByMemberStore(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.IntCmd { +func (m *MockCmdable) GeoRadiusByMemberStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoRadiusQuery) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", ctx, key, member, query) + ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) GeoRadiusByMemberStore(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMemberStore), arg0, arg1, arg2, arg3) } // GeoRadiusStore mocks base method. -func (m *MockCmdable) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd { +func (m *MockCmdable) GeoRadiusStore(arg0 context.Context, arg1 string, arg2, arg3 float64, arg4 *redis.GeoRadiusQuery) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GeoRadiusStore", ctx, key, longitude, latitude, query) + ret := m.ctrl.Call(m, "GeoRadiusStore", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) GeoRadiusStore(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusStore), arg0, arg1, arg2, arg3, arg4) } // GeoSearch mocks base method. -func (m *MockCmdable) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd { +func (m *MockCmdable) GeoSearch(arg0 context.Context, arg1 string, arg2 *redis.GeoSearchQuery) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GeoSearch", ctx, key, q) + ret := m.ctrl.Call(m, "GeoSearch", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // GeoSearch indicates an expected call of GeoSearch. -func (mr *MockCmdableMockRecorder) GeoSearch(ctx, key, q any) *gomock.Call { +func (mr *MockCmdableMockRecorder) GeoSearch(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockCmdable)(nil).GeoSearch), ctx, key, q) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockCmdable)(nil).GeoSearch), arg0, arg1, arg2) } // GeoSearchLocation mocks base method. -func (m *MockCmdable) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { +func (m *MockCmdable) GeoSearchLocation(arg0 context.Context, arg1 string, arg2 *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GeoSearchLocation", ctx, key, q) + ret := m.ctrl.Call(m, "GeoSearchLocation", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.GeoSearchLocationCmd) return ret0 } // GeoSearchLocation indicates an expected call of GeoSearchLocation. -func (mr *MockCmdableMockRecorder) GeoSearchLocation(ctx, key, q any) *gomock.Call { +func (mr *MockCmdableMockRecorder) GeoSearchLocation(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockCmdable)(nil).GeoSearchLocation), ctx, key, q) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockCmdable)(nil).GeoSearchLocation), arg0, arg1, arg2) } // GeoSearchStore mocks base method. -func (m *MockCmdable) GeoSearchStore(ctx context.Context, key, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd { +func (m *MockCmdable) GeoSearchStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoSearchStoreQuery) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GeoSearchStore", ctx, key, store, q) + ret := m.ctrl.Call(m, "GeoSearchStore", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) GeoSearchStore(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockCmdable)(nil).GeoSearchStore), arg0, arg1, arg2, arg3) } // Get mocks base method. -func (m *MockCmdable) Get(ctx context.Context, key string) *redis.StringCmd { +func (m *MockCmdable) Get(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", ctx, key) + ret := m.ctrl.Call(m, "Get", arg0, arg1) 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 { +func (mr *MockCmdableMockRecorder) Get(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockCmdable)(nil).GetBit), ctx, key, offset) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCmdable)(nil).Get), arg0, arg1) } // GetDel mocks base method. -func (m *MockCmdable) GetDel(ctx context.Context, key string) *redis.StringCmd { +func (m *MockCmdable) GetDel(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDel", ctx, key) + ret := m.ctrl.Call(m, "GetDel", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // GetDel indicates an expected call of GetDel. -func (mr *MockCmdableMockRecorder) GetDel(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) GetDel(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockCmdable)(nil).GetDel), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockCmdable)(nil).GetDel), arg0, arg1) } // GetEx mocks base method. -func (m *MockCmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd { +func (m *MockCmdable) GetEx(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEx", ctx, key, expiration) + ret := m.ctrl.Call(m, "GetEx", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // GetEx indicates an expected call of GetEx. -func (mr *MockCmdableMockRecorder) GetEx(ctx, key, expiration any) *gomock.Call { +func (mr *MockCmdableMockRecorder) GetEx(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockCmdable)(nil).GetEx), ctx, key, expiration) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockCmdable)(nil).GetEx), arg0, arg1, arg2) } // GetRange mocks base method. -func (m *MockCmdable) GetRange(ctx context.Context, key string, start, end int64) *redis.StringCmd { +func (m *MockCmdable) GetRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRange", ctx, key, start, end) + ret := m.ctrl.Call(m, "GetRange", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) GetRange(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockCmdable)(nil).GetRange), arg0, arg1, arg2, arg3) } // GetSet mocks base method. -func (m *MockCmdable) GetSet(ctx context.Context, key string, value any) *redis.StringCmd { +func (m *MockCmdable) GetSet(arg0 context.Context, arg1 string, arg2 any) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSet", ctx, key, value) + ret := m.ctrl.Call(m, "GetSet", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // GetSet indicates an expected call of GetSet. -func (mr *MockCmdableMockRecorder) GetSet(ctx, key, value any) *gomock.Call { +func (mr *MockCmdableMockRecorder) GetSet(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockCmdable)(nil).GetSet), ctx, key, value) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockCmdable)(nil).GetSet), arg0, arg1, arg2) } // HDel mocks base method. -func (m *MockCmdable) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd { +func (m *MockCmdable) HDel(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range fields { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "HDel", varargs...) @@ -2469,115 +2318,115 @@ func (m *MockCmdable) HDel(ctx context.Context, key string, fields ...string) *r } // HDel indicates an expected call of HDel. -func (mr *MockCmdableMockRecorder) HDel(ctx, key any, fields ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HDel(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, fields...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) HExists(arg0 context.Context, arg1, arg2 string) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HExists", ctx, key, field) + ret := m.ctrl.Call(m, "HExists", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // HExists indicates an expected call of HExists. -func (mr *MockCmdableMockRecorder) HExists(ctx, key, field any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HExists(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockCmdable)(nil).HExists), ctx, key, field) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockCmdable)(nil).HExists), arg0, arg1, arg2) } // HGet mocks base method. -func (m *MockCmdable) HGet(ctx context.Context, key, field string) *redis.StringCmd { +func (m *MockCmdable) HGet(arg0 context.Context, arg1, arg2 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HGet", ctx, key, field) + ret := m.ctrl.Call(m, "HGet", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // HGet indicates an expected call of HGet. -func (mr *MockCmdableMockRecorder) HGet(ctx, key, field any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HGet(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockCmdable)(nil).HGet), ctx, key, field) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockCmdable)(nil).HGet), arg0, arg1, arg2) } // HGetAll mocks base method. -func (m *MockCmdable) HGetAll(ctx context.Context, key string) *redis.MapStringStringCmd { +func (m *MockCmdable) HGetAll(arg0 context.Context, arg1 string) *redis.MapStringStringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HGetAll", ctx, key) + ret := m.ctrl.Call(m, "HGetAll", arg0, arg1) ret0, _ := ret[0].(*redis.MapStringStringCmd) return ret0 } // HGetAll indicates an expected call of HGetAll. -func (mr *MockCmdableMockRecorder) HGetAll(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HGetAll(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockCmdable)(nil).HGetAll), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockCmdable)(nil).HGetAll), arg0, arg1) } // HIncrBy mocks base method. -func (m *MockCmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *redis.IntCmd { +func (m *MockCmdable) HIncrBy(arg0 context.Context, arg1, arg2 string, arg3 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HIncrBy", ctx, key, field, incr) + ret := m.ctrl.Call(m, "HIncrBy", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) HIncrBy(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockCmdable)(nil).HIncrBy), arg0, arg1, arg2, arg3) } // HIncrByFloat mocks base method. -func (m *MockCmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *redis.FloatCmd { +func (m *MockCmdable) HIncrByFloat(arg0 context.Context, arg1, arg2 string, arg3 float64) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HIncrByFloat", ctx, key, field, incr) + ret := m.ctrl.Call(m, "HIncrByFloat", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) HIncrByFloat(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockCmdable)(nil).HIncrByFloat), arg0, arg1, arg2, arg3) } // HKeys mocks base method. -func (m *MockCmdable) HKeys(ctx context.Context, key string) *redis.StringSliceCmd { +func (m *MockCmdable) HKeys(arg0 context.Context, arg1 string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HKeys", ctx, key) + ret := m.ctrl.Call(m, "HKeys", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // HKeys indicates an expected call of HKeys. -func (mr *MockCmdableMockRecorder) HKeys(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HKeys(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockCmdable)(nil).HKeys), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockCmdable)(nil).HKeys), arg0, arg1) } // HLen mocks base method. -func (m *MockCmdable) HLen(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) HLen(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HLen", ctx, key) + ret := m.ctrl.Call(m, "HLen", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // HLen indicates an expected call of HLen. -func (mr *MockCmdableMockRecorder) HLen(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HLen(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockCmdable)(nil).HLen), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockCmdable)(nil).HLen), arg0, arg1) } // HMGet mocks base method. -func (m *MockCmdable) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd { +func (m *MockCmdable) HMGet(arg0 context.Context, arg1 string, arg2 ...string) *redis.SliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range fields { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "HMGet", varargs...) @@ -2586,17 +2435,17 @@ func (m *MockCmdable) HMGet(ctx context.Context, key string, fields ...string) * } // HMGet indicates an expected call of HMGet. -func (mr *MockCmdableMockRecorder) HMGet(ctx, key any, fields ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HMGet(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, fields...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) HMSet(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range values { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "HMSet", varargs...) @@ -2605,59 +2454,59 @@ func (m *MockCmdable) HMSet(ctx context.Context, key string, values ...any) *red } // HMSet indicates an expected call of HMSet. -func (mr *MockCmdableMockRecorder) HMSet(ctx, key any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HMSet(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, values...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) HRandField(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HRandField", ctx, key, count) + ret := m.ctrl.Call(m, "HRandField", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // HRandField indicates an expected call of HRandField. -func (mr *MockCmdableMockRecorder) HRandField(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HRandField(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockCmdable)(nil).HRandField), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockCmdable)(nil).HRandField), arg0, arg1, arg2) } // HRandFieldWithValues mocks base method. -func (m *MockCmdable) HRandFieldWithValues(ctx context.Context, key string, count int) *redis.KeyValueSliceCmd { +func (m *MockCmdable) HRandFieldWithValues(arg0 context.Context, arg1 string, arg2 int) *redis.KeyValueSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HRandFieldWithValues", ctx, key, count) + ret := m.ctrl.Call(m, "HRandFieldWithValues", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.KeyValueSliceCmd) return ret0 } // HRandFieldWithValues indicates an expected call of HRandFieldWithValues. -func (mr *MockCmdableMockRecorder) HRandFieldWithValues(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HRandFieldWithValues(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockCmdable)(nil).HRandFieldWithValues), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockCmdable)(nil).HRandFieldWithValues), arg0, arg1, arg2) } // HScan mocks base method. -func (m *MockCmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { +func (m *MockCmdable) HScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HScan", ctx, key, cursor, match, count) + ret := m.ctrl.Call(m, "HScan", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) HScan(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockCmdable)(nil).HScan), arg0, arg1, arg2, arg3, arg4) } // HSet mocks base method. -func (m *MockCmdable) HSet(ctx context.Context, key string, values ...any) *redis.IntCmd { +func (m *MockCmdable) HSet(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range values { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "HSet", varargs...) @@ -2666,87 +2515,87 @@ func (m *MockCmdable) HSet(ctx context.Context, key string, values ...any) *redi } // HSet indicates an expected call of HSet. -func (mr *MockCmdableMockRecorder) HSet(ctx, key any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HSet(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, values...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) HSetNX(arg0 context.Context, arg1, arg2 string, arg3 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HSetNX", ctx, key, field, value) + ret := m.ctrl.Call(m, "HSetNX", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) HSetNX(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockCmdable)(nil).HSetNX), arg0, arg1, arg2, arg3) } // HVals mocks base method. -func (m *MockCmdable) HVals(ctx context.Context, key string) *redis.StringSliceCmd { +func (m *MockCmdable) HVals(arg0 context.Context, arg1 string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HVals", ctx, key) + ret := m.ctrl.Call(m, "HVals", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // HVals indicates an expected call of HVals. -func (mr *MockCmdableMockRecorder) HVals(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) HVals(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockCmdable)(nil).HVals), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockCmdable)(nil).HVals), arg0, arg1) } // Incr mocks base method. -func (m *MockCmdable) Incr(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) Incr(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Incr", ctx, key) + ret := m.ctrl.Call(m, "Incr", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // Incr indicates an expected call of Incr. -func (mr *MockCmdableMockRecorder) Incr(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Incr(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockCmdable)(nil).Incr), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockCmdable)(nil).Incr), arg0, arg1) } // IncrBy mocks base method. -func (m *MockCmdable) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd { +func (m *MockCmdable) IncrBy(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IncrBy", ctx, key, value) + ret := m.ctrl.Call(m, "IncrBy", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // IncrBy indicates an expected call of IncrBy. -func (mr *MockCmdableMockRecorder) IncrBy(ctx, key, value any) *gomock.Call { +func (mr *MockCmdableMockRecorder) IncrBy(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockCmdable)(nil).IncrBy), ctx, key, value) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockCmdable)(nil).IncrBy), arg0, arg1, arg2) } // IncrByFloat mocks base method. -func (m *MockCmdable) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd { +func (m *MockCmdable) IncrByFloat(arg0 context.Context, arg1 string, arg2 float64) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IncrByFloat", ctx, key, value) + ret := m.ctrl.Call(m, "IncrByFloat", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.FloatCmd) return ret0 } // IncrByFloat indicates an expected call of IncrByFloat. -func (mr *MockCmdableMockRecorder) IncrByFloat(ctx, key, value any) *gomock.Call { +func (mr *MockCmdableMockRecorder) IncrByFloat(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockCmdable)(nil).IncrByFloat), ctx, key, value) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockCmdable)(nil).IncrByFloat), arg0, arg1, arg2) } // Info mocks base method. -func (m *MockCmdable) Info(ctx context.Context, section ...string) *redis.StringCmd { +func (m *MockCmdable) Info(arg0 context.Context, arg1 ...string) *redis.StringCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range section { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Info", varargs...) @@ -2755,115 +2604,115 @@ func (m *MockCmdable) Info(ctx context.Context, section ...string) *redis.String } // Info indicates an expected call of Info. -func (mr *MockCmdableMockRecorder) Info(ctx any, section ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Info(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, section...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) Keys(arg0 context.Context, arg1 string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Keys", ctx, pattern) + ret := m.ctrl.Call(m, "Keys", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // Keys indicates an expected call of Keys. -func (mr *MockCmdableMockRecorder) Keys(ctx, pattern any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Keys(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockCmdable)(nil).Keys), ctx, pattern) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockCmdable)(nil).Keys), arg0, arg1) } // LCS mocks base method. -func (m *MockCmdable) LCS(ctx context.Context, q *redis.LCSQuery) *redis.LCSCmd { +func (m *MockCmdable) LCS(arg0 context.Context, arg1 *redis.LCSQuery) *redis.LCSCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LCS", ctx, q) + ret := m.ctrl.Call(m, "LCS", arg0, arg1) ret0, _ := ret[0].(*redis.LCSCmd) return ret0 } // LCS indicates an expected call of LCS. -func (mr *MockCmdableMockRecorder) LCS(ctx, q any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LCS(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockCmdable)(nil).LCS), ctx, q) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockCmdable)(nil).LCS), arg0, arg1) } // LIndex mocks base method. -func (m *MockCmdable) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd { +func (m *MockCmdable) LIndex(arg0 context.Context, arg1 string, arg2 int64) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LIndex", ctx, key, index) + ret := m.ctrl.Call(m, "LIndex", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // LIndex indicates an expected call of LIndex. -func (mr *MockCmdableMockRecorder) LIndex(ctx, key, index any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LIndex(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockCmdable)(nil).LIndex), ctx, key, index) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockCmdable)(nil).LIndex), arg0, arg1, arg2) } // LInsert mocks base method. -func (m *MockCmdable) LInsert(ctx context.Context, key, op string, pivot, value any) *redis.IntCmd { +func (m *MockCmdable) LInsert(arg0 context.Context, arg1, arg2 string, arg3, arg4 any) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LInsert", ctx, key, op, pivot, value) + ret := m.ctrl.Call(m, "LInsert", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) LInsert(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockCmdable)(nil).LInsert), arg0, arg1, arg2, arg3, arg4) } // LInsertAfter mocks base method. -func (m *MockCmdable) LInsertAfter(ctx context.Context, key string, pivot, value any) *redis.IntCmd { +func (m *MockCmdable) LInsertAfter(arg0 context.Context, arg1 string, arg2, arg3 any) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LInsertAfter", ctx, key, pivot, value) + ret := m.ctrl.Call(m, "LInsertAfter", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) LInsertAfter(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockCmdable)(nil).LInsertAfter), arg0, arg1, arg2, arg3) } // LInsertBefore mocks base method. -func (m *MockCmdable) LInsertBefore(ctx context.Context, key string, pivot, value any) *redis.IntCmd { +func (m *MockCmdable) LInsertBefore(arg0 context.Context, arg1 string, arg2, arg3 any) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LInsertBefore", ctx, key, pivot, value) + ret := m.ctrl.Call(m, "LInsertBefore", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) LInsertBefore(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockCmdable)(nil).LInsertBefore), arg0, arg1, arg2, arg3) } // LLen mocks base method. -func (m *MockCmdable) LLen(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) LLen(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LLen", ctx, key) + ret := m.ctrl.Call(m, "LLen", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // LLen indicates an expected call of LLen. -func (mr *MockCmdableMockRecorder) LLen(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LLen(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockCmdable)(nil).LLen), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockCmdable)(nil).LLen), arg0, arg1) } // LMPop mocks base method. -func (m *MockCmdable) LMPop(ctx context.Context, direction string, count int64, keys ...string) *redis.KeyValuesCmd { +func (m *MockCmdable) LMPop(arg0 context.Context, arg1 string, arg2 int64, arg3 ...string) *redis.KeyValuesCmd { m.ctrl.T.Helper() - varargs := []any{ctx, direction, count} - for _, a := range keys { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "LMPop", varargs...) @@ -2872,87 +2721,87 @@ func (m *MockCmdable) LMPop(ctx context.Context, direction string, count int64, } // LMPop indicates an expected call of LMPop. -func (mr *MockCmdableMockRecorder) LMPop(ctx, direction, count any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LMPop(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, direction, count}, keys...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) LMove(arg0 context.Context, arg1, arg2, arg3, arg4 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LMove", ctx, source, destination, srcpos, destpos) + ret := m.ctrl.Call(m, "LMove", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) LMove(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockCmdable)(nil).LMove), arg0, arg1, arg2, arg3, arg4) } // LPop mocks base method. -func (m *MockCmdable) LPop(ctx context.Context, key string) *redis.StringCmd { +func (m *MockCmdable) LPop(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LPop", ctx, key) + ret := m.ctrl.Call(m, "LPop", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // LPop indicates an expected call of LPop. -func (mr *MockCmdableMockRecorder) LPop(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LPop(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockCmdable)(nil).LPop), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockCmdable)(nil).LPop), arg0, arg1) } // LPopCount mocks base method. -func (m *MockCmdable) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { +func (m *MockCmdable) LPopCount(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LPopCount", ctx, key, count) + ret := m.ctrl.Call(m, "LPopCount", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // LPopCount indicates an expected call of LPopCount. -func (mr *MockCmdableMockRecorder) LPopCount(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LPopCount(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockCmdable)(nil).LPopCount), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockCmdable)(nil).LPopCount), arg0, arg1, arg2) } // LPos mocks base method. -func (m *MockCmdable) LPos(ctx context.Context, key, value string, args redis.LPosArgs) *redis.IntCmd { +func (m *MockCmdable) LPos(arg0 context.Context, arg1, arg2 string, arg3 redis.LPosArgs) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LPos", ctx, key, value, args) + ret := m.ctrl.Call(m, "LPos", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) LPos(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockCmdable)(nil).LPos), arg0, arg1, arg2, arg3) } // LPosCount mocks base method. -func (m *MockCmdable) LPosCount(ctx context.Context, key, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd { +func (m *MockCmdable) LPosCount(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 redis.LPosArgs) *redis.IntSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LPosCount", ctx, key, value, count, args) + ret := m.ctrl.Call(m, "LPosCount", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) LPosCount(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockCmdable)(nil).LPosCount), arg0, arg1, arg2, arg3, arg4) } // LPush mocks base method. -func (m *MockCmdable) LPush(ctx context.Context, key string, values ...any) *redis.IntCmd { +func (m *MockCmdable) LPush(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range values { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "LPush", varargs...) @@ -2961,17 +2810,17 @@ func (m *MockCmdable) LPush(ctx context.Context, key string, values ...any) *red } // LPush indicates an expected call of LPush. -func (mr *MockCmdableMockRecorder) LPush(ctx, key any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LPush(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, values...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) LPushX(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range values { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "LPushX", varargs...) @@ -2980,87 +2829,87 @@ func (m *MockCmdable) LPushX(ctx context.Context, key string, values ...any) *re } // LPushX indicates an expected call of LPushX. -func (mr *MockCmdableMockRecorder) LPushX(ctx, key any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LPushX(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, values...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) LRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LRange", ctx, key, start, stop) + ret := m.ctrl.Call(m, "LRange", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) LRange(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockCmdable)(nil).LRange), arg0, arg1, arg2, arg3) } // LRem mocks base method. -func (m *MockCmdable) LRem(ctx context.Context, key string, count int64, value any) *redis.IntCmd { +func (m *MockCmdable) LRem(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LRem", ctx, key, count, value) + ret := m.ctrl.Call(m, "LRem", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) LRem(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockCmdable)(nil).LRem), arg0, arg1, arg2, arg3) } // LSet mocks base method. -func (m *MockCmdable) LSet(ctx context.Context, key string, index int64, value any) *redis.StatusCmd { +func (m *MockCmdable) LSet(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LSet", ctx, key, index, value) + ret := m.ctrl.Call(m, "LSet", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) LSet(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockCmdable)(nil).LSet), arg0, arg1, arg2, arg3) } // LTrim mocks base method. -func (m *MockCmdable) LTrim(ctx context.Context, key string, start, stop int64) *redis.StatusCmd { +func (m *MockCmdable) LTrim(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LTrim", ctx, key, start, stop) + ret := m.ctrl.Call(m, "LTrim", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) LTrim(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockCmdable)(nil).LTrim), arg0, arg1, arg2, arg3) } // LastSave mocks base method. -func (m *MockCmdable) LastSave(ctx context.Context) *redis.IntCmd { +func (m *MockCmdable) LastSave(arg0 context.Context) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LastSave", ctx) + ret := m.ctrl.Call(m, "LastSave", arg0) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // LastSave indicates an expected call of LastSave. -func (mr *MockCmdableMockRecorder) LastSave(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) LastSave(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockCmdable)(nil).LastSave), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockCmdable)(nil).LastSave), arg0) } // MGet mocks base method. -func (m *MockCmdable) MGet(ctx context.Context, keys ...string) *redis.SliceCmd { +func (m *MockCmdable) MGet(arg0 context.Context, arg1 ...string) *redis.SliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "MGet", varargs...) @@ -3069,17 +2918,17 @@ func (m *MockCmdable) MGet(ctx context.Context, keys ...string) *redis.SliceCmd } // MGet indicates an expected call of MGet. -func (mr *MockCmdableMockRecorder) MGet(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) MGet(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, keys...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) MSet(arg0 context.Context, arg1 ...any) *redis.StatusCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range values { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "MSet", varargs...) @@ -3088,17 +2937,17 @@ func (m *MockCmdable) MSet(ctx context.Context, values ...any) *redis.StatusCmd } // MSet indicates an expected call of MSet. -func (mr *MockCmdableMockRecorder) MSet(ctx any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) MSet(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, values...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) MSetNX(arg0 context.Context, arg1 ...any) *redis.BoolCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range values { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "MSetNX", varargs...) @@ -3107,17 +2956,17 @@ func (m *MockCmdable) MSetNX(ctx context.Context, values ...any) *redis.BoolCmd } // MSetNX indicates an expected call of MSetNX. -func (mr *MockCmdableMockRecorder) MSetNX(ctx any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) MSetNX(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, values...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) MemoryUsage(arg0 context.Context, arg1 string, arg2 ...int) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range samples { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "MemoryUsage", varargs...) @@ -3126,143 +2975,143 @@ func (m *MockCmdable) MemoryUsage(ctx context.Context, key string, samples ...in } // MemoryUsage indicates an expected call of MemoryUsage. -func (mr *MockCmdableMockRecorder) MemoryUsage(ctx, key any, samples ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) MemoryUsage(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, samples...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) Migrate(arg0 context.Context, arg1, arg2, arg3 string, arg4 int, arg5 time.Duration) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Migrate", ctx, host, port, key, db, timeout) + ret := m.ctrl.Call(m, "Migrate", arg0, arg1, arg2, arg3, arg4, arg5) 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 { +func (mr *MockCmdableMockRecorder) Migrate(arg0, arg1, arg2, arg3, arg4, arg5 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockCmdable)(nil).Migrate), arg0, arg1, arg2, arg3, arg4, arg5) } // ModuleLoadex mocks base method. -func (m *MockCmdable) ModuleLoadex(ctx context.Context, conf *redis.ModuleLoadexConfig) *redis.StringCmd { +func (m *MockCmdable) ModuleLoadex(arg0 context.Context, arg1 *redis.ModuleLoadexConfig) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModuleLoadex", ctx, conf) + ret := m.ctrl.Call(m, "ModuleLoadex", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // ModuleLoadex indicates an expected call of ModuleLoadex. -func (mr *MockCmdableMockRecorder) ModuleLoadex(ctx, conf any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ModuleLoadex(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockCmdable)(nil).ModuleLoadex), ctx, conf) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockCmdable)(nil).ModuleLoadex), arg0, arg1) } // Move mocks base method. -func (m *MockCmdable) Move(ctx context.Context, key string, db int) *redis.BoolCmd { +func (m *MockCmdable) Move(arg0 context.Context, arg1 string, arg2 int) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Move", ctx, key, db) + ret := m.ctrl.Call(m, "Move", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // Move indicates an expected call of Move. -func (mr *MockCmdableMockRecorder) Move(ctx, key, db any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Move(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockCmdable)(nil).Move), ctx, key, db) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockCmdable)(nil).Move), arg0, arg1, arg2) } // ObjectEncoding mocks base method. -func (m *MockCmdable) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd { +func (m *MockCmdable) ObjectEncoding(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ObjectEncoding", ctx, key) + ret := m.ctrl.Call(m, "ObjectEncoding", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // ObjectEncoding indicates an expected call of ObjectEncoding. -func (mr *MockCmdableMockRecorder) ObjectEncoding(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ObjectEncoding(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockCmdable)(nil).ObjectEncoding), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockCmdable)(nil).ObjectEncoding), arg0, arg1) } // ObjectIdleTime mocks base method. -func (m *MockCmdable) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd { +func (m *MockCmdable) ObjectIdleTime(arg0 context.Context, arg1 string) *redis.DurationCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ObjectIdleTime", ctx, key) + ret := m.ctrl.Call(m, "ObjectIdleTime", arg0, arg1) ret0, _ := ret[0].(*redis.DurationCmd) return ret0 } // ObjectIdleTime indicates an expected call of ObjectIdleTime. -func (mr *MockCmdableMockRecorder) ObjectIdleTime(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ObjectIdleTime(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockCmdable)(nil).ObjectIdleTime), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockCmdable)(nil).ObjectIdleTime), arg0, arg1) } // ObjectRefCount mocks base method. -func (m *MockCmdable) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) ObjectRefCount(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ObjectRefCount", ctx, key) + ret := m.ctrl.Call(m, "ObjectRefCount", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ObjectRefCount indicates an expected call of ObjectRefCount. -func (mr *MockCmdableMockRecorder) ObjectRefCount(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ObjectRefCount(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockCmdable)(nil).ObjectRefCount), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockCmdable)(nil).ObjectRefCount), arg0, arg1) } // PExpire mocks base method. -func (m *MockCmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { +func (m *MockCmdable) PExpire(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PExpire", ctx, key, expiration) + ret := m.ctrl.Call(m, "PExpire", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // PExpire indicates an expected call of PExpire. -func (mr *MockCmdableMockRecorder) PExpire(ctx, key, expiration any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PExpire(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockCmdable)(nil).PExpire), ctx, key, expiration) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockCmdable)(nil).PExpire), arg0, arg1, arg2) } // PExpireAt mocks base method. -func (m *MockCmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { +func (m *MockCmdable) PExpireAt(arg0 context.Context, arg1 string, arg2 time.Time) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PExpireAt", ctx, key, tm) + ret := m.ctrl.Call(m, "PExpireAt", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // PExpireAt indicates an expected call of PExpireAt. -func (mr *MockCmdableMockRecorder) PExpireAt(ctx, key, tm any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PExpireAt(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockCmdable)(nil).PExpireAt), ctx, key, tm) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockCmdable)(nil).PExpireAt), arg0, arg1, arg2) } // PExpireTime mocks base method. -func (m *MockCmdable) PExpireTime(ctx context.Context, key string) *redis.DurationCmd { +func (m *MockCmdable) PExpireTime(arg0 context.Context, arg1 string) *redis.DurationCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PExpireTime", ctx, key) + ret := m.ctrl.Call(m, "PExpireTime", arg0, arg1) ret0, _ := ret[0].(*redis.DurationCmd) return ret0 } // PExpireTime indicates an expected call of PExpireTime. -func (mr *MockCmdableMockRecorder) PExpireTime(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PExpireTime(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockCmdable)(nil).PExpireTime), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockCmdable)(nil).PExpireTime), arg0, arg1) } // PFAdd mocks base method. -func (m *MockCmdable) PFAdd(ctx context.Context, key string, els ...any) *redis.IntCmd { +func (m *MockCmdable) PFAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range els { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PFAdd", varargs...) @@ -3271,17 +3120,17 @@ func (m *MockCmdable) PFAdd(ctx context.Context, key string, els ...any) *redis. } // PFAdd indicates an expected call of PFAdd. -func (mr *MockCmdableMockRecorder) PFAdd(ctx, key any, els ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PFAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, els...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) PFCount(arg0 context.Context, arg1 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PFCount", varargs...) @@ -3290,17 +3139,17 @@ func (m *MockCmdable) PFCount(ctx context.Context, keys ...string) *redis.IntCmd } // PFCount indicates an expected call of PFCount. -func (mr *MockCmdableMockRecorder) PFCount(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PFCount(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, keys...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) PFMerge(arg0 context.Context, arg1 string, arg2 ...string) *redis.StatusCmd { m.ctrl.T.Helper() - varargs := []any{ctx, dest} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PFMerge", varargs...) @@ -3309,52 +3158,52 @@ func (m *MockCmdable) PFMerge(ctx context.Context, dest string, keys ...string) } // PFMerge indicates an expected call of PFMerge. -func (mr *MockCmdableMockRecorder) PFMerge(ctx, dest any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PFMerge(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, dest}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) PTTL(arg0 context.Context, arg1 string) *redis.DurationCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PTTL", ctx, key) + ret := m.ctrl.Call(m, "PTTL", arg0, arg1) ret0, _ := ret[0].(*redis.DurationCmd) return ret0 } // PTTL indicates an expected call of PTTL. -func (mr *MockCmdableMockRecorder) PTTL(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PTTL(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockCmdable)(nil).PTTL), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockCmdable)(nil).PTTL), arg0, arg1) } // Persist mocks base method. -func (m *MockCmdable) Persist(ctx context.Context, key string) *redis.BoolCmd { +func (m *MockCmdable) Persist(arg0 context.Context, arg1 string) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Persist", ctx, key) + ret := m.ctrl.Call(m, "Persist", arg0, arg1) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // Persist indicates an expected call of Persist. -func (mr *MockCmdableMockRecorder) Persist(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Persist(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockCmdable)(nil).Persist), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockCmdable)(nil).Persist), arg0, arg1) } // Ping mocks base method. -func (m *MockCmdable) Ping(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) Ping(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Ping", ctx) + ret := m.ctrl.Call(m, "Ping", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // Ping indicates an expected call of Ping. -func (mr *MockCmdableMockRecorder) Ping(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Ping(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockCmdable)(nil).Ping), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockCmdable)(nil).Ping), arg0) } // Pipeline mocks base method. @@ -3372,53 +3221,53 @@ func (mr *MockCmdableMockRecorder) Pipeline() *gomock.Call { } // Pipelined mocks base method. -func (m *MockCmdable) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { +func (m *MockCmdable) Pipelined(arg0 context.Context, arg1 func(redis.Pipeliner) error) ([]redis.Cmder, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Pipelined", ctx, fn) + ret := m.ctrl.Call(m, "Pipelined", arg0, arg1) 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 { +func (mr *MockCmdableMockRecorder) Pipelined(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockCmdable)(nil).Pipelined), ctx, fn) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockCmdable)(nil).Pipelined), arg0, arg1) } // PubSubChannels mocks base method. -func (m *MockCmdable) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { +func (m *MockCmdable) PubSubChannels(arg0 context.Context, arg1 string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PubSubChannels", ctx, pattern) + ret := m.ctrl.Call(m, "PubSubChannels", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // PubSubChannels indicates an expected call of PubSubChannels. -func (mr *MockCmdableMockRecorder) PubSubChannels(ctx, pattern any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PubSubChannels(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubChannels), ctx, pattern) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubChannels), arg0, arg1) } // PubSubNumPat mocks base method. -func (m *MockCmdable) PubSubNumPat(ctx context.Context) *redis.IntCmd { +func (m *MockCmdable) PubSubNumPat(arg0 context.Context) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PubSubNumPat", ctx) + ret := m.ctrl.Call(m, "PubSubNumPat", arg0) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // PubSubNumPat indicates an expected call of PubSubNumPat. -func (mr *MockCmdableMockRecorder) PubSubNumPat(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PubSubNumPat(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockCmdable)(nil).PubSubNumPat), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockCmdable)(nil).PubSubNumPat), arg0) } // PubSubNumSub mocks base method. -func (m *MockCmdable) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { +func (m *MockCmdable) PubSubNumSub(arg0 context.Context, arg1 ...string) *redis.MapStringIntCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range channels { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PubSubNumSub", varargs...) @@ -3427,31 +3276,31 @@ func (m *MockCmdable) PubSubNumSub(ctx context.Context, channels ...string) *red } // PubSubNumSub indicates an expected call of PubSubNumSub. -func (mr *MockCmdableMockRecorder) PubSubNumSub(ctx any, channels ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PubSubNumSub(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, channels...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) PubSubShardChannels(arg0 context.Context, arg1 string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PubSubShardChannels", ctx, pattern) + ret := m.ctrl.Call(m, "PubSubShardChannels", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // PubSubShardChannels indicates an expected call of PubSubShardChannels. -func (mr *MockCmdableMockRecorder) PubSubShardChannels(ctx, pattern any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PubSubShardChannels(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubShardChannels), ctx, pattern) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubShardChannels), arg0, arg1) } // PubSubShardNumSub mocks base method. -func (m *MockCmdable) PubSubShardNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { +func (m *MockCmdable) PubSubShardNumSub(arg0 context.Context, arg1 ...string) *redis.MapStringIntCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range channels { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...) @@ -3460,87 +3309,87 @@ func (m *MockCmdable) PubSubShardNumSub(ctx context.Context, channels ...string) } // PubSubShardNumSub indicates an expected call of PubSubShardNumSub. -func (mr *MockCmdableMockRecorder) PubSubShardNumSub(ctx any, channels ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) PubSubShardNumSub(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, channels...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) Publish(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Publish", ctx, channel, message) + ret := m.ctrl.Call(m, "Publish", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // Publish indicates an expected call of Publish. -func (mr *MockCmdableMockRecorder) Publish(ctx, channel, message any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Publish(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockCmdable)(nil).Publish), ctx, channel, message) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockCmdable)(nil).Publish), arg0, arg1, arg2) } // Quit mocks base method. -func (m *MockCmdable) Quit(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) Quit(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Quit", ctx) + ret := m.ctrl.Call(m, "Quit", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // Quit indicates an expected call of Quit. -func (mr *MockCmdableMockRecorder) Quit(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Quit(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockCmdable)(nil).Quit), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockCmdable)(nil).Quit), arg0) } // RPop mocks base method. -func (m *MockCmdable) RPop(ctx context.Context, key string) *redis.StringCmd { +func (m *MockCmdable) RPop(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RPop", ctx, key) + ret := m.ctrl.Call(m, "RPop", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // RPop indicates an expected call of RPop. -func (mr *MockCmdableMockRecorder) RPop(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) RPop(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockCmdable)(nil).RPop), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockCmdable)(nil).RPop), arg0, arg1) } // RPopCount mocks base method. -func (m *MockCmdable) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { +func (m *MockCmdable) RPopCount(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RPopCount", ctx, key, count) + ret := m.ctrl.Call(m, "RPopCount", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // RPopCount indicates an expected call of RPopCount. -func (mr *MockCmdableMockRecorder) RPopCount(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) RPopCount(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockCmdable)(nil).RPopCount), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockCmdable)(nil).RPopCount), arg0, arg1, arg2) } // RPopLPush mocks base method. -func (m *MockCmdable) RPopLPush(ctx context.Context, source, destination string) *redis.StringCmd { +func (m *MockCmdable) RPopLPush(arg0 context.Context, arg1, arg2 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RPopLPush", ctx, source, destination) + ret := m.ctrl.Call(m, "RPopLPush", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // RPopLPush indicates an expected call of RPopLPush. -func (mr *MockCmdableMockRecorder) RPopLPush(ctx, source, destination any) *gomock.Call { +func (mr *MockCmdableMockRecorder) RPopLPush(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockCmdable)(nil).RPopLPush), ctx, source, destination) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockCmdable)(nil).RPopLPush), arg0, arg1, arg2) } // RPush mocks base method. -func (m *MockCmdable) RPush(ctx context.Context, key string, values ...any) *redis.IntCmd { +func (m *MockCmdable) RPush(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range values { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RPush", varargs...) @@ -3549,17 +3398,17 @@ func (m *MockCmdable) RPush(ctx context.Context, key string, values ...any) *red } // RPush indicates an expected call of RPush. -func (mr *MockCmdableMockRecorder) RPush(ctx, key any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) RPush(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, values...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) RPushX(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range values { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RPushX", varargs...) @@ -3568,115 +3417,115 @@ func (m *MockCmdable) RPushX(ctx context.Context, key string, values ...any) *re } // RPushX indicates an expected call of RPushX. -func (mr *MockCmdableMockRecorder) RPushX(ctx, key any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) RPushX(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, values...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) RandomKey(arg0 context.Context) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RandomKey", ctx) + ret := m.ctrl.Call(m, "RandomKey", arg0) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // RandomKey indicates an expected call of RandomKey. -func (mr *MockCmdableMockRecorder) RandomKey(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) RandomKey(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockCmdable)(nil).RandomKey), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockCmdable)(nil).RandomKey), arg0) } // ReadOnly mocks base method. -func (m *MockCmdable) ReadOnly(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ReadOnly(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReadOnly", ctx) + ret := m.ctrl.Call(m, "ReadOnly", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ReadOnly indicates an expected call of ReadOnly. -func (mr *MockCmdableMockRecorder) ReadOnly(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ReadOnly(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockCmdable)(nil).ReadOnly), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockCmdable)(nil).ReadOnly), arg0) } // ReadWrite mocks base method. -func (m *MockCmdable) ReadWrite(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ReadWrite(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReadWrite", ctx) + ret := m.ctrl.Call(m, "ReadWrite", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ReadWrite indicates an expected call of ReadWrite. -func (mr *MockCmdableMockRecorder) ReadWrite(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ReadWrite(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockCmdable)(nil).ReadWrite), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockCmdable)(nil).ReadWrite), arg0) } // Rename mocks base method. -func (m *MockCmdable) Rename(ctx context.Context, key, newkey string) *redis.StatusCmd { +func (m *MockCmdable) Rename(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Rename", ctx, key, newkey) + ret := m.ctrl.Call(m, "Rename", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // Rename indicates an expected call of Rename. -func (mr *MockCmdableMockRecorder) Rename(ctx, key, newkey any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Rename(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockCmdable)(nil).Rename), ctx, key, newkey) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockCmdable)(nil).Rename), arg0, arg1, arg2) } // RenameNX mocks base method. -func (m *MockCmdable) RenameNX(ctx context.Context, key, newkey string) *redis.BoolCmd { +func (m *MockCmdable) RenameNX(arg0 context.Context, arg1, arg2 string) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RenameNX", ctx, key, newkey) + ret := m.ctrl.Call(m, "RenameNX", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // RenameNX indicates an expected call of RenameNX. -func (mr *MockCmdableMockRecorder) RenameNX(ctx, key, newkey any) *gomock.Call { +func (mr *MockCmdableMockRecorder) RenameNX(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockCmdable)(nil).RenameNX), ctx, key, newkey) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockCmdable)(nil).RenameNX), arg0, arg1, arg2) } // Restore mocks base method. -func (m *MockCmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { +func (m *MockCmdable) Restore(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Restore", ctx, key, ttl, value) + ret := m.ctrl.Call(m, "Restore", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) Restore(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockCmdable)(nil).Restore), arg0, arg1, arg2, arg3) } // RestoreReplace mocks base method. -func (m *MockCmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { +func (m *MockCmdable) RestoreReplace(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreReplace", ctx, key, ttl, value) + ret := m.ctrl.Call(m, "RestoreReplace", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) RestoreReplace(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockCmdable)(nil).RestoreReplace), arg0, arg1, arg2, arg3) } // SAdd mocks base method. -func (m *MockCmdable) SAdd(ctx context.Context, key string, members ...any) *redis.IntCmd { +func (m *MockCmdable) SAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SAdd", varargs...) @@ -3685,31 +3534,31 @@ func (m *MockCmdable) SAdd(ctx context.Context, key string, members ...any) *red } // SAdd indicates an expected call of SAdd. -func (mr *MockCmdableMockRecorder) SAdd(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, members...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) SCard(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SCard", ctx, key) + ret := m.ctrl.Call(m, "SCard", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // SCard indicates an expected call of SCard. -func (mr *MockCmdableMockRecorder) SCard(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SCard(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockCmdable)(nil).SCard), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockCmdable)(nil).SCard), arg0, arg1) } // SDiff mocks base method. -func (m *MockCmdable) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { +func (m *MockCmdable) SDiff(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SDiff", varargs...) @@ -3718,17 +3567,17 @@ func (m *MockCmdable) SDiff(ctx context.Context, keys ...string) *redis.StringSl } // SDiff indicates an expected call of SDiff. -func (mr *MockCmdableMockRecorder) SDiff(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SDiff(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, keys...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) SDiffStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, destination} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SDiffStore", varargs...) @@ -3737,17 +3586,17 @@ func (m *MockCmdable) SDiffStore(ctx context.Context, destination string, keys . } // SDiffStore indicates an expected call of SDiffStore. -func (mr *MockCmdableMockRecorder) SDiffStore(ctx, destination any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SDiffStore(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, destination}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) SInter(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SInter", varargs...) @@ -3756,17 +3605,17 @@ func (m *MockCmdable) SInter(ctx context.Context, keys ...string) *redis.StringS } // SInter indicates an expected call of SInter. -func (mr *MockCmdableMockRecorder) SInter(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SInter(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, keys...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) SInterCard(arg0 context.Context, arg1 int64, arg2 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, limit} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SInterCard", varargs...) @@ -3775,17 +3624,17 @@ func (m *MockCmdable) SInterCard(ctx context.Context, limit int64, keys ...strin } // SInterCard indicates an expected call of SInterCard. -func (mr *MockCmdableMockRecorder) SInterCard(ctx, limit any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SInterCard(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, limit}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) SInterStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, destination} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SInterStore", varargs...) @@ -3794,31 +3643,31 @@ func (m *MockCmdable) SInterStore(ctx context.Context, destination string, keys } // SInterStore indicates an expected call of SInterStore. -func (mr *MockCmdableMockRecorder) SInterStore(ctx, destination any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SInterStore(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, destination}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) SIsMember(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SIsMember", ctx, key, member) + ret := m.ctrl.Call(m, "SIsMember", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.BoolCmd) return ret0 } // SIsMember indicates an expected call of SIsMember. -func (mr *MockCmdableMockRecorder) SIsMember(ctx, key, member any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SIsMember(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockCmdable)(nil).SIsMember), ctx, key, member) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockCmdable)(nil).SIsMember), arg0, arg1, arg2) } // SMIsMember mocks base method. -func (m *MockCmdable) SMIsMember(ctx context.Context, key string, members ...any) *redis.BoolSliceCmd { +func (m *MockCmdable) SMIsMember(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SMIsMember", varargs...) @@ -3827,129 +3676,129 @@ func (m *MockCmdable) SMIsMember(ctx context.Context, key string, members ...any } // SMIsMember indicates an expected call of SMIsMember. -func (mr *MockCmdableMockRecorder) SMIsMember(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SMIsMember(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, members...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) SMembers(arg0 context.Context, arg1 string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SMembers", ctx, key) + ret := m.ctrl.Call(m, "SMembers", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // SMembers indicates an expected call of SMembers. -func (mr *MockCmdableMockRecorder) SMembers(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SMembers(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockCmdable)(nil).SMembers), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockCmdable)(nil).SMembers), arg0, arg1) } // SMembersMap mocks base method. -func (m *MockCmdable) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd { +func (m *MockCmdable) SMembersMap(arg0 context.Context, arg1 string) *redis.StringStructMapCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SMembersMap", ctx, key) + ret := m.ctrl.Call(m, "SMembersMap", arg0, arg1) ret0, _ := ret[0].(*redis.StringStructMapCmd) return ret0 } // SMembersMap indicates an expected call of SMembersMap. -func (mr *MockCmdableMockRecorder) SMembersMap(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SMembersMap(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockCmdable)(nil).SMembersMap), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockCmdable)(nil).SMembersMap), arg0, arg1) } // SMove mocks base method. -func (m *MockCmdable) SMove(ctx context.Context, source, destination string, member any) *redis.BoolCmd { +func (m *MockCmdable) SMove(arg0 context.Context, arg1, arg2 string, arg3 any) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SMove", ctx, source, destination, member) + ret := m.ctrl.Call(m, "SMove", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) SMove(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockCmdable)(nil).SMove), arg0, arg1, arg2, arg3) } // SPop mocks base method. -func (m *MockCmdable) SPop(ctx context.Context, key string) *redis.StringCmd { +func (m *MockCmdable) SPop(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SPop", ctx, key) + ret := m.ctrl.Call(m, "SPop", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // SPop indicates an expected call of SPop. -func (mr *MockCmdableMockRecorder) SPop(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SPop(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockCmdable)(nil).SPop), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockCmdable)(nil).SPop), arg0, arg1) } // SPopN mocks base method. -func (m *MockCmdable) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { +func (m *MockCmdable) SPopN(arg0 context.Context, arg1 string, arg2 int64) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SPopN", ctx, key, count) + ret := m.ctrl.Call(m, "SPopN", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // SPopN indicates an expected call of SPopN. -func (mr *MockCmdableMockRecorder) SPopN(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SPopN(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockCmdable)(nil).SPopN), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockCmdable)(nil).SPopN), arg0, arg1, arg2) } // SPublish mocks base method. -func (m *MockCmdable) SPublish(ctx context.Context, channel string, message any) *redis.IntCmd { +func (m *MockCmdable) SPublish(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SPublish", ctx, channel, message) + ret := m.ctrl.Call(m, "SPublish", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // SPublish indicates an expected call of SPublish. -func (mr *MockCmdableMockRecorder) SPublish(ctx, channel, message any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SPublish(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockCmdable)(nil).SPublish), ctx, channel, message) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockCmdable)(nil).SPublish), arg0, arg1, arg2) } // SRandMember mocks base method. -func (m *MockCmdable) SRandMember(ctx context.Context, key string) *redis.StringCmd { +func (m *MockCmdable) SRandMember(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SRandMember", ctx, key) + ret := m.ctrl.Call(m, "SRandMember", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // SRandMember indicates an expected call of SRandMember. -func (mr *MockCmdableMockRecorder) SRandMember(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SRandMember(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockCmdable)(nil).SRandMember), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockCmdable)(nil).SRandMember), arg0, arg1) } // SRandMemberN mocks base method. -func (m *MockCmdable) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { +func (m *MockCmdable) SRandMemberN(arg0 context.Context, arg1 string, arg2 int64) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SRandMemberN", ctx, key, count) + ret := m.ctrl.Call(m, "SRandMemberN", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // SRandMemberN indicates an expected call of SRandMemberN. -func (mr *MockCmdableMockRecorder) SRandMemberN(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SRandMemberN(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockCmdable)(nil).SRandMemberN), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockCmdable)(nil).SRandMemberN), arg0, arg1, arg2) } // SRem mocks base method. -func (m *MockCmdable) SRem(ctx context.Context, key string, members ...any) *redis.IntCmd { +func (m *MockCmdable) SRem(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SRem", varargs...) @@ -3958,31 +3807,31 @@ func (m *MockCmdable) SRem(ctx context.Context, key string, members ...any) *red } // SRem indicates an expected call of SRem. -func (mr *MockCmdableMockRecorder) SRem(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SRem(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, members...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) SScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SScan", ctx, key, cursor, match, count) + ret := m.ctrl.Call(m, "SScan", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) SScan(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockCmdable)(nil).SScan), arg0, arg1, arg2, arg3, arg4) } // SUnion mocks base method. -func (m *MockCmdable) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd { +func (m *MockCmdable) SUnion(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SUnion", varargs...) @@ -3991,17 +3840,17 @@ func (m *MockCmdable) SUnion(ctx context.Context, keys ...string) *redis.StringS } // SUnion indicates an expected call of SUnion. -func (mr *MockCmdableMockRecorder) SUnion(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SUnion(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, keys...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) SUnionStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, destination} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SUnionStore", varargs...) @@ -4010,59 +3859,59 @@ func (m *MockCmdable) SUnionStore(ctx context.Context, destination string, keys } // SUnionStore indicates an expected call of SUnionStore. -func (mr *MockCmdableMockRecorder) SUnionStore(ctx, destination any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SUnionStore(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, destination}, keys...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) Save(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Save", ctx) + ret := m.ctrl.Call(m, "Save", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // Save indicates an expected call of Save. -func (mr *MockCmdableMockRecorder) Save(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Save(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockCmdable)(nil).Save), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockCmdable)(nil).Save), arg0) } // Scan mocks base method. -func (m *MockCmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd { +func (m *MockCmdable) Scan(arg0 context.Context, arg1 uint64, arg2 string, arg3 int64) *redis.ScanCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Scan", ctx, cursor, match, count) + ret := m.ctrl.Call(m, "Scan", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) Scan(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockCmdable)(nil).Scan), arg0, arg1, arg2, arg3) } // ScanType mocks base method. -func (m *MockCmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd { +func (m *MockCmdable) ScanType(arg0 context.Context, arg1 uint64, arg2 string, arg3 int64, arg4 string) *redis.ScanCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScanType", ctx, cursor, match, count, keyType) + ret := m.ctrl.Call(m, "ScanType", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) ScanType(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockCmdable)(nil).ScanType), arg0, arg1, arg2, arg3, arg4) } // ScriptExists mocks base method. -func (m *MockCmdable) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd { +func (m *MockCmdable) ScriptExists(arg0 context.Context, arg1 ...string) *redis.BoolSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range hashes { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ScriptExists", varargs...) @@ -4071,297 +3920,283 @@ func (m *MockCmdable) ScriptExists(ctx context.Context, hashes ...string) *redis } // ScriptExists indicates an expected call of ScriptExists. -func (mr *MockCmdableMockRecorder) ScriptExists(ctx any, hashes ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ScriptExists(arg0 any, arg1 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, hashes...) + varargs := append([]any{arg0}, arg1...) 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 { +func (m *MockCmdable) ScriptFlush(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScriptFlush", ctx) + ret := m.ctrl.Call(m, "ScriptFlush", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ScriptFlush indicates an expected call of ScriptFlush. -func (mr *MockCmdableMockRecorder) ScriptFlush(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ScriptFlush(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockCmdable)(nil).ScriptFlush), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockCmdable)(nil).ScriptFlush), arg0) } // ScriptKill mocks base method. -func (m *MockCmdable) ScriptKill(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ScriptKill(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScriptKill", ctx) + ret := m.ctrl.Call(m, "ScriptKill", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ScriptKill indicates an expected call of ScriptKill. -func (mr *MockCmdableMockRecorder) ScriptKill(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ScriptKill(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockCmdable)(nil).ScriptKill), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockCmdable)(nil).ScriptKill), arg0) } // ScriptLoad mocks base method. -func (m *MockCmdable) ScriptLoad(ctx context.Context, script string) *redis.StringCmd { +func (m *MockCmdable) ScriptLoad(arg0 context.Context, arg1 string) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScriptLoad", ctx, script) + ret := m.ctrl.Call(m, "ScriptLoad", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // ScriptLoad indicates an expected call of ScriptLoad. -func (mr *MockCmdableMockRecorder) ScriptLoad(ctx, script any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ScriptLoad(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockCmdable)(nil).ScriptLoad), ctx, script) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockCmdable)(nil).ScriptLoad), arg0, arg1) } // Set mocks base method. -func (m *MockCmdable) Set(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd { +func (m *MockCmdable) Set(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Set", ctx, key, value, expiration) + ret := m.ctrl.Call(m, "Set", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) Set(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCmdable)(nil).Set), arg0, arg1, arg2, arg3) } // SetArgs mocks base method. -func (m *MockCmdable) SetArgs(ctx context.Context, key string, value any, a redis.SetArgs) *redis.StatusCmd { +func (m *MockCmdable) SetArgs(arg0 context.Context, arg1 string, arg2 any, arg3 redis.SetArgs) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetArgs", ctx, key, value, a) + ret := m.ctrl.Call(m, "SetArgs", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) SetArgs(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockCmdable)(nil).SetArgs), arg0, arg1, arg2, arg3) } // SetEx mocks base method. -func (m *MockCmdable) SetEx(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd { +func (m *MockCmdable) SetEx(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetEx", ctx, key, value, expiration) + ret := m.ctrl.Call(m, "SetEx", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) SetEx(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockCmdable)(nil).SetEx), arg0, arg1, arg2, arg3) } // SetNX mocks base method. -func (m *MockCmdable) SetNX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd { +func (m *MockCmdable) SetNX(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetNX", ctx, key, value, expiration) + ret := m.ctrl.Call(m, "SetNX", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) SetNX(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockCmdable)(nil).SetNX), arg0, arg1, arg2, arg3) } // SetRange mocks base method. -func (m *MockCmdable) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd { +func (m *MockCmdable) SetRange(arg0 context.Context, arg1 string, arg2 int64, arg3 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetRange", ctx, key, offset, value) + ret := m.ctrl.Call(m, "SetRange", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) SetRange(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockCmdable)(nil).SetRange), arg0, arg1, arg2, arg3) } // SetXX mocks base method. -func (m *MockCmdable) SetXX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd { +func (m *MockCmdable) SetXX(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.BoolCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetXX", ctx, key, value, expiration) + ret := m.ctrl.Call(m, "SetXX", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) SetXX(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockCmdable)(nil).SetXX), arg0, arg1, arg2, arg3) } // Shutdown mocks base method. -func (m *MockCmdable) Shutdown(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) Shutdown(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Shutdown", ctx) + ret := m.ctrl.Call(m, "Shutdown", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // Shutdown indicates an expected call of Shutdown. -func (mr *MockCmdableMockRecorder) Shutdown(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Shutdown(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockCmdable)(nil).Shutdown), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockCmdable)(nil).Shutdown), arg0) } // ShutdownNoSave mocks base method. -func (m *MockCmdable) ShutdownNoSave(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ShutdownNoSave(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ShutdownNoSave", ctx) + ret := m.ctrl.Call(m, "ShutdownNoSave", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ShutdownNoSave indicates an expected call of ShutdownNoSave. -func (mr *MockCmdableMockRecorder) ShutdownNoSave(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ShutdownNoSave(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownNoSave), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownNoSave), arg0) } // ShutdownSave mocks base method. -func (m *MockCmdable) ShutdownSave(ctx context.Context) *redis.StatusCmd { +func (m *MockCmdable) ShutdownSave(arg0 context.Context) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ShutdownSave", ctx) + ret := m.ctrl.Call(m, "ShutdownSave", arg0) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // ShutdownSave indicates an expected call of ShutdownSave. -func (mr *MockCmdableMockRecorder) ShutdownSave(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ShutdownSave(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownSave), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownSave), arg0) } // SlaveOf mocks base method. -func (m *MockCmdable) SlaveOf(ctx context.Context, host, port string) *redis.StatusCmd { +func (m *MockCmdable) SlaveOf(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SlaveOf", ctx, host, port) + ret := m.ctrl.Call(m, "SlaveOf", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // SlaveOf indicates an expected call of SlaveOf. -func (mr *MockCmdableMockRecorder) SlaveOf(ctx, host, port any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SlaveOf(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockCmdable)(nil).SlaveOf), ctx, host, port) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockCmdable)(nil).SlaveOf), arg0, arg1, arg2) } // SlowLogGet mocks base method. -func (m *MockCmdable) SlowLogGet(ctx context.Context, num int64) *redis.SlowLogCmd { +func (m *MockCmdable) SlowLogGet(arg0 context.Context, arg1 int64) *redis.SlowLogCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SlowLogGet", ctx, num) + ret := m.ctrl.Call(m, "SlowLogGet", arg0, arg1) ret0, _ := ret[0].(*redis.SlowLogCmd) return ret0 } // SlowLogGet indicates an expected call of SlowLogGet. -func (mr *MockCmdableMockRecorder) SlowLogGet(ctx, num any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SlowLogGet(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockCmdable)(nil).SlowLogGet), ctx, num) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockCmdable)(nil).SlowLogGet), arg0, arg1) } // Sort mocks base method. -func (m *MockCmdable) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { +func (m *MockCmdable) Sort(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Sort", ctx, key, sort) + ret := m.ctrl.Call(m, "Sort", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // Sort indicates an expected call of Sort. -func (mr *MockCmdableMockRecorder) Sort(ctx, key, sort any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Sort(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockCmdable)(nil).Sort), ctx, key, sort) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockCmdable)(nil).Sort), arg0, arg1, arg2) } // SortInterfaces mocks base method. -func (m *MockCmdable) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd { +func (m *MockCmdable) SortInterfaces(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.SliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SortInterfaces", ctx, key, sort) + ret := m.ctrl.Call(m, "SortInterfaces", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.SliceCmd) return ret0 } // SortInterfaces indicates an expected call of SortInterfaces. -func (mr *MockCmdableMockRecorder) SortInterfaces(ctx, key, sort any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SortInterfaces(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockCmdable)(nil).SortInterfaces), ctx, key, sort) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockCmdable)(nil).SortInterfaces), arg0, arg1, arg2) } // SortRO mocks base method. -func (m *MockCmdable) SortRO(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { +func (m *MockCmdable) SortRO(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SortRO", ctx, key, sort) + ret := m.ctrl.Call(m, "SortRO", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // SortRO indicates an expected call of SortRO. -func (mr *MockCmdableMockRecorder) SortRO(ctx, key, sort any) *gomock.Call { +func (mr *MockCmdableMockRecorder) SortRO(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockCmdable)(nil).SortRO), ctx, key, sort) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockCmdable)(nil).SortRO), arg0, arg1, arg2) } // SortStore mocks base method. -func (m *MockCmdable) SortStore(ctx context.Context, key, store string, sort *redis.Sort) *redis.IntCmd { +func (m *MockCmdable) SortStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.Sort) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SortStore", ctx, key, store, sort) + ret := m.ctrl.Call(m, "SortStore", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) SortStore(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockCmdable)(nil).SortStore), arg0, arg1, arg2, arg3) } // StrLen mocks base method. -func (m *MockCmdable) StrLen(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) StrLen(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StrLen", ctx, key) + ret := m.ctrl.Call(m, "StrLen", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // StrLen indicates an expected call of StrLen. -func (mr *MockCmdableMockRecorder) StrLen(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) StrLen(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockCmdable)(nil).StrLen), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockCmdable)(nil).StrLen), arg0, arg1) } // TDigestAdd mocks base method. -func (m *MockCmdable) TDigestAdd(ctx context.Context, key string, elements ...float64) *redis.StatusCmd { +func (m *MockCmdable) TDigestAdd(arg0 context.Context, arg1 string, arg2 ...float64) *redis.StatusCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TDigestAdd", varargs...) @@ -4370,17 +4205,17 @@ func (m *MockCmdable) TDigestAdd(ctx context.Context, key string, elements ...fl } // TDigestAdd indicates an expected call of TDigestAdd. -func (mr *MockCmdableMockRecorder) TDigestAdd(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, elements...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) TDigestByRank(arg0 context.Context, arg1 string, arg2 ...uint64) *redis.FloatSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range rank { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TDigestByRank", varargs...) @@ -4389,17 +4224,17 @@ func (m *MockCmdable) TDigestByRank(ctx context.Context, key string, rank ...uin } // TDigestByRank indicates an expected call of TDigestByRank. -func (mr *MockCmdableMockRecorder) TDigestByRank(ctx, key any, rank ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestByRank(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, rank...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) TDigestByRevRank(arg0 context.Context, arg1 string, arg2 ...uint64) *redis.FloatSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range rank { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TDigestByRevRank", varargs...) @@ -4408,17 +4243,17 @@ func (m *MockCmdable) TDigestByRevRank(ctx context.Context, key string, rank ... } // TDigestByRevRank indicates an expected call of TDigestByRevRank. -func (mr *MockCmdableMockRecorder) TDigestByRevRank(ctx, key any, rank ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestByRevRank(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, rank...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) TDigestCDF(arg0 context.Context, arg1 string, arg2 ...float64) *redis.FloatSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TDigestCDF", varargs...) @@ -4427,73 +4262,73 @@ func (m *MockCmdable) TDigestCDF(ctx context.Context, key string, elements ...fl } // TDigestCDF indicates an expected call of TDigestCDF. -func (mr *MockCmdableMockRecorder) TDigestCDF(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestCDF(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, elements...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) TDigestCreate(arg0 context.Context, arg1 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TDigestCreate", ctx, key) + ret := m.ctrl.Call(m, "TDigestCreate", arg0, arg1) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // TDigestCreate indicates an expected call of TDigestCreate. -func (mr *MockCmdableMockRecorder) TDigestCreate(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestCreate(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockCmdable)(nil).TDigestCreate), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockCmdable)(nil).TDigestCreate), arg0, arg1) } // TDigestCreateWithCompression mocks base method. -func (m *MockCmdable) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *redis.StatusCmd { +func (m *MockCmdable) TDigestCreateWithCompression(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TDigestCreateWithCompression", ctx, key, compression) + ret := m.ctrl.Call(m, "TDigestCreateWithCompression", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression. -func (mr *MockCmdableMockRecorder) TDigestCreateWithCompression(ctx, key, compression any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestCreateWithCompression(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockCmdable)(nil).TDigestCreateWithCompression), ctx, key, compression) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockCmdable)(nil).TDigestCreateWithCompression), arg0, arg1, arg2) } // TDigestInfo mocks base method. -func (m *MockCmdable) TDigestInfo(ctx context.Context, key string) *redis.TDigestInfoCmd { +func (m *MockCmdable) TDigestInfo(arg0 context.Context, arg1 string) *redis.TDigestInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TDigestInfo", ctx, key) + ret := m.ctrl.Call(m, "TDigestInfo", arg0, arg1) ret0, _ := ret[0].(*redis.TDigestInfoCmd) return ret0 } // TDigestInfo indicates an expected call of TDigestInfo. -func (mr *MockCmdableMockRecorder) TDigestInfo(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestInfo(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockCmdable)(nil).TDigestInfo), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockCmdable)(nil).TDigestInfo), arg0, arg1) } // TDigestMax mocks base method. -func (m *MockCmdable) TDigestMax(ctx context.Context, key string) *redis.FloatCmd { +func (m *MockCmdable) TDigestMax(arg0 context.Context, arg1 string) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TDigestMax", ctx, key) + ret := m.ctrl.Call(m, "TDigestMax", arg0, arg1) ret0, _ := ret[0].(*redis.FloatCmd) return ret0 } // TDigestMax indicates an expected call of TDigestMax. -func (mr *MockCmdableMockRecorder) TDigestMax(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestMax(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockCmdable)(nil).TDigestMax), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockCmdable)(nil).TDigestMax), arg0, arg1) } // TDigestMerge mocks base method. -func (m *MockCmdable) TDigestMerge(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string) *redis.StatusCmd { +func (m *MockCmdable) TDigestMerge(arg0 context.Context, arg1 string, arg2 *redis.TDigestMergeOptions, arg3 ...string) *redis.StatusCmd { m.ctrl.T.Helper() - varargs := []any{ctx, destKey, options} - for _, a := range sourceKeys { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TDigestMerge", varargs...) @@ -4502,31 +4337,31 @@ func (m *MockCmdable) TDigestMerge(ctx context.Context, destKey string, options } // TDigestMerge indicates an expected call of TDigestMerge. -func (mr *MockCmdableMockRecorder) TDigestMerge(ctx, destKey, options any, sourceKeys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestMerge(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, destKey, options}, sourceKeys...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) 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 { +func (m *MockCmdable) TDigestMin(arg0 context.Context, arg1 string) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TDigestMin", ctx, key) + ret := m.ctrl.Call(m, "TDigestMin", arg0, arg1) ret0, _ := ret[0].(*redis.FloatCmd) return ret0 } // TDigestMin indicates an expected call of TDigestMin. -func (mr *MockCmdableMockRecorder) TDigestMin(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestMin(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockCmdable)(nil).TDigestMin), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockCmdable)(nil).TDigestMin), arg0, arg1) } // TDigestQuantile mocks base method. -func (m *MockCmdable) TDigestQuantile(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { +func (m *MockCmdable) TDigestQuantile(arg0 context.Context, arg1 string, arg2 ...float64) *redis.FloatSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TDigestQuantile", varargs...) @@ -4535,17 +4370,17 @@ func (m *MockCmdable) TDigestQuantile(ctx context.Context, key string, elements } // TDigestQuantile indicates an expected call of TDigestQuantile. -func (mr *MockCmdableMockRecorder) TDigestQuantile(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestQuantile(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, elements...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) TDigestRank(arg0 context.Context, arg1 string, arg2 ...float64) *redis.IntSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range values { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TDigestRank", varargs...) @@ -4554,31 +4389,31 @@ func (m *MockCmdable) TDigestRank(ctx context.Context, key string, values ...flo } // TDigestRank indicates an expected call of TDigestRank. -func (mr *MockCmdableMockRecorder) TDigestRank(ctx, key any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestRank(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, values...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) TDigestReset(arg0 context.Context, arg1 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TDigestReset", ctx, key) + ret := m.ctrl.Call(m, "TDigestReset", arg0, arg1) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // TDigestReset indicates an expected call of TDigestReset. -func (mr *MockCmdableMockRecorder) TDigestReset(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestReset(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockCmdable)(nil).TDigestReset), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockCmdable)(nil).TDigestReset), arg0, arg1) } // TDigestRevRank mocks base method. -func (m *MockCmdable) TDigestRevRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { +func (m *MockCmdable) TDigestRevRank(arg0 context.Context, arg1 string, arg2 ...float64) *redis.IntSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range values { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TDigestRevRank", varargs...) @@ -4587,6445 +4422,591 @@ func (m *MockCmdable) TDigestRevRank(ctx context.Context, key string, values ... } // TDigestRevRank indicates an expected call of TDigestRevRank. -func (mr *MockCmdableMockRecorder) TDigestRevRank(ctx, key any, values ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TDigestRevRank(arg0, arg1 any, arg2 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, key}, values...) + varargs := append([]any{arg0, arg1}, arg2...) 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 { +func (m *MockCmdable) TDigestTrimmedMean(arg0 context.Context, arg1 string, arg2, arg3 float64) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TDigestTrimmedMean", ctx, key, lowCutQuantile, highCutQuantile) + ret := m.ctrl.Call(m, "TDigestTrimmedMean", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) TDigestTrimmedMean(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockCmdable)(nil).TDigestTrimmedMean), arg0, arg1, arg2, arg3) } // TFCall mocks base method. -func (m *MockCmdable) TFCall(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { +func (m *MockCmdable) TFCall(arg0 context.Context, arg1, arg2 string, arg3 int) *redis.Cmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFCall", ctx, libName, funcName, numKeys) + ret := m.ctrl.Call(m, "TFCall", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) TFCall(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockCmdable)(nil).TFCall), arg0, arg1, arg2, arg3) } // TFCallASYNC mocks base method. -func (m *MockCmdable) TFCallASYNC(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { +func (m *MockCmdable) TFCallASYNC(arg0 context.Context, arg1, arg2 string, arg3 int) *redis.Cmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFCallASYNC", ctx, libName, funcName, numKeys) + ret := m.ctrl.Call(m, "TFCallASYNC", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) TFCallASYNC(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockCmdable)(nil).TFCallASYNC), arg0, arg1, arg2, arg3) } // TFCallASYNCArgs mocks base method. -func (m *MockCmdable) TFCallASYNCArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { +func (m *MockCmdable) TFCallASYNCArgs(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 *redis.TFCallOptions) *redis.Cmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFCallASYNCArgs", ctx, libName, funcName, numKeys, options) + ret := m.ctrl.Call(m, "TFCallASYNCArgs", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) TFCallASYNCArgs(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockCmdable)(nil).TFCallASYNCArgs), arg0, arg1, arg2, arg3, arg4) } // TFCallArgs mocks base method. -func (m *MockCmdable) TFCallArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { +func (m *MockCmdable) TFCallArgs(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 *redis.TFCallOptions) *redis.Cmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFCallArgs", ctx, libName, funcName, numKeys, options) + ret := m.ctrl.Call(m, "TFCallArgs", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) TFCallArgs(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockCmdable)(nil).TFCallArgs), arg0, arg1, arg2, arg3, arg4) } // TFunctionDelete mocks base method. -func (m *MockCmdable) TFunctionDelete(ctx context.Context, libName string) *redis.StatusCmd { +func (m *MockCmdable) TFunctionDelete(arg0 context.Context, arg1 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFunctionDelete", ctx, libName) + ret := m.ctrl.Call(m, "TFunctionDelete", arg0, arg1) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // TFunctionDelete indicates an expected call of TFunctionDelete. -func (mr *MockCmdableMockRecorder) TFunctionDelete(ctx, libName any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TFunctionDelete(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockCmdable)(nil).TFunctionDelete), ctx, libName) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockCmdable)(nil).TFunctionDelete), arg0, arg1) } // TFunctionList mocks base method. -func (m *MockCmdable) TFunctionList(ctx context.Context) *redis.MapStringInterfaceSliceCmd { +func (m *MockCmdable) TFunctionList(arg0 context.Context) *redis.MapStringInterfaceSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFunctionList", ctx) + ret := m.ctrl.Call(m, "TFunctionList", arg0) ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) return ret0 } // TFunctionList indicates an expected call of TFunctionList. -func (mr *MockCmdableMockRecorder) TFunctionList(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TFunctionList(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockCmdable)(nil).TFunctionList), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockCmdable)(nil).TFunctionList), arg0) } // TFunctionListArgs mocks base method. -func (m *MockCmdable) TFunctionListArgs(ctx context.Context, options *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { +func (m *MockCmdable) TFunctionListArgs(arg0 context.Context, arg1 *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFunctionListArgs", ctx, options) + ret := m.ctrl.Call(m, "TFunctionListArgs", arg0, arg1) ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) return ret0 } // TFunctionListArgs indicates an expected call of TFunctionListArgs. -func (mr *MockCmdableMockRecorder) TFunctionListArgs(ctx, options any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TFunctionListArgs(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionListArgs), ctx, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionListArgs), arg0, arg1) } // TFunctionLoad mocks base method. -func (m *MockCmdable) TFunctionLoad(ctx context.Context, lib string) *redis.StatusCmd { +func (m *MockCmdable) TFunctionLoad(arg0 context.Context, arg1 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFunctionLoad", ctx, lib) + ret := m.ctrl.Call(m, "TFunctionLoad", arg0, arg1) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // TFunctionLoad indicates an expected call of TFunctionLoad. -func (mr *MockCmdableMockRecorder) TFunctionLoad(ctx, lib any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TFunctionLoad(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoad), ctx, lib) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoad), arg0, arg1) } // TFunctionLoadArgs mocks base method. -func (m *MockCmdable) TFunctionLoadArgs(ctx context.Context, lib string, options *redis.TFunctionLoadOptions) *redis.StatusCmd { +func (m *MockCmdable) TFunctionLoadArgs(arg0 context.Context, arg1 string, arg2 *redis.TFunctionLoadOptions) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TFunctionLoadArgs", ctx, lib, options) + ret := m.ctrl.Call(m, "TFunctionLoadArgs", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs. -func (mr *MockCmdableMockRecorder) TFunctionLoadArgs(ctx, lib, options any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TFunctionLoadArgs(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoadArgs), ctx, lib, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoadArgs), arg0, arg1, arg2) } -// TTL mocks base method. -func (m *MockCmdable) TTL(ctx context.Context, key string) *redis.DurationCmd { +// TSAdd mocks base method. +func (m *MockCmdable) TSAdd(arg0 context.Context, arg1 string, arg2 any, arg3 float64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TTL", ctx, key) - ret0, _ := ret[0].(*redis.DurationCmd) + ret := m.ctrl.Call(m, "TSAdd", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) return ret0 } -// TTL indicates an expected call of TTL. -func (mr *MockCmdableMockRecorder) TTL(ctx, key any) *gomock.Call { +// TSAdd indicates an expected call of TSAdd. +func (mr *MockCmdableMockRecorder) TSAdd(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockCmdable)(nil).TTL), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAdd", reflect.TypeOf((*MockCmdable)(nil).TSAdd), arg0, arg1, arg2, arg3) } -// Time mocks base method. -func (m *MockCmdable) Time(ctx context.Context) *redis.TimeCmd { +// TSAddWithArgs mocks base method. +func (m *MockCmdable) TSAddWithArgs(arg0 context.Context, arg1 string, arg2 any, arg3 float64, arg4 *redis.TSOptions) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Time", ctx) - ret0, _ := ret[0].(*redis.TimeCmd) + ret := m.ctrl.Call(m, "TSAddWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.IntCmd) return ret0 } -// Time indicates an expected call of Time. -func (mr *MockCmdableMockRecorder) Time(ctx any) *gomock.Call { +// TSAddWithArgs indicates an expected call of TSAddWithArgs. +func (mr *MockCmdableMockRecorder) TSAddWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockCmdable)(nil).Time), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAddWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSAddWithArgs), arg0, arg1, arg2, arg3, arg4) } -// TopKAdd mocks base method. -func (m *MockCmdable) TopKAdd(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd { +// TSAlter mocks base method. +func (m *MockCmdable) TSAlter(arg0 context.Context, arg1 string, arg2 *redis.TSAlterOptions) *redis.StatusCmd { 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) + ret := m.ctrl.Call(m, "TSAlter", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } -// TopKAdd indicates an expected call of TopKAdd. -func (mr *MockCmdableMockRecorder) TopKAdd(ctx, key any, elements ...any) *gomock.Call { +// TSAlter indicates an expected call of TSAlter. +func (mr *MockCmdableMockRecorder) TSAlter(arg0, arg1, arg2 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...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAlter", reflect.TypeOf((*MockCmdable)(nil).TSAlter), arg0, arg1, arg2) } -// TopKCount mocks base method. -func (m *MockCmdable) TopKCount(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { +// TSCreate mocks base method. +func (m *MockCmdable) TSCreate(arg0 context.Context, arg1 string) *redis.StatusCmd { 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) + ret := m.ctrl.Call(m, "TSCreate", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } -// TopKCount indicates an expected call of TopKCount. -func (mr *MockCmdableMockRecorder) TopKCount(ctx, key any, elements ...any) *gomock.Call { +// TSCreate indicates an expected call of TSCreate. +func (mr *MockCmdableMockRecorder) TSCreate(arg0, arg1 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...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreate", reflect.TypeOf((*MockCmdable)(nil).TSCreate), arg0, arg1) } -// TopKIncrBy mocks base method. -func (m *MockCmdable) TopKIncrBy(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd { +// TSCreateRule mocks base method. +func (m *MockCmdable) TSCreateRule(arg0 context.Context, arg1, arg2 string, arg3 redis.Aggregator, arg4 int) *redis.StatusCmd { 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) + ret := m.ctrl.Call(m, "TSCreateRule", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } -// TopKIncrBy indicates an expected call of TopKIncrBy. -func (mr *MockCmdableMockRecorder) TopKIncrBy(ctx, key any, elements ...any) *gomock.Call { +// TSCreateRule indicates an expected call of TSCreateRule. +func (mr *MockCmdableMockRecorder) TSCreateRule(arg0, arg1, arg2, arg3, arg4 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...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRule", reflect.TypeOf((*MockCmdable)(nil).TSCreateRule), arg0, arg1, arg2, arg3, arg4) } -// TopKInfo mocks base method. -func (m *MockCmdable) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd { +// TSCreateRuleWithArgs mocks base method. +func (m *MockCmdable) TSCreateRuleWithArgs(arg0 context.Context, arg1, arg2 string, arg3 redis.Aggregator, arg4 int, arg5 *redis.TSCreateRuleOptions) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKInfo", ctx, key) - ret0, _ := ret[0].(*redis.TopKInfoCmd) + ret := m.ctrl.Call(m, "TSCreateRuleWithArgs", arg0, arg1, arg2, arg3, arg4, arg5) + ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } -// TopKInfo indicates an expected call of TopKInfo. -func (mr *MockCmdableMockRecorder) TopKInfo(ctx, key any) *gomock.Call { +// TSCreateRuleWithArgs indicates an expected call of TSCreateRuleWithArgs. +func (mr *MockCmdableMockRecorder) TSCreateRuleWithArgs(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockCmdable)(nil).TopKInfo), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRuleWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSCreateRuleWithArgs), arg0, arg1, arg2, arg3, arg4, arg5) } -// TopKList mocks base method. -func (m *MockCmdable) TopKList(ctx context.Context, key string) *redis.StringSliceCmd { +// TSCreateWithArgs mocks base method. +func (m *MockCmdable) TSCreateWithArgs(arg0 context.Context, arg1 string, arg2 *redis.TSOptions) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKList", ctx, key) - ret0, _ := ret[0].(*redis.StringSliceCmd) + ret := m.ctrl.Call(m, "TSCreateWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } -// TopKList indicates an expected call of TopKList. -func (mr *MockCmdableMockRecorder) TopKList(ctx, key any) *gomock.Call { +// TSCreateWithArgs indicates an expected call of TSCreateWithArgs. +func (mr *MockCmdableMockRecorder) TSCreateWithArgs(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockCmdable)(nil).TopKList), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSCreateWithArgs), arg0, arg1, arg2) } -// TopKListWithCount mocks base method. -func (m *MockCmdable) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd { +// TSDecrBy mocks base method. +func (m *MockCmdable) TSDecrBy(arg0 context.Context, arg1 string, arg2 float64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKListWithCount", ctx, key) - ret0, _ := ret[0].(*redis.MapStringIntCmd) + ret := m.ctrl.Call(m, "TSDecrBy", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) return ret0 } -// TopKListWithCount indicates an expected call of TopKListWithCount. -func (mr *MockCmdableMockRecorder) TopKListWithCount(ctx, key any) *gomock.Call { +// TSDecrBy indicates an expected call of TSDecrBy. +func (mr *MockCmdableMockRecorder) TSDecrBy(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockCmdable)(nil).TopKListWithCount), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrBy", reflect.TypeOf((*MockCmdable)(nil).TSDecrBy), arg0, arg1, arg2) } -// TopKQuery mocks base method. -func (m *MockCmdable) TopKQuery(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { +// TSDecrByWithArgs mocks base method. +func (m *MockCmdable) TSDecrByWithArgs(arg0 context.Context, arg1 string, arg2 float64, arg3 *redis.TSIncrDecrOptions) *redis.IntCmd { 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) + ret := m.ctrl.Call(m, "TSDecrByWithArgs", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) return ret0 } -// TopKQuery indicates an expected call of TopKQuery. -func (mr *MockCmdableMockRecorder) TopKQuery(ctx, key any, elements ...any) *gomock.Call { +// TSDecrByWithArgs indicates an expected call of TSDecrByWithArgs. +func (mr *MockCmdableMockRecorder) TSDecrByWithArgs(arg0, arg1, arg2, arg3 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...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrByWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSDecrByWithArgs), arg0, arg1, arg2, arg3) } -// TopKReserve mocks base method. -func (m *MockCmdable) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd { +// TSDel mocks base method. +func (m *MockCmdable) TSDel(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKReserve", ctx, key, k) - ret0, _ := ret[0].(*redis.StatusCmd) + ret := m.ctrl.Call(m, "TSDel", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) return ret0 } -// TopKReserve indicates an expected call of TopKReserve. -func (mr *MockCmdableMockRecorder) TopKReserve(ctx, key, k any) *gomock.Call { +// TSDel indicates an expected call of TSDel. +func (mr *MockCmdableMockRecorder) TSDel(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockCmdable)(nil).TopKReserve), ctx, key, k) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDel", reflect.TypeOf((*MockCmdable)(nil).TSDel), arg0, arg1, arg2, arg3) } -// TopKReserveWithOptions mocks base method. -func (m *MockCmdable) TopKReserveWithOptions(ctx context.Context, key string, k, width, depth int64, decay float64) *redis.StatusCmd { +// TSDeleteRule mocks base method. +func (m *MockCmdable) TSDeleteRule(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKReserveWithOptions", ctx, key, k, width, depth, decay) + ret := m.ctrl.Call(m, "TSDeleteRule", arg0, arg1, arg2) 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 { +// TSDeleteRule indicates an expected call of TSDeleteRule. +func (mr *MockCmdableMockRecorder) TSDeleteRule(arg0, arg1, arg2 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDeleteRule", reflect.TypeOf((*MockCmdable)(nil).TSDeleteRule), arg0, arg1, arg2) } -// Touch mocks base method. -func (m *MockCmdable) Touch(ctx context.Context, keys ...string) *redis.IntCmd { +// TSGet mocks base method. +func (m *MockCmdable) TSGet(arg0 context.Context, arg1 string) *redis.TSTimestampValueCmd { 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) + ret := m.ctrl.Call(m, "TSGet", arg0, arg1) + ret0, _ := ret[0].(*redis.TSTimestampValueCmd) return ret0 } -// Touch indicates an expected call of Touch. -func (mr *MockCmdableMockRecorder) Touch(ctx any, keys ...any) *gomock.Call { +// TSGet indicates an expected call of TSGet. +func (mr *MockCmdableMockRecorder) TSGet(arg0, arg1 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...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGet", reflect.TypeOf((*MockCmdable)(nil).TSGet), arg0, arg1) } -// TxPipeline mocks base method. -func (m *MockCmdable) TxPipeline() redis.Pipeliner { +// TSGetWithArgs mocks base method. +func (m *MockCmdable) TSGetWithArgs(arg0 context.Context, arg1 string, arg2 *redis.TSGetOptions) *redis.TSTimestampValueCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TxPipeline") - ret0, _ := ret[0].(redis.Pipeliner) + ret := m.ctrl.Call(m, "TSGetWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.TSTimestampValueCmd) return ret0 } -// TxPipeline indicates an expected call of TxPipeline. -func (mr *MockCmdableMockRecorder) TxPipeline() *gomock.Call { +// TSGetWithArgs indicates an expected call of TSGetWithArgs. +func (mr *MockCmdableMockRecorder) TSGetWithArgs(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockCmdable)(nil).TxPipeline)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGetWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSGetWithArgs), arg0, arg1, arg2) } -// TxPipelined mocks base method. -func (m *MockCmdable) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { +// TSIncrBy mocks base method. +func (m *MockCmdable) TSIncrBy(arg0 context.Context, arg1 string, arg2 float64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TxPipelined", ctx, fn) - ret0, _ := ret[0].([]redis.Cmder) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "TSIncrBy", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 } -// TxPipelined indicates an expected call of TxPipelined. -func (mr *MockCmdableMockRecorder) TxPipelined(ctx, fn any) *gomock.Call { +// TSIncrBy indicates an expected call of TSIncrBy. +func (mr *MockCmdableMockRecorder) TSIncrBy(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockCmdable)(nil).TxPipelined), ctx, fn) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrBy", reflect.TypeOf((*MockCmdable)(nil).TSIncrBy), arg0, arg1, arg2) } -// Type mocks base method. -func (m *MockCmdable) Type(ctx context.Context, key string) *redis.StatusCmd { +// TSIncrByWithArgs mocks base method. +func (m *MockCmdable) TSIncrByWithArgs(arg0 context.Context, arg1 string, arg2 float64, arg3 *redis.TSIncrDecrOptions) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Type", ctx, key) - ret0, _ := ret[0].(*redis.StatusCmd) + ret := m.ctrl.Call(m, "TSIncrByWithArgs", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) return ret0 } -// Type indicates an expected call of Type. -func (mr *MockCmdableMockRecorder) Type(ctx, key any) *gomock.Call { +// TSIncrByWithArgs indicates an expected call of TSIncrByWithArgs. +func (mr *MockCmdableMockRecorder) TSIncrByWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockCmdable)(nil).Type), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrByWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSIncrByWithArgs), arg0, arg1, arg2, arg3) } -// Unlink mocks base method. -func (m *MockCmdable) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { +// TSInfo mocks base method. +func (m *MockCmdable) TSInfo(arg0 context.Context, arg1 string) *redis.MapStringInterfaceCmd { 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) + ret := m.ctrl.Call(m, "TSInfo", arg0, arg1) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) return ret0 } -// Unlink indicates an expected call of Unlink. -func (mr *MockCmdableMockRecorder) Unlink(ctx any, keys ...any) *gomock.Call { +// TSInfo indicates an expected call of TSInfo. +func (mr *MockCmdableMockRecorder) TSInfo(arg0, arg1 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...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfo", reflect.TypeOf((*MockCmdable)(nil).TSInfo), arg0, arg1) } -// XAck mocks base method. -func (m *MockCmdable) XAck(ctx context.Context, stream, group string, ids ...string) *redis.IntCmd { +// TSInfoWithArgs mocks base method. +func (m *MockCmdable) TSInfoWithArgs(arg0 context.Context, arg1 string, arg2 *redis.TSInfoOptions) *redis.MapStringInterfaceCmd { 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) + ret := m.ctrl.Call(m, "TSInfoWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) return ret0 } -// XAck indicates an expected call of XAck. -func (mr *MockCmdableMockRecorder) XAck(ctx, stream, group any, ids ...any) *gomock.Call { +// TSInfoWithArgs indicates an expected call of TSInfoWithArgs. +func (mr *MockCmdableMockRecorder) TSInfoWithArgs(arg0, arg1, arg2 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...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfoWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSInfoWithArgs), arg0, arg1, arg2) } -// XAdd mocks base method. -func (m *MockCmdable) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd { +// TSMAdd mocks base method. +func (m *MockCmdable) TSMAdd(arg0 context.Context, arg1 [][]any) *redis.IntSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XAdd", ctx, a) - ret0, _ := ret[0].(*redis.StringCmd) + ret := m.ctrl.Call(m, "TSMAdd", arg0, arg1) + ret0, _ := ret[0].(*redis.IntSliceCmd) return ret0 } -// XAdd indicates an expected call of XAdd. -func (mr *MockCmdableMockRecorder) XAdd(ctx, a any) *gomock.Call { +// TSMAdd indicates an expected call of TSMAdd. +func (mr *MockCmdableMockRecorder) TSMAdd(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockCmdable)(nil).XAdd), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMAdd", reflect.TypeOf((*MockCmdable)(nil).TSMAdd), arg0, arg1) } -// XAutoClaim mocks base method. -func (m *MockCmdable) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { +// TSMGet mocks base method. +func (m *MockCmdable) TSMGet(arg0 context.Context, arg1 []string) *redis.MapStringSliceInterfaceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XAutoClaim", ctx, a) - ret0, _ := ret[0].(*redis.XAutoClaimCmd) + ret := m.ctrl.Call(m, "TSMGet", arg0, arg1) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) return ret0 } -// XAutoClaim indicates an expected call of XAutoClaim. -func (mr *MockCmdableMockRecorder) XAutoClaim(ctx, a any) *gomock.Call { +// TSMGet indicates an expected call of TSMGet. +func (mr *MockCmdableMockRecorder) TSMGet(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockCmdable)(nil).XAutoClaim), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGet", reflect.TypeOf((*MockCmdable)(nil).TSMGet), arg0, arg1) } -// XAutoClaimJustID mocks base method. -func (m *MockCmdable) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { +// TSMGetWithArgs mocks base method. +func (m *MockCmdable) TSMGetWithArgs(arg0 context.Context, arg1 []string, arg2 *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XAutoClaimJustID", ctx, a) - ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd) + ret := m.ctrl.Call(m, "TSMGetWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) return ret0 } -// XAutoClaimJustID indicates an expected call of XAutoClaimJustID. -func (mr *MockCmdableMockRecorder) XAutoClaimJustID(ctx, a any) *gomock.Call { +// TSMGetWithArgs indicates an expected call of TSMGetWithArgs. +func (mr *MockCmdableMockRecorder) TSMGetWithArgs(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XAutoClaimJustID), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGetWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMGetWithArgs), arg0, arg1, arg2) } -// XClaim mocks base method. -func (m *MockCmdable) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd { +// TSMRange mocks base method. +func (m *MockCmdable) TSMRange(arg0 context.Context, arg1, arg2 int, arg3 []string) *redis.MapStringSliceInterfaceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XClaim", ctx, a) - ret0, _ := ret[0].(*redis.XMessageSliceCmd) + ret := m.ctrl.Call(m, "TSMRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) return ret0 } -// XClaim indicates an expected call of XClaim. -func (mr *MockCmdableMockRecorder) XClaim(ctx, a any) *gomock.Call { +// TSMRange indicates an expected call of TSMRange. +func (mr *MockCmdableMockRecorder) TSMRange(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockCmdable)(nil).XClaim), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRange", reflect.TypeOf((*MockCmdable)(nil).TSMRange), arg0, arg1, arg2, arg3) } -// XClaimJustID mocks base method. -func (m *MockCmdable) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd { +// TSMRangeWithArgs mocks base method. +func (m *MockCmdable) TSMRangeWithArgs(arg0 context.Context, arg1, arg2 int, arg3 []string, arg4 *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XClaimJustID", ctx, a) - ret0, _ := ret[0].(*redis.StringSliceCmd) + ret := m.ctrl.Call(m, "TSMRangeWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) return ret0 } -// XClaimJustID indicates an expected call of XClaimJustID. -func (mr *MockCmdableMockRecorder) XClaimJustID(ctx, a any) *gomock.Call { +// TSMRangeWithArgs indicates an expected call of TSMRangeWithArgs. +func (mr *MockCmdableMockRecorder) TSMRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XClaimJustID), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMRangeWithArgs), arg0, arg1, arg2, arg3, arg4) } -// XDel mocks base method. -func (m *MockCmdable) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd { +// TSMRevRange mocks base method. +func (m *MockCmdable) TSMRevRange(arg0 context.Context, arg1, arg2 int, arg3 []string) *redis.MapStringSliceInterfaceCmd { 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) + ret := m.ctrl.Call(m, "TSMRevRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) return ret0 } -// XDel indicates an expected call of XDel. -func (mr *MockCmdableMockRecorder) XDel(ctx, stream any, ids ...any) *gomock.Call { +// TSMRevRange indicates an expected call of TSMRevRange. +func (mr *MockCmdableMockRecorder) TSMRevRange(arg0, arg1, arg2, arg3 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...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRange", reflect.TypeOf((*MockCmdable)(nil).TSMRevRange), arg0, arg1, arg2, arg3) } -// XGroupCreate mocks base method. -func (m *MockCmdable) XGroupCreate(ctx context.Context, stream, group, start string) *redis.StatusCmd { +// TSMRevRangeWithArgs mocks base method. +func (m *MockCmdable) TSMRevRangeWithArgs(arg0 context.Context, arg1, arg2 int, arg3 []string, arg4 *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupCreate", ctx, stream, group, start) - ret0, _ := ret[0].(*redis.StatusCmd) + ret := m.ctrl.Call(m, "TSMRevRangeWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) return ret0 } -// XGroupCreate indicates an expected call of XGroupCreate. -func (mr *MockCmdableMockRecorder) XGroupCreate(ctx, stream, group, start any) *gomock.Call { +// TSMRevRangeWithArgs indicates an expected call of TSMRevRangeWithArgs. +func (mr *MockCmdableMockRecorder) TSMRevRangeWithArgs(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMRevRangeWithArgs), arg0, arg1, arg2, arg3, arg4) } -// XGroupCreateConsumer mocks base method. -func (m *MockCmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { +// TSQueryIndex mocks base method. +func (m *MockCmdable) TSQueryIndex(arg0 context.Context, arg1 []string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupCreateConsumer", ctx, stream, group, consumer) - ret0, _ := ret[0].(*redis.IntCmd) + ret := m.ctrl.Call(m, "TSQueryIndex", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } -// XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer. -func (mr *MockCmdableMockRecorder) XGroupCreateConsumer(ctx, stream, group, consumer any) *gomock.Call { +// TSQueryIndex indicates an expected call of TSQueryIndex. +func (mr *MockCmdableMockRecorder) TSQueryIndex(arg0, arg1 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSQueryIndex", reflect.TypeOf((*MockCmdable)(nil).TSQueryIndex), arg0, arg1) } -// XGroupCreateMkStream mocks base method. -func (m *MockCmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd { +// TSRange mocks base method. +func (m *MockCmdable) TSRange(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.TSTimestampValueSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupCreateMkStream", ctx, stream, group, start) - ret0, _ := ret[0].(*redis.StatusCmd) + ret := m.ctrl.Call(m, "TSRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) return ret0 } -// XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream. -func (mr *MockCmdableMockRecorder) XGroupCreateMkStream(ctx, stream, group, start any) *gomock.Call { +// TSRange indicates an expected call of TSRange. +func (mr *MockCmdableMockRecorder) TSRange(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRange", reflect.TypeOf((*MockCmdable)(nil).TSRange), arg0, arg1, arg2, arg3) } -// XGroupDelConsumer mocks base method. -func (m *MockCmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { +// TSRangeWithArgs mocks base method. +func (m *MockCmdable) TSRangeWithArgs(arg0 context.Context, arg1 string, arg2, arg3 int, arg4 *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupDelConsumer", ctx, stream, group, consumer) - ret0, _ := ret[0].(*redis.IntCmd) + ret := m.ctrl.Call(m, "TSRangeWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) return ret0 } -// XGroupDelConsumer indicates an expected call of XGroupDelConsumer. -func (mr *MockCmdableMockRecorder) XGroupDelConsumer(ctx, stream, group, consumer any) *gomock.Call { +// TSRangeWithArgs indicates an expected call of TSRangeWithArgs. +func (mr *MockCmdableMockRecorder) TSRangeWithArgs(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSRangeWithArgs), arg0, arg1, arg2, arg3, arg4) } -// XGroupDestroy mocks base method. -func (m *MockCmdable) XGroupDestroy(ctx context.Context, stream, group string) *redis.IntCmd { +// TSRevRange mocks base method. +func (m *MockCmdable) TSRevRange(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.TSTimestampValueSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupDestroy", ctx, stream, group) - ret0, _ := ret[0].(*redis.IntCmd) + ret := m.ctrl.Call(m, "TSRevRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) return ret0 } -// XGroupDestroy indicates an expected call of XGroupDestroy. -func (mr *MockCmdableMockRecorder) XGroupDestroy(ctx, stream, group any) *gomock.Call { +// TSRevRange indicates an expected call of TSRevRange. +func (mr *MockCmdableMockRecorder) TSRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockCmdable)(nil).XGroupDestroy), ctx, stream, group) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRange", reflect.TypeOf((*MockCmdable)(nil).TSRevRange), arg0, arg1, arg2, arg3) } -// XGroupSetID mocks base method. -func (m *MockCmdable) XGroupSetID(ctx context.Context, stream, group, start string) *redis.StatusCmd { +// TSRevRangeWithArgs mocks base method. +func (m *MockCmdable) TSRevRangeWithArgs(arg0 context.Context, arg1 string, arg2, arg3 int, arg4 *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupSetID", ctx, stream, group, start) - ret0, _ := ret[0].(*redis.StatusCmd) + ret := m.ctrl.Call(m, "TSRevRangeWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) return ret0 } -// XGroupSetID indicates an expected call of XGroupSetID. -func (mr *MockCmdableMockRecorder) XGroupSetID(ctx, stream, group, start any) *gomock.Call { +// TSRevRangeWithArgs indicates an expected call of TSRevRangeWithArgs. +func (mr *MockCmdableMockRecorder) TSRevRangeWithArgs(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSRevRangeWithArgs), arg0, arg1, arg2, arg3, arg4) } -// XInfoConsumers mocks base method. -func (m *MockCmdable) XInfoConsumers(ctx context.Context, key, group string) *redis.XInfoConsumersCmd { +// TTL mocks base method. +func (m *MockCmdable) TTL(arg0 context.Context, arg1 string) *redis.DurationCmd { 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) + ret := m.ctrl.Call(m, "TTL", arg0, arg1) + ret0, _ := ret[0].(*redis.DurationCmd) return ret0 } // TTL indicates an expected call of TTL. -func (mr *MockStatefulCmdableMockRecorder) TTL(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TTL(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockStatefulCmdable)(nil).TTL), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockCmdable)(nil).TTL), arg0, arg1) } // Time mocks base method. -func (m *MockStatefulCmdable) Time(ctx context.Context) *redis.TimeCmd { +func (m *MockCmdable) Time(arg0 context.Context) *redis.TimeCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Time", ctx) + ret := m.ctrl.Call(m, "Time", arg0) ret0, _ := ret[0].(*redis.TimeCmd) return ret0 } // Time indicates an expected call of Time. -func (mr *MockStatefulCmdableMockRecorder) Time(ctx any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Time(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockStatefulCmdable)(nil).Time), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockCmdable)(nil).Time), arg0) } // TopKAdd mocks base method. -func (m *MockStatefulCmdable) TopKAdd(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd { +func (m *MockCmdable) TopKAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TopKAdd", varargs...) @@ -11034,17 +5015,17 @@ func (m *MockStatefulCmdable) TopKAdd(ctx context.Context, key string, elements } // TopKAdd indicates an expected call of TopKAdd. -func (mr *MockStatefulCmdableMockRecorder) TopKAdd(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TopKAdd(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockCmdable)(nil).TopKAdd), varargs...) } // TopKCount mocks base method. -func (m *MockStatefulCmdable) TopKCount(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd { +func (m *MockCmdable) TopKCount(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TopKCount", varargs...) @@ -11053,17 +5034,17 @@ func (m *MockStatefulCmdable) TopKCount(ctx context.Context, key string, element } // TopKCount indicates an expected call of TopKCount. -func (mr *MockStatefulCmdableMockRecorder) TopKCount(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TopKCount(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockCmdable)(nil).TopKCount), varargs...) } // TopKIncrBy mocks base method. -func (m *MockStatefulCmdable) TopKIncrBy(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd { +func (m *MockCmdable) TopKIncrBy(arg0 context.Context, arg1 string, arg2 ...any) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TopKIncrBy", varargs...) @@ -11072,59 +5053,59 @@ func (m *MockStatefulCmdable) TopKIncrBy(ctx context.Context, key string, elemen } // TopKIncrBy indicates an expected call of TopKIncrBy. -func (mr *MockStatefulCmdableMockRecorder) TopKIncrBy(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TopKIncrBy(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockCmdable)(nil).TopKIncrBy), varargs...) } // TopKInfo mocks base method. -func (m *MockStatefulCmdable) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd { +func (m *MockCmdable) TopKInfo(arg0 context.Context, arg1 string) *redis.TopKInfoCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKInfo", ctx, key) + ret := m.ctrl.Call(m, "TopKInfo", arg0, arg1) ret0, _ := ret[0].(*redis.TopKInfoCmd) return ret0 } // TopKInfo indicates an expected call of TopKInfo. -func (mr *MockStatefulCmdableMockRecorder) TopKInfo(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TopKInfo(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKInfo), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockCmdable)(nil).TopKInfo), arg0, arg1) } // TopKList mocks base method. -func (m *MockStatefulCmdable) TopKList(ctx context.Context, key string) *redis.StringSliceCmd { +func (m *MockCmdable) TopKList(arg0 context.Context, arg1 string) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKList", ctx, key) + ret := m.ctrl.Call(m, "TopKList", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // TopKList indicates an expected call of TopKList. -func (mr *MockStatefulCmdableMockRecorder) TopKList(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TopKList(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKList), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockCmdable)(nil).TopKList), arg0, arg1) } // TopKListWithCount mocks base method. -func (m *MockStatefulCmdable) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd { +func (m *MockCmdable) TopKListWithCount(arg0 context.Context, arg1 string) *redis.MapStringIntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKListWithCount", ctx, key) + ret := m.ctrl.Call(m, "TopKListWithCount", arg0, arg1) ret0, _ := ret[0].(*redis.MapStringIntCmd) return ret0 } // TopKListWithCount indicates an expected call of TopKListWithCount. -func (mr *MockStatefulCmdableMockRecorder) TopKListWithCount(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TopKListWithCount(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKListWithCount), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockCmdable)(nil).TopKListWithCount), arg0, arg1) } // TopKQuery mocks base method. -func (m *MockStatefulCmdable) TopKQuery(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd { +func (m *MockCmdable) TopKQuery(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range elements { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TopKQuery", varargs...) @@ -11133,45 +5114,45 @@ func (m *MockStatefulCmdable) TopKQuery(ctx context.Context, key string, element } // TopKQuery indicates an expected call of TopKQuery. -func (mr *MockStatefulCmdableMockRecorder) TopKQuery(ctx, key any, elements ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TopKQuery(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockCmdable)(nil).TopKQuery), varargs...) } // TopKReserve mocks base method. -func (m *MockStatefulCmdable) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd { +func (m *MockCmdable) TopKReserve(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKReserve", ctx, key, k) + ret := m.ctrl.Call(m, "TopKReserve", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // TopKReserve indicates an expected call of TopKReserve. -func (mr *MockStatefulCmdableMockRecorder) TopKReserve(ctx, key, k any) *gomock.Call { +func (mr *MockCmdableMockRecorder) TopKReserve(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKReserve), ctx, key, k) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockCmdable)(nil).TopKReserve), arg0, arg1, arg2) } // TopKReserveWithOptions mocks base method. -func (m *MockStatefulCmdable) TopKReserveWithOptions(ctx context.Context, key string, k, width, depth int64, decay float64) *redis.StatusCmd { +func (m *MockCmdable) TopKReserveWithOptions(arg0 context.Context, arg1 string, arg2, arg3, arg4 int64, arg5 float64) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopKReserveWithOptions", ctx, key, k, width, depth, decay) + ret := m.ctrl.Call(m, "TopKReserveWithOptions", arg0, arg1, arg2, arg3, arg4, arg5) 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 { +func (mr *MockCmdableMockRecorder) TopKReserveWithOptions(arg0, arg1, arg2, arg3, arg4, arg5 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserveWithOptions", reflect.TypeOf((*MockCmdable)(nil).TopKReserveWithOptions), arg0, arg1, arg2, arg3, arg4, arg5) } // Touch mocks base method. -func (m *MockStatefulCmdable) Touch(ctx context.Context, keys ...string) *redis.IntCmd { +func (m *MockCmdable) Touch(arg0 context.Context, arg1 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Touch", varargs...) @@ -11180,14 +5161,14 @@ func (m *MockStatefulCmdable) Touch(ctx context.Context, keys ...string) *redis. } // Touch indicates an expected call of Touch. -func (mr *MockStatefulCmdableMockRecorder) Touch(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Touch(arg0 any, arg1 ...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...) + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockCmdable)(nil).Touch), varargs...) } // TxPipeline mocks base method. -func (m *MockStatefulCmdable) TxPipeline() redis.Pipeliner { +func (m *MockCmdable) TxPipeline() redis.Pipeliner { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "TxPipeline") ret0, _ := ret[0].(redis.Pipeliner) @@ -11195,45 +5176,45 @@ func (m *MockStatefulCmdable) TxPipeline() redis.Pipeliner { } // TxPipeline indicates an expected call of TxPipeline. -func (mr *MockStatefulCmdableMockRecorder) TxPipeline() *gomock.Call { +func (mr *MockCmdableMockRecorder) TxPipeline() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockStatefulCmdable)(nil).TxPipeline)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockCmdable)(nil).TxPipeline)) } // TxPipelined mocks base method. -func (m *MockStatefulCmdable) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { +func (m *MockCmdable) TxPipelined(arg0 context.Context, arg1 func(redis.Pipeliner) error) ([]redis.Cmder, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TxPipelined", ctx, fn) + ret := m.ctrl.Call(m, "TxPipelined", arg0, arg1) 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 { +func (mr *MockCmdableMockRecorder) TxPipelined(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockStatefulCmdable)(nil).TxPipelined), ctx, fn) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockCmdable)(nil).TxPipelined), arg0, arg1) } // Type mocks base method. -func (m *MockStatefulCmdable) Type(ctx context.Context, key string) *redis.StatusCmd { +func (m *MockCmdable) Type(arg0 context.Context, arg1 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Type", ctx, key) + ret := m.ctrl.Call(m, "Type", arg0, arg1) ret0, _ := ret[0].(*redis.StatusCmd) return ret0 } // Type indicates an expected call of Type. -func (mr *MockStatefulCmdableMockRecorder) Type(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Type(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockStatefulCmdable)(nil).Type), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockCmdable)(nil).Type), arg0, arg1) } // Unlink mocks base method. -func (m *MockStatefulCmdable) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { +func (m *MockCmdable) Unlink(arg0 context.Context, arg1 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Unlink", varargs...) @@ -11242,17 +5223,17 @@ func (m *MockStatefulCmdable) Unlink(ctx context.Context, keys ...string) *redis } // Unlink indicates an expected call of Unlink. -func (mr *MockStatefulCmdableMockRecorder) Unlink(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) Unlink(arg0 any, arg1 ...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...) + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockCmdable)(nil).Unlink), varargs...) } // XAck mocks base method. -func (m *MockStatefulCmdable) XAck(ctx context.Context, stream, group string, ids ...string) *redis.IntCmd { +func (m *MockCmdable) XAck(arg0 context.Context, arg1, arg2 string, arg3 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, stream, group} - for _, a := range ids { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "XAck", varargs...) @@ -11261,87 +5242,87 @@ func (m *MockStatefulCmdable) XAck(ctx context.Context, stream, group string, id } // XAck indicates an expected call of XAck. -func (mr *MockStatefulCmdableMockRecorder) XAck(ctx, stream, group any, ids ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XAck(arg0, arg1, arg2 any, arg3 ...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...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockCmdable)(nil).XAck), varargs...) } // XAdd mocks base method. -func (m *MockStatefulCmdable) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd { +func (m *MockCmdable) XAdd(arg0 context.Context, arg1 *redis.XAddArgs) *redis.StringCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XAdd", ctx, a) + ret := m.ctrl.Call(m, "XAdd", arg0, arg1) ret0, _ := ret[0].(*redis.StringCmd) return ret0 } // XAdd indicates an expected call of XAdd. -func (mr *MockStatefulCmdableMockRecorder) XAdd(ctx, a any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XAdd(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).XAdd), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockCmdable)(nil).XAdd), arg0, arg1) } // XAutoClaim mocks base method. -func (m *MockStatefulCmdable) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { +func (m *MockCmdable) XAutoClaim(arg0 context.Context, arg1 *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XAutoClaim", ctx, a) + ret := m.ctrl.Call(m, "XAutoClaim", arg0, arg1) ret0, _ := ret[0].(*redis.XAutoClaimCmd) return ret0 } // XAutoClaim indicates an expected call of XAutoClaim. -func (mr *MockStatefulCmdableMockRecorder) XAutoClaim(ctx, a any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XAutoClaim(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockStatefulCmdable)(nil).XAutoClaim), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockCmdable)(nil).XAutoClaim), arg0, arg1) } // XAutoClaimJustID mocks base method. -func (m *MockStatefulCmdable) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { +func (m *MockCmdable) XAutoClaimJustID(arg0 context.Context, arg1 *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XAutoClaimJustID", ctx, a) + ret := m.ctrl.Call(m, "XAutoClaimJustID", arg0, arg1) ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd) return ret0 } // XAutoClaimJustID indicates an expected call of XAutoClaimJustID. -func (mr *MockStatefulCmdableMockRecorder) XAutoClaimJustID(ctx, a any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XAutoClaimJustID(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockStatefulCmdable)(nil).XAutoClaimJustID), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XAutoClaimJustID), arg0, arg1) } // XClaim mocks base method. -func (m *MockStatefulCmdable) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd { +func (m *MockCmdable) XClaim(arg0 context.Context, arg1 *redis.XClaimArgs) *redis.XMessageSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XClaim", ctx, a) + ret := m.ctrl.Call(m, "XClaim", arg0, arg1) ret0, _ := ret[0].(*redis.XMessageSliceCmd) return ret0 } // XClaim indicates an expected call of XClaim. -func (mr *MockStatefulCmdableMockRecorder) XClaim(ctx, a any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XClaim(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockStatefulCmdable)(nil).XClaim), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockCmdable)(nil).XClaim), arg0, arg1) } // XClaimJustID mocks base method. -func (m *MockStatefulCmdable) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd { +func (m *MockCmdable) XClaimJustID(arg0 context.Context, arg1 *redis.XClaimArgs) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XClaimJustID", ctx, a) + ret := m.ctrl.Call(m, "XClaimJustID", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // XClaimJustID indicates an expected call of XClaimJustID. -func (mr *MockStatefulCmdableMockRecorder) XClaimJustID(ctx, a any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XClaimJustID(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockStatefulCmdable)(nil).XClaimJustID), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XClaimJustID), arg0, arg1) } // XDel mocks base method. -func (m *MockStatefulCmdable) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd { +func (m *MockCmdable) XDel(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, stream} - for _, a := range ids { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "XDel", varargs...) @@ -11350,255 +5331,255 @@ func (m *MockStatefulCmdable) XDel(ctx context.Context, stream string, ids ...st } // XDel indicates an expected call of XDel. -func (mr *MockStatefulCmdableMockRecorder) XDel(ctx, stream any, ids ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XDel(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockCmdable)(nil).XDel), varargs...) } // XGroupCreate mocks base method. -func (m *MockStatefulCmdable) XGroupCreate(ctx context.Context, stream, group, start string) *redis.StatusCmd { +func (m *MockCmdable) XGroupCreate(arg0 context.Context, arg1, arg2, arg3 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupCreate", ctx, stream, group, start) + ret := m.ctrl.Call(m, "XGroupCreate", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XGroupCreate(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockCmdable)(nil).XGroupCreate), arg0, arg1, arg2, arg3) } // XGroupCreateConsumer mocks base method. -func (m *MockStatefulCmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { +func (m *MockCmdable) XGroupCreateConsumer(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupCreateConsumer", ctx, stream, group, consumer) + ret := m.ctrl.Call(m, "XGroupCreateConsumer", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XGroupCreateConsumer(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockCmdable)(nil).XGroupCreateConsumer), arg0, arg1, arg2, arg3) } // XGroupCreateMkStream mocks base method. -func (m *MockStatefulCmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd { +func (m *MockCmdable) XGroupCreateMkStream(arg0 context.Context, arg1, arg2, arg3 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupCreateMkStream", ctx, stream, group, start) + ret := m.ctrl.Call(m, "XGroupCreateMkStream", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XGroupCreateMkStream(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockCmdable)(nil).XGroupCreateMkStream), arg0, arg1, arg2, arg3) } // XGroupDelConsumer mocks base method. -func (m *MockStatefulCmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { +func (m *MockCmdable) XGroupDelConsumer(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupDelConsumer", ctx, stream, group, consumer) + ret := m.ctrl.Call(m, "XGroupDelConsumer", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XGroupDelConsumer(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockCmdable)(nil).XGroupDelConsumer), arg0, arg1, arg2, arg3) } // XGroupDestroy mocks base method. -func (m *MockStatefulCmdable) XGroupDestroy(ctx context.Context, stream, group string) *redis.IntCmd { +func (m *MockCmdable) XGroupDestroy(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupDestroy", ctx, stream, group) + ret := m.ctrl.Call(m, "XGroupDestroy", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // XGroupDestroy indicates an expected call of XGroupDestroy. -func (mr *MockStatefulCmdableMockRecorder) XGroupDestroy(ctx, stream, group any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XGroupDestroy(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupDestroy), ctx, stream, group) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockCmdable)(nil).XGroupDestroy), arg0, arg1, arg2) } // XGroupSetID mocks base method. -func (m *MockStatefulCmdable) XGroupSetID(ctx context.Context, stream, group, start string) *redis.StatusCmd { +func (m *MockCmdable) XGroupSetID(arg0 context.Context, arg1, arg2, arg3 string) *redis.StatusCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XGroupSetID", ctx, stream, group, start) + ret := m.ctrl.Call(m, "XGroupSetID", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XGroupSetID(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockCmdable)(nil).XGroupSetID), arg0, arg1, arg2, arg3) } // XInfoConsumers mocks base method. -func (m *MockStatefulCmdable) XInfoConsumers(ctx context.Context, key, group string) *redis.XInfoConsumersCmd { +func (m *MockCmdable) XInfoConsumers(arg0 context.Context, arg1, arg2 string) *redis.XInfoConsumersCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XInfoConsumers", ctx, key, group) + ret := m.ctrl.Call(m, "XInfoConsumers", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.XInfoConsumersCmd) return ret0 } // XInfoConsumers indicates an expected call of XInfoConsumers. -func (mr *MockStatefulCmdableMockRecorder) XInfoConsumers(ctx, key, group any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XInfoConsumers(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoConsumers), ctx, key, group) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockCmdable)(nil).XInfoConsumers), arg0, arg1, arg2) } // XInfoGroups mocks base method. -func (m *MockStatefulCmdable) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd { +func (m *MockCmdable) XInfoGroups(arg0 context.Context, arg1 string) *redis.XInfoGroupsCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XInfoGroups", ctx, key) + ret := m.ctrl.Call(m, "XInfoGroups", arg0, arg1) ret0, _ := ret[0].(*redis.XInfoGroupsCmd) return ret0 } // XInfoGroups indicates an expected call of XInfoGroups. -func (mr *MockStatefulCmdableMockRecorder) XInfoGroups(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XInfoGroups(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoGroups), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockCmdable)(nil).XInfoGroups), arg0, arg1) } // XInfoStream mocks base method. -func (m *MockStatefulCmdable) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd { +func (m *MockCmdable) XInfoStream(arg0 context.Context, arg1 string) *redis.XInfoStreamCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XInfoStream", ctx, key) + ret := m.ctrl.Call(m, "XInfoStream", arg0, arg1) ret0, _ := ret[0].(*redis.XInfoStreamCmd) return ret0 } // XInfoStream indicates an expected call of XInfoStream. -func (mr *MockStatefulCmdableMockRecorder) XInfoStream(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XInfoStream(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoStream), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockCmdable)(nil).XInfoStream), arg0, arg1) } // XInfoStreamFull mocks base method. -func (m *MockStatefulCmdable) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd { +func (m *MockCmdable) XInfoStreamFull(arg0 context.Context, arg1 string, arg2 int) *redis.XInfoStreamFullCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XInfoStreamFull", ctx, key, count) + ret := m.ctrl.Call(m, "XInfoStreamFull", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.XInfoStreamFullCmd) return ret0 } // XInfoStreamFull indicates an expected call of XInfoStreamFull. -func (mr *MockStatefulCmdableMockRecorder) XInfoStreamFull(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XInfoStreamFull(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoStreamFull), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockCmdable)(nil).XInfoStreamFull), arg0, arg1, arg2) } // XLen mocks base method. -func (m *MockStatefulCmdable) XLen(ctx context.Context, stream string) *redis.IntCmd { +func (m *MockCmdable) XLen(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XLen", ctx, stream) + ret := m.ctrl.Call(m, "XLen", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // XLen indicates an expected call of XLen. -func (mr *MockStatefulCmdableMockRecorder) XLen(ctx, stream any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XLen(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockStatefulCmdable)(nil).XLen), ctx, stream) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockCmdable)(nil).XLen), arg0, arg1) } // XPending mocks base method. -func (m *MockStatefulCmdable) XPending(ctx context.Context, stream, group string) *redis.XPendingCmd { +func (m *MockCmdable) XPending(arg0 context.Context, arg1, arg2 string) *redis.XPendingCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XPending", ctx, stream, group) + ret := m.ctrl.Call(m, "XPending", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.XPendingCmd) return ret0 } // XPending indicates an expected call of XPending. -func (mr *MockStatefulCmdableMockRecorder) XPending(ctx, stream, group any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XPending(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockStatefulCmdable)(nil).XPending), ctx, stream, group) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockCmdable)(nil).XPending), arg0, arg1, arg2) } // XPendingExt mocks base method. -func (m *MockStatefulCmdable) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd { +func (m *MockCmdable) XPendingExt(arg0 context.Context, arg1 *redis.XPendingExtArgs) *redis.XPendingExtCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XPendingExt", ctx, a) + ret := m.ctrl.Call(m, "XPendingExt", arg0, arg1) ret0, _ := ret[0].(*redis.XPendingExtCmd) return ret0 } // XPendingExt indicates an expected call of XPendingExt. -func (mr *MockStatefulCmdableMockRecorder) XPendingExt(ctx, a any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XPendingExt(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockStatefulCmdable)(nil).XPendingExt), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockCmdable)(nil).XPendingExt), arg0, arg1) } // XRange mocks base method. -func (m *MockStatefulCmdable) XRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { +func (m *MockCmdable) XRange(arg0 context.Context, arg1, arg2, arg3 string) *redis.XMessageSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XRange", ctx, stream, start, stop) + ret := m.ctrl.Call(m, "XRange", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XRange(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockCmdable)(nil).XRange), arg0, arg1, arg2, arg3) } // XRangeN mocks base method. -func (m *MockStatefulCmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { +func (m *MockCmdable) XRangeN(arg0 context.Context, arg1, arg2, arg3 string, arg4 int64) *redis.XMessageSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XRangeN", ctx, stream, start, stop, count) + ret := m.ctrl.Call(m, "XRangeN", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) XRangeN(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockCmdable)(nil).XRangeN), arg0, arg1, arg2, arg3, arg4) } // XRead mocks base method. -func (m *MockStatefulCmdable) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd { +func (m *MockCmdable) XRead(arg0 context.Context, arg1 *redis.XReadArgs) *redis.XStreamSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XRead", ctx, a) + ret := m.ctrl.Call(m, "XRead", arg0, arg1) ret0, _ := ret[0].(*redis.XStreamSliceCmd) return ret0 } // XRead indicates an expected call of XRead. -func (mr *MockStatefulCmdableMockRecorder) XRead(ctx, a any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XRead(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockStatefulCmdable)(nil).XRead), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockCmdable)(nil).XRead), arg0, arg1) } // XReadGroup mocks base method. -func (m *MockStatefulCmdable) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd { +func (m *MockCmdable) XReadGroup(arg0 context.Context, arg1 *redis.XReadGroupArgs) *redis.XStreamSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XReadGroup", ctx, a) + ret := m.ctrl.Call(m, "XReadGroup", arg0, arg1) ret0, _ := ret[0].(*redis.XStreamSliceCmd) return ret0 } // XReadGroup indicates an expected call of XReadGroup. -func (mr *MockStatefulCmdableMockRecorder) XReadGroup(ctx, a any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XReadGroup(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockStatefulCmdable)(nil).XReadGroup), ctx, a) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockCmdable)(nil).XReadGroup), arg0, arg1) } // XReadStreams mocks base method. -func (m *MockStatefulCmdable) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd { +func (m *MockCmdable) XReadStreams(arg0 context.Context, arg1 ...string) *redis.XStreamSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range streams { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "XReadStreams", varargs...) @@ -11607,101 +5588,101 @@ func (m *MockStatefulCmdable) XReadStreams(ctx context.Context, streams ...strin } // XReadStreams indicates an expected call of XReadStreams. -func (mr *MockStatefulCmdableMockRecorder) XReadStreams(ctx any, streams ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XReadStreams(arg0 any, arg1 ...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...) + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockCmdable)(nil).XReadStreams), varargs...) } // XRevRange mocks base method. -func (m *MockStatefulCmdable) XRevRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { +func (m *MockCmdable) XRevRange(arg0 context.Context, arg1, arg2, arg3 string) *redis.XMessageSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XRevRange", ctx, stream, start, stop) + ret := m.ctrl.Call(m, "XRevRange", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XRevRange(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockCmdable)(nil).XRevRange), arg0, arg1, arg2, arg3) } // XRevRangeN mocks base method. -func (m *MockStatefulCmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { +func (m *MockCmdable) XRevRangeN(arg0 context.Context, arg1, arg2, arg3 string, arg4 int64) *redis.XMessageSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XRevRangeN", ctx, stream, start, stop, count) + ret := m.ctrl.Call(m, "XRevRangeN", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) XRevRangeN(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockCmdable)(nil).XRevRangeN), arg0, arg1, arg2, arg3, arg4) } // XTrimMaxLen mocks base method. -func (m *MockStatefulCmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd { +func (m *MockCmdable) XTrimMaxLen(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XTrimMaxLen", ctx, key, maxLen) + ret := m.ctrl.Call(m, "XTrimMaxLen", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // XTrimMaxLen indicates an expected call of XTrimMaxLen. -func (mr *MockStatefulCmdableMockRecorder) XTrimMaxLen(ctx, key, maxLen any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XTrimMaxLen(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMaxLen), ctx, key, maxLen) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLen), arg0, arg1, arg2) } // XTrimMaxLenApprox mocks base method. -func (m *MockStatefulCmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *redis.IntCmd { +func (m *MockCmdable) XTrimMaxLenApprox(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XTrimMaxLenApprox", ctx, key, maxLen, limit) + ret := m.ctrl.Call(m, "XTrimMaxLenApprox", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XTrimMaxLenApprox(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLenApprox), arg0, arg1, arg2, arg3) } // XTrimMinID mocks base method. -func (m *MockStatefulCmdable) XTrimMinID(ctx context.Context, key, minID string) *redis.IntCmd { +func (m *MockCmdable) XTrimMinID(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XTrimMinID", ctx, key, minID) + ret := m.ctrl.Call(m, "XTrimMinID", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // XTrimMinID indicates an expected call of XTrimMinID. -func (mr *MockStatefulCmdableMockRecorder) XTrimMinID(ctx, key, minID any) *gomock.Call { +func (mr *MockCmdableMockRecorder) XTrimMinID(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMinID), ctx, key, minID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockCmdable)(nil).XTrimMinID), arg0, arg1, arg2) } // XTrimMinIDApprox mocks base method. -func (m *MockStatefulCmdable) XTrimMinIDApprox(ctx context.Context, key, minID string, limit int64) *redis.IntCmd { +func (m *MockCmdable) XTrimMinIDApprox(arg0 context.Context, arg1, arg2 string, arg3 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "XTrimMinIDApprox", ctx, key, minID, limit) + ret := m.ctrl.Call(m, "XTrimMinIDApprox", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) XTrimMinIDApprox(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockCmdable)(nil).XTrimMinIDApprox), arg0, arg1, arg2, arg3) } // ZAdd mocks base method. -func (m *MockStatefulCmdable) ZAdd(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { +func (m *MockCmdable) ZAdd(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZAdd", varargs...) @@ -11710,45 +5691,45 @@ func (m *MockStatefulCmdable) ZAdd(ctx context.Context, key string, members ...r } // ZAdd indicates an expected call of ZAdd. -func (mr *MockStatefulCmdableMockRecorder) ZAdd(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZAdd(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockCmdable)(nil).ZAdd), varargs...) } // ZAddArgs mocks base method. -func (m *MockStatefulCmdable) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd { +func (m *MockCmdable) ZAddArgs(arg0 context.Context, arg1 string, arg2 redis.ZAddArgs) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZAddArgs", ctx, key, args) + ret := m.ctrl.Call(m, "ZAddArgs", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ZAddArgs indicates an expected call of ZAddArgs. -func (mr *MockStatefulCmdableMockRecorder) ZAddArgs(ctx, key, args any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZAddArgs(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddArgs), ctx, key, args) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockCmdable)(nil).ZAddArgs), arg0, arg1, arg2) } // ZAddArgsIncr mocks base method. -func (m *MockStatefulCmdable) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd { +func (m *MockCmdable) ZAddArgsIncr(arg0 context.Context, arg1 string, arg2 redis.ZAddArgs) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZAddArgsIncr", ctx, key, args) + ret := m.ctrl.Call(m, "ZAddArgsIncr", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.FloatCmd) return ret0 } // ZAddArgsIncr indicates an expected call of ZAddArgsIncr. -func (mr *MockStatefulCmdableMockRecorder) ZAddArgsIncr(ctx, key, args any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZAddArgsIncr(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddArgsIncr), ctx, key, args) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockCmdable)(nil).ZAddArgsIncr), arg0, arg1, arg2) } // ZAddGT mocks base method. -func (m *MockStatefulCmdable) ZAddGT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { +func (m *MockCmdable) ZAddGT(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZAddGT", varargs...) @@ -11757,17 +5738,17 @@ func (m *MockStatefulCmdable) ZAddGT(ctx context.Context, key string, members .. } // ZAddGT indicates an expected call of ZAddGT. -func (mr *MockStatefulCmdableMockRecorder) ZAddGT(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZAddGT(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddGT", reflect.TypeOf((*MockCmdable)(nil).ZAddGT), varargs...) } // ZAddLT mocks base method. -func (m *MockStatefulCmdable) ZAddLT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { +func (m *MockCmdable) ZAddLT(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZAddLT", varargs...) @@ -11776,17 +5757,17 @@ func (m *MockStatefulCmdable) ZAddLT(ctx context.Context, key string, members .. } // ZAddLT indicates an expected call of ZAddLT. -func (mr *MockStatefulCmdableMockRecorder) ZAddLT(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZAddLT(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddLT", reflect.TypeOf((*MockCmdable)(nil).ZAddLT), varargs...) } // ZAddNX mocks base method. -func (m *MockStatefulCmdable) ZAddNX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { +func (m *MockCmdable) ZAddNX(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZAddNX", varargs...) @@ -11795,17 +5776,17 @@ func (m *MockStatefulCmdable) ZAddNX(ctx context.Context, key string, members .. } // ZAddNX indicates an expected call of ZAddNX. -func (mr *MockStatefulCmdableMockRecorder) ZAddNX(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZAddNX(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockCmdable)(nil).ZAddNX), varargs...) } // ZAddXX mocks base method. -func (m *MockStatefulCmdable) ZAddXX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { +func (m *MockCmdable) ZAddXX(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZAddXX", varargs...) @@ -11814,45 +5795,45 @@ func (m *MockStatefulCmdable) ZAddXX(ctx context.Context, key string, members .. } // ZAddXX indicates an expected call of ZAddXX. -func (mr *MockStatefulCmdableMockRecorder) ZAddXX(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZAddXX(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockCmdable)(nil).ZAddXX), varargs...) } // ZCard mocks base method. -func (m *MockStatefulCmdable) ZCard(ctx context.Context, key string) *redis.IntCmd { +func (m *MockCmdable) ZCard(arg0 context.Context, arg1 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZCard", ctx, key) + ret := m.ctrl.Call(m, "ZCard", arg0, arg1) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ZCard indicates an expected call of ZCard. -func (mr *MockStatefulCmdableMockRecorder) ZCard(ctx, key any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZCard(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockStatefulCmdable)(nil).ZCard), ctx, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockCmdable)(nil).ZCard), arg0, arg1) } // ZCount mocks base method. -func (m *MockStatefulCmdable) ZCount(ctx context.Context, key, min, max string) *redis.IntCmd { +func (m *MockCmdable) ZCount(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZCount", ctx, key, min, max) + ret := m.ctrl.Call(m, "ZCount", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZCount(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockCmdable)(nil).ZCount), arg0, arg1, arg2, arg3) } // ZDiff mocks base method. -func (m *MockStatefulCmdable) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { +func (m *MockCmdable) ZDiff(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZDiff", varargs...) @@ -11861,17 +5842,17 @@ func (m *MockStatefulCmdable) ZDiff(ctx context.Context, keys ...string) *redis. } // ZDiff indicates an expected call of ZDiff. -func (mr *MockStatefulCmdableMockRecorder) ZDiff(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZDiff(arg0 any, arg1 ...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...) + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockCmdable)(nil).ZDiff), varargs...) } // ZDiffStore mocks base method. -func (m *MockStatefulCmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { +func (m *MockCmdable) ZDiffStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, destination} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZDiffStore", varargs...) @@ -11880,17 +5861,17 @@ func (m *MockStatefulCmdable) ZDiffStore(ctx context.Context, destination string } // ZDiffStore indicates an expected call of ZDiffStore. -func (mr *MockStatefulCmdableMockRecorder) ZDiffStore(ctx, destination any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZDiffStore(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockCmdable)(nil).ZDiffStore), varargs...) } // ZDiffWithScores mocks base method. -func (m *MockStatefulCmdable) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd { +func (m *MockCmdable) ZDiffWithScores(arg0 context.Context, arg1 ...string) *redis.ZSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range keys { + varargs := []any{arg0} + for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZDiffWithScores", varargs...) @@ -11899,45 +5880,45 @@ func (m *MockStatefulCmdable) ZDiffWithScores(ctx context.Context, keys ...strin } // ZDiffWithScores indicates an expected call of ZDiffWithScores. -func (mr *MockStatefulCmdableMockRecorder) ZDiffWithScores(ctx any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZDiffWithScores(arg0 any, arg1 ...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...) + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockCmdable)(nil).ZDiffWithScores), varargs...) } // ZIncrBy mocks base method. -func (m *MockStatefulCmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd { +func (m *MockCmdable) ZIncrBy(arg0 context.Context, arg1 string, arg2 float64, arg3 string) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZIncrBy", ctx, key, increment, member) + ret := m.ctrl.Call(m, "ZIncrBy", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZIncrBy(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockCmdable)(nil).ZIncrBy), arg0, arg1, arg2, arg3) } // ZInter mocks base method. -func (m *MockStatefulCmdable) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd { +func (m *MockCmdable) ZInter(arg0 context.Context, arg1 *redis.ZStore) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZInter", ctx, store) + ret := m.ctrl.Call(m, "ZInter", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ZInter indicates an expected call of ZInter. -func (mr *MockStatefulCmdableMockRecorder) ZInter(ctx, store any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZInter(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInter), ctx, store) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockCmdable)(nil).ZInter), arg0, arg1) } // ZInterCard mocks base method. -func (m *MockStatefulCmdable) ZInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { +func (m *MockCmdable) ZInterCard(arg0 context.Context, arg1 int64, arg2 ...string) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, limit} - for _, a := range keys { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZInterCard", varargs...) @@ -11946,59 +5927,59 @@ func (m *MockStatefulCmdable) ZInterCard(ctx context.Context, limit int64, keys } // ZInterCard indicates an expected call of ZInterCard. -func (mr *MockStatefulCmdableMockRecorder) ZInterCard(ctx, limit any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZInterCard(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterCard", reflect.TypeOf((*MockCmdable)(nil).ZInterCard), varargs...) } // ZInterStore mocks base method. -func (m *MockStatefulCmdable) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd { +func (m *MockCmdable) ZInterStore(arg0 context.Context, arg1 string, arg2 *redis.ZStore) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZInterStore", ctx, destination, store) + ret := m.ctrl.Call(m, "ZInterStore", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ZInterStore indicates an expected call of ZInterStore. -func (mr *MockStatefulCmdableMockRecorder) ZInterStore(ctx, destination, store any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZInterStore(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInterStore), ctx, destination, store) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockCmdable)(nil).ZInterStore), arg0, arg1, arg2) } // ZInterWithScores mocks base method. -func (m *MockStatefulCmdable) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd { +func (m *MockCmdable) ZInterWithScores(arg0 context.Context, arg1 *redis.ZStore) *redis.ZSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZInterWithScores", ctx, store) + ret := m.ctrl.Call(m, "ZInterWithScores", arg0, arg1) ret0, _ := ret[0].(*redis.ZSliceCmd) return ret0 } // ZInterWithScores indicates an expected call of ZInterWithScores. -func (mr *MockStatefulCmdableMockRecorder) ZInterWithScores(ctx, store any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZInterWithScores(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInterWithScores), ctx, store) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockCmdable)(nil).ZInterWithScores), arg0, arg1) } // ZLexCount mocks base method. -func (m *MockStatefulCmdable) ZLexCount(ctx context.Context, key, min, max string) *redis.IntCmd { +func (m *MockCmdable) ZLexCount(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZLexCount", ctx, key, min, max) + ret := m.ctrl.Call(m, "ZLexCount", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZLexCount(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockCmdable)(nil).ZLexCount), arg0, arg1, arg2, arg3) } // ZMPop mocks base method. -func (m *MockStatefulCmdable) ZMPop(ctx context.Context, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { +func (m *MockCmdable) ZMPop(arg0 context.Context, arg1 string, arg2 int64, arg3 ...string) *redis.ZSliceWithKeyCmd { m.ctrl.T.Helper() - varargs := []any{ctx, order, count} - for _, a := range keys { + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZMPop", varargs...) @@ -12007,17 +5988,17 @@ func (m *MockStatefulCmdable) ZMPop(ctx context.Context, order string, count int } // ZMPop indicates an expected call of ZMPop. -func (mr *MockStatefulCmdableMockRecorder) ZMPop(ctx, order, count any, keys ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZMPop(arg0, arg1, arg2 any, arg3 ...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...) + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMPop", reflect.TypeOf((*MockCmdable)(nil).ZMPop), varargs...) } // ZMScore mocks base method. -func (m *MockStatefulCmdable) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd { +func (m *MockCmdable) ZMScore(arg0 context.Context, arg1 string, arg2 ...string) *redis.FloatSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZMScore", varargs...) @@ -12026,17 +6007,17 @@ func (m *MockStatefulCmdable) ZMScore(ctx context.Context, key string, members . } // ZMScore indicates an expected call of ZMScore. -func (mr *MockStatefulCmdableMockRecorder) ZMScore(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZMScore(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockCmdable)(nil).ZMScore), varargs...) } // ZPopMax mocks base method. -func (m *MockStatefulCmdable) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { +func (m *MockCmdable) ZPopMax(arg0 context.Context, arg1 string, arg2 ...int64) *redis.ZSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range count { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZPopMax", varargs...) @@ -12045,17 +6026,17 @@ func (m *MockStatefulCmdable) ZPopMax(ctx context.Context, key string, count ... } // ZPopMax indicates an expected call of ZPopMax. -func (mr *MockStatefulCmdableMockRecorder) ZPopMax(ctx, key any, count ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZPopMax(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockCmdable)(nil).ZPopMax), varargs...) } // ZPopMin mocks base method. -func (m *MockStatefulCmdable) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { +func (m *MockCmdable) ZPopMin(arg0 context.Context, arg1 string, arg2 ...int64) *redis.ZSliceCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range count { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZPopMin", varargs...) @@ -12064,185 +6045,185 @@ func (m *MockStatefulCmdable) ZPopMin(ctx context.Context, key string, count ... } // ZPopMin indicates an expected call of ZPopMin. -func (mr *MockStatefulCmdableMockRecorder) ZPopMin(ctx, key any, count ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZPopMin(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockCmdable)(nil).ZPopMin), varargs...) } // ZRandMember mocks base method. -func (m *MockStatefulCmdable) ZRandMember(ctx context.Context, key string, count int) *redis.StringSliceCmd { +func (m *MockCmdable) ZRandMember(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRandMember", ctx, key, count) + ret := m.ctrl.Call(m, "ZRandMember", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ZRandMember indicates an expected call of ZRandMember. -func (mr *MockStatefulCmdableMockRecorder) ZRandMember(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRandMember(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRandMember), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockCmdable)(nil).ZRandMember), arg0, arg1, arg2) } // ZRandMemberWithScores mocks base method. -func (m *MockStatefulCmdable) ZRandMemberWithScores(ctx context.Context, key string, count int) *redis.ZSliceCmd { +func (m *MockCmdable) ZRandMemberWithScores(arg0 context.Context, arg1 string, arg2 int) *redis.ZSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRandMemberWithScores", ctx, key, count) + ret := m.ctrl.Call(m, "ZRandMemberWithScores", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.ZSliceCmd) return ret0 } // ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores. -func (mr *MockStatefulCmdableMockRecorder) ZRandMemberWithScores(ctx, key, count any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRandMemberWithScores(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRandMemberWithScores), ctx, key, count) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRandMemberWithScores), arg0, arg1, arg2) } // ZRange mocks base method. -func (m *MockStatefulCmdable) ZRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { +func (m *MockCmdable) ZRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRange", ctx, key, start, stop) + ret := m.ctrl.Call(m, "ZRange", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZRange(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockCmdable)(nil).ZRange), arg0, arg1, arg2, arg3) } // ZRangeArgs mocks base method. -func (m *MockStatefulCmdable) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd { +func (m *MockCmdable) ZRangeArgs(arg0 context.Context, arg1 redis.ZRangeArgs) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRangeArgs", ctx, z) + ret := m.ctrl.Call(m, "ZRangeArgs", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ZRangeArgs indicates an expected call of ZRangeArgs. -func (mr *MockStatefulCmdableMockRecorder) ZRangeArgs(ctx, z any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRangeArgs(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeArgs), ctx, z) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockCmdable)(nil).ZRangeArgs), arg0, arg1) } // ZRangeArgsWithScores mocks base method. -func (m *MockStatefulCmdable) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd { +func (m *MockCmdable) ZRangeArgsWithScores(arg0 context.Context, arg1 redis.ZRangeArgs) *redis.ZSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRangeArgsWithScores", ctx, z) + ret := m.ctrl.Call(m, "ZRangeArgsWithScores", arg0, arg1) ret0, _ := ret[0].(*redis.ZSliceCmd) return ret0 } // ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores. -func (mr *MockStatefulCmdableMockRecorder) ZRangeArgsWithScores(ctx, z any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRangeArgsWithScores(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeArgsWithScores), ctx, z) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeArgsWithScores), arg0, arg1) } // ZRangeByLex mocks base method. -func (m *MockStatefulCmdable) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { +func (m *MockCmdable) ZRangeByLex(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRangeByLex", ctx, key, opt) + ret := m.ctrl.Call(m, "ZRangeByLex", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ZRangeByLex indicates an expected call of ZRangeByLex. -func (mr *MockStatefulCmdableMockRecorder) ZRangeByLex(ctx, key, opt any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRangeByLex(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByLex), ctx, key, opt) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRangeByLex), arg0, arg1, arg2) } // ZRangeByScore mocks base method. -func (m *MockStatefulCmdable) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { +func (m *MockCmdable) ZRangeByScore(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRangeByScore", ctx, key, opt) + ret := m.ctrl.Call(m, "ZRangeByScore", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ZRangeByScore indicates an expected call of ZRangeByScore. -func (mr *MockStatefulCmdableMockRecorder) ZRangeByScore(ctx, key, opt any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRangeByScore(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByScore), ctx, key, opt) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRangeByScore), arg0, arg1, arg2) } // ZRangeByScoreWithScores mocks base method. -func (m *MockStatefulCmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { +func (m *MockCmdable) ZRangeByScoreWithScores(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.ZSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", ctx, key, opt) + ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.ZSliceCmd) return ret0 } // ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores. -func (mr *MockStatefulCmdableMockRecorder) ZRangeByScoreWithScores(ctx, key, opt any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRangeByScoreWithScores(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByScoreWithScores), ctx, key, opt) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeByScoreWithScores), arg0, arg1, arg2) } // ZRangeStore mocks base method. -func (m *MockStatefulCmdable) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd { +func (m *MockCmdable) ZRangeStore(arg0 context.Context, arg1 string, arg2 redis.ZRangeArgs) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRangeStore", ctx, dst, z) + ret := m.ctrl.Call(m, "ZRangeStore", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ZRangeStore indicates an expected call of ZRangeStore. -func (mr *MockStatefulCmdableMockRecorder) ZRangeStore(ctx, dst, z any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRangeStore(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeStore), ctx, dst, z) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockCmdable)(nil).ZRangeStore), arg0, arg1, arg2) } // ZRangeWithScores mocks base method. -func (m *MockStatefulCmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { +func (m *MockCmdable) ZRangeWithScores(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.ZSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRangeWithScores", ctx, key, start, stop) + ret := m.ctrl.Call(m, "ZRangeWithScores", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZRangeWithScores(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeWithScores), arg0, arg1, arg2, arg3) } // ZRank mocks base method. -func (m *MockStatefulCmdable) ZRank(ctx context.Context, key, member string) *redis.IntCmd { +func (m *MockCmdable) ZRank(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRank", ctx, key, member) + ret := m.ctrl.Call(m, "ZRank", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ZRank indicates an expected call of ZRank. -func (mr *MockStatefulCmdableMockRecorder) ZRank(ctx, key, member any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRank(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRank), ctx, key, member) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockCmdable)(nil).ZRank), arg0, arg1, arg2) } // ZRankWithScore mocks base method. -func (m *MockStatefulCmdable) ZRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { +func (m *MockCmdable) ZRankWithScore(arg0 context.Context, arg1, arg2 string) *redis.RankWithScoreCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRankWithScore", ctx, key, member) + ret := m.ctrl.Call(m, "ZRankWithScore", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.RankWithScoreCmd) return ret0 } // ZRankWithScore indicates an expected call of ZRankWithScore. -func (mr *MockStatefulCmdableMockRecorder) ZRankWithScore(ctx, key, member any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRankWithScore(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRankWithScore), ctx, key, member) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockCmdable)(nil).ZRankWithScore), arg0, arg1, arg2) } // ZRem mocks base method. -func (m *MockStatefulCmdable) ZRem(ctx context.Context, key string, members ...any) *redis.IntCmd { +func (m *MockCmdable) ZRem(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { m.ctrl.T.Helper() - varargs := []any{ctx, key} - for _, a := range members { + varargs := []any{arg0, arg1} + for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ZRem", varargs...) @@ -12251,218 +6232,218 @@ func (m *MockStatefulCmdable) ZRem(ctx context.Context, key string, members ...a } // ZRem indicates an expected call of ZRem. -func (mr *MockStatefulCmdableMockRecorder) ZRem(ctx, key any, members ...any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRem(arg0, arg1 any, arg2 ...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...) + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockCmdable)(nil).ZRem), varargs...) } // ZRemRangeByLex mocks base method. -func (m *MockStatefulCmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *redis.IntCmd { +func (m *MockCmdable) ZRemRangeByLex(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRemRangeByLex", ctx, key, min, max) + ret := m.ctrl.Call(m, "ZRemRangeByLex", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZRemRangeByLex(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByLex), arg0, arg1, arg2, arg3) } // ZRemRangeByRank mocks base method. -func (m *MockStatefulCmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *redis.IntCmd { +func (m *MockCmdable) ZRemRangeByRank(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRemRangeByRank", ctx, key, start, stop) + ret := m.ctrl.Call(m, "ZRemRangeByRank", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZRemRangeByRank(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByRank), arg0, arg1, arg2, arg3) } // ZRemRangeByScore mocks base method. -func (m *MockStatefulCmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *redis.IntCmd { +func (m *MockCmdable) ZRemRangeByScore(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRemRangeByScore", ctx, key, min, max) + ret := m.ctrl.Call(m, "ZRemRangeByScore", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZRemRangeByScore(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByScore), arg0, arg1, arg2, arg3) } // ZRevRange mocks base method. -func (m *MockStatefulCmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { +func (m *MockCmdable) ZRevRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRevRange", ctx, key, start, stop) + ret := m.ctrl.Call(m, "ZRevRange", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZRevRange(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockCmdable)(nil).ZRevRange), arg0, arg1, arg2, arg3) } // ZRevRangeByLex mocks base method. -func (m *MockStatefulCmdable) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { +func (m *MockCmdable) ZRevRangeByLex(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRevRangeByLex", ctx, key, opt) + ret := m.ctrl.Call(m, "ZRevRangeByLex", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ZRevRangeByLex indicates an expected call of ZRevRangeByLex. -func (mr *MockStatefulCmdableMockRecorder) ZRevRangeByLex(ctx, key, opt any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRevRangeByLex(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByLex), ctx, key, opt) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByLex), arg0, arg1, arg2) } // ZRevRangeByScore mocks base method. -func (m *MockStatefulCmdable) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { +func (m *MockCmdable) ZRevRangeByScore(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRevRangeByScore", ctx, key, opt) + ret := m.ctrl.Call(m, "ZRevRangeByScore", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ZRevRangeByScore indicates an expected call of ZRevRangeByScore. -func (mr *MockStatefulCmdableMockRecorder) ZRevRangeByScore(ctx, key, opt any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRevRangeByScore(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByScore), ctx, key, opt) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByScore), arg0, arg1, arg2) } // ZRevRangeByScoreWithScores mocks base method. -func (m *MockStatefulCmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { +func (m *MockCmdable) ZRevRangeByScoreWithScores(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.ZSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", ctx, key, opt) + ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.ZSliceCmd) return ret0 } // ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores. -func (mr *MockStatefulCmdableMockRecorder) ZRevRangeByScoreWithScores(ctx, key, opt any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRevRangeByScoreWithScores(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByScoreWithScores), ctx, key, opt) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByScoreWithScores), arg0, arg1, arg2) } // ZRevRangeWithScores mocks base method. -func (m *MockStatefulCmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { +func (m *MockCmdable) ZRevRangeWithScores(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.ZSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRevRangeWithScores", ctx, key, start, stop) + ret := m.ctrl.Call(m, "ZRevRangeWithScores", arg0, arg1, arg2, arg3) 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 { +func (mr *MockCmdableMockRecorder) ZRevRangeWithScores(arg0, arg1, arg2, arg3 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeWithScores), arg0, arg1, arg2, arg3) } // ZRevRank mocks base method. -func (m *MockStatefulCmdable) ZRevRank(ctx context.Context, key, member string) *redis.IntCmd { +func (m *MockCmdable) ZRevRank(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRevRank", ctx, key, member) + ret := m.ctrl.Call(m, "ZRevRank", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ZRevRank indicates an expected call of ZRevRank. -func (mr *MockStatefulCmdableMockRecorder) ZRevRank(ctx, key, member any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRevRank(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRank), ctx, key, member) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockCmdable)(nil).ZRevRank), arg0, arg1, arg2) } // ZRevRankWithScore mocks base method. -func (m *MockStatefulCmdable) ZRevRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { +func (m *MockCmdable) ZRevRankWithScore(arg0 context.Context, arg1, arg2 string) *redis.RankWithScoreCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZRevRankWithScore", ctx, key, member) + ret := m.ctrl.Call(m, "ZRevRankWithScore", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.RankWithScoreCmd) return ret0 } // ZRevRankWithScore indicates an expected call of ZRevRankWithScore. -func (mr *MockStatefulCmdableMockRecorder) ZRevRankWithScore(ctx, key, member any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZRevRankWithScore(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRankWithScore), ctx, key, member) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockCmdable)(nil).ZRevRankWithScore), arg0, arg1, arg2) } // ZScan mocks base method. -func (m *MockStatefulCmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { +func (m *MockCmdable) ZScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZScan", ctx, key, cursor, match, count) + ret := m.ctrl.Call(m, "ZScan", arg0, arg1, arg2, arg3, arg4) 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 { +func (mr *MockCmdableMockRecorder) ZScan(arg0, arg1, arg2, arg3, arg4 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) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockCmdable)(nil).ZScan), arg0, arg1, arg2, arg3, arg4) } // ZScore mocks base method. -func (m *MockStatefulCmdable) ZScore(ctx context.Context, key, member string) *redis.FloatCmd { +func (m *MockCmdable) ZScore(arg0 context.Context, arg1, arg2 string) *redis.FloatCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZScore", ctx, key, member) + ret := m.ctrl.Call(m, "ZScore", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.FloatCmd) return ret0 } // ZScore indicates an expected call of ZScore. -func (mr *MockStatefulCmdableMockRecorder) ZScore(ctx, key, member any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZScore(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZScore), ctx, key, member) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockCmdable)(nil).ZScore), arg0, arg1, arg2) } // ZUnion mocks base method. -func (m *MockStatefulCmdable) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd { +func (m *MockCmdable) ZUnion(arg0 context.Context, arg1 redis.ZStore) *redis.StringSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZUnion", ctx, store) + ret := m.ctrl.Call(m, "ZUnion", arg0, arg1) ret0, _ := ret[0].(*redis.StringSliceCmd) return ret0 } // ZUnion indicates an expected call of ZUnion. -func (mr *MockStatefulCmdableMockRecorder) ZUnion(ctx, store any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZUnion(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnion), ctx, store) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockCmdable)(nil).ZUnion), arg0, arg1) } // ZUnionStore mocks base method. -func (m *MockStatefulCmdable) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd { +func (m *MockCmdable) ZUnionStore(arg0 context.Context, arg1 string, arg2 *redis.ZStore) *redis.IntCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZUnionStore", ctx, dest, store) + ret := m.ctrl.Call(m, "ZUnionStore", arg0, arg1, arg2) ret0, _ := ret[0].(*redis.IntCmd) return ret0 } // ZUnionStore indicates an expected call of ZUnionStore. -func (mr *MockStatefulCmdableMockRecorder) ZUnionStore(ctx, dest, store any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZUnionStore(arg0, arg1, arg2 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnionStore), ctx, dest, store) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockCmdable)(nil).ZUnionStore), arg0, arg1, arg2) } // ZUnionWithScores mocks base method. -func (m *MockStatefulCmdable) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd { +func (m *MockCmdable) ZUnionWithScores(arg0 context.Context, arg1 redis.ZStore) *redis.ZSliceCmd { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ZUnionWithScores", ctx, store) + ret := m.ctrl.Call(m, "ZUnionWithScores", arg0, arg1) ret0, _ := ret[0].(*redis.ZSliceCmd) return ret0 } // ZUnionWithScores indicates an expected call of ZUnionWithScores. -func (mr *MockStatefulCmdableMockRecorder) ZUnionWithScores(ctx, store any) *gomock.Call { +func (mr *MockCmdableMockRecorder) ZUnionWithScores(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnionWithScores), ctx, store) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockCmdable)(nil).ZUnionWithScores), arg0, arg1) } diff --git a/middlewares/activelimit/redislimit/builder_test.go b/middlewares/activelimit/redislimit/builder_test.go index 0e07abb..a6ca14e 100644 --- a/middlewares/activelimit/redislimit/builder_test.go +++ b/middlewares/activelimit/redislimit/builder_test.go @@ -20,7 +20,6 @@ import ( "net/http" "net/http/httptest" "testing" - "time" "github.com/gin-gonic/gin" "github.com/redis/go-redis/v9" @@ -28,214 +27,113 @@ import ( "github.com/stretchr/testify/require" "go.uber.org/mock/gomock" - redismocks "github.com/ecodeclub/ginx/internal/mocks" + "github.com/ecodeclub/ginx/internal/mocks" ) func TestRedisActiveLimit_Build(t *testing.T) { - testCases := []struct { - name string - 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 - - // 响应的code + const ( + url = "/" + key = "limit" + ) + tests := []struct { + name string + mock func(ctrl *gomock.Controller) redis.Cmdable + reqBuilder func(t *testing.T) *http.Request + + // 预期响应 wantCode int }{ { - 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) {}, - 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) + name: "正常通过", + mock: func(ctrl *gomock.Controller) redis.Cmdable { + cmd := mocks.NewMockCmdable(ctrl) + res := redis.NewIntCmd(context.Background()) + res.SetVal(int64(1)) + cmd.EXPECT().Incr(gomock.Any(), key).Return(res) + res = redis.NewIntCmd(context.Background()) + cmd.EXPECT().Decr(gomock.Any(), key).Return(res) + return cmd + }, + reqBuilder: func(t *testing.T) *http.Request { + req, err := http.NewRequest(http.MethodGet, url, nil) require.NoError(t, err) return req }, - before: func(server *gin.Engine, key string) {}, - key: "test", - wantCode: http.StatusOK, + wantCode: http.StatusNoContent, }, { - 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) + name: "限流中", + mock: func(ctrl *gomock.Controller) redis.Cmdable { + ctx := context.Background() + cmd := mocks.NewMockCmdable(ctrl) + res := redis.NewIntCmd(ctx) 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() - - return redisClient + cmd.EXPECT().Incr(gomock.Any(), key).Return(res) + res = redis.NewIntCmd(ctx) + cmd.EXPECT().Decr(gomock.Any(), key).Return(res) + return cmd }, - - 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) + reqBuilder: func(t *testing.T) *http.Request { + req, err := http.NewRequest(http.MethodGet, url, 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, - key: "test", wantCode: http.StatusTooManyRequests, }, { - name: "开启限流,RedisLimit,有一个人长时间没退出,等待前面退出后,正常请求....", - mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { - // 第1个请求开始 - redisClient := redismocks.NewMockCmdable(ctrl) - res1 := redis.NewIntCmd(context.Background()) - res1.SetErr(nil) - res1.SetVal(int64(1)) - redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) - // 第1个请求结束 - res2 := redis.NewIntCmd(context.Background()) - res2.SetErr(nil) - res2.SetVal(int64(0)) - redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2) - - // 第2个请求开始 - redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) - // 第2个请求结束 - 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) + name: "defer 的减1操作失败", + mock: func(ctrl *gomock.Controller) redis.Cmdable { + ctx := context.Background() + cmd := mocks.NewMockCmdable(ctrl) + res := redis.NewIntCmd(ctx) + res.SetVal(int64(1)) + cmd.EXPECT().Incr(gomock.Any(), key).Return(res) + res = redis.NewIntCmd(ctx) + res.SetErr(errors.New("模拟 redis 操作失败")) + cmd.EXPECT().Decr(gomock.Any(), key).Return(res) + return cmd + }, + reqBuilder: func(t *testing.T) *http.Request { + req, err := http.NewRequest(http.MethodGet, url, 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, - key: "test", - wantCode: http.StatusOK, + wantCode: http.StatusNoContent, }, { - 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() + name: "刚进入中间件的加1操作失败", + mock: func(ctrl *gomock.Controller) redis.Cmdable { + cmd := mocks.NewMockCmdable(ctrl) + res := redis.NewIntCmd(context.Background()) + res.SetErr(errors.New("模拟 redis 操作失败")) + cmd.EXPECT().Incr(gomock.Any(), key).Return(res) + return cmd }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + reqBuilder: func(t *testing.T) *http.Request { + req, err := http.NewRequest(http.MethodGet, url, nil) require.NoError(t, err) return req }, - before: func(server *gin.Engine, key string) {}, - - interval: time.Millisecond * 20, - key: "test", wantCode: http.StatusInternalServerError, }, } - - for _, tc := range testCases { - t.Run(tc.name, func(t *testing.T) { - ctl := gomock.NewController(t) - defer ctl.Finish() + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + limit := NewRedisActiveLimit(tt.mock(ctrl), 1, key) 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) + server.Use(limit.Build()) + server.GET(url, func(c *gin.Context) { + c.Status(http.StatusNoContent) }) - 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) + + req := tt.reqBuilder(t) + recorder := httptest.NewRecorder() + + server.ServeHTTP(recorder, req) + + assert.Equal(t, tt.wantCode, recorder.Code) }) } } From 9ae5463100d74d1dc328a5625b23df1685d9b031 Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 14:21:01 +0800 Subject: [PATCH 07/12] fix: actions --- .licenserc.json | 2 +- .../mocks/{redis_mock.go => redis.mock.go} | 14 --- internal/ratelimit/mocks/ratelimit.mock.go | 14 --- .../activelimit/locallimit/builder_test.go | 113 +++++------------- script/integrate_test.sh | 14 +++ script/integration_test_compose.yml | 14 +++ 6 files changed, 60 insertions(+), 111 deletions(-) rename internal/mocks/{redis_mock.go => redis.mock.go} (99%) diff --git a/.licenserc.json b/.licenserc.json index 4709c9b..32d9c55 100644 --- a/.licenserc.json +++ b/.licenserc.json @@ -3,6 +3,6 @@ "**/*.{yml,toml}": "# Copyright 2023 ecodeclub", "**/*.sh": "# Copyright 2023 ecodeclub", "ignore": [ - "*.mock.go" + "**/*.mock.go" ] } \ No newline at end of file diff --git a/internal/mocks/redis_mock.go b/internal/mocks/redis.mock.go similarity index 99% rename from internal/mocks/redis_mock.go rename to internal/mocks/redis.mock.go index dc5180a..6013341 100644 --- a/internal/mocks/redis_mock.go +++ b/internal/mocks/redis.mock.go @@ -1,17 +1,3 @@ -// Copyright 2023 ecodeclub -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// 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. - // Code generated by MockGen. DO NOT EDIT. // Source: github.com/redis/go-redis/v9 (interfaces: Cmdable) // diff --git a/internal/ratelimit/mocks/ratelimit.mock.go b/internal/ratelimit/mocks/ratelimit.mock.go index 063b1f2..01883ae 100644 --- a/internal/ratelimit/mocks/ratelimit.mock.go +++ b/internal/ratelimit/mocks/ratelimit.mock.go @@ -1,17 +1,3 @@ -// Copyright 2023 ecodeclub -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// 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. - // Code generated by MockGen. DO NOT EDIT. // Source: types.go diff --git a/middlewares/activelimit/locallimit/builder_test.go b/middlewares/activelimit/locallimit/builder_test.go index ddaf5cb..9831154 100644 --- a/middlewares/activelimit/locallimit/builder_test.go +++ b/middlewares/activelimit/locallimit/builder_test.go @@ -18,7 +18,6 @@ import ( "net/http" "net/http/httptest" "testing" - "time" "github.com/gin-gonic/gin" "github.com/stretchr/testify/assert" @@ -26,104 +25,54 @@ import ( ) 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) - - // 响应的code + const ( + url = "/" + ) + tests := []struct { + name string + countActive int64 + reqBuilder func(t *testing.T) *http.Request + + // 预期响应 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) + name: "正常通过", + countActive: 0, + reqBuilder: func(t *testing.T) *http.Request { + req, err := http.NewRequest(http.MethodGet, url, nil) require.NoError(t, err) return req }, - before: func(server *gin.Engine) {}, - - maxCount: 1, - wantCode: 200, + wantCode: http.StatusNoContent, }, { - name: "开启限流,LocalLimit 有一个人很久没出来,新请求被限流", - - createMiddleware: func(maxActive int64) gin.HandlerFunc { - return NewLocalActiveLimit(maxActive).Build() - }, - getReq: func() *http.Request { - req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + name: "限流中", + countActive: 1, + reqBuilder: func(t *testing.T) *http.Request { + req, err := http.NewRequest(http.MethodGet, url, 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) - }, - - 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) - }, - - interval: time.Millisecond * 600, - maxCount: 1, - wantCode: http.StatusOK, - }, } - - for _, tc := range testCases { - t.Run(tc.name, func(t *testing.T) { - + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + limit := NewLocalActiveLimit(1) + limit.countActive.Store(tt.countActive) 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) + server.Use(limit.Build()) + server.GET(url, func(c *gin.Context) { + c.Status(http.StatusNoContent) }) - 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) + req := tt.reqBuilder(t) + recorder := httptest.NewRecorder() + + server.ServeHTTP(recorder, req) + + assert.Equal(t, tt.wantCode, recorder.Code) }) } - } diff --git a/script/integrate_test.sh b/script/integrate_test.sh index c14633b..975029d 100644 --- a/script/integrate_test.sh +++ b/script/integrate_test.sh @@ -1,3 +1,17 @@ +# Copyright 2023 ecodeclub +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# 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. + #!/usr/bin/env bash set -e diff --git a/script/integration_test_compose.yml b/script/integration_test_compose.yml index b9112c8..48f6658 100644 --- a/script/integration_test_compose.yml +++ b/script/integration_test_compose.yml @@ -1,3 +1,17 @@ +# Copyright 2023 ecodeclub +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# 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. + version: '3.0' services: redis: From abf3af2401a7ed9948a57cef8855e36e594c6b74 Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 14:38:09 +0800 Subject: [PATCH 08/12] fix: actions --- internal/ratelimit/redis_slide_window_test.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/internal/ratelimit/redis_slide_window_test.go b/internal/ratelimit/redis_slide_window_test.go index c7afd1b..6d303a8 100644 --- a/internal/ratelimit/redis_slide_window_test.go +++ b/internal/ratelimit/redis_slide_window_test.go @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +//go:build e2e + package ratelimit import ( From e91ab9df09748c007bcb4dee2aa90c2d3f8efb50 Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 14:51:59 +0800 Subject: [PATCH 09/12] fix: actions --- .github/workflows/go.yml | 2 +- .github/workflows/golangci-lint.yml | 2 +- .github/workflows/integration_test.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index ed96142..a35975e 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: 1.21.0 + go-version: "1.21.0" - name: Build run: go build -v ./... diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml index 2a7ab19..9961ddc 100644 --- a/.github/workflows/golangci-lint.yml +++ b/.github/workflows/golangci-lint.yml @@ -33,7 +33,7 @@ jobs: steps: - uses: actions/setup-go@v3 with: - go-version: 1.21.0 + go-version: "1.21.0" - uses: actions/checkout@v4 - name: golangci-lint uses: golangci/golangci-lint-action@v3 diff --git a/.github/workflows/integration_test.yml b/.github/workflows/integration_test.yml index e13cbcc..cc8377f 100644 --- a/.github/workflows/integration_test.yml +++ b/.github/workflows/integration_test.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: 1.21.0 + go-version: "1.21.0" - name: Test run: sudo sh ./script/integrate_test.sh \ No newline at end of file From 48835b14d4691e182aabf40da18e26b39246bf73 Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 14:59:26 +0800 Subject: [PATCH 10/12] fix: actions --- .github/workflows/go-fmt.yml | 2 +- .github/workflows/go.yml | 2 +- .github/workflows/golangci-lint.yml | 2 +- .github/workflows/integration_test.yml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/go-fmt.yml b/.github/workflows/go-fmt.yml index 0f1506a..2352038 100644 --- a/.github/workflows/go-fmt.yml +++ b/.github/workflows/go-fmt.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: ">=1.21.0" + go-version: '>=1.21.0' - name: Install goimports run: go install golang.org/x/tools/cmd/goimports@latest diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index a35975e..22b4d61 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: "1.21.0" + go-version: '1.21.0' - name: Build run: go build -v ./... diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml index 9961ddc..d4fd7c4 100644 --- a/.github/workflows/golangci-lint.yml +++ b/.github/workflows/golangci-lint.yml @@ -33,7 +33,7 @@ jobs: steps: - uses: actions/setup-go@v3 with: - go-version: "1.21.0" + go-version: '1.21.0' - uses: actions/checkout@v4 - name: golangci-lint uses: golangci/golangci-lint-action@v3 diff --git a/.github/workflows/integration_test.yml b/.github/workflows/integration_test.yml index cc8377f..15d10a3 100644 --- a/.github/workflows/integration_test.yml +++ b/.github/workflows/integration_test.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: "1.21.0" + go-version: '1.21.0' - name: Test run: sudo sh ./script/integrate_test.sh \ No newline at end of file From a3de89ab835e9d4702e4505e7dbebc620ee36862 Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 15:04:10 +0800 Subject: [PATCH 11/12] fix: actions --- .github/workflows/go-fmt.yml | 2 +- .github/workflows/go.yml | 2 +- .github/workflows/golangci-lint.yml | 2 +- .github/workflows/integration_test.yml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/go-fmt.yml b/.github/workflows/go-fmt.yml index 2352038..edad54b 100644 --- a/.github/workflows/go-fmt.yml +++ b/.github/workflows/go-fmt.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: '>=1.21.0' + go-version: '>=1.21.1' - name: Install goimports run: go install golang.org/x/tools/cmd/goimports@latest diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 22b4d61..e8443a8 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: '1.21.0' + go-version: '1.21.1' - name: Build run: go build -v ./... diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml index d4fd7c4..e60b7d4 100644 --- a/.github/workflows/golangci-lint.yml +++ b/.github/workflows/golangci-lint.yml @@ -33,7 +33,7 @@ jobs: steps: - uses: actions/setup-go@v3 with: - go-version: '1.21.0' + go-version: '1.21.1' - uses: actions/checkout@v4 - name: golangci-lint uses: golangci/golangci-lint-action@v3 diff --git a/.github/workflows/integration_test.yml b/.github/workflows/integration_test.yml index 15d10a3..47e5b39 100644 --- a/.github/workflows/integration_test.yml +++ b/.github/workflows/integration_test.yml @@ -28,7 +28,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: '1.21.0' + go-version: '1.21.1' - name: Test run: sudo sh ./script/integrate_test.sh \ No newline at end of file From 52e34d0517ba1897bb59ef11d93105314b7235be Mon Sep 17 00:00:00 2001 From: joil Date: Fri, 13 Oct 2023 15:16:09 +0800 Subject: [PATCH 12/12] fix: actions --- .github/workflows/integration_test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/integration_test.yml b/.github/workflows/integration_test.yml index 47e5b39..0f6d589 100644 --- a/.github/workflows/integration_test.yml +++ b/.github/workflows/integration_test.yml @@ -26,7 +26,7 @@ jobs: steps: - uses: actions/checkout@v4 - name: Set up Go - uses: actions/setup-go@v3 + uses: actions/setup-go@v2 with: go-version: '1.21.1'