From 110b0b547444f4b1ea8ccfee7218771ede701c12 Mon Sep 17 00:00:00 2001 From: Jonas Falck Date: Thu, 28 Nov 2024 16:27:28 +0100 Subject: [PATCH] Add group locking feature --- .mockery.yaml | 7 + cmd/gmc/main.go | 10 +- e2e/e2e_test.go | 136 +- e2e/utils_test.go | 4 + go.mod | 10 +- go.sum | 209 +- mocks/mock_Cmdable.go | 26770 ++++++++++++++++ pkg/agent/agent.go | 4 +- pkg/agent/reconciliation/commands.go | 11 +- pkg/agent/reconciliation/files.go | 3 +- pkg/agent/reconciliation/line.go | 3 +- pkg/agent/reconciliation/packages.go | 3 +- pkg/agent/reconciliation/reconciliation.go | 61 +- .../reconciliation/reconciliation_test.go | 34 +- pkg/api/v1/protocol/websocket.go | 35 + pkg/api/v1/types/types.go | 30 +- pkg/master/master.go | 139 +- pkg/secrets/secret.go | 9 + pkg/websocket/websocketclient.go | 72 +- 19 files changed, 27251 insertions(+), 299 deletions(-) create mode 100644 mocks/mock_Cmdable.go diff --git a/.mockery.yaml b/.mockery.yaml index 8636c5b..e7789ae 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -1,4 +1,11 @@ packages: + github.com/redis/go-redis/v9: + interfaces: + # select the interfaces you want mocked + Cmdable: + config: + outpkg: mocks + dir: ../../mocks github.com/fortnoxab/gitmachinecontroller/pkg/agent/command: interfaces: # select the interfaces you want mocked diff --git a/cmd/gmc/main.go b/cmd/gmc/main.go index bfc0ba9..650db3d 100644 --- a/cmd/gmc/main.go +++ b/cmd/gmc/main.go @@ -155,6 +155,10 @@ func app() *cli.App { Value: "8080", Usage: "webserver port to listen to", }, + &cli.StringFlag{ + Name: "redis-url", + Usage: "redis url, ex redis://[[username]:[password]]@localhost:6379/0 or rediss://[[username]:[password]]@localhost:6379/0 for tls/ssl connections", + }, }, }, { @@ -281,7 +285,7 @@ func app() *cli.App { { Name: "zsh", Usage: "put in .zshrc: 'source <(" + os.Args[0] + " completion zsh)'", - Action: bashCompletion, + Action: zshCompletion, }, }, }, @@ -330,7 +334,7 @@ _cli_bash_autocomplete() { complete -o bashdefault -o default -o nospace -F _cli_bash_autocomplete %s `, binaryName) - fmt.Printf(script) + fmt.Print(script) // fmt.Println(os.Args) return nil } @@ -358,7 +362,7 @@ _cli_zsh_autocomplete() { compdef _cli_zsh_autocomplete %s `, binaryName) - fmt.Printf(script) + fmt.Print(script) // fmt.Println(os.Args) return nil } diff --git a/e2e/e2e_test.go b/e2e/e2e_test.go index 2a59194..621e4df 100644 --- a/e2e/e2e_test.go +++ b/e2e/e2e_test.go @@ -14,8 +14,10 @@ import ( "github.com/fortnoxab/gitmachinecontroller/pkg/admin" "github.com/fortnoxab/gitmachinecontroller/pkg/api/v1/types" "github.com/fortnoxab/gitmachinecontroller/pkg/secrets" + "github.com/redis/go-redis/v9" "github.com/sirupsen/logrus" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" ) func TestMasterAgentAccept(t *testing.T) { @@ -70,25 +72,27 @@ metadata: type: server name: mycooltestagent spec: - commands: [] - files: - - checksum: 9b76e7ea790545334ea524f3ca33db8eb6c4541a9b476911e5abf850a566b41c - path: /tmp/testfromurl - url: %s - - content: | - filecontentishere - path: /tmp/test.systemd - systemd: - action: restart - name: exporter_exporter - daemonreload: true - ip: 10.81.22.150 - lines: [] - packages: - - name: vim-enhanced - version: '*' - - name: mycoolpackage - version: '*'`, ts.URL) + tasks: + - commands: [] + files: + - checksum: 9b76e7ea790545334ea524f3ca33db8eb6c4541a9b476911e5abf850a566b41c + path: /tmp/testfromurl + url: %s + - content: | + filecontentishere + path: /tmp/test.systemd + systemd: + action: restart + name: exporter_exporter + daemonreload: true + ip: 10.81.22.150 + lines: [] + packages: + - name: vim-enhanced + version: '*' + - name: mycoolpackage + version: '*' +`, ts.URL) err := os.WriteFile("./gitrepo/mycooltestagent.yml", []byte(machineYaml), 0666) assert.NoError(t, err) @@ -126,6 +130,70 @@ spec: c.wg.Wait() } +func TestMasterAgentGitOpsWithLock(t *testing.T) { + t.Cleanup(func() { + os.Remove("./gitrepo/mycooltestagent.yml") + os.Remove("/tmp/test.systemd") + os.Remove("/tmp/testfromurl") + }) + machineYaml := `apiVersion: gitmachinecontroller.io/v1beta1 +metadata: + annotations: + feature: ihavecoolfeature + labels: + os: rocky9 + type: server + name: mycooltestagent +spec: + tasks: + - name: install cool service + lock: + key: cool-service + ttl: 10m + commands: + - command: touch /tmp/test + files: + - content: | + filecontentishere + path: /tmp/test.systemd + systemd: + action: restart + name: exporter_exporter + daemonreload: true +` + + err := os.WriteFile("./gitrepo/mycooltestagent.yml", []byte(machineYaml), 0666) + assert.NoError(t, err) + + ctx, cancel := context.WithTimeout(context.Background(), time.Second*10) + defer cancel() + c := initMasterAgent(t, ctx) + + c.commander.Mock.On("Run", "systemctl restart exporter_exporter").Return("", "", nil).Once() + c.commander.Mock.On("Run", "systemctl daemon reload").Return("", "", nil).Once() + c.commander.Mock.On("Run", "touch /tmp/test").Return("", "", nil).Twice() + + c.redis.On("SetNX", mock.Anything, "gmc.lockcool-service", "mycooltestagent", time.Minute*10). + Return(redis.NewBoolResult(true, nil)). + Twice() + + c.redis.On("Del", mock.Anything, "gmc.lockcool-service"). + Return(redis.NewIntResult(1, nil)). + Twice() + + _, err = c.client.Post("/api/machines/accept-v1", bytes.NewBufferString(`{"host":"mycooltestagent"}`)) + assert.NoError(t, err) + + time.Sleep(2 * time.Second) + + content, err := os.ReadFile("/tmp/test.systemd") + assert.NoError(t, err) + assert.EqualValues(t, "filecontentishere\n", content) + + cancel() + c.wg.Wait() +} + func TestCliCommand(t *testing.T) { os.Setenv("NO_COLOR", "true") t.Cleanup(func() { @@ -141,8 +209,7 @@ metadata: type: server name: mycooltestagent spec: - ip: 127.0.0.1 - lines: []` + ip: 127.0.0.1` err := os.WriteFile("./gitrepo/mycooltestagent.yml", []byte(machineYaml), 0666) assert.NoError(t, err) @@ -191,8 +258,7 @@ metadata: type: server name: mycooltestagent spec: - ip: 127.0.0.1 - lines: []` + ip: 127.0.0.1` err := os.WriteFile("./gitrepo/mycooltestagent.yml", []byte(machineYaml), 0666) assert.NoError(t, err) @@ -235,8 +301,7 @@ metadata: type: server name: mycooltestagent spec: - ip: 127.0.0.1 - lines: []` + ip: 127.0.0.1` err := os.WriteFile("./gitrepo/mycooltestagent.yml", []byte(machineYaml), 0666) assert.NoError(t, err) @@ -277,12 +342,12 @@ metadata: type: server name: mycooltestagent spec: - files: - - content: | - itsfromgit - path: newfile.txt - ip: 127.0.0.1 - lines: []` + tasks: + - files: + - content: | + itsfromgit + path: newfile.txt + ip: 127.0.0.1` err := os.WriteFile("./gitrepo/mycooltestagent.yml", []byte(machineYaml), 0666) assert.NoError(t, err) @@ -319,10 +384,11 @@ metadata: name: mycooltestagent spec: ip: 127.0.0.1 - files: - - content: | - filecontentishere - path: newfile.txt + tasks: + - files: + - content: | + filecontentishere + path: newfile.txt lines: []` err = os.WriteFile("./newspec.yml", []byte(applyMachineYaml), 0666) diff --git a/e2e/utils_test.go b/e2e/utils_test.go index 2ffb5f4..4d0f8a3 100644 --- a/e2e/utils_test.go +++ b/e2e/utils_test.go @@ -25,6 +25,7 @@ type testWrapper struct { agent *agent.Agent commander *mocks.MockCommander wg *sync.WaitGroup + redis *mocks.MockCmdable } func initMasterAgent(t *testing.T, ctx context.Context) testWrapper { @@ -33,12 +34,14 @@ func initMasterAgent(t *testing.T, ctx context.Context) testWrapper { port, err := freePort() assert.NoError(t, err) portStr := strconv.Itoa(port) + redisMock := mocks.NewMockCmdable(t) master := &master.Master{ GitURL: "https://test/gitrepo", GitPollInterval: time.Second, WsPort: portStr, JWTKey: "asdfasdf", SecretKey: "asdfasdf", + RedisClient: redisMock, Masters: config.Masters{ { URL: "http://localhost:" + portStr, @@ -79,6 +82,7 @@ func initMasterAgent(t *testing.T, ctx context.Context) testWrapper { agent: agent, commander: mockedCommander, wg: wg, + redis: redisMock, } } func freePort() (port int, err error) { diff --git a/go.mod b/go.mod index aab550f..a161fb9 100644 --- a/go.mod +++ b/go.mod @@ -15,6 +15,7 @@ require ( github.com/gorilla/websocket v1.5.3 github.com/jonaz/ginlogrus v0.0.0-20191118094232-2f4da50f5dd6 github.com/olahol/melody v1.2.1 + github.com/redis/go-redis/v9 v9.7.0 github.com/sirupsen/logrus v1.9.3 github.com/stretchr/testify v1.10.0 github.com/urfave/cli/v2 v2.27.5 @@ -31,7 +32,6 @@ require ( github.com/Masterminds/semver/v3 v3.3.1 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect github.com/ProtonMail/go-crypto v1.1.3 // indirect - github.com/acomagu/bufpipe v1.0.4 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/bytedance/sonic v1.12.5 // indirect github.com/bytedance/sonic/loader v0.2.1 // indirect @@ -42,8 +42,8 @@ require ( github.com/cpuguy83/go-md2man/v2 v2.0.5 // indirect github.com/cyphar/filepath-securejoin v0.3.4 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect github.com/emirpasic/gods v1.18.1 // indirect - github.com/fluxcd/go-git/v5 v5.0.0-20221219190809-2e5c9d01cfc4 // indirect github.com/fluxcd/pkg/auth v0.0.1 // indirect github.com/fluxcd/pkg/ssh v0.14.1 // indirect github.com/fluxcd/pkg/version v0.4.1 // indirect @@ -59,8 +59,6 @@ require ( github.com/goccy/go-json v0.10.3 // indirect github.com/golang-jwt/jwt/v5 v5.2.1 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect - github.com/golang/protobuf v1.5.4 // indirect - github.com/imdario/mergo v0.3.16 // indirect github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect github.com/json-iterator/go v1.1.12 // indirect github.com/kevinburke/ssh_config v1.2.0 // indirect @@ -70,7 +68,6 @@ require ( github.com/leodido/go-urn v1.4.0 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.20 // indirect - github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect @@ -92,14 +89,11 @@ require ( github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect golang.org/x/arch v0.12.0 // indirect golang.org/x/crypto v0.29.0 // indirect - golang.org/x/mod v0.22.0 // indirect golang.org/x/net v0.31.0 // indirect golang.org/x/sys v0.27.0 // indirect golang.org/x/text v0.20.0 // indirect - golang.org/x/tools v0.27.0 // indirect google.golang.org/protobuf v1.35.2 // indirect gopkg.in/warnings.v0 v0.1.2 // indirect - gopkg.in/yaml.v2 v2.4.0 // indirect k8s.io/klog/v2 v2.130.1 // indirect k8s.io/utils v0.0.0-20241104163129-6fe5fd82f078 // indirect ) diff --git a/go.sum b/go.sum index 4043abe..2af9da5 100644 --- a/go.sum +++ b/go.sum @@ -37,29 +37,23 @@ github.com/Azure/azure-sdk-for-go/sdk/azcore v1.16.0 h1:JZg6HRh6W6U4OLl6lk7BZ7BL github.com/Azure/azure-sdk-for-go/sdk/azcore v1.16.0/go.mod h1:YL1xnZ6QejvQHWJrX/AvhFl4WW4rqHVoKspWNVwFk0M= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.0 h1:B/dfvscEQtew9dVuoxqxrUKKv8Ih2f55PydknDamU+g= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.0/go.mod h1:fiPSssYvltE08HJchL04dOy+RD4hgrjph0cwGGMntdI= +github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.0 h1:+m0M/LFxN43KvULkDNfdXOgrjtg6UYJPFBJyuEcRCAw= +github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.0/go.mod h1:PwOyop78lveYMRs6oCxjiVyBdyCgIYH6XHIVZO9/SFQ= github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY= github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY= +github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1 h1:WJTmL004Abzc5wDB5VtZG2PJk5ndYDgVacGqfirKxjM= +github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1/go.mod h1:tCcJZ0uHAmvjsVYzEFivsRTN00oz5BEsRgQHu5JZ9WE= github.com/AzureAD/microsoft-authentication-library-for-go v1.3.2 h1:kYRSnvJju5gYVyhkij+RTJ/VR6QIUaCfWeaFm2ycsjQ= github.com/AzureAD/microsoft-authentication-library-for-go v1.3.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= -github.com/Masterminds/semver/v3 v3.2.0 h1:3MEsd0SM6jqZojhjLWWeBY+Kcjy9i6MQAeY7YgDP83g= -github.com/Masterminds/semver/v3 v3.2.0/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ= github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4= github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= -github.com/Microsoft/go-winio v0.6.0 h1:slsWYD/zyx7lCXoZVlvQrj0hPTM1HI4+v1sIda2yDvg= -github.com/Microsoft/go-winio v0.6.0/go.mod h1:cTAf44im0RAYeL23bpB+fzCyDH2MJiz2BO69KH/soAE= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/ProtonMail/go-crypto v0.0.0-20221026131551-cf6655e29de4 h1:ra2OtmuW0AE5csawV4YXMNGNQQXvLRps3z2Z59OPO+I= -github.com/ProtonMail/go-crypto v0.0.0-20221026131551-cf6655e29de4/go.mod h1:UBYPn8k0D56RtnR8RFQMjmh4KrZzWJ5o7Z9SYjossQ8= github.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk= github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE= -github.com/acomagu/bufpipe v1.0.3 h1:fxAGrHZTgQ9w5QqVItgzwj235/uYZYgbXitB+dLupOk= -github.com/acomagu/bufpipe v1.0.3/go.mod h1:mxdxdup/WdsKVreO5GpW4+M/1CE2sMG4jeGJ2sYmHc4= -github.com/acomagu/bufpipe v1.0.4 h1:e3H4WUzM3npvo5uv95QuJM3cQspFNtFBzvJ2oNjKIDQ= -github.com/acomagu/bufpipe v1.0.4/go.mod h1:mxdxdup/WdsKVreO5GpW4+M/1CE2sMG4jeGJ2sYmHc4= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= @@ -73,7 +67,10 @@ github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= +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.12.5 h1:hoZxY8uW+mT+OpkcUWw4k0fDINtOcVavEsGfzwzFU/w= github.com/bytedance/sonic v1.12.5/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk= github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU= @@ -82,17 +79,12 @@ github.com/bytedance/sonic/loader v0.2.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= -github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cloudflare/circl v1.1.0/go.mod h1:prBCrKB9DV4poKZY1l9zBXg2QJY7mvgRvtMxxK7fi4I= -github.com/cloudflare/circl v1.3.0 h1:Anq00jxDtoyX3+aCaYUZ0vXC5r4k4epberfWGDXV1zE= -github.com/cloudflare/circl v1.3.0/go.mod h1:+CauBF6R70Jqcyl8N2hC8pAXYbWkGIezuSbuGLtRhnw= github.com/cloudflare/circl v1.5.0 h1:hxIWksrX6XN5a1L2TI/h53AGPhNHoUBo+TD1ms9+pys= github.com/cloudflare/circl v1.5.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs= github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y= @@ -100,63 +92,45 @@ github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJ github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg= github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= -github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/cpuguy83/go-md2man/v2 v2.0.5 h1:ZtcqGrnekaHpVLArFSe4HK5DoKx1T0rq2DwVB0alcyc= github.com/cpuguy83/go-md2man/v2 v2.0.5/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/cyphar/filepath-securejoin v0.2.3 h1:YX6ebbZCZP7VkM3scTTokDgBL2TY741X51MTk3ycuNI= -github.com/cyphar/filepath-securejoin v0.2.3/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4= github.com/cyphar/filepath-securejoin v0.3.4 h1:VBWugsJh2ZxJmLFSM06/0qzQyiQX2Qs0ViKrUAcqdZ8= github.com/cyphar/filepath-securejoin v0.3.4/go.mod h1:8s/MCNJREmFK0H02MF6Ihv1nakJe4L/w3WZLHNkvlYM= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/elazarl/goproxy v0.0.0-20240909085733-6741dbfc16a1 h1:g7YUigN4dW2+zpdusdTTghZ+5Py3BaUMAStvL8Nk+FY= +github.com/elazarl/goproxy v0.0.0-20240909085733-6741dbfc16a1/go.mod h1:thX175TtLTzLj3p7N/Q9IiKZ7NF+p72cvL91emV0hzo= github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w= -github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/fluxcd/gitkit v0.6.0 h1:iNg5LTx6ePo+Pl0ZwqHTAkhbUHxGVSY3YCxCdw7VIFg= github.com/fluxcd/gitkit v0.6.0/go.mod h1:svOHuKi0fO9HoawdK4HfHAJJseZDHHjk7I3ihnCIqNo= -github.com/fluxcd/go-git/v5 v5.0.0-20221206140629-ec778c2c37df h1:2BHXJp1PwX7D47Q2oaKDekn+BZVZCmxeCWNi+FyownE= -github.com/fluxcd/go-git/v5 v5.0.0-20221206140629-ec778c2c37df/go.mod h1:raWgfUV7lDQVXp4QXUaeNNJkRVKz97UQuF+0kdY7Vmo= -github.com/fluxcd/go-git/v5 v5.0.0-20221219190809-2e5c9d01cfc4 h1:Gm5sGGk+/Wq6RhX4xpCZ2IqjDp5XkjlhENaAuAlpdKc= -github.com/fluxcd/go-git/v5 v5.0.0-20221219190809-2e5c9d01cfc4/go.mod h1:raWgfUV7lDQVXp4QXUaeNNJkRVKz97UQuF+0kdY7Vmo= github.com/fluxcd/pkg/auth v0.0.1 h1:3fMg1EdkQdY2Rv1qHbiPPWCBa27xsNeu09y9SuZk6Co= github.com/fluxcd/pkg/auth v0.0.1/go.mod h1:tdCkiB3/LBg7CcxX1fhVmM5ZjDIaOduK0XX88pBXie0= -github.com/fluxcd/pkg/git v0.7.0 h1:sQHRpFMcOzEdqlyGMjFv2LKMdcoE5xeUr2UcRrsLRG8= -github.com/fluxcd/pkg/git v0.7.0/go.mod h1:3deiLPws4DSQ3hqwtQd7Dt66GXTN/4RcT/yHAljXaHo= github.com/fluxcd/pkg/git v0.21.0 h1:5FfcKj9bDVz8KwoOQUOSJABLMeSdhvLBf7yctwwuMzc= github.com/fluxcd/pkg/git v0.21.0/go.mod h1:iCCmUCunoFLgntySJfIDxsHGYfS97ky990gEKIDZ9lo= -github.com/fluxcd/pkg/git/gogit v0.3.1 h1:00GjuVuNYcLwJXolwOqnL/tAcDXcNqZATS8cnrO22Pw= -github.com/fluxcd/pkg/git/gogit v0.3.1/go.mod h1:5b3+lylk3oPkKazfnK5K7DWC2d6MMhYj8wWG1Qx6v3U= github.com/fluxcd/pkg/git/gogit v0.21.0 h1:iR2kzW1XrcBDYuC8zVIAdC/2/aeXuRkZ9jupdd54E6I= github.com/fluxcd/pkg/git/gogit v0.21.0/go.mod h1:gyoSlEIqzsOiTwSL0iFuEiJat+W0uGgc+WEiCVC1xk8= -github.com/fluxcd/pkg/gittestserver v0.8.0 h1:YrYe63KScKlLxx0GAiQthx2XqHDx0vKitIIx4JnDtIo= -github.com/fluxcd/pkg/gittestserver v0.8.0/go.mod h1:/LI/xKMrnQbIsTDnTyABQ71iaYhFIZ8fb4cvY7WAlBU= github.com/fluxcd/pkg/gittestserver v0.13.1 h1:5rXF8ANlk6wtAsvqH7tI7gaO2zhMySftf7ALh0AhfU4= -github.com/fluxcd/pkg/ssh v0.7.0 h1:FX5ky8SU9dYwbM6zEIDR3TSveLF01iyS95CtB5Ykpno= -github.com/fluxcd/pkg/ssh v0.7.0/go.mod h1:tCVZJI8jPOL0XCInJOrYGKapWA/zZCzqPtpiYUSQxww= +github.com/fluxcd/pkg/gittestserver v0.13.1/go.mod h1:nPO7ibtBRgLWFHTSvxI63zZubJXU82cVMH6nViVnHsY= github.com/fluxcd/pkg/ssh v0.14.1 h1:C/RBDch6cxAqQtaOohcasSAeGfZznNEeZtvpfI+hXQY= github.com/fluxcd/pkg/ssh v0.14.1/go.mod h1:HsVzHyF7CkfTnjtLEI6XK+8tfyWqwI1TPxJ34HcMg2o= -github.com/fluxcd/pkg/version v0.2.0 h1:jG22c59Bsv6vL51N7Bqn8tjHArYOXrjbIkGArlIrv5w= -github.com/fluxcd/pkg/version v0.2.0/go.mod h1:umN1VAOV0sB1JDVwb8eXZzuuqIAEku+y+vcCVBBUIf0= github.com/fluxcd/pkg/version v0.4.1 h1:xnw+cu+GRcQSBTejcGiigYpipszO4Cn5UUGpAHVN4F0= github.com/fluxcd/pkg/version v0.4.1/go.mod h1:hO3ul44vTFFrosekcnrpxoPaM4cLbET4Fc/LR6pz4YQ= github.com/fortnoxab/ginprometheus v0.0.0-20211026110220-d3da4ce1dc2b h1:zwWE+1hqhdbJTgVMyr4GzS9Yi7Lb4NNLMxZZNNSjRbc= github.com/fortnoxab/ginprometheus v0.0.0-20211026110220-d3da4ce1dc2b/go.mod h1:1ugW7UVpH27ZTA/bA4iSS+6qeo0DW1SshPyWtzmeKpg= github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW8ZzUMYCA= github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU= -github.com/gin-contrib/pprof v1.4.0 h1:XxiBSf5jWZ5i16lNOPbMTVdgHBdhfGRD5PZ1LWazzvg= -github.com/gin-contrib/pprof v1.4.0/go.mod h1:RrehPJasUVBPK6yTUwOl8/NP6i0vbUgmxtis+Z5KE90= github.com/gin-contrib/pprof v1.5.1 h1:Mzy+3HHtHbtwr4VewBTXZp/hR7pS6ZuZkueBIrQiLL4= github.com/gin-contrib/pprof v1.5.1/go.mod h1:uwzoF6FxdzJJGyMdcZB+VSuVjOBe1kSH+KMIvKGwvCQ= github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s= @@ -164,24 +138,16 @@ github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM= github.com/gin-gonic/gin v1.7.4/go.mod h1:jD2toBW3GZUr5UMcdrwQA10I7RuaFOl/SGeDjXkfUtY= -github.com/gin-gonic/gin v1.8.1 h1:4+fr/el88TOO3ewCmQr8cx/CtZ/umlIRIs5M4NTNjf8= -github.com/gin-gonic/gin v1.8.1/go.mod h1:ji8BvRH1azfM+SYow9zQ6SZMvR8qOMZHmsCuWR9tTTk= github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU= github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y= -github.com/gliderlabs/ssh v0.3.5 h1:OcaySEmAQJgyYcArR+gGGTHCyE7nvhEMTlYY+Dp8CpY= -github.com/gliderlabs/ssh v0.3.5/go.mod h1:8XB4KraRrX39qHhT6yxPsHedjA08I/uBVwj4xC+/+z4= github.com/gliderlabs/ssh v0.3.7 h1:iV3Bqi942d9huXnzEF2Mt+CY9gLu8DNM4Obd+8bODRE= -github.com/go-git/gcfg v1.5.0 h1:Q5ViNfGF8zFgyJWPqYwA7qGFoMTEiBmdlkcfRmpIMa4= -github.com/go-git/gcfg v1.5.0/go.mod h1:5m20vg6GwYabIxaOonVkTdrILxQMpEShl1xiMF4ua+E= +github.com/gliderlabs/ssh v0.3.7/go.mod h1:zpHEXBstFnQYtGnB8k8kQLol82umzn/2/snG7alWVD8= github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= -github.com/go-git/go-billy/v5 v5.3.1 h1:CPiOUAzKtMRvolEKw+bG1PLRpT7D3LIs3/3ey4Aiu34= -github.com/go-git/go-billy/v5 v5.3.1/go.mod h1:pmpqyWchKfYfrkb/UVH4otLvyi/5gJlGI4Hb3ZqZ3W0= github.com/go-git/go-billy/v5 v5.6.0 h1:w2hPNtoehvJIxR00Vb4xX94qHQi/ApZfX+nBE2Cjio8= github.com/go-git/go-billy/v5 v5.6.0/go.mod h1:sFDq7xD3fn3E0GOwUSZqHo9lrkmx8xJhA0ZrfvjBRGM= -github.com/go-git/go-git-fixtures/v4 v4.3.1 h1:y5z6dd3qi8Hl+stezc8p3JxDkoTRqMAlKnXHuzrfjTQ= -github.com/go-git/go-git-fixtures/v4 v4.3.1/go.mod h1:8LHG1a3SRW71ettAD/jW13h8c6AqjVSeL11RAdgaqpo= github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII= github.com/go-git/go-git/v5 v5.12.0 h1:7Md+ndsjrzZxbddRDZjF14qK+NN56sy6wkqaVrjZtys= github.com/go-git/go-git/v5 v5.12.0/go.mod h1:FTM9VKtnI2m65hNI/TenDDDnUf2Q9FHnXYjuz9i5OEY= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= @@ -193,41 +159,29 @@ github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vb github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= -github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0= -github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= -github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A= github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= +github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= -github.com/go-playground/locales v0.14.0 h1:u50s323jtVGugKlcYeyzC0etD1HifMjqmJqb8WugfUU= github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs= github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA= -github.com/go-playground/universal-translator v0.18.0 h1:82dyy6p4OuJq4/CByFNOn/jYrnRPArHwAcmLoJZxyho= github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA= github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4= github.com/go-playground/validator/v10 v10.9.0/go.mod h1:74x4gJWsvQexRdW8Pn3dXSGrTK4nAUsbPlLADvpJkos= -github.com/go-playground/validator/v10 v10.10.0/go.mod h1:74x4gJWsvQexRdW8Pn3dXSGrTK4nAUsbPlLADvpJkos= -github.com/go-playground/validator/v10 v10.11.1 h1:prmOlTVv+YjZjmRmNSF3VmspqJIxJWXmqUsHwfTRRkQ= -github.com/go-playground/validator/v10 v10.11.1/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU= github.com/go-playground/validator/v10 v10.23.0 h1:/PwmTwZhS0dPkav3cdK9kV1FsAmrL8sThn8IHr/sO+o= github.com/go-playground/validator/v10 v10.23.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= -github.com/goccy/go-json v0.9.7/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= -github.com/goccy/go-json v0.10.0 h1:mXKd9Qw4NuzShiRlOXKews24ufknHO7gx30lsDyokKA= -github.com/goccy/go-json v0.10.0/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA= github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= -github.com/gofrs/uuid v4.2.0+incompatible h1:yyYWMnhkhrKwwr8gAOcOCYxOOscHgDS9yZgBrnJfGa0= -github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= +github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA= +github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= -github.com/golang-jwt/jwt/v4 v4.4.3 h1:Hxl6lhQFj4AnOX6MLrsCb/+7tCj7DxP7VA+2rDIq5AU= -github.com/golang-jwt/jwt/v4 v4.4.3/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= github.com/golang-jwt/jwt/v4 v4.5.1 h1:JdqV9zKUdtaa9gdPlywC3aeoEsR681PlKC+4F5gQgeo= github.com/golang-jwt/jwt/v4 v4.5.1/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk= @@ -260,10 +214,7 @@ github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QD github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw= github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= -github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= @@ -275,8 +226,8 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= @@ -290,25 +241,17 @@ github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hf github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= -github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= -github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= -github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= -github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= -github.com/imdario/mergo v0.3.13 h1:lFzP57bqS/wsqKssCGmtLAb8A0wKjLGrve2q3PPVcBk= -github.com/imdario/mergo v0.3.13/go.mod h1:4lJ1jqUDcsbIECGy0RUJAXNIhg+6ocWgb1ALK2O4oXg= -github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY= github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= -github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4= github.com/jonaz/ginlogrus v0.0.0-20191118094232-2f4da50f5dd6 h1:eSDBw96rsjHo6ul9fMfUn/1I3iUbR5PWt/mj46Ksxcc= github.com/jonaz/ginlogrus v0.0.0-20191118094232-2f4da50f5dd6/go.mod h1:FMy6Xd1eGEvmKOIAJAVZlp+azKxMhED8I4BExTVcYac= github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= @@ -324,6 +267,8 @@ github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7V github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= +github.com/keybase/go-keychain v0.0.0-20231219164618-57a3676c3af6 h1:IsMZxCuZqKuao2vNdfD82fjjgPLfyHLpR41Z88viRWs= +github.com/keybase/go-keychain v0.0.0-20231219164618-57a3676c3af6/go.mod h1:3VeWNIJaW+O5xpRQbPp0Ybqu1vJd/pm7s2F473HRrkw= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc= github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0= @@ -336,8 +281,9 @@ github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxv github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -345,26 +291,18 @@ github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= -github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w= github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY= github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= -github.com/matryer/is v1.2.0 h1:92UTHpy8CDwaJ08GqLDzhhuixiBUUD1p3AU6PHddz4A= -github.com/matryer/is v1.2.0/go.mod h1:2fLPjFQM9rhQ15aVEtbuwhJinnOqrmgXPNdZsdwlWXA= -github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U= -github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= -github.com/mattn/go-isatty v0.0.16 h1:bq3VjFmv/sOjHtdEhmkEV4x1AJtvUvOJ2PFAZ5+peKQ= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= -github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= -github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= @@ -376,21 +314,12 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= -github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= -github.com/olahol/melody v1.1.1 h1:amgBhR7pDY0rA0JHWprgLF0LnVztognAwEQgf/WYLVM= -github.com/olahol/melody v1.1.1/go.mod h1:GgkTl6Y7yWj/HtfD48Q5vLKPVoZOH+Qqgfa7CvJgJM4= github.com/olahol/melody v1.2.1 h1:xdwRkzHxf+B0w4TKbGpUSSkV516ZucQZJIWLztOWICQ= github.com/olahol/melody v1.2.1/go.mod h1:GgkTl6Y7yWj/HtfD48Q5vLKPVoZOH+Qqgfa7CvJgJM4= -github.com/onsi/gomega v1.24.1 h1:KORJXNNTzJXzu4ScJWssJfJMnJ+2QJqhoQSRwNlze9E= -github.com/onsi/gomega v1.24.1/go.mod h1:3AOiACssS3/MajrniINInwbfOOtfZvplPzuRSmvt1jM= github.com/onsi/gomega v1.34.2 h1:pNCwDkzrsv7MS9kpaQvVb1aVLahQXyJ/Tv5oAZMI3i8= -github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo= -github.com/pelletier/go-toml/v2 v2.0.6 h1:nrzqCb7j9cDFj2coyLNLaZuJTLjWjlaz6nvTvIwycIU= -github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek= +github.com/onsi/gomega v1.34.2/go.mod h1:v1xfxRgk0KIsG+QOdm7p8UosrOzPYRo60fd3B/1Dukc= github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M= github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc= -github.com/pjbgf/sha1cd v0.2.3 h1:uKQP/7QOzNtKYH7UTohZLcjF5/55EnTw0jO/Ru4jZwI= -github.com/pjbgf/sha1cd v0.2.3/go.mod h1:HOK9QrgzdHpbc2Kzip0Q1yi3M2MFGPADtR6HjG65m5M= github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4= github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= @@ -400,7 +329,6 @@ github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -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/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= @@ -408,24 +336,18 @@ github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXP github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M= github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0= -github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw= -github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y= github.com/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y= github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4= -github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= -github.com/prometheus/common v0.38.0 h1:VTQitp6mXTdUoCmDMugDVOJ1opi6ADftKfp/yeqTR/E= -github.com/prometheus/common v0.38.0/go.mod h1:MBXfmBQZrK5XpbCkjofnXs96LD2QQ7fEq4C0xjC/yec= github.com/prometheus/common v0.60.1 h1:FUas6GcOw66yB/73KC+BOZoFJmbo/1pojoILArPAaSc= github.com/prometheus/common v0.60.1/go.mod h1:h0LYf1R1deLSKtD4Vdg8gy4RuOvENW2J/h19V5NADQw= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= @@ -433,31 +355,25 @@ github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsT github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= -github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo= -github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4= github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= +github.com/redis/go-redis/v9 v9.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E= +github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= -github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8= github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= -github.com/sergi/go-diff v1.2.0 h1:XU+rvMAioB0UC3q1MFrIQy4Vo5/4VsRDQQXHsEya6xQ= -github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= -github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0= -github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= -github.com/skeema/knownhosts v1.1.0 h1:Wvr9V0MxhjRbl3f9nMnKnFfiWTJmtECJ9Njkea3ysW0= -github.com/skeema/knownhosts v1.1.0/go.mod h1:sKFq3RD6/TKZkSWn8boUbDC7Qkgcv+8XXijpFO6roag= github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY= github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -474,8 +390,6 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= 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.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= @@ -483,28 +397,19 @@ github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2 github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= github.com/ugorji/go v1.2.6/go.mod h1:anCg0y61KIhDlPZmnH+so+RQbysYVyDko0IMgJv0Nn0= -github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M= github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= github.com/ugorji/go/codec v1.2.6/go.mod h1:V6TCNZ4PHqoHGFZuSG1W8nrCzzdgA2DozYxWFFpvxTw= -github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0= -github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY= github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE= github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= -github.com/urfave/cli/v2 v2.23.7 h1:YHDQ46s3VghFHFf1DdF+Sh7H4RqhcM+t0TmZRJx4oJY= -github.com/urfave/cli/v2 v2.23.7/go.mod h1:GHupkWPMM0M/sj1a2b4wUrWBPzazNrIjouW6fmdJLxc= github.com/urfave/cli/v2 v2.27.5 h1:WoHEJLdsXr6dDWoJgMq/CboDmyY/8HMMH1fTECbih+w= github.com/urfave/cli/v2 v2.27.5/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ= -github.com/xanzy/ssh-agent v0.3.2/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4= github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= @@ -520,13 +425,7 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.0.0-20220826181053-bd7e27e6170d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw= -golang.org/x/crypto v0.4.0 h1:UVQgzMY87xqpKNgb+kDsll2Igd33HszWHFLmpaRMq/8= -golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80= golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ= golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -559,11 +458,6 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA= -golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4= -golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -595,11 +489,6 @@ golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81R golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= -golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= -golang.org/x/net v0.4.0 h1:Q5QPcMlvfxFTAPV0+07Xz/MpK9NTXu2VDUuy0FeMfaU= -golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE= golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo= golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -617,9 +506,6 @@ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= -golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -656,32 +542,21 @@ golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211020174200-9d6173849985/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ= -golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.0.0-20220722155259-a9ba230a4035/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI= -golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA= +golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU= +golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -689,9 +564,6 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM= -golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -737,11 +609,6 @@ golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roY golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.4.0 h1:7mTAgkunk3fr4GAloyyCasadO6h9zSsQZbwvcaIciV4= -golang.org/x/tools v0.4.0/go.mod h1:UE5sM2OK9E/d67R0ANs2xJizIymRP5gJU295PvKXxjQ= -golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o= -golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -822,16 +689,12 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w= -google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= google.golang.org/protobuf v1.35.2 h1:8Ar7bF+apOIoThw1EdZl0p1oWvMqTHmpA2fRTyZO8io= google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= @@ -845,11 +708,9 @@ gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= @@ -859,16 +720,10 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -k8s.io/apimachinery v0.26.0 h1:1feANjElT7MvPqp0JT6F3Ss6TWDwmcjLypwoPpEf7zg= -k8s.io/apimachinery v0.26.0/go.mod h1:tnPmbONNJ7ByJNz9+n9kMjNP8ON+1qoAIIC70lztu74= k8s.io/apimachinery v0.31.3 h1:6l0WhcYgasZ/wk9ktLq5vLaoXJJr5ts6lkaQzgeYPq4= k8s.io/apimachinery v0.31.3/go.mod h1:rsPdaZJfTfLsNJSQzNHQvYoTmxhoOEofxtOsF3rtsMo= -k8s.io/klog/v2 v2.80.1 h1:atnLQ121W371wYYFawwYx1aEY2eUfs4l3J72wtgAwV4= -k8s.io/klog/v2 v2.80.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk= k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE= -k8s.io/utils v0.0.0-20221107191617-1a15be271d1d h1:0Smp/HP1OH4Rvhe+4B8nWGERtlqAGSftbSbbmm45oFs= -k8s.io/utils v0.0.0-20221107191617-1a15be271d1d/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= k8s.io/utils v0.0.0-20241104163129-6fe5fd82f078 h1:jGnCPejIetjiy2gqaJ5V0NLwTpF4wbQ6cZIItJCSHno= k8s.io/utils v0.0.0-20241104163129-6fe5fd82f078/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50= diff --git a/mocks/mock_Cmdable.go b/mocks/mock_Cmdable.go new file mode 100644 index 0000000..931dc37 --- /dev/null +++ b/mocks/mock_Cmdable.go @@ -0,0 +1,26770 @@ +// Code generated by mockery v2.45.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + redis "github.com/redis/go-redis/v9" + mock "github.com/stretchr/testify/mock" + + time "time" +) + +// MockCmdable is an autogenerated mock type for the Cmdable type +type MockCmdable struct { + mock.Mock +} + +type MockCmdable_Expecter struct { + mock *mock.Mock +} + +func (_m *MockCmdable) EXPECT() *MockCmdable_Expecter { + return &MockCmdable_Expecter{mock: &_m.Mock} +} + +// ACLDryRun provides a mock function with given fields: ctx, username, command +func (_m *MockCmdable) ACLDryRun(ctx context.Context, username string, command ...interface{}) *redis.StringCmd { + var _ca []interface{} + _ca = append(_ca, ctx, username) + _ca = append(_ca, command...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ACLDryRun") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.StringCmd); ok { + r0 = rf(ctx, username, command...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ACLDryRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ACLDryRun' +type MockCmdable_ACLDryRun_Call struct { + *mock.Call +} + +// ACLDryRun is a helper method to define mock.On call +// - ctx context.Context +// - username string +// - command ...interface{} +func (_e *MockCmdable_Expecter) ACLDryRun(ctx interface{}, username interface{}, command ...interface{}) *MockCmdable_ACLDryRun_Call { + return &MockCmdable_ACLDryRun_Call{Call: _e.mock.On("ACLDryRun", + append([]interface{}{ctx, username}, command...)...)} +} + +func (_c *MockCmdable_ACLDryRun_Call) Run(run func(ctx context.Context, username string, command ...interface{})) *MockCmdable_ACLDryRun_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ACLDryRun_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ACLDryRun_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ACLDryRun_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.StringCmd) *MockCmdable_ACLDryRun_Call { + _c.Call.Return(run) + return _c +} + +// ACLLog provides a mock function with given fields: ctx, count +func (_m *MockCmdable) ACLLog(ctx context.Context, count int64) *redis.ACLLogCmd { + ret := _m.Called(ctx, count) + + if len(ret) == 0 { + panic("no return value specified for ACLLog") + } + + var r0 *redis.ACLLogCmd + if rf, ok := ret.Get(0).(func(context.Context, int64) *redis.ACLLogCmd); ok { + r0 = rf(ctx, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ACLLogCmd) + } + } + + return r0 +} + +// MockCmdable_ACLLog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ACLLog' +type MockCmdable_ACLLog_Call struct { + *mock.Call +} + +// ACLLog is a helper method to define mock.On call +// - ctx context.Context +// - count int64 +func (_e *MockCmdable_Expecter) ACLLog(ctx interface{}, count interface{}) *MockCmdable_ACLLog_Call { + return &MockCmdable_ACLLog_Call{Call: _e.mock.On("ACLLog", ctx, count)} +} + +func (_c *MockCmdable_ACLLog_Call) Run(run func(ctx context.Context, count int64)) *MockCmdable_ACLLog_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ACLLog_Call) Return(_a0 *redis.ACLLogCmd) *MockCmdable_ACLLog_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ACLLog_Call) RunAndReturn(run func(context.Context, int64) *redis.ACLLogCmd) *MockCmdable_ACLLog_Call { + _c.Call.Return(run) + return _c +} + +// ACLLogReset provides a mock function with given fields: ctx +func (_m *MockCmdable) ACLLogReset(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ACLLogReset") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ACLLogReset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ACLLogReset' +type MockCmdable_ACLLogReset_Call struct { + *mock.Call +} + +// ACLLogReset is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ACLLogReset(ctx interface{}) *MockCmdable_ACLLogReset_Call { + return &MockCmdable_ACLLogReset_Call{Call: _e.mock.On("ACLLogReset", ctx)} +} + +func (_c *MockCmdable_ACLLogReset_Call) Run(run func(ctx context.Context)) *MockCmdable_ACLLogReset_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ACLLogReset_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ACLLogReset_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ACLLogReset_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ACLLogReset_Call { + _c.Call.Return(run) + return _c +} + +// Append provides a mock function with given fields: ctx, key, value +func (_m *MockCmdable) Append(ctx context.Context, key string, value string) *redis.IntCmd { + ret := _m.Called(ctx, key, value) + + if len(ret) == 0 { + panic("no return value specified for Append") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Append_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Append' +type MockCmdable_Append_Call struct { + *mock.Call +} + +// Append is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value string +func (_e *MockCmdable_Expecter) Append(ctx interface{}, key interface{}, value interface{}) *MockCmdable_Append_Call { + return &MockCmdable_Append_Call{Call: _e.mock.On("Append", ctx, key, value)} +} + +func (_c *MockCmdable_Append_Call) Run(run func(ctx context.Context, key string, value string)) *MockCmdable_Append_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_Append_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Append_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Append_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_Append_Call { + _c.Call.Return(run) + return _c +} + +// BFAdd provides a mock function with given fields: ctx, key, element +func (_m *MockCmdable) BFAdd(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, key, element) + + if len(ret) == 0 { + panic("no return value specified for BFAdd") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, element) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_BFAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFAdd' +type MockCmdable_BFAdd_Call struct { + *mock.Call +} + +// BFAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - element interface{} +func (_e *MockCmdable_Expecter) BFAdd(ctx interface{}, key interface{}, element interface{}) *MockCmdable_BFAdd_Call { + return &MockCmdable_BFAdd_Call{Call: _e.mock.On("BFAdd", ctx, key, element)} +} + +func (_c *MockCmdable_BFAdd_Call) Run(run func(ctx context.Context, key string, element interface{})) *MockCmdable_BFAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_BFAdd_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_BFAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFAdd_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *MockCmdable_BFAdd_Call { + _c.Call.Return(run) + return _c +} + +// BFCard provides a mock function with given fields: ctx, key +func (_m *MockCmdable) BFCard(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for BFCard") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_BFCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFCard' +type MockCmdable_BFCard_Call struct { + *mock.Call +} + +// BFCard is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) BFCard(ctx interface{}, key interface{}) *MockCmdable_BFCard_Call { + return &MockCmdable_BFCard_Call{Call: _e.mock.On("BFCard", ctx, key)} +} + +func (_c *MockCmdable_BFCard_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_BFCard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_BFCard_Call) Return(_a0 *redis.IntCmd) *MockCmdable_BFCard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFCard_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_BFCard_Call { + _c.Call.Return(run) + return _c +} + +// BFExists provides a mock function with given fields: ctx, key, element +func (_m *MockCmdable) BFExists(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, key, element) + + if len(ret) == 0 { + panic("no return value specified for BFExists") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, element) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_BFExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFExists' +type MockCmdable_BFExists_Call struct { + *mock.Call +} + +// BFExists is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - element interface{} +func (_e *MockCmdable_Expecter) BFExists(ctx interface{}, key interface{}, element interface{}) *MockCmdable_BFExists_Call { + return &MockCmdable_BFExists_Call{Call: _e.mock.On("BFExists", ctx, key, element)} +} + +func (_c *MockCmdable_BFExists_Call) Run(run func(ctx context.Context, key string, element interface{})) *MockCmdable_BFExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_BFExists_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_BFExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFExists_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *MockCmdable_BFExists_Call { + _c.Call.Return(run) + return _c +} + +// BFInfo provides a mock function with given fields: ctx, key +func (_m *MockCmdable) BFInfo(ctx context.Context, key string) *redis.BFInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for BFInfo") + } + + var r0 *redis.BFInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.BFInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BFInfoCmd) + } + } + + return r0 +} + +// MockCmdable_BFInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFInfo' +type MockCmdable_BFInfo_Call struct { + *mock.Call +} + +// BFInfo is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) BFInfo(ctx interface{}, key interface{}) *MockCmdable_BFInfo_Call { + return &MockCmdable_BFInfo_Call{Call: _e.mock.On("BFInfo", ctx, key)} +} + +func (_c *MockCmdable_BFInfo_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_BFInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_BFInfo_Call) Return(_a0 *redis.BFInfoCmd) *MockCmdable_BFInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFInfo_Call) RunAndReturn(run func(context.Context, string) *redis.BFInfoCmd) *MockCmdable_BFInfo_Call { + _c.Call.Return(run) + return _c +} + +// BFInfoArg provides a mock function with given fields: ctx, key, option +func (_m *MockCmdable) BFInfoArg(ctx context.Context, key string, option string) *redis.BFInfoCmd { + ret := _m.Called(ctx, key, option) + + if len(ret) == 0 { + panic("no return value specified for BFInfoArg") + } + + var r0 *redis.BFInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.BFInfoCmd); ok { + r0 = rf(ctx, key, option) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BFInfoCmd) + } + } + + return r0 +} + +// MockCmdable_BFInfoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFInfoArg' +type MockCmdable_BFInfoArg_Call struct { + *mock.Call +} + +// BFInfoArg is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - option string +func (_e *MockCmdable_Expecter) BFInfoArg(ctx interface{}, key interface{}, option interface{}) *MockCmdable_BFInfoArg_Call { + return &MockCmdable_BFInfoArg_Call{Call: _e.mock.On("BFInfoArg", ctx, key, option)} +} + +func (_c *MockCmdable_BFInfoArg_Call) Run(run func(ctx context.Context, key string, option string)) *MockCmdable_BFInfoArg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_BFInfoArg_Call) Return(_a0 *redis.BFInfoCmd) *MockCmdable_BFInfoArg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFInfoArg_Call) RunAndReturn(run func(context.Context, string, string) *redis.BFInfoCmd) *MockCmdable_BFInfoArg_Call { + _c.Call.Return(run) + return _c +} + +// BFInfoCapacity provides a mock function with given fields: ctx, key +func (_m *MockCmdable) BFInfoCapacity(ctx context.Context, key string) *redis.BFInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for BFInfoCapacity") + } + + var r0 *redis.BFInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.BFInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BFInfoCmd) + } + } + + return r0 +} + +// MockCmdable_BFInfoCapacity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFInfoCapacity' +type MockCmdable_BFInfoCapacity_Call struct { + *mock.Call +} + +// BFInfoCapacity is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) BFInfoCapacity(ctx interface{}, key interface{}) *MockCmdable_BFInfoCapacity_Call { + return &MockCmdable_BFInfoCapacity_Call{Call: _e.mock.On("BFInfoCapacity", ctx, key)} +} + +func (_c *MockCmdable_BFInfoCapacity_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_BFInfoCapacity_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_BFInfoCapacity_Call) Return(_a0 *redis.BFInfoCmd) *MockCmdable_BFInfoCapacity_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFInfoCapacity_Call) RunAndReturn(run func(context.Context, string) *redis.BFInfoCmd) *MockCmdable_BFInfoCapacity_Call { + _c.Call.Return(run) + return _c +} + +// BFInfoExpansion provides a mock function with given fields: ctx, key +func (_m *MockCmdable) BFInfoExpansion(ctx context.Context, key string) *redis.BFInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for BFInfoExpansion") + } + + var r0 *redis.BFInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.BFInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BFInfoCmd) + } + } + + return r0 +} + +// MockCmdable_BFInfoExpansion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFInfoExpansion' +type MockCmdable_BFInfoExpansion_Call struct { + *mock.Call +} + +// BFInfoExpansion is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) BFInfoExpansion(ctx interface{}, key interface{}) *MockCmdable_BFInfoExpansion_Call { + return &MockCmdable_BFInfoExpansion_Call{Call: _e.mock.On("BFInfoExpansion", ctx, key)} +} + +func (_c *MockCmdable_BFInfoExpansion_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_BFInfoExpansion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_BFInfoExpansion_Call) Return(_a0 *redis.BFInfoCmd) *MockCmdable_BFInfoExpansion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFInfoExpansion_Call) RunAndReturn(run func(context.Context, string) *redis.BFInfoCmd) *MockCmdable_BFInfoExpansion_Call { + _c.Call.Return(run) + return _c +} + +// BFInfoFilters provides a mock function with given fields: ctx, key +func (_m *MockCmdable) BFInfoFilters(ctx context.Context, key string) *redis.BFInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for BFInfoFilters") + } + + var r0 *redis.BFInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.BFInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BFInfoCmd) + } + } + + return r0 +} + +// MockCmdable_BFInfoFilters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFInfoFilters' +type MockCmdable_BFInfoFilters_Call struct { + *mock.Call +} + +// BFInfoFilters is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) BFInfoFilters(ctx interface{}, key interface{}) *MockCmdable_BFInfoFilters_Call { + return &MockCmdable_BFInfoFilters_Call{Call: _e.mock.On("BFInfoFilters", ctx, key)} +} + +func (_c *MockCmdable_BFInfoFilters_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_BFInfoFilters_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_BFInfoFilters_Call) Return(_a0 *redis.BFInfoCmd) *MockCmdable_BFInfoFilters_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFInfoFilters_Call) RunAndReturn(run func(context.Context, string) *redis.BFInfoCmd) *MockCmdable_BFInfoFilters_Call { + _c.Call.Return(run) + return _c +} + +// BFInfoItems provides a mock function with given fields: ctx, key +func (_m *MockCmdable) BFInfoItems(ctx context.Context, key string) *redis.BFInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for BFInfoItems") + } + + var r0 *redis.BFInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.BFInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BFInfoCmd) + } + } + + return r0 +} + +// MockCmdable_BFInfoItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFInfoItems' +type MockCmdable_BFInfoItems_Call struct { + *mock.Call +} + +// BFInfoItems is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) BFInfoItems(ctx interface{}, key interface{}) *MockCmdable_BFInfoItems_Call { + return &MockCmdable_BFInfoItems_Call{Call: _e.mock.On("BFInfoItems", ctx, key)} +} + +func (_c *MockCmdable_BFInfoItems_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_BFInfoItems_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_BFInfoItems_Call) Return(_a0 *redis.BFInfoCmd) *MockCmdable_BFInfoItems_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFInfoItems_Call) RunAndReturn(run func(context.Context, string) *redis.BFInfoCmd) *MockCmdable_BFInfoItems_Call { + _c.Call.Return(run) + return _c +} + +// BFInfoSize provides a mock function with given fields: ctx, key +func (_m *MockCmdable) BFInfoSize(ctx context.Context, key string) *redis.BFInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for BFInfoSize") + } + + var r0 *redis.BFInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.BFInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BFInfoCmd) + } + } + + return r0 +} + +// MockCmdable_BFInfoSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFInfoSize' +type MockCmdable_BFInfoSize_Call struct { + *mock.Call +} + +// BFInfoSize is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) BFInfoSize(ctx interface{}, key interface{}) *MockCmdable_BFInfoSize_Call { + return &MockCmdable_BFInfoSize_Call{Call: _e.mock.On("BFInfoSize", ctx, key)} +} + +func (_c *MockCmdable_BFInfoSize_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_BFInfoSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_BFInfoSize_Call) Return(_a0 *redis.BFInfoCmd) *MockCmdable_BFInfoSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFInfoSize_Call) RunAndReturn(run func(context.Context, string) *redis.BFInfoCmd) *MockCmdable_BFInfoSize_Call { + _c.Call.Return(run) + return _c +} + +// BFInsert provides a mock function with given fields: ctx, key, options, elements +func (_m *MockCmdable) BFInsert(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...interface{}) *redis.BoolSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key, options) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BFInsert") + } + + var r0 *redis.BoolSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.BFInsertOptions, ...interface{}) *redis.BoolSliceCmd); ok { + r0 = rf(ctx, key, options, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolSliceCmd) + } + } + + return r0 +} + +// MockCmdable_BFInsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFInsert' +type MockCmdable_BFInsert_Call struct { + *mock.Call +} + +// BFInsert is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.BFInsertOptions +// - elements ...interface{} +func (_e *MockCmdable_Expecter) BFInsert(ctx interface{}, key interface{}, options interface{}, elements ...interface{}) *MockCmdable_BFInsert_Call { + return &MockCmdable_BFInsert_Call{Call: _e.mock.On("BFInsert", + append([]interface{}{ctx, key, options}, elements...)...)} +} + +func (_c *MockCmdable_BFInsert_Call) Run(run func(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...interface{})) *MockCmdable_BFInsert_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*redis.BFInsertOptions), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BFInsert_Call) Return(_a0 *redis.BoolSliceCmd) *MockCmdable_BFInsert_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFInsert_Call) RunAndReturn(run func(context.Context, string, *redis.BFInsertOptions, ...interface{}) *redis.BoolSliceCmd) *MockCmdable_BFInsert_Call { + _c.Call.Return(run) + return _c +} + +// BFLoadChunk provides a mock function with given fields: ctx, key, iterator, data +func (_m *MockCmdable) BFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *redis.StatusCmd { + ret := _m.Called(ctx, key, iterator, data) + + if len(ret) == 0 { + panic("no return value specified for BFLoadChunk") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, key, iterator, data) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_BFLoadChunk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFLoadChunk' +type MockCmdable_BFLoadChunk_Call struct { + *mock.Call +} + +// BFLoadChunk is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - iterator int64 +// - data interface{} +func (_e *MockCmdable_Expecter) BFLoadChunk(ctx interface{}, key interface{}, iterator interface{}, data interface{}) *MockCmdable_BFLoadChunk_Call { + return &MockCmdable_BFLoadChunk_Call{Call: _e.mock.On("BFLoadChunk", ctx, key, iterator, data)} +} + +func (_c *MockCmdable_BFLoadChunk_Call) Run(run func(ctx context.Context, key string, iterator int64, data interface{})) *MockCmdable_BFLoadChunk_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_BFLoadChunk_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_BFLoadChunk_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFLoadChunk_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) *redis.StatusCmd) *MockCmdable_BFLoadChunk_Call { + _c.Call.Return(run) + return _c +} + +// BFMAdd provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) BFMAdd(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BFMAdd") + } + + var r0 *redis.BoolSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.BoolSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolSliceCmd) + } + } + + return r0 +} + +// MockCmdable_BFMAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFMAdd' +type MockCmdable_BFMAdd_Call struct { + *mock.Call +} + +// BFMAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) BFMAdd(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_BFMAdd_Call { + return &MockCmdable_BFMAdd_Call{Call: _e.mock.On("BFMAdd", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_BFMAdd_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_BFMAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BFMAdd_Call) Return(_a0 *redis.BoolSliceCmd) *MockCmdable_BFMAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFMAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolSliceCmd) *MockCmdable_BFMAdd_Call { + _c.Call.Return(run) + return _c +} + +// BFMExists provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) BFMExists(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BFMExists") + } + + var r0 *redis.BoolSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.BoolSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolSliceCmd) + } + } + + return r0 +} + +// MockCmdable_BFMExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFMExists' +type MockCmdable_BFMExists_Call struct { + *mock.Call +} + +// BFMExists is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) BFMExists(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_BFMExists_Call { + return &MockCmdable_BFMExists_Call{Call: _e.mock.On("BFMExists", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_BFMExists_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_BFMExists_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BFMExists_Call) Return(_a0 *redis.BoolSliceCmd) *MockCmdable_BFMExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFMExists_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolSliceCmd) *MockCmdable_BFMExists_Call { + _c.Call.Return(run) + return _c +} + +// BFReserve provides a mock function with given fields: ctx, key, errorRate, capacity +func (_m *MockCmdable) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, errorRate, capacity) + + if len(ret) == 0 { + panic("no return value specified for BFReserve") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, errorRate, capacity) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_BFReserve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFReserve' +type MockCmdable_BFReserve_Call struct { + *mock.Call +} + +// BFReserve is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - errorRate float64 +// - capacity int64 +func (_e *MockCmdable_Expecter) BFReserve(ctx interface{}, key interface{}, errorRate interface{}, capacity interface{}) *MockCmdable_BFReserve_Call { + return &MockCmdable_BFReserve_Call{Call: _e.mock.On("BFReserve", ctx, key, errorRate, capacity)} +} + +func (_c *MockCmdable_BFReserve_Call) Run(run func(ctx context.Context, key string, errorRate float64, capacity int64)) *MockCmdable_BFReserve_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_BFReserve_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_BFReserve_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFReserve_Call) RunAndReturn(run func(context.Context, string, float64, int64) *redis.StatusCmd) *MockCmdable_BFReserve_Call { + _c.Call.Return(run) + return _c +} + +// BFReserveExpansion provides a mock function with given fields: ctx, key, errorRate, capacity, expansion +func (_m *MockCmdable) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity int64, expansion int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, errorRate, capacity, expansion) + + if len(ret) == 0 { + panic("no return value specified for BFReserveExpansion") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, int64, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, errorRate, capacity, expansion) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_BFReserveExpansion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFReserveExpansion' +type MockCmdable_BFReserveExpansion_Call struct { + *mock.Call +} + +// BFReserveExpansion is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - errorRate float64 +// - capacity int64 +// - expansion int64 +func (_e *MockCmdable_Expecter) BFReserveExpansion(ctx interface{}, key interface{}, errorRate interface{}, capacity interface{}, expansion interface{}) *MockCmdable_BFReserveExpansion_Call { + return &MockCmdable_BFReserveExpansion_Call{Call: _e.mock.On("BFReserveExpansion", ctx, key, errorRate, capacity, expansion)} +} + +func (_c *MockCmdable_BFReserveExpansion_Call) Run(run func(ctx context.Context, key string, errorRate float64, capacity int64, expansion int64)) *MockCmdable_BFReserveExpansion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(int64), args[4].(int64)) + }) + return _c +} + +func (_c *MockCmdable_BFReserveExpansion_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_BFReserveExpansion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFReserveExpansion_Call) RunAndReturn(run func(context.Context, string, float64, int64, int64) *redis.StatusCmd) *MockCmdable_BFReserveExpansion_Call { + _c.Call.Return(run) + return _c +} + +// BFReserveNonScaling provides a mock function with given fields: ctx, key, errorRate, capacity +func (_m *MockCmdable) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, errorRate, capacity) + + if len(ret) == 0 { + panic("no return value specified for BFReserveNonScaling") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, errorRate, capacity) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_BFReserveNonScaling_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFReserveNonScaling' +type MockCmdable_BFReserveNonScaling_Call struct { + *mock.Call +} + +// BFReserveNonScaling is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - errorRate float64 +// - capacity int64 +func (_e *MockCmdable_Expecter) BFReserveNonScaling(ctx interface{}, key interface{}, errorRate interface{}, capacity interface{}) *MockCmdable_BFReserveNonScaling_Call { + return &MockCmdable_BFReserveNonScaling_Call{Call: _e.mock.On("BFReserveNonScaling", ctx, key, errorRate, capacity)} +} + +func (_c *MockCmdable_BFReserveNonScaling_Call) Run(run func(ctx context.Context, key string, errorRate float64, capacity int64)) *MockCmdable_BFReserveNonScaling_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_BFReserveNonScaling_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_BFReserveNonScaling_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFReserveNonScaling_Call) RunAndReturn(run func(context.Context, string, float64, int64) *redis.StatusCmd) *MockCmdable_BFReserveNonScaling_Call { + _c.Call.Return(run) + return _c +} + +// BFReserveWithArgs provides a mock function with given fields: ctx, key, options +func (_m *MockCmdable) BFReserveWithArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd { + ret := _m.Called(ctx, key, options) + + if len(ret) == 0 { + panic("no return value specified for BFReserveWithArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.BFReserveOptions) *redis.StatusCmd); ok { + r0 = rf(ctx, key, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_BFReserveWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFReserveWithArgs' +type MockCmdable_BFReserveWithArgs_Call struct { + *mock.Call +} + +// BFReserveWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.BFReserveOptions +func (_e *MockCmdable_Expecter) BFReserveWithArgs(ctx interface{}, key interface{}, options interface{}) *MockCmdable_BFReserveWithArgs_Call { + return &MockCmdable_BFReserveWithArgs_Call{Call: _e.mock.On("BFReserveWithArgs", ctx, key, options)} +} + +func (_c *MockCmdable_BFReserveWithArgs_Call) Run(run func(ctx context.Context, key string, options *redis.BFReserveOptions)) *MockCmdable_BFReserveWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.BFReserveOptions)) + }) + return _c +} + +func (_c *MockCmdable_BFReserveWithArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_BFReserveWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFReserveWithArgs_Call) RunAndReturn(run func(context.Context, string, *redis.BFReserveOptions) *redis.StatusCmd) *MockCmdable_BFReserveWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// BFScanDump provides a mock function with given fields: ctx, key, iterator +func (_m *MockCmdable) BFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + ret := _m.Called(ctx, key, iterator) + + if len(ret) == 0 { + panic("no return value specified for BFScanDump") + } + + var r0 *redis.ScanDumpCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.ScanDumpCmd); ok { + r0 = rf(ctx, key, iterator) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ScanDumpCmd) + } + } + + return r0 +} + +// MockCmdable_BFScanDump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BFScanDump' +type MockCmdable_BFScanDump_Call struct { + *mock.Call +} + +// BFScanDump is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - iterator int64 +func (_e *MockCmdable_Expecter) BFScanDump(ctx interface{}, key interface{}, iterator interface{}) *MockCmdable_BFScanDump_Call { + return &MockCmdable_BFScanDump_Call{Call: _e.mock.On("BFScanDump", ctx, key, iterator)} +} + +func (_c *MockCmdable_BFScanDump_Call) Run(run func(ctx context.Context, key string, iterator int64)) *MockCmdable_BFScanDump_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_BFScanDump_Call) Return(_a0 *redis.ScanDumpCmd) *MockCmdable_BFScanDump_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BFScanDump_Call) RunAndReturn(run func(context.Context, string, int64) *redis.ScanDumpCmd) *MockCmdable_BFScanDump_Call { + _c.Call.Return(run) + return _c +} + +// BLMPop provides a mock function with given fields: ctx, timeout, direction, count, keys +func (_m *MockCmdable) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, timeout, direction, count) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BLMPop") + } + + var r0 *redis.KeyValuesCmd + if rf, ok := ret.Get(0).(func(context.Context, time.Duration, string, int64, ...string) *redis.KeyValuesCmd); ok { + r0 = rf(ctx, timeout, direction, count, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.KeyValuesCmd) + } + } + + return r0 +} + +// MockCmdable_BLMPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BLMPop' +type MockCmdable_BLMPop_Call struct { + *mock.Call +} + +// BLMPop is a helper method to define mock.On call +// - ctx context.Context +// - timeout time.Duration +// - direction string +// - count int64 +// - keys ...string +func (_e *MockCmdable_Expecter) BLMPop(ctx interface{}, timeout interface{}, direction interface{}, count interface{}, keys ...interface{}) *MockCmdable_BLMPop_Call { + return &MockCmdable_BLMPop_Call{Call: _e.mock.On("BLMPop", + append([]interface{}{ctx, timeout, direction, count}, keys...)...)} +} + +func (_c *MockCmdable_BLMPop_Call) Run(run func(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string)) *MockCmdable_BLMPop_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(time.Duration), args[2].(string), args[3].(int64), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BLMPop_Call) Return(_a0 *redis.KeyValuesCmd) *MockCmdable_BLMPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BLMPop_Call) RunAndReturn(run func(context.Context, time.Duration, string, int64, ...string) *redis.KeyValuesCmd) *MockCmdable_BLMPop_Call { + _c.Call.Return(run) + return _c +} + +// BLMove provides a mock function with given fields: ctx, source, destination, srcpos, destpos, timeout +func (_m *MockCmdable) BLMove(ctx context.Context, source string, destination string, srcpos string, destpos string, timeout time.Duration) *redis.StringCmd { + ret := _m.Called(ctx, source, destination, srcpos, destpos, timeout) + + if len(ret) == 0 { + panic("no return value specified for BLMove") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, time.Duration) *redis.StringCmd); ok { + r0 = rf(ctx, source, destination, srcpos, destpos, timeout) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_BLMove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BLMove' +type MockCmdable_BLMove_Call struct { + *mock.Call +} + +// BLMove is a helper method to define mock.On call +// - ctx context.Context +// - source string +// - destination string +// - srcpos string +// - destpos string +// - timeout time.Duration +func (_e *MockCmdable_Expecter) BLMove(ctx interface{}, source interface{}, destination interface{}, srcpos interface{}, destpos interface{}, timeout interface{}) *MockCmdable_BLMove_Call { + return &MockCmdable_BLMove_Call{Call: _e.mock.On("BLMove", ctx, source, destination, srcpos, destpos, timeout)} +} + +func (_c *MockCmdable_BLMove_Call) Run(run func(ctx context.Context, source string, destination string, srcpos string, destpos string, timeout time.Duration)) *MockCmdable_BLMove_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_BLMove_Call) Return(_a0 *redis.StringCmd) *MockCmdable_BLMove_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BLMove_Call) RunAndReturn(run func(context.Context, string, string, string, string, time.Duration) *redis.StringCmd) *MockCmdable_BLMove_Call { + _c.Call.Return(run) + return _c +} + +// BLPop provides a mock function with given fields: ctx, timeout, keys +func (_m *MockCmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, timeout) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BLPop") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, time.Duration, ...string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, timeout, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_BLPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BLPop' +type MockCmdable_BLPop_Call struct { + *mock.Call +} + +// BLPop is a helper method to define mock.On call +// - ctx context.Context +// - timeout time.Duration +// - keys ...string +func (_e *MockCmdable_Expecter) BLPop(ctx interface{}, timeout interface{}, keys ...interface{}) *MockCmdable_BLPop_Call { + return &MockCmdable_BLPop_Call{Call: _e.mock.On("BLPop", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *MockCmdable_BLPop_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *MockCmdable_BLPop_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(time.Duration), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BLPop_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_BLPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BLPop_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.StringSliceCmd) *MockCmdable_BLPop_Call { + _c.Call.Return(run) + return _c +} + +// BRPop provides a mock function with given fields: ctx, timeout, keys +func (_m *MockCmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, timeout) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BRPop") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, time.Duration, ...string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, timeout, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_BRPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BRPop' +type MockCmdable_BRPop_Call struct { + *mock.Call +} + +// BRPop is a helper method to define mock.On call +// - ctx context.Context +// - timeout time.Duration +// - keys ...string +func (_e *MockCmdable_Expecter) BRPop(ctx interface{}, timeout interface{}, keys ...interface{}) *MockCmdable_BRPop_Call { + return &MockCmdable_BRPop_Call{Call: _e.mock.On("BRPop", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *MockCmdable_BRPop_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *MockCmdable_BRPop_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(time.Duration), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BRPop_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_BRPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BRPop_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.StringSliceCmd) *MockCmdable_BRPop_Call { + _c.Call.Return(run) + return _c +} + +// BRPopLPush provides a mock function with given fields: ctx, source, destination, timeout +func (_m *MockCmdable) BRPopLPush(ctx context.Context, source string, destination string, timeout time.Duration) *redis.StringCmd { + ret := _m.Called(ctx, source, destination, timeout) + + if len(ret) == 0 { + panic("no return value specified for BRPopLPush") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, time.Duration) *redis.StringCmd); ok { + r0 = rf(ctx, source, destination, timeout) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_BRPopLPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BRPopLPush' +type MockCmdable_BRPopLPush_Call struct { + *mock.Call +} + +// BRPopLPush is a helper method to define mock.On call +// - ctx context.Context +// - source string +// - destination string +// - timeout time.Duration +func (_e *MockCmdable_Expecter) BRPopLPush(ctx interface{}, source interface{}, destination interface{}, timeout interface{}) *MockCmdable_BRPopLPush_Call { + return &MockCmdable_BRPopLPush_Call{Call: _e.mock.On("BRPopLPush", ctx, source, destination, timeout)} +} + +func (_c *MockCmdable_BRPopLPush_Call) Run(run func(ctx context.Context, source string, destination string, timeout time.Duration)) *MockCmdable_BRPopLPush_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_BRPopLPush_Call) Return(_a0 *redis.StringCmd) *MockCmdable_BRPopLPush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BRPopLPush_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) *redis.StringCmd) *MockCmdable_BRPopLPush_Call { + _c.Call.Return(run) + return _c +} + +// BZMPop provides a mock function with given fields: ctx, timeout, order, count, keys +func (_m *MockCmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, timeout, order, count) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BZMPop") + } + + var r0 *redis.ZSliceWithKeyCmd + if rf, ok := ret.Get(0).(func(context.Context, time.Duration, string, int64, ...string) *redis.ZSliceWithKeyCmd); ok { + r0 = rf(ctx, timeout, order, count, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceWithKeyCmd) + } + } + + return r0 +} + +// MockCmdable_BZMPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BZMPop' +type MockCmdable_BZMPop_Call struct { + *mock.Call +} + +// BZMPop is a helper method to define mock.On call +// - ctx context.Context +// - timeout time.Duration +// - order string +// - count int64 +// - keys ...string +func (_e *MockCmdable_Expecter) BZMPop(ctx interface{}, timeout interface{}, order interface{}, count interface{}, keys ...interface{}) *MockCmdable_BZMPop_Call { + return &MockCmdable_BZMPop_Call{Call: _e.mock.On("BZMPop", + append([]interface{}{ctx, timeout, order, count}, keys...)...)} +} + +func (_c *MockCmdable_BZMPop_Call) Run(run func(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string)) *MockCmdable_BZMPop_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(time.Duration), args[2].(string), args[3].(int64), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BZMPop_Call) Return(_a0 *redis.ZSliceWithKeyCmd) *MockCmdable_BZMPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BZMPop_Call) RunAndReturn(run func(context.Context, time.Duration, string, int64, ...string) *redis.ZSliceWithKeyCmd) *MockCmdable_BZMPop_Call { + _c.Call.Return(run) + return _c +} + +// BZPopMax provides a mock function with given fields: ctx, timeout, keys +func (_m *MockCmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, timeout) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BZPopMax") + } + + var r0 *redis.ZWithKeyCmd + if rf, ok := ret.Get(0).(func(context.Context, time.Duration, ...string) *redis.ZWithKeyCmd); ok { + r0 = rf(ctx, timeout, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZWithKeyCmd) + } + } + + return r0 +} + +// MockCmdable_BZPopMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BZPopMax' +type MockCmdable_BZPopMax_Call struct { + *mock.Call +} + +// BZPopMax is a helper method to define mock.On call +// - ctx context.Context +// - timeout time.Duration +// - keys ...string +func (_e *MockCmdable_Expecter) BZPopMax(ctx interface{}, timeout interface{}, keys ...interface{}) *MockCmdable_BZPopMax_Call { + return &MockCmdable_BZPopMax_Call{Call: _e.mock.On("BZPopMax", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *MockCmdable_BZPopMax_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *MockCmdable_BZPopMax_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(time.Duration), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BZPopMax_Call) Return(_a0 *redis.ZWithKeyCmd) *MockCmdable_BZPopMax_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BZPopMax_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.ZWithKeyCmd) *MockCmdable_BZPopMax_Call { + _c.Call.Return(run) + return _c +} + +// BZPopMin provides a mock function with given fields: ctx, timeout, keys +func (_m *MockCmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, timeout) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BZPopMin") + } + + var r0 *redis.ZWithKeyCmd + if rf, ok := ret.Get(0).(func(context.Context, time.Duration, ...string) *redis.ZWithKeyCmd); ok { + r0 = rf(ctx, timeout, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZWithKeyCmd) + } + } + + return r0 +} + +// MockCmdable_BZPopMin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BZPopMin' +type MockCmdable_BZPopMin_Call struct { + *mock.Call +} + +// BZPopMin is a helper method to define mock.On call +// - ctx context.Context +// - timeout time.Duration +// - keys ...string +func (_e *MockCmdable_Expecter) BZPopMin(ctx interface{}, timeout interface{}, keys ...interface{}) *MockCmdable_BZPopMin_Call { + return &MockCmdable_BZPopMin_Call{Call: _e.mock.On("BZPopMin", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *MockCmdable_BZPopMin_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *MockCmdable_BZPopMin_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(time.Duration), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BZPopMin_Call) Return(_a0 *redis.ZWithKeyCmd) *MockCmdable_BZPopMin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BZPopMin_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.ZWithKeyCmd) *MockCmdable_BZPopMin_Call { + _c.Call.Return(run) + return _c +} + +// BgRewriteAOF provides a mock function with given fields: ctx +func (_m *MockCmdable) BgRewriteAOF(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for BgRewriteAOF") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_BgRewriteAOF_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BgRewriteAOF' +type MockCmdable_BgRewriteAOF_Call struct { + *mock.Call +} + +// BgRewriteAOF is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) BgRewriteAOF(ctx interface{}) *MockCmdable_BgRewriteAOF_Call { + return &MockCmdable_BgRewriteAOF_Call{Call: _e.mock.On("BgRewriteAOF", ctx)} +} + +func (_c *MockCmdable_BgRewriteAOF_Call) Run(run func(ctx context.Context)) *MockCmdable_BgRewriteAOF_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_BgRewriteAOF_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_BgRewriteAOF_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BgRewriteAOF_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_BgRewriteAOF_Call { + _c.Call.Return(run) + return _c +} + +// BgSave provides a mock function with given fields: ctx +func (_m *MockCmdable) BgSave(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for BgSave") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_BgSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BgSave' +type MockCmdable_BgSave_Call struct { + *mock.Call +} + +// BgSave is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) BgSave(ctx interface{}) *MockCmdable_BgSave_Call { + return &MockCmdable_BgSave_Call{Call: _e.mock.On("BgSave", ctx)} +} + +func (_c *MockCmdable_BgSave_Call) Run(run func(ctx context.Context)) *MockCmdable_BgSave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_BgSave_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_BgSave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BgSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_BgSave_Call { + _c.Call.Return(run) + return _c +} + +// BitCount provides a mock function with given fields: ctx, key, bitCount +func (_m *MockCmdable) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd { + ret := _m.Called(ctx, key, bitCount) + + if len(ret) == 0 { + panic("no return value specified for BitCount") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.BitCount) *redis.IntCmd); ok { + r0 = rf(ctx, key, bitCount) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_BitCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitCount' +type MockCmdable_BitCount_Call struct { + *mock.Call +} + +// BitCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - bitCount *redis.BitCount +func (_e *MockCmdable_Expecter) BitCount(ctx interface{}, key interface{}, bitCount interface{}) *MockCmdable_BitCount_Call { + return &MockCmdable_BitCount_Call{Call: _e.mock.On("BitCount", ctx, key, bitCount)} +} + +func (_c *MockCmdable_BitCount_Call) Run(run func(ctx context.Context, key string, bitCount *redis.BitCount)) *MockCmdable_BitCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.BitCount)) + }) + return _c +} + +func (_c *MockCmdable_BitCount_Call) Return(_a0 *redis.IntCmd) *MockCmdable_BitCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitCount_Call) RunAndReturn(run func(context.Context, string, *redis.BitCount) *redis.IntCmd) *MockCmdable_BitCount_Call { + _c.Call.Return(run) + return _c +} + +// BitField provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) BitField(ctx context.Context, key string, values ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BitField") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_BitField_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitField' +type MockCmdable_BitField_Call struct { + *mock.Call +} + +// BitField is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *MockCmdable_Expecter) BitField(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_BitField_Call { + return &MockCmdable_BitField_Call{Call: _e.mock.On("BitField", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_BitField_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *MockCmdable_BitField_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BitField_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_BitField_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitField_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntSliceCmd) *MockCmdable_BitField_Call { + _c.Call.Return(run) + return _c +} + +// BitFieldRO provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) BitFieldRO(ctx context.Context, key string, values ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BitFieldRO") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_BitFieldRO_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitFieldRO' +type MockCmdable_BitFieldRO_Call struct { + *mock.Call +} + +// BitFieldRO is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *MockCmdable_Expecter) BitFieldRO(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_BitFieldRO_Call { + return &MockCmdable_BitFieldRO_Call{Call: _e.mock.On("BitFieldRO", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_BitFieldRO_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *MockCmdable_BitFieldRO_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BitFieldRO_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_BitFieldRO_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitFieldRO_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntSliceCmd) *MockCmdable_BitFieldRO_Call { + _c.Call.Return(run) + return _c +} + +// BitOpAnd provides a mock function with given fields: ctx, destKey, keys +func (_m *MockCmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destKey) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BitOpAnd") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, destKey, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_BitOpAnd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitOpAnd' +type MockCmdable_BitOpAnd_Call struct { + *mock.Call +} + +// BitOpAnd is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - keys ...string +func (_e *MockCmdable_Expecter) BitOpAnd(ctx interface{}, destKey interface{}, keys ...interface{}) *MockCmdable_BitOpAnd_Call { + return &MockCmdable_BitOpAnd_Call{Call: _e.mock.On("BitOpAnd", + append([]interface{}{ctx, destKey}, keys...)...)} +} + +func (_c *MockCmdable_BitOpAnd_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *MockCmdable_BitOpAnd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BitOpAnd_Call) Return(_a0 *redis.IntCmd) *MockCmdable_BitOpAnd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitOpAnd_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_BitOpAnd_Call { + _c.Call.Return(run) + return _c +} + +// BitOpNot provides a mock function with given fields: ctx, destKey, key +func (_m *MockCmdable) BitOpNot(ctx context.Context, destKey string, key string) *redis.IntCmd { + ret := _m.Called(ctx, destKey, key) + + if len(ret) == 0 { + panic("no return value specified for BitOpNot") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, destKey, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_BitOpNot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitOpNot' +type MockCmdable_BitOpNot_Call struct { + *mock.Call +} + +// BitOpNot is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - key string +func (_e *MockCmdable_Expecter) BitOpNot(ctx interface{}, destKey interface{}, key interface{}) *MockCmdable_BitOpNot_Call { + return &MockCmdable_BitOpNot_Call{Call: _e.mock.On("BitOpNot", ctx, destKey, key)} +} + +func (_c *MockCmdable_BitOpNot_Call) Run(run func(ctx context.Context, destKey string, key string)) *MockCmdable_BitOpNot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_BitOpNot_Call) Return(_a0 *redis.IntCmd) *MockCmdable_BitOpNot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitOpNot_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_BitOpNot_Call { + _c.Call.Return(run) + return _c +} + +// BitOpOr provides a mock function with given fields: ctx, destKey, keys +func (_m *MockCmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destKey) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BitOpOr") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, destKey, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_BitOpOr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitOpOr' +type MockCmdable_BitOpOr_Call struct { + *mock.Call +} + +// BitOpOr is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - keys ...string +func (_e *MockCmdable_Expecter) BitOpOr(ctx interface{}, destKey interface{}, keys ...interface{}) *MockCmdable_BitOpOr_Call { + return &MockCmdable_BitOpOr_Call{Call: _e.mock.On("BitOpOr", + append([]interface{}{ctx, destKey}, keys...)...)} +} + +func (_c *MockCmdable_BitOpOr_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *MockCmdable_BitOpOr_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BitOpOr_Call) Return(_a0 *redis.IntCmd) *MockCmdable_BitOpOr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitOpOr_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_BitOpOr_Call { + _c.Call.Return(run) + return _c +} + +// BitOpXor provides a mock function with given fields: ctx, destKey, keys +func (_m *MockCmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destKey) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BitOpXor") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, destKey, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_BitOpXor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitOpXor' +type MockCmdable_BitOpXor_Call struct { + *mock.Call +} + +// BitOpXor is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - keys ...string +func (_e *MockCmdable_Expecter) BitOpXor(ctx interface{}, destKey interface{}, keys ...interface{}) *MockCmdable_BitOpXor_Call { + return &MockCmdable_BitOpXor_Call{Call: _e.mock.On("BitOpXor", + append([]interface{}{ctx, destKey}, keys...)...)} +} + +func (_c *MockCmdable_BitOpXor_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *MockCmdable_BitOpXor_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BitOpXor_Call) Return(_a0 *redis.IntCmd) *MockCmdable_BitOpXor_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitOpXor_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_BitOpXor_Call { + _c.Call.Return(run) + return _c +} + +// BitPos provides a mock function with given fields: ctx, key, bit, pos +func (_m *MockCmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd { + _va := make([]interface{}, len(pos)) + for _i := range pos { + _va[_i] = pos[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, bit) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BitPos") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, ...int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, bit, pos...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_BitPos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitPos' +type MockCmdable_BitPos_Call struct { + *mock.Call +} + +// BitPos is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - bit int64 +// - pos ...int64 +func (_e *MockCmdable_Expecter) BitPos(ctx interface{}, key interface{}, bit interface{}, pos ...interface{}) *MockCmdable_BitPos_Call { + return &MockCmdable_BitPos_Call{Call: _e.mock.On("BitPos", + append([]interface{}{ctx, key, bit}, pos...)...)} +} + +func (_c *MockCmdable_BitPos_Call) Run(run func(ctx context.Context, key string, bit int64, pos ...int64)) *MockCmdable_BitPos_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]int64, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(int64) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(int64), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_BitPos_Call) Return(_a0 *redis.IntCmd) *MockCmdable_BitPos_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitPos_Call) RunAndReturn(run func(context.Context, string, int64, ...int64) *redis.IntCmd) *MockCmdable_BitPos_Call { + _c.Call.Return(run) + return _c +} + +// BitPosSpan provides a mock function with given fields: ctx, key, bit, start, end, span +func (_m *MockCmdable) BitPosSpan(ctx context.Context, key string, bit int8, start int64, end int64, span string) *redis.IntCmd { + ret := _m.Called(ctx, key, bit, start, end, span) + + if len(ret) == 0 { + panic("no return value specified for BitPosSpan") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int8, int64, int64, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, bit, start, end, span) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_BitPosSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitPosSpan' +type MockCmdable_BitPosSpan_Call struct { + *mock.Call +} + +// BitPosSpan is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - bit int8 +// - start int64 +// - end int64 +// - span string +func (_e *MockCmdable_Expecter) BitPosSpan(ctx interface{}, key interface{}, bit interface{}, start interface{}, end interface{}, span interface{}) *MockCmdable_BitPosSpan_Call { + return &MockCmdable_BitPosSpan_Call{Call: _e.mock.On("BitPosSpan", ctx, key, bit, start, end, span)} +} + +func (_c *MockCmdable_BitPosSpan_Call) Run(run func(ctx context.Context, key string, bit int8, start int64, end int64, span string)) *MockCmdable_BitPosSpan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int8), args[3].(int64), args[4].(int64), args[5].(string)) + }) + return _c +} + +func (_c *MockCmdable_BitPosSpan_Call) Return(_a0 *redis.IntCmd) *MockCmdable_BitPosSpan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_BitPosSpan_Call) RunAndReturn(run func(context.Context, string, int8, int64, int64, string) *redis.IntCmd) *MockCmdable_BitPosSpan_Call { + _c.Call.Return(run) + return _c +} + +// CFAdd provides a mock function with given fields: ctx, key, element +func (_m *MockCmdable) CFAdd(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, key, element) + + if len(ret) == 0 { + panic("no return value specified for CFAdd") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, element) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_CFAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFAdd' +type MockCmdable_CFAdd_Call struct { + *mock.Call +} + +// CFAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - element interface{} +func (_e *MockCmdable_Expecter) CFAdd(ctx interface{}, key interface{}, element interface{}) *MockCmdable_CFAdd_Call { + return &MockCmdable_CFAdd_Call{Call: _e.mock.On("CFAdd", ctx, key, element)} +} + +func (_c *MockCmdable_CFAdd_Call) Run(run func(ctx context.Context, key string, element interface{})) *MockCmdable_CFAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_CFAdd_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_CFAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFAdd_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *MockCmdable_CFAdd_Call { + _c.Call.Return(run) + return _c +} + +// CFAddNX provides a mock function with given fields: ctx, key, element +func (_m *MockCmdable) CFAddNX(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, key, element) + + if len(ret) == 0 { + panic("no return value specified for CFAddNX") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, element) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_CFAddNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFAddNX' +type MockCmdable_CFAddNX_Call struct { + *mock.Call +} + +// CFAddNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - element interface{} +func (_e *MockCmdable_Expecter) CFAddNX(ctx interface{}, key interface{}, element interface{}) *MockCmdable_CFAddNX_Call { + return &MockCmdable_CFAddNX_Call{Call: _e.mock.On("CFAddNX", ctx, key, element)} +} + +func (_c *MockCmdable_CFAddNX_Call) Run(run func(ctx context.Context, key string, element interface{})) *MockCmdable_CFAddNX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_CFAddNX_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_CFAddNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFAddNX_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *MockCmdable_CFAddNX_Call { + _c.Call.Return(run) + return _c +} + +// CFCount provides a mock function with given fields: ctx, key, element +func (_m *MockCmdable) CFCount(ctx context.Context, key string, element interface{}) *redis.IntCmd { + ret := _m.Called(ctx, key, element) + + if len(ret) == 0 { + panic("no return value specified for CFCount") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, element) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_CFCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFCount' +type MockCmdable_CFCount_Call struct { + *mock.Call +} + +// CFCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - element interface{} +func (_e *MockCmdable_Expecter) CFCount(ctx interface{}, key interface{}, element interface{}) *MockCmdable_CFCount_Call { + return &MockCmdable_CFCount_Call{Call: _e.mock.On("CFCount", ctx, key, element)} +} + +func (_c *MockCmdable_CFCount_Call) Run(run func(ctx context.Context, key string, element interface{})) *MockCmdable_CFCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_CFCount_Call) Return(_a0 *redis.IntCmd) *MockCmdable_CFCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFCount_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.IntCmd) *MockCmdable_CFCount_Call { + _c.Call.Return(run) + return _c +} + +// CFDel provides a mock function with given fields: ctx, key, element +func (_m *MockCmdable) CFDel(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, key, element) + + if len(ret) == 0 { + panic("no return value specified for CFDel") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, element) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_CFDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFDel' +type MockCmdable_CFDel_Call struct { + *mock.Call +} + +// CFDel is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - element interface{} +func (_e *MockCmdable_Expecter) CFDel(ctx interface{}, key interface{}, element interface{}) *MockCmdable_CFDel_Call { + return &MockCmdable_CFDel_Call{Call: _e.mock.On("CFDel", ctx, key, element)} +} + +func (_c *MockCmdable_CFDel_Call) Run(run func(ctx context.Context, key string, element interface{})) *MockCmdable_CFDel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_CFDel_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_CFDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFDel_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *MockCmdable_CFDel_Call { + _c.Call.Return(run) + return _c +} + +// CFExists provides a mock function with given fields: ctx, key, element +func (_m *MockCmdable) CFExists(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, key, element) + + if len(ret) == 0 { + panic("no return value specified for CFExists") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, element) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_CFExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFExists' +type MockCmdable_CFExists_Call struct { + *mock.Call +} + +// CFExists is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - element interface{} +func (_e *MockCmdable_Expecter) CFExists(ctx interface{}, key interface{}, element interface{}) *MockCmdable_CFExists_Call { + return &MockCmdable_CFExists_Call{Call: _e.mock.On("CFExists", ctx, key, element)} +} + +func (_c *MockCmdable_CFExists_Call) Run(run func(ctx context.Context, key string, element interface{})) *MockCmdable_CFExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_CFExists_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_CFExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFExists_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *MockCmdable_CFExists_Call { + _c.Call.Return(run) + return _c +} + +// CFInfo provides a mock function with given fields: ctx, key +func (_m *MockCmdable) CFInfo(ctx context.Context, key string) *redis.CFInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for CFInfo") + } + + var r0 *redis.CFInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.CFInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.CFInfoCmd) + } + } + + return r0 +} + +// MockCmdable_CFInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFInfo' +type MockCmdable_CFInfo_Call struct { + *mock.Call +} + +// CFInfo is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) CFInfo(ctx interface{}, key interface{}) *MockCmdable_CFInfo_Call { + return &MockCmdable_CFInfo_Call{Call: _e.mock.On("CFInfo", ctx, key)} +} + +func (_c *MockCmdable_CFInfo_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_CFInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_CFInfo_Call) Return(_a0 *redis.CFInfoCmd) *MockCmdable_CFInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFInfo_Call) RunAndReturn(run func(context.Context, string) *redis.CFInfoCmd) *MockCmdable_CFInfo_Call { + _c.Call.Return(run) + return _c +} + +// CFInsert provides a mock function with given fields: ctx, key, options, elements +func (_m *MockCmdable) CFInsert(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...interface{}) *redis.BoolSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key, options) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CFInsert") + } + + var r0 *redis.BoolSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.CFInsertOptions, ...interface{}) *redis.BoolSliceCmd); ok { + r0 = rf(ctx, key, options, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolSliceCmd) + } + } + + return r0 +} + +// MockCmdable_CFInsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFInsert' +type MockCmdable_CFInsert_Call struct { + *mock.Call +} + +// CFInsert is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.CFInsertOptions +// - elements ...interface{} +func (_e *MockCmdable_Expecter) CFInsert(ctx interface{}, key interface{}, options interface{}, elements ...interface{}) *MockCmdable_CFInsert_Call { + return &MockCmdable_CFInsert_Call{Call: _e.mock.On("CFInsert", + append([]interface{}{ctx, key, options}, elements...)...)} +} + +func (_c *MockCmdable_CFInsert_Call) Run(run func(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...interface{})) *MockCmdable_CFInsert_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*redis.CFInsertOptions), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_CFInsert_Call) Return(_a0 *redis.BoolSliceCmd) *MockCmdable_CFInsert_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFInsert_Call) RunAndReturn(run func(context.Context, string, *redis.CFInsertOptions, ...interface{}) *redis.BoolSliceCmd) *MockCmdable_CFInsert_Call { + _c.Call.Return(run) + return _c +} + +// CFInsertNX provides a mock function with given fields: ctx, key, options, elements +func (_m *MockCmdable) CFInsertNX(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key, options) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CFInsertNX") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.CFInsertOptions, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, options, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_CFInsertNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFInsertNX' +type MockCmdable_CFInsertNX_Call struct { + *mock.Call +} + +// CFInsertNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.CFInsertOptions +// - elements ...interface{} +func (_e *MockCmdable_Expecter) CFInsertNX(ctx interface{}, key interface{}, options interface{}, elements ...interface{}) *MockCmdable_CFInsertNX_Call { + return &MockCmdable_CFInsertNX_Call{Call: _e.mock.On("CFInsertNX", + append([]interface{}{ctx, key, options}, elements...)...)} +} + +func (_c *MockCmdable_CFInsertNX_Call) Run(run func(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...interface{})) *MockCmdable_CFInsertNX_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*redis.CFInsertOptions), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_CFInsertNX_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_CFInsertNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFInsertNX_Call) RunAndReturn(run func(context.Context, string, *redis.CFInsertOptions, ...interface{}) *redis.IntSliceCmd) *MockCmdable_CFInsertNX_Call { + _c.Call.Return(run) + return _c +} + +// CFLoadChunk provides a mock function with given fields: ctx, key, iterator, data +func (_m *MockCmdable) CFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *redis.StatusCmd { + ret := _m.Called(ctx, key, iterator, data) + + if len(ret) == 0 { + panic("no return value specified for CFLoadChunk") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, key, iterator, data) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CFLoadChunk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFLoadChunk' +type MockCmdable_CFLoadChunk_Call struct { + *mock.Call +} + +// CFLoadChunk is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - iterator int64 +// - data interface{} +func (_e *MockCmdable_Expecter) CFLoadChunk(ctx interface{}, key interface{}, iterator interface{}, data interface{}) *MockCmdable_CFLoadChunk_Call { + return &MockCmdable_CFLoadChunk_Call{Call: _e.mock.On("CFLoadChunk", ctx, key, iterator, data)} +} + +func (_c *MockCmdable_CFLoadChunk_Call) Run(run func(ctx context.Context, key string, iterator int64, data interface{})) *MockCmdable_CFLoadChunk_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_CFLoadChunk_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CFLoadChunk_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFLoadChunk_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) *redis.StatusCmd) *MockCmdable_CFLoadChunk_Call { + _c.Call.Return(run) + return _c +} + +// CFMExists provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) CFMExists(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CFMExists") + } + + var r0 *redis.BoolSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.BoolSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolSliceCmd) + } + } + + return r0 +} + +// MockCmdable_CFMExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFMExists' +type MockCmdable_CFMExists_Call struct { + *mock.Call +} + +// CFMExists is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) CFMExists(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_CFMExists_Call { + return &MockCmdable_CFMExists_Call{Call: _e.mock.On("CFMExists", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_CFMExists_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_CFMExists_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_CFMExists_Call) Return(_a0 *redis.BoolSliceCmd) *MockCmdable_CFMExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFMExists_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolSliceCmd) *MockCmdable_CFMExists_Call { + _c.Call.Return(run) + return _c +} + +// CFReserve provides a mock function with given fields: ctx, key, capacity +func (_m *MockCmdable) CFReserve(ctx context.Context, key string, capacity int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, capacity) + + if len(ret) == 0 { + panic("no return value specified for CFReserve") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, capacity) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CFReserve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFReserve' +type MockCmdable_CFReserve_Call struct { + *mock.Call +} + +// CFReserve is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - capacity int64 +func (_e *MockCmdable_Expecter) CFReserve(ctx interface{}, key interface{}, capacity interface{}) *MockCmdable_CFReserve_Call { + return &MockCmdable_CFReserve_Call{Call: _e.mock.On("CFReserve", ctx, key, capacity)} +} + +func (_c *MockCmdable_CFReserve_Call) Run(run func(ctx context.Context, key string, capacity int64)) *MockCmdable_CFReserve_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_CFReserve_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CFReserve_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFReserve_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StatusCmd) *MockCmdable_CFReserve_Call { + _c.Call.Return(run) + return _c +} + +// CFReserveBucketSize provides a mock function with given fields: ctx, key, capacity, bucketsize +func (_m *MockCmdable) CFReserveBucketSize(ctx context.Context, key string, capacity int64, bucketsize int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, capacity, bucketsize) + + if len(ret) == 0 { + panic("no return value specified for CFReserveBucketSize") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, capacity, bucketsize) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CFReserveBucketSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFReserveBucketSize' +type MockCmdable_CFReserveBucketSize_Call struct { + *mock.Call +} + +// CFReserveBucketSize is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - capacity int64 +// - bucketsize int64 +func (_e *MockCmdable_Expecter) CFReserveBucketSize(ctx interface{}, key interface{}, capacity interface{}, bucketsize interface{}) *MockCmdable_CFReserveBucketSize_Call { + return &MockCmdable_CFReserveBucketSize_Call{Call: _e.mock.On("CFReserveBucketSize", ctx, key, capacity, bucketsize)} +} + +func (_c *MockCmdable_CFReserveBucketSize_Call) Run(run func(ctx context.Context, key string, capacity int64, bucketsize int64)) *MockCmdable_CFReserveBucketSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_CFReserveBucketSize_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CFReserveBucketSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFReserveBucketSize_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StatusCmd) *MockCmdable_CFReserveBucketSize_Call { + _c.Call.Return(run) + return _c +} + +// CFReserveExpansion provides a mock function with given fields: ctx, key, capacity, expansion +func (_m *MockCmdable) CFReserveExpansion(ctx context.Context, key string, capacity int64, expansion int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, capacity, expansion) + + if len(ret) == 0 { + panic("no return value specified for CFReserveExpansion") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, capacity, expansion) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CFReserveExpansion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFReserveExpansion' +type MockCmdable_CFReserveExpansion_Call struct { + *mock.Call +} + +// CFReserveExpansion is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - capacity int64 +// - expansion int64 +func (_e *MockCmdable_Expecter) CFReserveExpansion(ctx interface{}, key interface{}, capacity interface{}, expansion interface{}) *MockCmdable_CFReserveExpansion_Call { + return &MockCmdable_CFReserveExpansion_Call{Call: _e.mock.On("CFReserveExpansion", ctx, key, capacity, expansion)} +} + +func (_c *MockCmdable_CFReserveExpansion_Call) Run(run func(ctx context.Context, key string, capacity int64, expansion int64)) *MockCmdable_CFReserveExpansion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_CFReserveExpansion_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CFReserveExpansion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFReserveExpansion_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StatusCmd) *MockCmdable_CFReserveExpansion_Call { + _c.Call.Return(run) + return _c +} + +// CFReserveMaxIterations provides a mock function with given fields: ctx, key, capacity, maxiterations +func (_m *MockCmdable) CFReserveMaxIterations(ctx context.Context, key string, capacity int64, maxiterations int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, capacity, maxiterations) + + if len(ret) == 0 { + panic("no return value specified for CFReserveMaxIterations") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, capacity, maxiterations) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CFReserveMaxIterations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFReserveMaxIterations' +type MockCmdable_CFReserveMaxIterations_Call struct { + *mock.Call +} + +// CFReserveMaxIterations is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - capacity int64 +// - maxiterations int64 +func (_e *MockCmdable_Expecter) CFReserveMaxIterations(ctx interface{}, key interface{}, capacity interface{}, maxiterations interface{}) *MockCmdable_CFReserveMaxIterations_Call { + return &MockCmdable_CFReserveMaxIterations_Call{Call: _e.mock.On("CFReserveMaxIterations", ctx, key, capacity, maxiterations)} +} + +func (_c *MockCmdable_CFReserveMaxIterations_Call) Run(run func(ctx context.Context, key string, capacity int64, maxiterations int64)) *MockCmdable_CFReserveMaxIterations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_CFReserveMaxIterations_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CFReserveMaxIterations_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFReserveMaxIterations_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StatusCmd) *MockCmdable_CFReserveMaxIterations_Call { + _c.Call.Return(run) + return _c +} + +// CFReserveWithArgs provides a mock function with given fields: ctx, key, options +func (_m *MockCmdable) CFReserveWithArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd { + ret := _m.Called(ctx, key, options) + + if len(ret) == 0 { + panic("no return value specified for CFReserveWithArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.CFReserveOptions) *redis.StatusCmd); ok { + r0 = rf(ctx, key, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CFReserveWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFReserveWithArgs' +type MockCmdable_CFReserveWithArgs_Call struct { + *mock.Call +} + +// CFReserveWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.CFReserveOptions +func (_e *MockCmdable_Expecter) CFReserveWithArgs(ctx interface{}, key interface{}, options interface{}) *MockCmdable_CFReserveWithArgs_Call { + return &MockCmdable_CFReserveWithArgs_Call{Call: _e.mock.On("CFReserveWithArgs", ctx, key, options)} +} + +func (_c *MockCmdable_CFReserveWithArgs_Call) Run(run func(ctx context.Context, key string, options *redis.CFReserveOptions)) *MockCmdable_CFReserveWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.CFReserveOptions)) + }) + return _c +} + +func (_c *MockCmdable_CFReserveWithArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CFReserveWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFReserveWithArgs_Call) RunAndReturn(run func(context.Context, string, *redis.CFReserveOptions) *redis.StatusCmd) *MockCmdable_CFReserveWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// CFScanDump provides a mock function with given fields: ctx, key, iterator +func (_m *MockCmdable) CFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + ret := _m.Called(ctx, key, iterator) + + if len(ret) == 0 { + panic("no return value specified for CFScanDump") + } + + var r0 *redis.ScanDumpCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.ScanDumpCmd); ok { + r0 = rf(ctx, key, iterator) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ScanDumpCmd) + } + } + + return r0 +} + +// MockCmdable_CFScanDump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CFScanDump' +type MockCmdable_CFScanDump_Call struct { + *mock.Call +} + +// CFScanDump is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - iterator int64 +func (_e *MockCmdable_Expecter) CFScanDump(ctx interface{}, key interface{}, iterator interface{}) *MockCmdable_CFScanDump_Call { + return &MockCmdable_CFScanDump_Call{Call: _e.mock.On("CFScanDump", ctx, key, iterator)} +} + +func (_c *MockCmdable_CFScanDump_Call) Run(run func(ctx context.Context, key string, iterator int64)) *MockCmdable_CFScanDump_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_CFScanDump_Call) Return(_a0 *redis.ScanDumpCmd) *MockCmdable_CFScanDump_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CFScanDump_Call) RunAndReturn(run func(context.Context, string, int64) *redis.ScanDumpCmd) *MockCmdable_CFScanDump_Call { + _c.Call.Return(run) + return _c +} + +// CMSIncrBy provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) CMSIncrBy(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CMSIncrBy") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_CMSIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CMSIncrBy' +type MockCmdable_CMSIncrBy_Call struct { + *mock.Call +} + +// CMSIncrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) CMSIncrBy(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_CMSIncrBy_Call { + return &MockCmdable_CMSIncrBy_Call{Call: _e.mock.On("CMSIncrBy", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_CMSIncrBy_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_CMSIncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_CMSIncrBy_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_CMSIncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CMSIncrBy_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntSliceCmd) *MockCmdable_CMSIncrBy_Call { + _c.Call.Return(run) + return _c +} + +// CMSInfo provides a mock function with given fields: ctx, key +func (_m *MockCmdable) CMSInfo(ctx context.Context, key string) *redis.CMSInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for CMSInfo") + } + + var r0 *redis.CMSInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.CMSInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.CMSInfoCmd) + } + } + + return r0 +} + +// MockCmdable_CMSInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CMSInfo' +type MockCmdable_CMSInfo_Call struct { + *mock.Call +} + +// CMSInfo is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) CMSInfo(ctx interface{}, key interface{}) *MockCmdable_CMSInfo_Call { + return &MockCmdable_CMSInfo_Call{Call: _e.mock.On("CMSInfo", ctx, key)} +} + +func (_c *MockCmdable_CMSInfo_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_CMSInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_CMSInfo_Call) Return(_a0 *redis.CMSInfoCmd) *MockCmdable_CMSInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CMSInfo_Call) RunAndReturn(run func(context.Context, string) *redis.CMSInfoCmd) *MockCmdable_CMSInfo_Call { + _c.Call.Return(run) + return _c +} + +// CMSInitByDim provides a mock function with given fields: ctx, key, width, height +func (_m *MockCmdable) CMSInitByDim(ctx context.Context, key string, width int64, height int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, width, height) + + if len(ret) == 0 { + panic("no return value specified for CMSInitByDim") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, width, height) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CMSInitByDim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CMSInitByDim' +type MockCmdable_CMSInitByDim_Call struct { + *mock.Call +} + +// CMSInitByDim is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - width int64 +// - height int64 +func (_e *MockCmdable_Expecter) CMSInitByDim(ctx interface{}, key interface{}, width interface{}, height interface{}) *MockCmdable_CMSInitByDim_Call { + return &MockCmdable_CMSInitByDim_Call{Call: _e.mock.On("CMSInitByDim", ctx, key, width, height)} +} + +func (_c *MockCmdable_CMSInitByDim_Call) Run(run func(ctx context.Context, key string, width int64, height int64)) *MockCmdable_CMSInitByDim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_CMSInitByDim_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CMSInitByDim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CMSInitByDim_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StatusCmd) *MockCmdable_CMSInitByDim_Call { + _c.Call.Return(run) + return _c +} + +// CMSInitByProb provides a mock function with given fields: ctx, key, errorRate, probability +func (_m *MockCmdable) CMSInitByProb(ctx context.Context, key string, errorRate float64, probability float64) *redis.StatusCmd { + ret := _m.Called(ctx, key, errorRate, probability) + + if len(ret) == 0 { + panic("no return value specified for CMSInitByProb") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, float64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, errorRate, probability) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CMSInitByProb_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CMSInitByProb' +type MockCmdable_CMSInitByProb_Call struct { + *mock.Call +} + +// CMSInitByProb is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - errorRate float64 +// - probability float64 +func (_e *MockCmdable_Expecter) CMSInitByProb(ctx interface{}, key interface{}, errorRate interface{}, probability interface{}) *MockCmdable_CMSInitByProb_Call { + return &MockCmdable_CMSInitByProb_Call{Call: _e.mock.On("CMSInitByProb", ctx, key, errorRate, probability)} +} + +func (_c *MockCmdable_CMSInitByProb_Call) Run(run func(ctx context.Context, key string, errorRate float64, probability float64)) *MockCmdable_CMSInitByProb_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(float64)) + }) + return _c +} + +func (_c *MockCmdable_CMSInitByProb_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CMSInitByProb_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CMSInitByProb_Call) RunAndReturn(run func(context.Context, string, float64, float64) *redis.StatusCmd) *MockCmdable_CMSInitByProb_Call { + _c.Call.Return(run) + return _c +} + +// CMSMerge provides a mock function with given fields: ctx, destKey, sourceKeys +func (_m *MockCmdable) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *redis.StatusCmd { + _va := make([]interface{}, len(sourceKeys)) + for _i := range sourceKeys { + _va[_i] = sourceKeys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destKey) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CMSMerge") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.StatusCmd); ok { + r0 = rf(ctx, destKey, sourceKeys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CMSMerge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CMSMerge' +type MockCmdable_CMSMerge_Call struct { + *mock.Call +} + +// CMSMerge is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - sourceKeys ...string +func (_e *MockCmdable_Expecter) CMSMerge(ctx interface{}, destKey interface{}, sourceKeys ...interface{}) *MockCmdable_CMSMerge_Call { + return &MockCmdable_CMSMerge_Call{Call: _e.mock.On("CMSMerge", + append([]interface{}{ctx, destKey}, sourceKeys...)...)} +} + +func (_c *MockCmdable_CMSMerge_Call) Run(run func(ctx context.Context, destKey string, sourceKeys ...string)) *MockCmdable_CMSMerge_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_CMSMerge_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CMSMerge_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CMSMerge_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.StatusCmd) *MockCmdable_CMSMerge_Call { + _c.Call.Return(run) + return _c +} + +// CMSMergeWithWeight provides a mock function with given fields: ctx, destKey, sourceKeys +func (_m *MockCmdable) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *redis.StatusCmd { + ret := _m.Called(ctx, destKey, sourceKeys) + + if len(ret) == 0 { + panic("no return value specified for CMSMergeWithWeight") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, map[string]int64) *redis.StatusCmd); ok { + r0 = rf(ctx, destKey, sourceKeys) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_CMSMergeWithWeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CMSMergeWithWeight' +type MockCmdable_CMSMergeWithWeight_Call struct { + *mock.Call +} + +// CMSMergeWithWeight is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - sourceKeys map[string]int64 +func (_e *MockCmdable_Expecter) CMSMergeWithWeight(ctx interface{}, destKey interface{}, sourceKeys interface{}) *MockCmdable_CMSMergeWithWeight_Call { + return &MockCmdable_CMSMergeWithWeight_Call{Call: _e.mock.On("CMSMergeWithWeight", ctx, destKey, sourceKeys)} +} + +func (_c *MockCmdable_CMSMergeWithWeight_Call) Run(run func(ctx context.Context, destKey string, sourceKeys map[string]int64)) *MockCmdable_CMSMergeWithWeight_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(map[string]int64)) + }) + return _c +} + +func (_c *MockCmdable_CMSMergeWithWeight_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_CMSMergeWithWeight_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CMSMergeWithWeight_Call) RunAndReturn(run func(context.Context, string, map[string]int64) *redis.StatusCmd) *MockCmdable_CMSMergeWithWeight_Call { + _c.Call.Return(run) + return _c +} + +// CMSQuery provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) CMSQuery(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CMSQuery") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_CMSQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CMSQuery' +type MockCmdable_CMSQuery_Call struct { + *mock.Call +} + +// CMSQuery is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) CMSQuery(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_CMSQuery_Call { + return &MockCmdable_CMSQuery_Call{Call: _e.mock.On("CMSQuery", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_CMSQuery_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_CMSQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_CMSQuery_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_CMSQuery_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CMSQuery_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntSliceCmd) *MockCmdable_CMSQuery_Call { + _c.Call.Return(run) + return _c +} + +// ClientGetName provides a mock function with given fields: ctx +func (_m *MockCmdable) ClientGetName(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClientGetName") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ClientGetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientGetName' +type MockCmdable_ClientGetName_Call struct { + *mock.Call +} + +// ClientGetName is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClientGetName(ctx interface{}) *MockCmdable_ClientGetName_Call { + return &MockCmdable_ClientGetName_Call{Call: _e.mock.On("ClientGetName", ctx)} +} + +func (_c *MockCmdable_ClientGetName_Call) Run(run func(ctx context.Context)) *MockCmdable_ClientGetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClientGetName_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ClientGetName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientGetName_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_ClientGetName_Call { + _c.Call.Return(run) + return _c +} + +// ClientID provides a mock function with given fields: ctx +func (_m *MockCmdable) ClientID(ctx context.Context) *redis.IntCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClientID") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.IntCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ClientID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientID' +type MockCmdable_ClientID_Call struct { + *mock.Call +} + +// ClientID is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClientID(ctx interface{}) *MockCmdable_ClientID_Call { + return &MockCmdable_ClientID_Call{Call: _e.mock.On("ClientID", ctx)} +} + +func (_c *MockCmdable_ClientID_Call) Run(run func(ctx context.Context)) *MockCmdable_ClientID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClientID_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ClientID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientID_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *MockCmdable_ClientID_Call { + _c.Call.Return(run) + return _c +} + +// ClientInfo provides a mock function with given fields: ctx +func (_m *MockCmdable) ClientInfo(ctx context.Context) *redis.ClientInfoCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClientInfo") + } + + var r0 *redis.ClientInfoCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.ClientInfoCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ClientInfoCmd) + } + } + + return r0 +} + +// MockCmdable_ClientInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientInfo' +type MockCmdable_ClientInfo_Call struct { + *mock.Call +} + +// ClientInfo is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClientInfo(ctx interface{}) *MockCmdable_ClientInfo_Call { + return &MockCmdable_ClientInfo_Call{Call: _e.mock.On("ClientInfo", ctx)} +} + +func (_c *MockCmdable_ClientInfo_Call) Run(run func(ctx context.Context)) *MockCmdable_ClientInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClientInfo_Call) Return(_a0 *redis.ClientInfoCmd) *MockCmdable_ClientInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientInfo_Call) RunAndReturn(run func(context.Context) *redis.ClientInfoCmd) *MockCmdable_ClientInfo_Call { + _c.Call.Return(run) + return _c +} + +// ClientKill provides a mock function with given fields: ctx, ipPort +func (_m *MockCmdable) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd { + ret := _m.Called(ctx, ipPort) + + if len(ret) == 0 { + panic("no return value specified for ClientKill") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, ipPort) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClientKill_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientKill' +type MockCmdable_ClientKill_Call struct { + *mock.Call +} + +// ClientKill is a helper method to define mock.On call +// - ctx context.Context +// - ipPort string +func (_e *MockCmdable_Expecter) ClientKill(ctx interface{}, ipPort interface{}) *MockCmdable_ClientKill_Call { + return &MockCmdable_ClientKill_Call{Call: _e.mock.On("ClientKill", ctx, ipPort)} +} + +func (_c *MockCmdable_ClientKill_Call) Run(run func(ctx context.Context, ipPort string)) *MockCmdable_ClientKill_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ClientKill_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClientKill_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientKill_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_ClientKill_Call { + _c.Call.Return(run) + return _c +} + +// ClientKillByFilter provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ClientKillByFilter") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ClientKillByFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientKillByFilter' +type MockCmdable_ClientKillByFilter_Call struct { + *mock.Call +} + +// ClientKillByFilter is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) ClientKillByFilter(ctx interface{}, keys ...interface{}) *MockCmdable_ClientKillByFilter_Call { + return &MockCmdable_ClientKillByFilter_Call{Call: _e.mock.On("ClientKillByFilter", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_ClientKillByFilter_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_ClientKillByFilter_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ClientKillByFilter_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ClientKillByFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientKillByFilter_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *MockCmdable_ClientKillByFilter_Call { + _c.Call.Return(run) + return _c +} + +// ClientList provides a mock function with given fields: ctx +func (_m *MockCmdable) ClientList(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClientList") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ClientList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientList' +type MockCmdable_ClientList_Call struct { + *mock.Call +} + +// ClientList is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClientList(ctx interface{}) *MockCmdable_ClientList_Call { + return &MockCmdable_ClientList_Call{Call: _e.mock.On("ClientList", ctx)} +} + +func (_c *MockCmdable_ClientList_Call) Run(run func(ctx context.Context)) *MockCmdable_ClientList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClientList_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ClientList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientList_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_ClientList_Call { + _c.Call.Return(run) + return _c +} + +// ClientPause provides a mock function with given fields: ctx, dur +func (_m *MockCmdable) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, dur) + + if len(ret) == 0 { + panic("no return value specified for ClientPause") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, dur) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_ClientPause_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientPause' +type MockCmdable_ClientPause_Call struct { + *mock.Call +} + +// ClientPause is a helper method to define mock.On call +// - ctx context.Context +// - dur time.Duration +func (_e *MockCmdable_Expecter) ClientPause(ctx interface{}, dur interface{}) *MockCmdable_ClientPause_Call { + return &MockCmdable_ClientPause_Call{Call: _e.mock.On("ClientPause", ctx, dur)} +} + +func (_c *MockCmdable_ClientPause_Call) Run(run func(ctx context.Context, dur time.Duration)) *MockCmdable_ClientPause_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_ClientPause_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_ClientPause_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientPause_Call) RunAndReturn(run func(context.Context, time.Duration) *redis.BoolCmd) *MockCmdable_ClientPause_Call { + _c.Call.Return(run) + return _c +} + +// ClientUnblock provides a mock function with given fields: ctx, id +func (_m *MockCmdable) ClientUnblock(ctx context.Context, id int64) *redis.IntCmd { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for ClientUnblock") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, int64) *redis.IntCmd); ok { + r0 = rf(ctx, id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ClientUnblock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientUnblock' +type MockCmdable_ClientUnblock_Call struct { + *mock.Call +} + +// ClientUnblock is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +func (_e *MockCmdable_Expecter) ClientUnblock(ctx interface{}, id interface{}) *MockCmdable_ClientUnblock_Call { + return &MockCmdable_ClientUnblock_Call{Call: _e.mock.On("ClientUnblock", ctx, id)} +} + +func (_c *MockCmdable_ClientUnblock_Call) Run(run func(ctx context.Context, id int64)) *MockCmdable_ClientUnblock_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ClientUnblock_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ClientUnblock_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientUnblock_Call) RunAndReturn(run func(context.Context, int64) *redis.IntCmd) *MockCmdable_ClientUnblock_Call { + _c.Call.Return(run) + return _c +} + +// ClientUnblockWithError provides a mock function with given fields: ctx, id +func (_m *MockCmdable) ClientUnblockWithError(ctx context.Context, id int64) *redis.IntCmd { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for ClientUnblockWithError") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, int64) *redis.IntCmd); ok { + r0 = rf(ctx, id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ClientUnblockWithError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientUnblockWithError' +type MockCmdable_ClientUnblockWithError_Call struct { + *mock.Call +} + +// ClientUnblockWithError is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +func (_e *MockCmdable_Expecter) ClientUnblockWithError(ctx interface{}, id interface{}) *MockCmdable_ClientUnblockWithError_Call { + return &MockCmdable_ClientUnblockWithError_Call{Call: _e.mock.On("ClientUnblockWithError", ctx, id)} +} + +func (_c *MockCmdable_ClientUnblockWithError_Call) Run(run func(ctx context.Context, id int64)) *MockCmdable_ClientUnblockWithError_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ClientUnblockWithError_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ClientUnblockWithError_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientUnblockWithError_Call) RunAndReturn(run func(context.Context, int64) *redis.IntCmd) *MockCmdable_ClientUnblockWithError_Call { + _c.Call.Return(run) + return _c +} + +// ClientUnpause provides a mock function with given fields: ctx +func (_m *MockCmdable) ClientUnpause(ctx context.Context) *redis.BoolCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClientUnpause") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.BoolCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_ClientUnpause_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientUnpause' +type MockCmdable_ClientUnpause_Call struct { + *mock.Call +} + +// ClientUnpause is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClientUnpause(ctx interface{}) *MockCmdable_ClientUnpause_Call { + return &MockCmdable_ClientUnpause_Call{Call: _e.mock.On("ClientUnpause", ctx)} +} + +func (_c *MockCmdable_ClientUnpause_Call) Run(run func(ctx context.Context)) *MockCmdable_ClientUnpause_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClientUnpause_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_ClientUnpause_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClientUnpause_Call) RunAndReturn(run func(context.Context) *redis.BoolCmd) *MockCmdable_ClientUnpause_Call { + _c.Call.Return(run) + return _c +} + +// ClusterAddSlots provides a mock function with given fields: ctx, slots +func (_m *MockCmdable) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + _va := make([]interface{}, len(slots)) + for _i := range slots { + _va[_i] = slots[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ClusterAddSlots") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, ...int) *redis.StatusCmd); ok { + r0 = rf(ctx, slots...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterAddSlots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterAddSlots' +type MockCmdable_ClusterAddSlots_Call struct { + *mock.Call +} + +// ClusterAddSlots is a helper method to define mock.On call +// - ctx context.Context +// - slots ...int +func (_e *MockCmdable_Expecter) ClusterAddSlots(ctx interface{}, slots ...interface{}) *MockCmdable_ClusterAddSlots_Call { + return &MockCmdable_ClusterAddSlots_Call{Call: _e.mock.On("ClusterAddSlots", + append([]interface{}{ctx}, slots...)...)} +} + +func (_c *MockCmdable_ClusterAddSlots_Call) Run(run func(ctx context.Context, slots ...int)) *MockCmdable_ClusterAddSlots_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]int, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(int) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ClusterAddSlots_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterAddSlots_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterAddSlots_Call) RunAndReturn(run func(context.Context, ...int) *redis.StatusCmd) *MockCmdable_ClusterAddSlots_Call { + _c.Call.Return(run) + return _c +} + +// ClusterAddSlotsRange provides a mock function with given fields: ctx, min, max +func (_m *MockCmdable) ClusterAddSlotsRange(ctx context.Context, min int, max int) *redis.StatusCmd { + ret := _m.Called(ctx, min, max) + + if len(ret) == 0 { + panic("no return value specified for ClusterAddSlotsRange") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, int, int) *redis.StatusCmd); ok { + r0 = rf(ctx, min, max) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterAddSlotsRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterAddSlotsRange' +type MockCmdable_ClusterAddSlotsRange_Call struct { + *mock.Call +} + +// ClusterAddSlotsRange is a helper method to define mock.On call +// - ctx context.Context +// - min int +// - max int +func (_e *MockCmdable_Expecter) ClusterAddSlotsRange(ctx interface{}, min interface{}, max interface{}) *MockCmdable_ClusterAddSlotsRange_Call { + return &MockCmdable_ClusterAddSlotsRange_Call{Call: _e.mock.On("ClusterAddSlotsRange", ctx, min, max)} +} + +func (_c *MockCmdable_ClusterAddSlotsRange_Call) Run(run func(ctx context.Context, min int, max int)) *MockCmdable_ClusterAddSlotsRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_ClusterAddSlotsRange_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterAddSlotsRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterAddSlotsRange_Call) RunAndReturn(run func(context.Context, int, int) *redis.StatusCmd) *MockCmdable_ClusterAddSlotsRange_Call { + _c.Call.Return(run) + return _c +} + +// ClusterCountFailureReports provides a mock function with given fields: ctx, nodeID +func (_m *MockCmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd { + ret := _m.Called(ctx, nodeID) + + if len(ret) == 0 { + panic("no return value specified for ClusterCountFailureReports") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, nodeID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterCountFailureReports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterCountFailureReports' +type MockCmdable_ClusterCountFailureReports_Call struct { + *mock.Call +} + +// ClusterCountFailureReports is a helper method to define mock.On call +// - ctx context.Context +// - nodeID string +func (_e *MockCmdable_Expecter) ClusterCountFailureReports(ctx interface{}, nodeID interface{}) *MockCmdable_ClusterCountFailureReports_Call { + return &MockCmdable_ClusterCountFailureReports_Call{Call: _e.mock.On("ClusterCountFailureReports", ctx, nodeID)} +} + +func (_c *MockCmdable_ClusterCountFailureReports_Call) Run(run func(ctx context.Context, nodeID string)) *MockCmdable_ClusterCountFailureReports_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ClusterCountFailureReports_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ClusterCountFailureReports_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterCountFailureReports_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_ClusterCountFailureReports_Call { + _c.Call.Return(run) + return _c +} + +// ClusterCountKeysInSlot provides a mock function with given fields: ctx, slot +func (_m *MockCmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd { + ret := _m.Called(ctx, slot) + + if len(ret) == 0 { + panic("no return value specified for ClusterCountKeysInSlot") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, int) *redis.IntCmd); ok { + r0 = rf(ctx, slot) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterCountKeysInSlot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterCountKeysInSlot' +type MockCmdable_ClusterCountKeysInSlot_Call struct { + *mock.Call +} + +// ClusterCountKeysInSlot is a helper method to define mock.On call +// - ctx context.Context +// - slot int +func (_e *MockCmdable_Expecter) ClusterCountKeysInSlot(ctx interface{}, slot interface{}) *MockCmdable_ClusterCountKeysInSlot_Call { + return &MockCmdable_ClusterCountKeysInSlot_Call{Call: _e.mock.On("ClusterCountKeysInSlot", ctx, slot)} +} + +func (_c *MockCmdable_ClusterCountKeysInSlot_Call) Run(run func(ctx context.Context, slot int)) *MockCmdable_ClusterCountKeysInSlot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int)) + }) + return _c +} + +func (_c *MockCmdable_ClusterCountKeysInSlot_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ClusterCountKeysInSlot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterCountKeysInSlot_Call) RunAndReturn(run func(context.Context, int) *redis.IntCmd) *MockCmdable_ClusterCountKeysInSlot_Call { + _c.Call.Return(run) + return _c +} + +// ClusterDelSlots provides a mock function with given fields: ctx, slots +func (_m *MockCmdable) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + _va := make([]interface{}, len(slots)) + for _i := range slots { + _va[_i] = slots[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ClusterDelSlots") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, ...int) *redis.StatusCmd); ok { + r0 = rf(ctx, slots...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterDelSlots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterDelSlots' +type MockCmdable_ClusterDelSlots_Call struct { + *mock.Call +} + +// ClusterDelSlots is a helper method to define mock.On call +// - ctx context.Context +// - slots ...int +func (_e *MockCmdable_Expecter) ClusterDelSlots(ctx interface{}, slots ...interface{}) *MockCmdable_ClusterDelSlots_Call { + return &MockCmdable_ClusterDelSlots_Call{Call: _e.mock.On("ClusterDelSlots", + append([]interface{}{ctx}, slots...)...)} +} + +func (_c *MockCmdable_ClusterDelSlots_Call) Run(run func(ctx context.Context, slots ...int)) *MockCmdable_ClusterDelSlots_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]int, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(int) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ClusterDelSlots_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterDelSlots_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterDelSlots_Call) RunAndReturn(run func(context.Context, ...int) *redis.StatusCmd) *MockCmdable_ClusterDelSlots_Call { + _c.Call.Return(run) + return _c +} + +// ClusterDelSlotsRange provides a mock function with given fields: ctx, min, max +func (_m *MockCmdable) ClusterDelSlotsRange(ctx context.Context, min int, max int) *redis.StatusCmd { + ret := _m.Called(ctx, min, max) + + if len(ret) == 0 { + panic("no return value specified for ClusterDelSlotsRange") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, int, int) *redis.StatusCmd); ok { + r0 = rf(ctx, min, max) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterDelSlotsRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterDelSlotsRange' +type MockCmdable_ClusterDelSlotsRange_Call struct { + *mock.Call +} + +// ClusterDelSlotsRange is a helper method to define mock.On call +// - ctx context.Context +// - min int +// - max int +func (_e *MockCmdable_Expecter) ClusterDelSlotsRange(ctx interface{}, min interface{}, max interface{}) *MockCmdable_ClusterDelSlotsRange_Call { + return &MockCmdable_ClusterDelSlotsRange_Call{Call: _e.mock.On("ClusterDelSlotsRange", ctx, min, max)} +} + +func (_c *MockCmdable_ClusterDelSlotsRange_Call) Run(run func(ctx context.Context, min int, max int)) *MockCmdable_ClusterDelSlotsRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_ClusterDelSlotsRange_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterDelSlotsRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterDelSlotsRange_Call) RunAndReturn(run func(context.Context, int, int) *redis.StatusCmd) *MockCmdable_ClusterDelSlotsRange_Call { + _c.Call.Return(run) + return _c +} + +// ClusterFailover provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterFailover(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterFailover") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterFailover_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterFailover' +type MockCmdable_ClusterFailover_Call struct { + *mock.Call +} + +// ClusterFailover is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterFailover(ctx interface{}) *MockCmdable_ClusterFailover_Call { + return &MockCmdable_ClusterFailover_Call{Call: _e.mock.On("ClusterFailover", ctx)} +} + +func (_c *MockCmdable_ClusterFailover_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterFailover_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterFailover_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterFailover_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterFailover_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ClusterFailover_Call { + _c.Call.Return(run) + return _c +} + +// ClusterForget provides a mock function with given fields: ctx, nodeID +func (_m *MockCmdable) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd { + ret := _m.Called(ctx, nodeID) + + if len(ret) == 0 { + panic("no return value specified for ClusterForget") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, nodeID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterForget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterForget' +type MockCmdable_ClusterForget_Call struct { + *mock.Call +} + +// ClusterForget is a helper method to define mock.On call +// - ctx context.Context +// - nodeID string +func (_e *MockCmdable_Expecter) ClusterForget(ctx interface{}, nodeID interface{}) *MockCmdable_ClusterForget_Call { + return &MockCmdable_ClusterForget_Call{Call: _e.mock.On("ClusterForget", ctx, nodeID)} +} + +func (_c *MockCmdable_ClusterForget_Call) Run(run func(ctx context.Context, nodeID string)) *MockCmdable_ClusterForget_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ClusterForget_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterForget_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterForget_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_ClusterForget_Call { + _c.Call.Return(run) + return _c +} + +// ClusterGetKeysInSlot provides a mock function with given fields: ctx, slot, count +func (_m *MockCmdable) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *redis.StringSliceCmd { + ret := _m.Called(ctx, slot, count) + + if len(ret) == 0 { + panic("no return value specified for ClusterGetKeysInSlot") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, int, int) *redis.StringSliceCmd); ok { + r0 = rf(ctx, slot, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterGetKeysInSlot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterGetKeysInSlot' +type MockCmdable_ClusterGetKeysInSlot_Call struct { + *mock.Call +} + +// ClusterGetKeysInSlot is a helper method to define mock.On call +// - ctx context.Context +// - slot int +// - count int +func (_e *MockCmdable_Expecter) ClusterGetKeysInSlot(ctx interface{}, slot interface{}, count interface{}) *MockCmdable_ClusterGetKeysInSlot_Call { + return &MockCmdable_ClusterGetKeysInSlot_Call{Call: _e.mock.On("ClusterGetKeysInSlot", ctx, slot, count)} +} + +func (_c *MockCmdable_ClusterGetKeysInSlot_Call) Run(run func(ctx context.Context, slot int, count int)) *MockCmdable_ClusterGetKeysInSlot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_ClusterGetKeysInSlot_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ClusterGetKeysInSlot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterGetKeysInSlot_Call) RunAndReturn(run func(context.Context, int, int) *redis.StringSliceCmd) *MockCmdable_ClusterGetKeysInSlot_Call { + _c.Call.Return(run) + return _c +} + +// ClusterInfo provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterInfo(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterInfo") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterInfo' +type MockCmdable_ClusterInfo_Call struct { + *mock.Call +} + +// ClusterInfo is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterInfo(ctx interface{}) *MockCmdable_ClusterInfo_Call { + return &MockCmdable_ClusterInfo_Call{Call: _e.mock.On("ClusterInfo", ctx)} +} + +func (_c *MockCmdable_ClusterInfo_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterInfo_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ClusterInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterInfo_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_ClusterInfo_Call { + _c.Call.Return(run) + return _c +} + +// ClusterKeySlot provides a mock function with given fields: ctx, key +func (_m *MockCmdable) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for ClusterKeySlot") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterKeySlot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterKeySlot' +type MockCmdable_ClusterKeySlot_Call struct { + *mock.Call +} + +// ClusterKeySlot is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) ClusterKeySlot(ctx interface{}, key interface{}) *MockCmdable_ClusterKeySlot_Call { + return &MockCmdable_ClusterKeySlot_Call{Call: _e.mock.On("ClusterKeySlot", ctx, key)} +} + +func (_c *MockCmdable_ClusterKeySlot_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_ClusterKeySlot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ClusterKeySlot_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ClusterKeySlot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterKeySlot_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_ClusterKeySlot_Call { + _c.Call.Return(run) + return _c +} + +// ClusterLinks provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterLinks(ctx context.Context) *redis.ClusterLinksCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterLinks") + } + + var r0 *redis.ClusterLinksCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.ClusterLinksCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ClusterLinksCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterLinks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterLinks' +type MockCmdable_ClusterLinks_Call struct { + *mock.Call +} + +// ClusterLinks is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterLinks(ctx interface{}) *MockCmdable_ClusterLinks_Call { + return &MockCmdable_ClusterLinks_Call{Call: _e.mock.On("ClusterLinks", ctx)} +} + +func (_c *MockCmdable_ClusterLinks_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterLinks_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterLinks_Call) Return(_a0 *redis.ClusterLinksCmd) *MockCmdable_ClusterLinks_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterLinks_Call) RunAndReturn(run func(context.Context) *redis.ClusterLinksCmd) *MockCmdable_ClusterLinks_Call { + _c.Call.Return(run) + return _c +} + +// ClusterMeet provides a mock function with given fields: ctx, host, port +func (_m *MockCmdable) ClusterMeet(ctx context.Context, host string, port string) *redis.StatusCmd { + ret := _m.Called(ctx, host, port) + + if len(ret) == 0 { + panic("no return value specified for ClusterMeet") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, host, port) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterMeet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterMeet' +type MockCmdable_ClusterMeet_Call struct { + *mock.Call +} + +// ClusterMeet is a helper method to define mock.On call +// - ctx context.Context +// - host string +// - port string +func (_e *MockCmdable_Expecter) ClusterMeet(ctx interface{}, host interface{}, port interface{}) *MockCmdable_ClusterMeet_Call { + return &MockCmdable_ClusterMeet_Call{Call: _e.mock.On("ClusterMeet", ctx, host, port)} +} + +func (_c *MockCmdable_ClusterMeet_Call) Run(run func(ctx context.Context, host string, port string)) *MockCmdable_ClusterMeet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_ClusterMeet_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterMeet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterMeet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *MockCmdable_ClusterMeet_Call { + _c.Call.Return(run) + return _c +} + +// ClusterMyShardID provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterMyShardID(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterMyShardID") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterMyShardID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterMyShardID' +type MockCmdable_ClusterMyShardID_Call struct { + *mock.Call +} + +// ClusterMyShardID is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterMyShardID(ctx interface{}) *MockCmdable_ClusterMyShardID_Call { + return &MockCmdable_ClusterMyShardID_Call{Call: _e.mock.On("ClusterMyShardID", ctx)} +} + +func (_c *MockCmdable_ClusterMyShardID_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterMyShardID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterMyShardID_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ClusterMyShardID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterMyShardID_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_ClusterMyShardID_Call { + _c.Call.Return(run) + return _c +} + +// ClusterNodes provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterNodes(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterNodes") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterNodes' +type MockCmdable_ClusterNodes_Call struct { + *mock.Call +} + +// ClusterNodes is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterNodes(ctx interface{}) *MockCmdable_ClusterNodes_Call { + return &MockCmdable_ClusterNodes_Call{Call: _e.mock.On("ClusterNodes", ctx)} +} + +func (_c *MockCmdable_ClusterNodes_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterNodes_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterNodes_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ClusterNodes_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterNodes_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_ClusterNodes_Call { + _c.Call.Return(run) + return _c +} + +// ClusterReplicate provides a mock function with given fields: ctx, nodeID +func (_m *MockCmdable) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd { + ret := _m.Called(ctx, nodeID) + + if len(ret) == 0 { + panic("no return value specified for ClusterReplicate") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, nodeID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterReplicate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterReplicate' +type MockCmdable_ClusterReplicate_Call struct { + *mock.Call +} + +// ClusterReplicate is a helper method to define mock.On call +// - ctx context.Context +// - nodeID string +func (_e *MockCmdable_Expecter) ClusterReplicate(ctx interface{}, nodeID interface{}) *MockCmdable_ClusterReplicate_Call { + return &MockCmdable_ClusterReplicate_Call{Call: _e.mock.On("ClusterReplicate", ctx, nodeID)} +} + +func (_c *MockCmdable_ClusterReplicate_Call) Run(run func(ctx context.Context, nodeID string)) *MockCmdable_ClusterReplicate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ClusterReplicate_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterReplicate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterReplicate_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_ClusterReplicate_Call { + _c.Call.Return(run) + return _c +} + +// ClusterResetHard provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterResetHard(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterResetHard") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterResetHard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterResetHard' +type MockCmdable_ClusterResetHard_Call struct { + *mock.Call +} + +// ClusterResetHard is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterResetHard(ctx interface{}) *MockCmdable_ClusterResetHard_Call { + return &MockCmdable_ClusterResetHard_Call{Call: _e.mock.On("ClusterResetHard", ctx)} +} + +func (_c *MockCmdable_ClusterResetHard_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterResetHard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterResetHard_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterResetHard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterResetHard_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ClusterResetHard_Call { + _c.Call.Return(run) + return _c +} + +// ClusterResetSoft provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterResetSoft(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterResetSoft") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterResetSoft_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterResetSoft' +type MockCmdable_ClusterResetSoft_Call struct { + *mock.Call +} + +// ClusterResetSoft is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterResetSoft(ctx interface{}) *MockCmdable_ClusterResetSoft_Call { + return &MockCmdable_ClusterResetSoft_Call{Call: _e.mock.On("ClusterResetSoft", ctx)} +} + +func (_c *MockCmdable_ClusterResetSoft_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterResetSoft_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterResetSoft_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterResetSoft_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterResetSoft_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ClusterResetSoft_Call { + _c.Call.Return(run) + return _c +} + +// ClusterSaveConfig provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterSaveConfig") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterSaveConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterSaveConfig' +type MockCmdable_ClusterSaveConfig_Call struct { + *mock.Call +} + +// ClusterSaveConfig is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterSaveConfig(ctx interface{}) *MockCmdable_ClusterSaveConfig_Call { + return &MockCmdable_ClusterSaveConfig_Call{Call: _e.mock.On("ClusterSaveConfig", ctx)} +} + +func (_c *MockCmdable_ClusterSaveConfig_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterSaveConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterSaveConfig_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ClusterSaveConfig_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterSaveConfig_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ClusterSaveConfig_Call { + _c.Call.Return(run) + return _c +} + +// ClusterShards provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterShards(ctx context.Context) *redis.ClusterShardsCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterShards") + } + + var r0 *redis.ClusterShardsCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.ClusterShardsCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ClusterShardsCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterShards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterShards' +type MockCmdable_ClusterShards_Call struct { + *mock.Call +} + +// ClusterShards is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterShards(ctx interface{}) *MockCmdable_ClusterShards_Call { + return &MockCmdable_ClusterShards_Call{Call: _e.mock.On("ClusterShards", ctx)} +} + +func (_c *MockCmdable_ClusterShards_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterShards_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterShards_Call) Return(_a0 *redis.ClusterShardsCmd) *MockCmdable_ClusterShards_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterShards_Call) RunAndReturn(run func(context.Context) *redis.ClusterShardsCmd) *MockCmdable_ClusterShards_Call { + _c.Call.Return(run) + return _c +} + +// ClusterSlaves provides a mock function with given fields: ctx, nodeID +func (_m *MockCmdable) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd { + ret := _m.Called(ctx, nodeID) + + if len(ret) == 0 { + panic("no return value specified for ClusterSlaves") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, nodeID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterSlaves_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterSlaves' +type MockCmdable_ClusterSlaves_Call struct { + *mock.Call +} + +// ClusterSlaves is a helper method to define mock.On call +// - ctx context.Context +// - nodeID string +func (_e *MockCmdable_Expecter) ClusterSlaves(ctx interface{}, nodeID interface{}) *MockCmdable_ClusterSlaves_Call { + return &MockCmdable_ClusterSlaves_Call{Call: _e.mock.On("ClusterSlaves", ctx, nodeID)} +} + +func (_c *MockCmdable_ClusterSlaves_Call) Run(run func(ctx context.Context, nodeID string)) *MockCmdable_ClusterSlaves_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ClusterSlaves_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ClusterSlaves_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterSlaves_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_ClusterSlaves_Call { + _c.Call.Return(run) + return _c +} + +// ClusterSlots provides a mock function with given fields: ctx +func (_m *MockCmdable) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ClusterSlots") + } + + var r0 *redis.ClusterSlotsCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.ClusterSlotsCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ClusterSlotsCmd) + } + } + + return r0 +} + +// MockCmdable_ClusterSlots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterSlots' +type MockCmdable_ClusterSlots_Call struct { + *mock.Call +} + +// ClusterSlots is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ClusterSlots(ctx interface{}) *MockCmdable_ClusterSlots_Call { + return &MockCmdable_ClusterSlots_Call{Call: _e.mock.On("ClusterSlots", ctx)} +} + +func (_c *MockCmdable_ClusterSlots_Call) Run(run func(ctx context.Context)) *MockCmdable_ClusterSlots_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ClusterSlots_Call) Return(_a0 *redis.ClusterSlotsCmd) *MockCmdable_ClusterSlots_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ClusterSlots_Call) RunAndReturn(run func(context.Context) *redis.ClusterSlotsCmd) *MockCmdable_ClusterSlots_Call { + _c.Call.Return(run) + return _c +} + +// Command provides a mock function with given fields: ctx +func (_m *MockCmdable) Command(ctx context.Context) *redis.CommandsInfoCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Command") + } + + var r0 *redis.CommandsInfoCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.CommandsInfoCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.CommandsInfoCmd) + } + } + + return r0 +} + +// MockCmdable_Command_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Command' +type MockCmdable_Command_Call struct { + *mock.Call +} + +// Command is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) Command(ctx interface{}) *MockCmdable_Command_Call { + return &MockCmdable_Command_Call{Call: _e.mock.On("Command", ctx)} +} + +func (_c *MockCmdable_Command_Call) Run(run func(ctx context.Context)) *MockCmdable_Command_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_Command_Call) Return(_a0 *redis.CommandsInfoCmd) *MockCmdable_Command_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Command_Call) RunAndReturn(run func(context.Context) *redis.CommandsInfoCmd) *MockCmdable_Command_Call { + _c.Call.Return(run) + return _c +} + +// CommandGetKeys provides a mock function with given fields: ctx, commands +func (_m *MockCmdable) CommandGetKeys(ctx context.Context, commands ...interface{}) *redis.StringSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, commands...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CommandGetKeys") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...interface{}) *redis.StringSliceCmd); ok { + r0 = rf(ctx, commands...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_CommandGetKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandGetKeys' +type MockCmdable_CommandGetKeys_Call struct { + *mock.Call +} + +// CommandGetKeys is a helper method to define mock.On call +// - ctx context.Context +// - commands ...interface{} +func (_e *MockCmdable_Expecter) CommandGetKeys(ctx interface{}, commands ...interface{}) *MockCmdable_CommandGetKeys_Call { + return &MockCmdable_CommandGetKeys_Call{Call: _e.mock.On("CommandGetKeys", + append([]interface{}{ctx}, commands...)...)} +} + +func (_c *MockCmdable_CommandGetKeys_Call) Run(run func(ctx context.Context, commands ...interface{})) *MockCmdable_CommandGetKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_CommandGetKeys_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_CommandGetKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CommandGetKeys_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.StringSliceCmd) *MockCmdable_CommandGetKeys_Call { + _c.Call.Return(run) + return _c +} + +// CommandGetKeysAndFlags provides a mock function with given fields: ctx, commands +func (_m *MockCmdable) CommandGetKeysAndFlags(ctx context.Context, commands ...interface{}) *redis.KeyFlagsCmd { + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, commands...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CommandGetKeysAndFlags") + } + + var r0 *redis.KeyFlagsCmd + if rf, ok := ret.Get(0).(func(context.Context, ...interface{}) *redis.KeyFlagsCmd); ok { + r0 = rf(ctx, commands...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.KeyFlagsCmd) + } + } + + return r0 +} + +// MockCmdable_CommandGetKeysAndFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandGetKeysAndFlags' +type MockCmdable_CommandGetKeysAndFlags_Call struct { + *mock.Call +} + +// CommandGetKeysAndFlags is a helper method to define mock.On call +// - ctx context.Context +// - commands ...interface{} +func (_e *MockCmdable_Expecter) CommandGetKeysAndFlags(ctx interface{}, commands ...interface{}) *MockCmdable_CommandGetKeysAndFlags_Call { + return &MockCmdable_CommandGetKeysAndFlags_Call{Call: _e.mock.On("CommandGetKeysAndFlags", + append([]interface{}{ctx}, commands...)...)} +} + +func (_c *MockCmdable_CommandGetKeysAndFlags_Call) Run(run func(ctx context.Context, commands ...interface{})) *MockCmdable_CommandGetKeysAndFlags_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_CommandGetKeysAndFlags_Call) Return(_a0 *redis.KeyFlagsCmd) *MockCmdable_CommandGetKeysAndFlags_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CommandGetKeysAndFlags_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.KeyFlagsCmd) *MockCmdable_CommandGetKeysAndFlags_Call { + _c.Call.Return(run) + return _c +} + +// CommandList provides a mock function with given fields: ctx, filter +func (_m *MockCmdable) CommandList(ctx context.Context, filter *redis.FilterBy) *redis.StringSliceCmd { + ret := _m.Called(ctx, filter) + + if len(ret) == 0 { + panic("no return value specified for CommandList") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.FilterBy) *redis.StringSliceCmd); ok { + r0 = rf(ctx, filter) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_CommandList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandList' +type MockCmdable_CommandList_Call struct { + *mock.Call +} + +// CommandList is a helper method to define mock.On call +// - ctx context.Context +// - filter *redis.FilterBy +func (_e *MockCmdable_Expecter) CommandList(ctx interface{}, filter interface{}) *MockCmdable_CommandList_Call { + return &MockCmdable_CommandList_Call{Call: _e.mock.On("CommandList", ctx, filter)} +} + +func (_c *MockCmdable_CommandList_Call) Run(run func(ctx context.Context, filter *redis.FilterBy)) *MockCmdable_CommandList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.FilterBy)) + }) + return _c +} + +func (_c *MockCmdable_CommandList_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_CommandList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_CommandList_Call) RunAndReturn(run func(context.Context, *redis.FilterBy) *redis.StringSliceCmd) *MockCmdable_CommandList_Call { + _c.Call.Return(run) + return _c +} + +// ConfigGet provides a mock function with given fields: ctx, parameter +func (_m *MockCmdable) ConfigGet(ctx context.Context, parameter string) *redis.MapStringStringCmd { + ret := _m.Called(ctx, parameter) + + if len(ret) == 0 { + panic("no return value specified for ConfigGet") + } + + var r0 *redis.MapStringStringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.MapStringStringCmd); ok { + r0 = rf(ctx, parameter) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringStringCmd) + } + } + + return r0 +} + +// MockCmdable_ConfigGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigGet' +type MockCmdable_ConfigGet_Call struct { + *mock.Call +} + +// ConfigGet is a helper method to define mock.On call +// - ctx context.Context +// - parameter string +func (_e *MockCmdable_Expecter) ConfigGet(ctx interface{}, parameter interface{}) *MockCmdable_ConfigGet_Call { + return &MockCmdable_ConfigGet_Call{Call: _e.mock.On("ConfigGet", ctx, parameter)} +} + +func (_c *MockCmdable_ConfigGet_Call) Run(run func(ctx context.Context, parameter string)) *MockCmdable_ConfigGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ConfigGet_Call) Return(_a0 *redis.MapStringStringCmd) *MockCmdable_ConfigGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ConfigGet_Call) RunAndReturn(run func(context.Context, string) *redis.MapStringStringCmd) *MockCmdable_ConfigGet_Call { + _c.Call.Return(run) + return _c +} + +// ConfigResetStat provides a mock function with given fields: ctx +func (_m *MockCmdable) ConfigResetStat(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ConfigResetStat") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ConfigResetStat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigResetStat' +type MockCmdable_ConfigResetStat_Call struct { + *mock.Call +} + +// ConfigResetStat is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ConfigResetStat(ctx interface{}) *MockCmdable_ConfigResetStat_Call { + return &MockCmdable_ConfigResetStat_Call{Call: _e.mock.On("ConfigResetStat", ctx)} +} + +func (_c *MockCmdable_ConfigResetStat_Call) Run(run func(ctx context.Context)) *MockCmdable_ConfigResetStat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ConfigResetStat_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ConfigResetStat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ConfigResetStat_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ConfigResetStat_Call { + _c.Call.Return(run) + return _c +} + +// ConfigRewrite provides a mock function with given fields: ctx +func (_m *MockCmdable) ConfigRewrite(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ConfigRewrite") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ConfigRewrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigRewrite' +type MockCmdable_ConfigRewrite_Call struct { + *mock.Call +} + +// ConfigRewrite is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ConfigRewrite(ctx interface{}) *MockCmdable_ConfigRewrite_Call { + return &MockCmdable_ConfigRewrite_Call{Call: _e.mock.On("ConfigRewrite", ctx)} +} + +func (_c *MockCmdable_ConfigRewrite_Call) Run(run func(ctx context.Context)) *MockCmdable_ConfigRewrite_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ConfigRewrite_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ConfigRewrite_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ConfigRewrite_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ConfigRewrite_Call { + _c.Call.Return(run) + return _c +} + +// ConfigSet provides a mock function with given fields: ctx, parameter, value +func (_m *MockCmdable) ConfigSet(ctx context.Context, parameter string, value string) *redis.StatusCmd { + ret := _m.Called(ctx, parameter, value) + + if len(ret) == 0 { + panic("no return value specified for ConfigSet") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, parameter, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ConfigSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigSet' +type MockCmdable_ConfigSet_Call struct { + *mock.Call +} + +// ConfigSet is a helper method to define mock.On call +// - ctx context.Context +// - parameter string +// - value string +func (_e *MockCmdable_Expecter) ConfigSet(ctx interface{}, parameter interface{}, value interface{}) *MockCmdable_ConfigSet_Call { + return &MockCmdable_ConfigSet_Call{Call: _e.mock.On("ConfigSet", ctx, parameter, value)} +} + +func (_c *MockCmdable_ConfigSet_Call) Run(run func(ctx context.Context, parameter string, value string)) *MockCmdable_ConfigSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_ConfigSet_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ConfigSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ConfigSet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *MockCmdable_ConfigSet_Call { + _c.Call.Return(run) + return _c +} + +// Copy provides a mock function with given fields: ctx, sourceKey, destKey, db, replace +func (_m *MockCmdable) Copy(ctx context.Context, sourceKey string, destKey string, db int, replace bool) *redis.IntCmd { + ret := _m.Called(ctx, sourceKey, destKey, db, replace) + + if len(ret) == 0 { + panic("no return value specified for Copy") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int, bool) *redis.IntCmd); ok { + r0 = rf(ctx, sourceKey, destKey, db, replace) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Copy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Copy' +type MockCmdable_Copy_Call struct { + *mock.Call +} + +// Copy is a helper method to define mock.On call +// - ctx context.Context +// - sourceKey string +// - destKey string +// - db int +// - replace bool +func (_e *MockCmdable_Expecter) Copy(ctx interface{}, sourceKey interface{}, destKey interface{}, db interface{}, replace interface{}) *MockCmdable_Copy_Call { + return &MockCmdable_Copy_Call{Call: _e.mock.On("Copy", ctx, sourceKey, destKey, db, replace)} +} + +func (_c *MockCmdable_Copy_Call) Run(run func(ctx context.Context, sourceKey string, destKey string, db int, replace bool)) *MockCmdable_Copy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int), args[4].(bool)) + }) + return _c +} + +func (_c *MockCmdable_Copy_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Copy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Copy_Call) RunAndReturn(run func(context.Context, string, string, int, bool) *redis.IntCmd) *MockCmdable_Copy_Call { + _c.Call.Return(run) + return _c +} + +// DBSize provides a mock function with given fields: ctx +func (_m *MockCmdable) DBSize(ctx context.Context) *redis.IntCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for DBSize") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.IntCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_DBSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DBSize' +type MockCmdable_DBSize_Call struct { + *mock.Call +} + +// DBSize is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) DBSize(ctx interface{}) *MockCmdable_DBSize_Call { + return &MockCmdable_DBSize_Call{Call: _e.mock.On("DBSize", ctx)} +} + +func (_c *MockCmdable_DBSize_Call) Run(run func(ctx context.Context)) *MockCmdable_DBSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_DBSize_Call) Return(_a0 *redis.IntCmd) *MockCmdable_DBSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_DBSize_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *MockCmdable_DBSize_Call { + _c.Call.Return(run) + return _c +} + +// DebugObject provides a mock function with given fields: ctx, key +func (_m *MockCmdable) DebugObject(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for DebugObject") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_DebugObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DebugObject' +type MockCmdable_DebugObject_Call struct { + *mock.Call +} + +// DebugObject is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) DebugObject(ctx interface{}, key interface{}) *MockCmdable_DebugObject_Call { + return &MockCmdable_DebugObject_Call{Call: _e.mock.On("DebugObject", ctx, key)} +} + +func (_c *MockCmdable_DebugObject_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_DebugObject_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_DebugObject_Call) Return(_a0 *redis.StringCmd) *MockCmdable_DebugObject_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_DebugObject_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_DebugObject_Call { + _c.Call.Return(run) + return _c +} + +// Decr provides a mock function with given fields: ctx, key +func (_m *MockCmdable) Decr(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Decr") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Decr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Decr' +type MockCmdable_Decr_Call struct { + *mock.Call +} + +// Decr is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) Decr(ctx interface{}, key interface{}) *MockCmdable_Decr_Call { + return &MockCmdable_Decr_Call{Call: _e.mock.On("Decr", ctx, key)} +} + +func (_c *MockCmdable_Decr_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_Decr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_Decr_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Decr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Decr_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_Decr_Call { + _c.Call.Return(run) + return _c +} + +// DecrBy provides a mock function with given fields: ctx, key, decrement +func (_m *MockCmdable) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd { + ret := _m.Called(ctx, key, decrement) + + if len(ret) == 0 { + panic("no return value specified for DecrBy") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, decrement) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_DecrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DecrBy' +type MockCmdable_DecrBy_Call struct { + *mock.Call +} + +// DecrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - decrement int64 +func (_e *MockCmdable_Expecter) DecrBy(ctx interface{}, key interface{}, decrement interface{}) *MockCmdable_DecrBy_Call { + return &MockCmdable_DecrBy_Call{Call: _e.mock.On("DecrBy", ctx, key, decrement)} +} + +func (_c *MockCmdable_DecrBy_Call) Run(run func(ctx context.Context, key string, decrement int64)) *MockCmdable_DecrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_DecrBy_Call) Return(_a0 *redis.IntCmd) *MockCmdable_DecrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_DecrBy_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *MockCmdable_DecrBy_Call { + _c.Call.Return(run) + return _c +} + +// Del provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) Del(ctx context.Context, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Del") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Del_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Del' +type MockCmdable_Del_Call struct { + *mock.Call +} + +// Del is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) Del(ctx interface{}, keys ...interface{}) *MockCmdable_Del_Call { + return &MockCmdable_Del_Call{Call: _e.mock.On("Del", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_Del_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_Del_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_Del_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Del_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Del_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *MockCmdable_Del_Call { + _c.Call.Return(run) + return _c +} + +// Dump provides a mock function with given fields: ctx, key +func (_m *MockCmdable) Dump(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Dump") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_Dump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dump' +type MockCmdable_Dump_Call struct { + *mock.Call +} + +// Dump is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) Dump(ctx interface{}, key interface{}) *MockCmdable_Dump_Call { + return &MockCmdable_Dump_Call{Call: _e.mock.On("Dump", ctx, key)} +} + +func (_c *MockCmdable_Dump_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_Dump_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_Dump_Call) Return(_a0 *redis.StringCmd) *MockCmdable_Dump_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Dump_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_Dump_Call { + _c.Call.Return(run) + return _c +} + +// Echo provides a mock function with given fields: ctx, message +func (_m *MockCmdable) Echo(ctx context.Context, message interface{}) *redis.StringCmd { + ret := _m.Called(ctx, message) + + if len(ret) == 0 { + panic("no return value specified for Echo") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, interface{}) *redis.StringCmd); ok { + r0 = rf(ctx, message) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_Echo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Echo' +type MockCmdable_Echo_Call struct { + *mock.Call +} + +// Echo is a helper method to define mock.On call +// - ctx context.Context +// - message interface{} +func (_e *MockCmdable_Expecter) Echo(ctx interface{}, message interface{}) *MockCmdable_Echo_Call { + return &MockCmdable_Echo_Call{Call: _e.mock.On("Echo", ctx, message)} +} + +func (_c *MockCmdable_Echo_Call) Run(run func(ctx context.Context, message interface{})) *MockCmdable_Echo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_Echo_Call) Return(_a0 *redis.StringCmd) *MockCmdable_Echo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Echo_Call) RunAndReturn(run func(context.Context, interface{}) *redis.StringCmd) *MockCmdable_Echo_Call { + _c.Call.Return(run) + return _c +} + +// Eval provides a mock function with given fields: ctx, script, keys, args +func (_m *MockCmdable) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd { + var _ca []interface{} + _ca = append(_ca, ctx, script, keys) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Eval") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, []string, ...interface{}) *redis.Cmd); ok { + r0 = rf(ctx, script, keys, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_Eval_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Eval' +type MockCmdable_Eval_Call struct { + *mock.Call +} + +// Eval is a helper method to define mock.On call +// - ctx context.Context +// - script string +// - keys []string +// - args ...interface{} +func (_e *MockCmdable_Expecter) Eval(ctx interface{}, script interface{}, keys interface{}, args ...interface{}) *MockCmdable_Eval_Call { + return &MockCmdable_Eval_Call{Call: _e.mock.On("Eval", + append([]interface{}{ctx, script, keys}, args...)...)} +} + +func (_c *MockCmdable_Eval_Call) Run(run func(ctx context.Context, script string, keys []string, args ...interface{})) *MockCmdable_Eval_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].([]string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_Eval_Call) Return(_a0 *redis.Cmd) *MockCmdable_Eval_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Eval_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *MockCmdable_Eval_Call { + _c.Call.Return(run) + return _c +} + +// EvalRO provides a mock function with given fields: ctx, script, keys, args +func (_m *MockCmdable) EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd { + var _ca []interface{} + _ca = append(_ca, ctx, script, keys) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for EvalRO") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, []string, ...interface{}) *redis.Cmd); ok { + r0 = rf(ctx, script, keys, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_EvalRO_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EvalRO' +type MockCmdable_EvalRO_Call struct { + *mock.Call +} + +// EvalRO is a helper method to define mock.On call +// - ctx context.Context +// - script string +// - keys []string +// - args ...interface{} +func (_e *MockCmdable_Expecter) EvalRO(ctx interface{}, script interface{}, keys interface{}, args ...interface{}) *MockCmdable_EvalRO_Call { + return &MockCmdable_EvalRO_Call{Call: _e.mock.On("EvalRO", + append([]interface{}{ctx, script, keys}, args...)...)} +} + +func (_c *MockCmdable_EvalRO_Call) Run(run func(ctx context.Context, script string, keys []string, args ...interface{})) *MockCmdable_EvalRO_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].([]string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_EvalRO_Call) Return(_a0 *redis.Cmd) *MockCmdable_EvalRO_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_EvalRO_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *MockCmdable_EvalRO_Call { + _c.Call.Return(run) + return _c +} + +// EvalSha provides a mock function with given fields: ctx, sha1, keys, args +func (_m *MockCmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd { + var _ca []interface{} + _ca = append(_ca, ctx, sha1, keys) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for EvalSha") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, []string, ...interface{}) *redis.Cmd); ok { + r0 = rf(ctx, sha1, keys, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_EvalSha_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EvalSha' +type MockCmdable_EvalSha_Call struct { + *mock.Call +} + +// EvalSha is a helper method to define mock.On call +// - ctx context.Context +// - sha1 string +// - keys []string +// - args ...interface{} +func (_e *MockCmdable_Expecter) EvalSha(ctx interface{}, sha1 interface{}, keys interface{}, args ...interface{}) *MockCmdable_EvalSha_Call { + return &MockCmdable_EvalSha_Call{Call: _e.mock.On("EvalSha", + append([]interface{}{ctx, sha1, keys}, args...)...)} +} + +func (_c *MockCmdable_EvalSha_Call) Run(run func(ctx context.Context, sha1 string, keys []string, args ...interface{})) *MockCmdable_EvalSha_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].([]string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_EvalSha_Call) Return(_a0 *redis.Cmd) *MockCmdable_EvalSha_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_EvalSha_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *MockCmdable_EvalSha_Call { + _c.Call.Return(run) + return _c +} + +// EvalShaRO provides a mock function with given fields: ctx, sha1, keys, args +func (_m *MockCmdable) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd { + var _ca []interface{} + _ca = append(_ca, ctx, sha1, keys) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for EvalShaRO") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, []string, ...interface{}) *redis.Cmd); ok { + r0 = rf(ctx, sha1, keys, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_EvalShaRO_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EvalShaRO' +type MockCmdable_EvalShaRO_Call struct { + *mock.Call +} + +// EvalShaRO is a helper method to define mock.On call +// - ctx context.Context +// - sha1 string +// - keys []string +// - args ...interface{} +func (_e *MockCmdable_Expecter) EvalShaRO(ctx interface{}, sha1 interface{}, keys interface{}, args ...interface{}) *MockCmdable_EvalShaRO_Call { + return &MockCmdable_EvalShaRO_Call{Call: _e.mock.On("EvalShaRO", + append([]interface{}{ctx, sha1, keys}, args...)...)} +} + +func (_c *MockCmdable_EvalShaRO_Call) Run(run func(ctx context.Context, sha1 string, keys []string, args ...interface{})) *MockCmdable_EvalShaRO_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].([]string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_EvalShaRO_Call) Return(_a0 *redis.Cmd) *MockCmdable_EvalShaRO_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_EvalShaRO_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *MockCmdable_EvalShaRO_Call { + _c.Call.Return(run) + return _c +} + +// Exists provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) Exists(ctx context.Context, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Exists") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists' +type MockCmdable_Exists_Call struct { + *mock.Call +} + +// Exists is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) Exists(ctx interface{}, keys ...interface{}) *MockCmdable_Exists_Call { + return &MockCmdable_Exists_Call{Call: _e.mock.On("Exists", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_Exists_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_Exists_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_Exists_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Exists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Exists_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *MockCmdable_Exists_Call { + _c.Call.Return(run) + return _c +} + +// Expire provides a mock function with given fields: ctx, key, expiration +func (_m *MockCmdable) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, key, expiration) + + if len(ret) == 0 { + panic("no return value specified for Expire") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, key, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_Expire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expire' +type MockCmdable_Expire_Call struct { + *mock.Call +} + +// Expire is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +func (_e *MockCmdable_Expecter) Expire(ctx interface{}, key interface{}, expiration interface{}) *MockCmdable_Expire_Call { + return &MockCmdable_Expire_Call{Call: _e.mock.On("Expire", ctx, key, expiration)} +} + +func (_c *MockCmdable_Expire_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockCmdable_Expire_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_Expire_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_Expire_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Expire_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *MockCmdable_Expire_Call { + _c.Call.Return(run) + return _c +} + +// ExpireAt provides a mock function with given fields: ctx, key, tm +func (_m *MockCmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + ret := _m.Called(ctx, key, tm) + + if len(ret) == 0 { + panic("no return value specified for ExpireAt") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Time) *redis.BoolCmd); ok { + r0 = rf(ctx, key, tm) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_ExpireAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireAt' +type MockCmdable_ExpireAt_Call struct { + *mock.Call +} + +// ExpireAt is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - tm time.Time +func (_e *MockCmdable_Expecter) ExpireAt(ctx interface{}, key interface{}, tm interface{}) *MockCmdable_ExpireAt_Call { + return &MockCmdable_ExpireAt_Call{Call: _e.mock.On("ExpireAt", ctx, key, tm)} +} + +func (_c *MockCmdable_ExpireAt_Call) Run(run func(ctx context.Context, key string, tm time.Time)) *MockCmdable_ExpireAt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Time)) + }) + return _c +} + +func (_c *MockCmdable_ExpireAt_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_ExpireAt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ExpireAt_Call) RunAndReturn(run func(context.Context, string, time.Time) *redis.BoolCmd) *MockCmdable_ExpireAt_Call { + _c.Call.Return(run) + return _c +} + +// ExpireGT provides a mock function with given fields: ctx, key, expiration +func (_m *MockCmdable) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, key, expiration) + + if len(ret) == 0 { + panic("no return value specified for ExpireGT") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, key, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_ExpireGT_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireGT' +type MockCmdable_ExpireGT_Call struct { + *mock.Call +} + +// ExpireGT is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +func (_e *MockCmdable_Expecter) ExpireGT(ctx interface{}, key interface{}, expiration interface{}) *MockCmdable_ExpireGT_Call { + return &MockCmdable_ExpireGT_Call{Call: _e.mock.On("ExpireGT", ctx, key, expiration)} +} + +func (_c *MockCmdable_ExpireGT_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockCmdable_ExpireGT_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_ExpireGT_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_ExpireGT_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ExpireGT_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *MockCmdable_ExpireGT_Call { + _c.Call.Return(run) + return _c +} + +// ExpireLT provides a mock function with given fields: ctx, key, expiration +func (_m *MockCmdable) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, key, expiration) + + if len(ret) == 0 { + panic("no return value specified for ExpireLT") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, key, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_ExpireLT_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireLT' +type MockCmdable_ExpireLT_Call struct { + *mock.Call +} + +// ExpireLT is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +func (_e *MockCmdable_Expecter) ExpireLT(ctx interface{}, key interface{}, expiration interface{}) *MockCmdable_ExpireLT_Call { + return &MockCmdable_ExpireLT_Call{Call: _e.mock.On("ExpireLT", ctx, key, expiration)} +} + +func (_c *MockCmdable_ExpireLT_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockCmdable_ExpireLT_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_ExpireLT_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_ExpireLT_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ExpireLT_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *MockCmdable_ExpireLT_Call { + _c.Call.Return(run) + return _c +} + +// ExpireNX provides a mock function with given fields: ctx, key, expiration +func (_m *MockCmdable) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, key, expiration) + + if len(ret) == 0 { + panic("no return value specified for ExpireNX") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, key, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_ExpireNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireNX' +type MockCmdable_ExpireNX_Call struct { + *mock.Call +} + +// ExpireNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +func (_e *MockCmdable_Expecter) ExpireNX(ctx interface{}, key interface{}, expiration interface{}) *MockCmdable_ExpireNX_Call { + return &MockCmdable_ExpireNX_Call{Call: _e.mock.On("ExpireNX", ctx, key, expiration)} +} + +func (_c *MockCmdable_ExpireNX_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockCmdable_ExpireNX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_ExpireNX_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_ExpireNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ExpireNX_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *MockCmdable_ExpireNX_Call { + _c.Call.Return(run) + return _c +} + +// ExpireTime provides a mock function with given fields: ctx, key +func (_m *MockCmdable) ExpireTime(ctx context.Context, key string) *redis.DurationCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for ExpireTime") + } + + var r0 *redis.DurationCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.DurationCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.DurationCmd) + } + } + + return r0 +} + +// MockCmdable_ExpireTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireTime' +type MockCmdable_ExpireTime_Call struct { + *mock.Call +} + +// ExpireTime is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) ExpireTime(ctx interface{}, key interface{}) *MockCmdable_ExpireTime_Call { + return &MockCmdable_ExpireTime_Call{Call: _e.mock.On("ExpireTime", ctx, key)} +} + +func (_c *MockCmdable_ExpireTime_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_ExpireTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ExpireTime_Call) Return(_a0 *redis.DurationCmd) *MockCmdable_ExpireTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ExpireTime_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *MockCmdable_ExpireTime_Call { + _c.Call.Return(run) + return _c +} + +// ExpireXX provides a mock function with given fields: ctx, key, expiration +func (_m *MockCmdable) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, key, expiration) + + if len(ret) == 0 { + panic("no return value specified for ExpireXX") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, key, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_ExpireXX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireXX' +type MockCmdable_ExpireXX_Call struct { + *mock.Call +} + +// ExpireXX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +func (_e *MockCmdable_Expecter) ExpireXX(ctx interface{}, key interface{}, expiration interface{}) *MockCmdable_ExpireXX_Call { + return &MockCmdable_ExpireXX_Call{Call: _e.mock.On("ExpireXX", ctx, key, expiration)} +} + +func (_c *MockCmdable_ExpireXX_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockCmdable_ExpireXX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_ExpireXX_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_ExpireXX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ExpireXX_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *MockCmdable_ExpireXX_Call { + _c.Call.Return(run) + return _c +} + +// FCall provides a mock function with given fields: ctx, function, keys, args +func (_m *MockCmdable) FCall(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + var _ca []interface{} + _ca = append(_ca, ctx, function, keys) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FCall") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, []string, ...interface{}) *redis.Cmd); ok { + r0 = rf(ctx, function, keys, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_FCall_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FCall' +type MockCmdable_FCall_Call struct { + *mock.Call +} + +// FCall is a helper method to define mock.On call +// - ctx context.Context +// - function string +// - keys []string +// - args ...interface{} +func (_e *MockCmdable_Expecter) FCall(ctx interface{}, function interface{}, keys interface{}, args ...interface{}) *MockCmdable_FCall_Call { + return &MockCmdable_FCall_Call{Call: _e.mock.On("FCall", + append([]interface{}{ctx, function, keys}, args...)...)} +} + +func (_c *MockCmdable_FCall_Call) Run(run func(ctx context.Context, function string, keys []string, args ...interface{})) *MockCmdable_FCall_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].([]string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_FCall_Call) Return(_a0 *redis.Cmd) *MockCmdable_FCall_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FCall_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *MockCmdable_FCall_Call { + _c.Call.Return(run) + return _c +} + +// FCallRO provides a mock function with given fields: ctx, function, keys, args +func (_m *MockCmdable) FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + var _ca []interface{} + _ca = append(_ca, ctx, function, keys) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FCallRO") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, []string, ...interface{}) *redis.Cmd); ok { + r0 = rf(ctx, function, keys, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_FCallRO_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FCallRO' +type MockCmdable_FCallRO_Call struct { + *mock.Call +} + +// FCallRO is a helper method to define mock.On call +// - ctx context.Context +// - function string +// - keys []string +// - args ...interface{} +func (_e *MockCmdable_Expecter) FCallRO(ctx interface{}, function interface{}, keys interface{}, args ...interface{}) *MockCmdable_FCallRO_Call { + return &MockCmdable_FCallRO_Call{Call: _e.mock.On("FCallRO", + append([]interface{}{ctx, function, keys}, args...)...)} +} + +func (_c *MockCmdable_FCallRO_Call) Run(run func(ctx context.Context, function string, keys []string, args ...interface{})) *MockCmdable_FCallRO_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].([]string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_FCallRO_Call) Return(_a0 *redis.Cmd) *MockCmdable_FCallRO_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FCallRO_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *MockCmdable_FCallRO_Call { + _c.Call.Return(run) + return _c +} + +// FCallRo provides a mock function with given fields: ctx, function, keys, args +func (_m *MockCmdable) FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + var _ca []interface{} + _ca = append(_ca, ctx, function, keys) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FCallRo") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, []string, ...interface{}) *redis.Cmd); ok { + r0 = rf(ctx, function, keys, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_FCallRo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FCallRo' +type MockCmdable_FCallRo_Call struct { + *mock.Call +} + +// FCallRo is a helper method to define mock.On call +// - ctx context.Context +// - function string +// - keys []string +// - args ...interface{} +func (_e *MockCmdable_Expecter) FCallRo(ctx interface{}, function interface{}, keys interface{}, args ...interface{}) *MockCmdable_FCallRo_Call { + return &MockCmdable_FCallRo_Call{Call: _e.mock.On("FCallRo", + append([]interface{}{ctx, function, keys}, args...)...)} +} + +func (_c *MockCmdable_FCallRo_Call) Run(run func(ctx context.Context, function string, keys []string, args ...interface{})) *MockCmdable_FCallRo_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].([]string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_FCallRo_Call) Return(_a0 *redis.Cmd) *MockCmdable_FCallRo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FCallRo_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *MockCmdable_FCallRo_Call { + _c.Call.Return(run) + return _c +} + +// FTAggregate provides a mock function with given fields: ctx, index, query +func (_m *MockCmdable) FTAggregate(ctx context.Context, index string, query string) *redis.MapStringInterfaceCmd { + ret := _m.Called(ctx, index, query) + + if len(ret) == 0 { + panic("no return value specified for FTAggregate") + } + + var r0 *redis.MapStringInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.MapStringInterfaceCmd); ok { + r0 = rf(ctx, index, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_FTAggregate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTAggregate' +type MockCmdable_FTAggregate_Call struct { + *mock.Call +} + +// FTAggregate is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +func (_e *MockCmdable_Expecter) FTAggregate(ctx interface{}, index interface{}, query interface{}) *MockCmdable_FTAggregate_Call { + return &MockCmdable_FTAggregate_Call{Call: _e.mock.On("FTAggregate", ctx, index, query)} +} + +func (_c *MockCmdable_FTAggregate_Call) Run(run func(ctx context.Context, index string, query string)) *MockCmdable_FTAggregate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTAggregate_Call) Return(_a0 *redis.MapStringInterfaceCmd) *MockCmdable_FTAggregate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTAggregate_Call) RunAndReturn(run func(context.Context, string, string) *redis.MapStringInterfaceCmd) *MockCmdable_FTAggregate_Call { + _c.Call.Return(run) + return _c +} + +// FTAggregateWithArgs provides a mock function with given fields: ctx, index, query, options +func (_m *MockCmdable) FTAggregateWithArgs(ctx context.Context, index string, query string, options *redis.FTAggregateOptions) *redis.AggregateCmd { + ret := _m.Called(ctx, index, query, options) + + if len(ret) == 0 { + panic("no return value specified for FTAggregateWithArgs") + } + + var r0 *redis.AggregateCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.FTAggregateOptions) *redis.AggregateCmd); ok { + r0 = rf(ctx, index, query, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.AggregateCmd) + } + } + + return r0 +} + +// MockCmdable_FTAggregateWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTAggregateWithArgs' +type MockCmdable_FTAggregateWithArgs_Call struct { + *mock.Call +} + +// FTAggregateWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +// - options *redis.FTAggregateOptions +func (_e *MockCmdable_Expecter) FTAggregateWithArgs(ctx interface{}, index interface{}, query interface{}, options interface{}) *MockCmdable_FTAggregateWithArgs_Call { + return &MockCmdable_FTAggregateWithArgs_Call{Call: _e.mock.On("FTAggregateWithArgs", ctx, index, query, options)} +} + +func (_c *MockCmdable_FTAggregateWithArgs_Call) Run(run func(ctx context.Context, index string, query string, options *redis.FTAggregateOptions)) *MockCmdable_FTAggregateWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.FTAggregateOptions)) + }) + return _c +} + +func (_c *MockCmdable_FTAggregateWithArgs_Call) Return(_a0 *redis.AggregateCmd) *MockCmdable_FTAggregateWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTAggregateWithArgs_Call) RunAndReturn(run func(context.Context, string, string, *redis.FTAggregateOptions) *redis.AggregateCmd) *MockCmdable_FTAggregateWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// FTAliasAdd provides a mock function with given fields: ctx, index, alias +func (_m *MockCmdable) FTAliasAdd(ctx context.Context, index string, alias string) *redis.StatusCmd { + ret := _m.Called(ctx, index, alias) + + if len(ret) == 0 { + panic("no return value specified for FTAliasAdd") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, index, alias) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTAliasAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTAliasAdd' +type MockCmdable_FTAliasAdd_Call struct { + *mock.Call +} + +// FTAliasAdd is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - alias string +func (_e *MockCmdable_Expecter) FTAliasAdd(ctx interface{}, index interface{}, alias interface{}) *MockCmdable_FTAliasAdd_Call { + return &MockCmdable_FTAliasAdd_Call{Call: _e.mock.On("FTAliasAdd", ctx, index, alias)} +} + +func (_c *MockCmdable_FTAliasAdd_Call) Run(run func(ctx context.Context, index string, alias string)) *MockCmdable_FTAliasAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTAliasAdd_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTAliasAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTAliasAdd_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *MockCmdable_FTAliasAdd_Call { + _c.Call.Return(run) + return _c +} + +// FTAliasDel provides a mock function with given fields: ctx, alias +func (_m *MockCmdable) FTAliasDel(ctx context.Context, alias string) *redis.StatusCmd { + ret := _m.Called(ctx, alias) + + if len(ret) == 0 { + panic("no return value specified for FTAliasDel") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, alias) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTAliasDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTAliasDel' +type MockCmdable_FTAliasDel_Call struct { + *mock.Call +} + +// FTAliasDel is a helper method to define mock.On call +// - ctx context.Context +// - alias string +func (_e *MockCmdable_Expecter) FTAliasDel(ctx interface{}, alias interface{}) *MockCmdable_FTAliasDel_Call { + return &MockCmdable_FTAliasDel_Call{Call: _e.mock.On("FTAliasDel", ctx, alias)} +} + +func (_c *MockCmdable_FTAliasDel_Call) Run(run func(ctx context.Context, alias string)) *MockCmdable_FTAliasDel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTAliasDel_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTAliasDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTAliasDel_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_FTAliasDel_Call { + _c.Call.Return(run) + return _c +} + +// FTAliasUpdate provides a mock function with given fields: ctx, index, alias +func (_m *MockCmdable) FTAliasUpdate(ctx context.Context, index string, alias string) *redis.StatusCmd { + ret := _m.Called(ctx, index, alias) + + if len(ret) == 0 { + panic("no return value specified for FTAliasUpdate") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, index, alias) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTAliasUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTAliasUpdate' +type MockCmdable_FTAliasUpdate_Call struct { + *mock.Call +} + +// FTAliasUpdate is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - alias string +func (_e *MockCmdable_Expecter) FTAliasUpdate(ctx interface{}, index interface{}, alias interface{}) *MockCmdable_FTAliasUpdate_Call { + return &MockCmdable_FTAliasUpdate_Call{Call: _e.mock.On("FTAliasUpdate", ctx, index, alias)} +} + +func (_c *MockCmdable_FTAliasUpdate_Call) Run(run func(ctx context.Context, index string, alias string)) *MockCmdable_FTAliasUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTAliasUpdate_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTAliasUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTAliasUpdate_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *MockCmdable_FTAliasUpdate_Call { + _c.Call.Return(run) + return _c +} + +// FTAlter provides a mock function with given fields: ctx, index, skipInitialScan, definition +func (_m *MockCmdable) FTAlter(ctx context.Context, index string, skipInitialScan bool, definition []interface{}) *redis.StatusCmd { + ret := _m.Called(ctx, index, skipInitialScan, definition) + + if len(ret) == 0 { + panic("no return value specified for FTAlter") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, bool, []interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, index, skipInitialScan, definition) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTAlter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTAlter' +type MockCmdable_FTAlter_Call struct { + *mock.Call +} + +// FTAlter is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - skipInitialScan bool +// - definition []interface{} +func (_e *MockCmdable_Expecter) FTAlter(ctx interface{}, index interface{}, skipInitialScan interface{}, definition interface{}) *MockCmdable_FTAlter_Call { + return &MockCmdable_FTAlter_Call{Call: _e.mock.On("FTAlter", ctx, index, skipInitialScan, definition)} +} + +func (_c *MockCmdable_FTAlter_Call) Run(run func(ctx context.Context, index string, skipInitialScan bool, definition []interface{})) *MockCmdable_FTAlter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(bool), args[3].([]interface{})) + }) + return _c +} + +func (_c *MockCmdable_FTAlter_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTAlter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTAlter_Call) RunAndReturn(run func(context.Context, string, bool, []interface{}) *redis.StatusCmd) *MockCmdable_FTAlter_Call { + _c.Call.Return(run) + return _c +} + +// FTConfigGet provides a mock function with given fields: ctx, option +func (_m *MockCmdable) FTConfigGet(ctx context.Context, option string) *redis.MapMapStringInterfaceCmd { + ret := _m.Called(ctx, option) + + if len(ret) == 0 { + panic("no return value specified for FTConfigGet") + } + + var r0 *redis.MapMapStringInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.MapMapStringInterfaceCmd); ok { + r0 = rf(ctx, option) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapMapStringInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_FTConfigGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTConfigGet' +type MockCmdable_FTConfigGet_Call struct { + *mock.Call +} + +// FTConfigGet is a helper method to define mock.On call +// - ctx context.Context +// - option string +func (_e *MockCmdable_Expecter) FTConfigGet(ctx interface{}, option interface{}) *MockCmdable_FTConfigGet_Call { + return &MockCmdable_FTConfigGet_Call{Call: _e.mock.On("FTConfigGet", ctx, option)} +} + +func (_c *MockCmdable_FTConfigGet_Call) Run(run func(ctx context.Context, option string)) *MockCmdable_FTConfigGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTConfigGet_Call) Return(_a0 *redis.MapMapStringInterfaceCmd) *MockCmdable_FTConfigGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTConfigGet_Call) RunAndReturn(run func(context.Context, string) *redis.MapMapStringInterfaceCmd) *MockCmdable_FTConfigGet_Call { + _c.Call.Return(run) + return _c +} + +// FTConfigSet provides a mock function with given fields: ctx, option, value +func (_m *MockCmdable) FTConfigSet(ctx context.Context, option string, value interface{}) *redis.StatusCmd { + ret := _m.Called(ctx, option, value) + + if len(ret) == 0 { + panic("no return value specified for FTConfigSet") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, option, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTConfigSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTConfigSet' +type MockCmdable_FTConfigSet_Call struct { + *mock.Call +} + +// FTConfigSet is a helper method to define mock.On call +// - ctx context.Context +// - option string +// - value interface{} +func (_e *MockCmdable_Expecter) FTConfigSet(ctx interface{}, option interface{}, value interface{}) *MockCmdable_FTConfigSet_Call { + return &MockCmdable_FTConfigSet_Call{Call: _e.mock.On("FTConfigSet", ctx, option, value)} +} + +func (_c *MockCmdable_FTConfigSet_Call) Run(run func(ctx context.Context, option string, value interface{})) *MockCmdable_FTConfigSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_FTConfigSet_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTConfigSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTConfigSet_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.StatusCmd) *MockCmdable_FTConfigSet_Call { + _c.Call.Return(run) + return _c +} + +// FTCreate provides a mock function with given fields: ctx, index, options, schema +func (_m *MockCmdable) FTCreate(ctx context.Context, index string, options *redis.FTCreateOptions, schema ...*redis.FieldSchema) *redis.StatusCmd { + _va := make([]interface{}, len(schema)) + for _i := range schema { + _va[_i] = schema[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, index, options) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FTCreate") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.FTCreateOptions, ...*redis.FieldSchema) *redis.StatusCmd); ok { + r0 = rf(ctx, index, options, schema...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTCreate' +type MockCmdable_FTCreate_Call struct { + *mock.Call +} + +// FTCreate is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - options *redis.FTCreateOptions +// - schema ...*redis.FieldSchema +func (_e *MockCmdable_Expecter) FTCreate(ctx interface{}, index interface{}, options interface{}, schema ...interface{}) *MockCmdable_FTCreate_Call { + return &MockCmdable_FTCreate_Call{Call: _e.mock.On("FTCreate", + append([]interface{}{ctx, index, options}, schema...)...)} +} + +func (_c *MockCmdable_FTCreate_Call) Run(run func(ctx context.Context, index string, options *redis.FTCreateOptions, schema ...*redis.FieldSchema)) *MockCmdable_FTCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]*redis.FieldSchema, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(*redis.FieldSchema) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*redis.FTCreateOptions), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_FTCreate_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTCreate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTCreate_Call) RunAndReturn(run func(context.Context, string, *redis.FTCreateOptions, ...*redis.FieldSchema) *redis.StatusCmd) *MockCmdable_FTCreate_Call { + _c.Call.Return(run) + return _c +} + +// FTCursorDel provides a mock function with given fields: ctx, index, cursorId +func (_m *MockCmdable) FTCursorDel(ctx context.Context, index string, cursorId int) *redis.StatusCmd { + ret := _m.Called(ctx, index, cursorId) + + if len(ret) == 0 { + panic("no return value specified for FTCursorDel") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.StatusCmd); ok { + r0 = rf(ctx, index, cursorId) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTCursorDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTCursorDel' +type MockCmdable_FTCursorDel_Call struct { + *mock.Call +} + +// FTCursorDel is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - cursorId int +func (_e *MockCmdable_Expecter) FTCursorDel(ctx interface{}, index interface{}, cursorId interface{}) *MockCmdable_FTCursorDel_Call { + return &MockCmdable_FTCursorDel_Call{Call: _e.mock.On("FTCursorDel", ctx, index, cursorId)} +} + +func (_c *MockCmdable_FTCursorDel_Call) Run(run func(ctx context.Context, index string, cursorId int)) *MockCmdable_FTCursorDel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_FTCursorDel_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTCursorDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTCursorDel_Call) RunAndReturn(run func(context.Context, string, int) *redis.StatusCmd) *MockCmdable_FTCursorDel_Call { + _c.Call.Return(run) + return _c +} + +// FTCursorRead provides a mock function with given fields: ctx, index, cursorId, count +func (_m *MockCmdable) FTCursorRead(ctx context.Context, index string, cursorId int, count int) *redis.MapStringInterfaceCmd { + ret := _m.Called(ctx, index, cursorId, count) + + if len(ret) == 0 { + panic("no return value specified for FTCursorRead") + } + + var r0 *redis.MapStringInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int, int) *redis.MapStringInterfaceCmd); ok { + r0 = rf(ctx, index, cursorId, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_FTCursorRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTCursorRead' +type MockCmdable_FTCursorRead_Call struct { + *mock.Call +} + +// FTCursorRead is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - cursorId int +// - count int +func (_e *MockCmdable_Expecter) FTCursorRead(ctx interface{}, index interface{}, cursorId interface{}, count interface{}) *MockCmdable_FTCursorRead_Call { + return &MockCmdable_FTCursorRead_Call{Call: _e.mock.On("FTCursorRead", ctx, index, cursorId, count)} +} + +func (_c *MockCmdable_FTCursorRead_Call) Run(run func(ctx context.Context, index string, cursorId int, count int)) *MockCmdable_FTCursorRead_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(int)) + }) + return _c +} + +func (_c *MockCmdable_FTCursorRead_Call) Return(_a0 *redis.MapStringInterfaceCmd) *MockCmdable_FTCursorRead_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTCursorRead_Call) RunAndReturn(run func(context.Context, string, int, int) *redis.MapStringInterfaceCmd) *MockCmdable_FTCursorRead_Call { + _c.Call.Return(run) + return _c +} + +// FTDictAdd provides a mock function with given fields: ctx, dict, term +func (_m *MockCmdable) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, dict) + _ca = append(_ca, term...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FTDictAdd") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, dict, term...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_FTDictAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTDictAdd' +type MockCmdable_FTDictAdd_Call struct { + *mock.Call +} + +// FTDictAdd is a helper method to define mock.On call +// - ctx context.Context +// - dict string +// - term ...interface{} +func (_e *MockCmdable_Expecter) FTDictAdd(ctx interface{}, dict interface{}, term ...interface{}) *MockCmdable_FTDictAdd_Call { + return &MockCmdable_FTDictAdd_Call{Call: _e.mock.On("FTDictAdd", + append([]interface{}{ctx, dict}, term...)...)} +} + +func (_c *MockCmdable_FTDictAdd_Call) Run(run func(ctx context.Context, dict string, term ...interface{})) *MockCmdable_FTDictAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_FTDictAdd_Call) Return(_a0 *redis.IntCmd) *MockCmdable_FTDictAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTDictAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_FTDictAdd_Call { + _c.Call.Return(run) + return _c +} + +// FTDictDel provides a mock function with given fields: ctx, dict, term +func (_m *MockCmdable) FTDictDel(ctx context.Context, dict string, term ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, dict) + _ca = append(_ca, term...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FTDictDel") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, dict, term...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_FTDictDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTDictDel' +type MockCmdable_FTDictDel_Call struct { + *mock.Call +} + +// FTDictDel is a helper method to define mock.On call +// - ctx context.Context +// - dict string +// - term ...interface{} +func (_e *MockCmdable_Expecter) FTDictDel(ctx interface{}, dict interface{}, term ...interface{}) *MockCmdable_FTDictDel_Call { + return &MockCmdable_FTDictDel_Call{Call: _e.mock.On("FTDictDel", + append([]interface{}{ctx, dict}, term...)...)} +} + +func (_c *MockCmdable_FTDictDel_Call) Run(run func(ctx context.Context, dict string, term ...interface{})) *MockCmdable_FTDictDel_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_FTDictDel_Call) Return(_a0 *redis.IntCmd) *MockCmdable_FTDictDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTDictDel_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_FTDictDel_Call { + _c.Call.Return(run) + return _c +} + +// FTDictDump provides a mock function with given fields: ctx, dict +func (_m *MockCmdable) FTDictDump(ctx context.Context, dict string) *redis.StringSliceCmd { + ret := _m.Called(ctx, dict) + + if len(ret) == 0 { + panic("no return value specified for FTDictDump") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, dict) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_FTDictDump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTDictDump' +type MockCmdable_FTDictDump_Call struct { + *mock.Call +} + +// FTDictDump is a helper method to define mock.On call +// - ctx context.Context +// - dict string +func (_e *MockCmdable_Expecter) FTDictDump(ctx interface{}, dict interface{}) *MockCmdable_FTDictDump_Call { + return &MockCmdable_FTDictDump_Call{Call: _e.mock.On("FTDictDump", ctx, dict)} +} + +func (_c *MockCmdable_FTDictDump_Call) Run(run func(ctx context.Context, dict string)) *MockCmdable_FTDictDump_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTDictDump_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_FTDictDump_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTDictDump_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_FTDictDump_Call { + _c.Call.Return(run) + return _c +} + +// FTDropIndex provides a mock function with given fields: ctx, index +func (_m *MockCmdable) FTDropIndex(ctx context.Context, index string) *redis.StatusCmd { + ret := _m.Called(ctx, index) + + if len(ret) == 0 { + panic("no return value specified for FTDropIndex") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, index) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTDropIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTDropIndex' +type MockCmdable_FTDropIndex_Call struct { + *mock.Call +} + +// FTDropIndex is a helper method to define mock.On call +// - ctx context.Context +// - index string +func (_e *MockCmdable_Expecter) FTDropIndex(ctx interface{}, index interface{}) *MockCmdable_FTDropIndex_Call { + return &MockCmdable_FTDropIndex_Call{Call: _e.mock.On("FTDropIndex", ctx, index)} +} + +func (_c *MockCmdable_FTDropIndex_Call) Run(run func(ctx context.Context, index string)) *MockCmdable_FTDropIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTDropIndex_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTDropIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTDropIndex_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_FTDropIndex_Call { + _c.Call.Return(run) + return _c +} + +// FTDropIndexWithArgs provides a mock function with given fields: ctx, index, options +func (_m *MockCmdable) FTDropIndexWithArgs(ctx context.Context, index string, options *redis.FTDropIndexOptions) *redis.StatusCmd { + ret := _m.Called(ctx, index, options) + + if len(ret) == 0 { + panic("no return value specified for FTDropIndexWithArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.FTDropIndexOptions) *redis.StatusCmd); ok { + r0 = rf(ctx, index, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTDropIndexWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTDropIndexWithArgs' +type MockCmdable_FTDropIndexWithArgs_Call struct { + *mock.Call +} + +// FTDropIndexWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - options *redis.FTDropIndexOptions +func (_e *MockCmdable_Expecter) FTDropIndexWithArgs(ctx interface{}, index interface{}, options interface{}) *MockCmdable_FTDropIndexWithArgs_Call { + return &MockCmdable_FTDropIndexWithArgs_Call{Call: _e.mock.On("FTDropIndexWithArgs", ctx, index, options)} +} + +func (_c *MockCmdable_FTDropIndexWithArgs_Call) Run(run func(ctx context.Context, index string, options *redis.FTDropIndexOptions)) *MockCmdable_FTDropIndexWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.FTDropIndexOptions)) + }) + return _c +} + +func (_c *MockCmdable_FTDropIndexWithArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTDropIndexWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTDropIndexWithArgs_Call) RunAndReturn(run func(context.Context, string, *redis.FTDropIndexOptions) *redis.StatusCmd) *MockCmdable_FTDropIndexWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// FTExplain provides a mock function with given fields: ctx, index, query +func (_m *MockCmdable) FTExplain(ctx context.Context, index string, query string) *redis.StringCmd { + ret := _m.Called(ctx, index, query) + + if len(ret) == 0 { + panic("no return value specified for FTExplain") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StringCmd); ok { + r0 = rf(ctx, index, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FTExplain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTExplain' +type MockCmdable_FTExplain_Call struct { + *mock.Call +} + +// FTExplain is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +func (_e *MockCmdable_Expecter) FTExplain(ctx interface{}, index interface{}, query interface{}) *MockCmdable_FTExplain_Call { + return &MockCmdable_FTExplain_Call{Call: _e.mock.On("FTExplain", ctx, index, query)} +} + +func (_c *MockCmdable_FTExplain_Call) Run(run func(ctx context.Context, index string, query string)) *MockCmdable_FTExplain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTExplain_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FTExplain_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTExplain_Call) RunAndReturn(run func(context.Context, string, string) *redis.StringCmd) *MockCmdable_FTExplain_Call { + _c.Call.Return(run) + return _c +} + +// FTExplainWithArgs provides a mock function with given fields: ctx, index, query, options +func (_m *MockCmdable) FTExplainWithArgs(ctx context.Context, index string, query string, options *redis.FTExplainOptions) *redis.StringCmd { + ret := _m.Called(ctx, index, query, options) + + if len(ret) == 0 { + panic("no return value specified for FTExplainWithArgs") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.FTExplainOptions) *redis.StringCmd); ok { + r0 = rf(ctx, index, query, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FTExplainWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTExplainWithArgs' +type MockCmdable_FTExplainWithArgs_Call struct { + *mock.Call +} + +// FTExplainWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +// - options *redis.FTExplainOptions +func (_e *MockCmdable_Expecter) FTExplainWithArgs(ctx interface{}, index interface{}, query interface{}, options interface{}) *MockCmdable_FTExplainWithArgs_Call { + return &MockCmdable_FTExplainWithArgs_Call{Call: _e.mock.On("FTExplainWithArgs", ctx, index, query, options)} +} + +func (_c *MockCmdable_FTExplainWithArgs_Call) Run(run func(ctx context.Context, index string, query string, options *redis.FTExplainOptions)) *MockCmdable_FTExplainWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.FTExplainOptions)) + }) + return _c +} + +func (_c *MockCmdable_FTExplainWithArgs_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FTExplainWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTExplainWithArgs_Call) RunAndReturn(run func(context.Context, string, string, *redis.FTExplainOptions) *redis.StringCmd) *MockCmdable_FTExplainWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// FTInfo provides a mock function with given fields: ctx, index +func (_m *MockCmdable) FTInfo(ctx context.Context, index string) *redis.FTInfoCmd { + ret := _m.Called(ctx, index) + + if len(ret) == 0 { + panic("no return value specified for FTInfo") + } + + var r0 *redis.FTInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.FTInfoCmd); ok { + r0 = rf(ctx, index) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FTInfoCmd) + } + } + + return r0 +} + +// MockCmdable_FTInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTInfo' +type MockCmdable_FTInfo_Call struct { + *mock.Call +} + +// FTInfo is a helper method to define mock.On call +// - ctx context.Context +// - index string +func (_e *MockCmdable_Expecter) FTInfo(ctx interface{}, index interface{}) *MockCmdable_FTInfo_Call { + return &MockCmdable_FTInfo_Call{Call: _e.mock.On("FTInfo", ctx, index)} +} + +func (_c *MockCmdable_FTInfo_Call) Run(run func(ctx context.Context, index string)) *MockCmdable_FTInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTInfo_Call) Return(_a0 *redis.FTInfoCmd) *MockCmdable_FTInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTInfo_Call) RunAndReturn(run func(context.Context, string) *redis.FTInfoCmd) *MockCmdable_FTInfo_Call { + _c.Call.Return(run) + return _c +} + +// FTSearch provides a mock function with given fields: ctx, index, query +func (_m *MockCmdable) FTSearch(ctx context.Context, index string, query string) *redis.FTSearchCmd { + ret := _m.Called(ctx, index, query) + + if len(ret) == 0 { + panic("no return value specified for FTSearch") + } + + var r0 *redis.FTSearchCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.FTSearchCmd); ok { + r0 = rf(ctx, index, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FTSearchCmd) + } + } + + return r0 +} + +// MockCmdable_FTSearch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTSearch' +type MockCmdable_FTSearch_Call struct { + *mock.Call +} + +// FTSearch is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +func (_e *MockCmdable_Expecter) FTSearch(ctx interface{}, index interface{}, query interface{}) *MockCmdable_FTSearch_Call { + return &MockCmdable_FTSearch_Call{Call: _e.mock.On("FTSearch", ctx, index, query)} +} + +func (_c *MockCmdable_FTSearch_Call) Run(run func(ctx context.Context, index string, query string)) *MockCmdable_FTSearch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTSearch_Call) Return(_a0 *redis.FTSearchCmd) *MockCmdable_FTSearch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTSearch_Call) RunAndReturn(run func(context.Context, string, string) *redis.FTSearchCmd) *MockCmdable_FTSearch_Call { + _c.Call.Return(run) + return _c +} + +// FTSearchWithArgs provides a mock function with given fields: ctx, index, query, options +func (_m *MockCmdable) FTSearchWithArgs(ctx context.Context, index string, query string, options *redis.FTSearchOptions) *redis.FTSearchCmd { + ret := _m.Called(ctx, index, query, options) + + if len(ret) == 0 { + panic("no return value specified for FTSearchWithArgs") + } + + var r0 *redis.FTSearchCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.FTSearchOptions) *redis.FTSearchCmd); ok { + r0 = rf(ctx, index, query, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FTSearchCmd) + } + } + + return r0 +} + +// MockCmdable_FTSearchWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTSearchWithArgs' +type MockCmdable_FTSearchWithArgs_Call struct { + *mock.Call +} + +// FTSearchWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +// - options *redis.FTSearchOptions +func (_e *MockCmdable_Expecter) FTSearchWithArgs(ctx interface{}, index interface{}, query interface{}, options interface{}) *MockCmdable_FTSearchWithArgs_Call { + return &MockCmdable_FTSearchWithArgs_Call{Call: _e.mock.On("FTSearchWithArgs", ctx, index, query, options)} +} + +func (_c *MockCmdable_FTSearchWithArgs_Call) Run(run func(ctx context.Context, index string, query string, options *redis.FTSearchOptions)) *MockCmdable_FTSearchWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.FTSearchOptions)) + }) + return _c +} + +func (_c *MockCmdable_FTSearchWithArgs_Call) Return(_a0 *redis.FTSearchCmd) *MockCmdable_FTSearchWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTSearchWithArgs_Call) RunAndReturn(run func(context.Context, string, string, *redis.FTSearchOptions) *redis.FTSearchCmd) *MockCmdable_FTSearchWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// FTSpellCheck provides a mock function with given fields: ctx, index, query +func (_m *MockCmdable) FTSpellCheck(ctx context.Context, index string, query string) *redis.FTSpellCheckCmd { + ret := _m.Called(ctx, index, query) + + if len(ret) == 0 { + panic("no return value specified for FTSpellCheck") + } + + var r0 *redis.FTSpellCheckCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.FTSpellCheckCmd); ok { + r0 = rf(ctx, index, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FTSpellCheckCmd) + } + } + + return r0 +} + +// MockCmdable_FTSpellCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTSpellCheck' +type MockCmdable_FTSpellCheck_Call struct { + *mock.Call +} + +// FTSpellCheck is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +func (_e *MockCmdable_Expecter) FTSpellCheck(ctx interface{}, index interface{}, query interface{}) *MockCmdable_FTSpellCheck_Call { + return &MockCmdable_FTSpellCheck_Call{Call: _e.mock.On("FTSpellCheck", ctx, index, query)} +} + +func (_c *MockCmdable_FTSpellCheck_Call) Run(run func(ctx context.Context, index string, query string)) *MockCmdable_FTSpellCheck_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTSpellCheck_Call) Return(_a0 *redis.FTSpellCheckCmd) *MockCmdable_FTSpellCheck_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTSpellCheck_Call) RunAndReturn(run func(context.Context, string, string) *redis.FTSpellCheckCmd) *MockCmdable_FTSpellCheck_Call { + _c.Call.Return(run) + return _c +} + +// FTSpellCheckWithArgs provides a mock function with given fields: ctx, index, query, options +func (_m *MockCmdable) FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd { + ret := _m.Called(ctx, index, query, options) + + if len(ret) == 0 { + panic("no return value specified for FTSpellCheckWithArgs") + } + + var r0 *redis.FTSpellCheckCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd); ok { + r0 = rf(ctx, index, query, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FTSpellCheckCmd) + } + } + + return r0 +} + +// MockCmdable_FTSpellCheckWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTSpellCheckWithArgs' +type MockCmdable_FTSpellCheckWithArgs_Call struct { + *mock.Call +} + +// FTSpellCheckWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +// - options *redis.FTSpellCheckOptions +func (_e *MockCmdable_Expecter) FTSpellCheckWithArgs(ctx interface{}, index interface{}, query interface{}, options interface{}) *MockCmdable_FTSpellCheckWithArgs_Call { + return &MockCmdable_FTSpellCheckWithArgs_Call{Call: _e.mock.On("FTSpellCheckWithArgs", ctx, index, query, options)} +} + +func (_c *MockCmdable_FTSpellCheckWithArgs_Call) Run(run func(ctx context.Context, index string, query string, options *redis.FTSpellCheckOptions)) *MockCmdable_FTSpellCheckWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.FTSpellCheckOptions)) + }) + return _c +} + +func (_c *MockCmdable_FTSpellCheckWithArgs_Call) Return(_a0 *redis.FTSpellCheckCmd) *MockCmdable_FTSpellCheckWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTSpellCheckWithArgs_Call) RunAndReturn(run func(context.Context, string, string, *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd) *MockCmdable_FTSpellCheckWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// FTSynDump provides a mock function with given fields: ctx, index +func (_m *MockCmdable) FTSynDump(ctx context.Context, index string) *redis.FTSynDumpCmd { + ret := _m.Called(ctx, index) + + if len(ret) == 0 { + panic("no return value specified for FTSynDump") + } + + var r0 *redis.FTSynDumpCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.FTSynDumpCmd); ok { + r0 = rf(ctx, index) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FTSynDumpCmd) + } + } + + return r0 +} + +// MockCmdable_FTSynDump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTSynDump' +type MockCmdable_FTSynDump_Call struct { + *mock.Call +} + +// FTSynDump is a helper method to define mock.On call +// - ctx context.Context +// - index string +func (_e *MockCmdable_Expecter) FTSynDump(ctx interface{}, index interface{}) *MockCmdable_FTSynDump_Call { + return &MockCmdable_FTSynDump_Call{Call: _e.mock.On("FTSynDump", ctx, index)} +} + +func (_c *MockCmdable_FTSynDump_Call) Run(run func(ctx context.Context, index string)) *MockCmdable_FTSynDump_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTSynDump_Call) Return(_a0 *redis.FTSynDumpCmd) *MockCmdable_FTSynDump_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTSynDump_Call) RunAndReturn(run func(context.Context, string) *redis.FTSynDumpCmd) *MockCmdable_FTSynDump_Call { + _c.Call.Return(run) + return _c +} + +// FTSynUpdate provides a mock function with given fields: ctx, index, synGroupId, terms +func (_m *MockCmdable) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *redis.StatusCmd { + ret := _m.Called(ctx, index, synGroupId, terms) + + if len(ret) == 0 { + panic("no return value specified for FTSynUpdate") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, []interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, index, synGroupId, terms) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTSynUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTSynUpdate' +type MockCmdable_FTSynUpdate_Call struct { + *mock.Call +} + +// FTSynUpdate is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - synGroupId interface{} +// - terms []interface{} +func (_e *MockCmdable_Expecter) FTSynUpdate(ctx interface{}, index interface{}, synGroupId interface{}, terms interface{}) *MockCmdable_FTSynUpdate_Call { + return &MockCmdable_FTSynUpdate_Call{Call: _e.mock.On("FTSynUpdate", ctx, index, synGroupId, terms)} +} + +func (_c *MockCmdable_FTSynUpdate_Call) Run(run func(ctx context.Context, index string, synGroupId interface{}, terms []interface{})) *MockCmdable_FTSynUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].([]interface{})) + }) + return _c +} + +func (_c *MockCmdable_FTSynUpdate_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTSynUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTSynUpdate_Call) RunAndReturn(run func(context.Context, string, interface{}, []interface{}) *redis.StatusCmd) *MockCmdable_FTSynUpdate_Call { + _c.Call.Return(run) + return _c +} + +// FTSynUpdateWithArgs provides a mock function with given fields: ctx, index, synGroupId, options, terms +func (_m *MockCmdable) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *redis.FTSynUpdateOptions, terms []interface{}) *redis.StatusCmd { + ret := _m.Called(ctx, index, synGroupId, options, terms) + + if len(ret) == 0 { + panic("no return value specified for FTSynUpdateWithArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, *redis.FTSynUpdateOptions, []interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, index, synGroupId, options, terms) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FTSynUpdateWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTSynUpdateWithArgs' +type MockCmdable_FTSynUpdateWithArgs_Call struct { + *mock.Call +} + +// FTSynUpdateWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - synGroupId interface{} +// - options *redis.FTSynUpdateOptions +// - terms []interface{} +func (_e *MockCmdable_Expecter) FTSynUpdateWithArgs(ctx interface{}, index interface{}, synGroupId interface{}, options interface{}, terms interface{}) *MockCmdable_FTSynUpdateWithArgs_Call { + return &MockCmdable_FTSynUpdateWithArgs_Call{Call: _e.mock.On("FTSynUpdateWithArgs", ctx, index, synGroupId, options, terms)} +} + +func (_c *MockCmdable_FTSynUpdateWithArgs_Call) Run(run func(ctx context.Context, index string, synGroupId interface{}, options *redis.FTSynUpdateOptions, terms []interface{})) *MockCmdable_FTSynUpdateWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(*redis.FTSynUpdateOptions), args[4].([]interface{})) + }) + return _c +} + +func (_c *MockCmdable_FTSynUpdateWithArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FTSynUpdateWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTSynUpdateWithArgs_Call) RunAndReturn(run func(context.Context, string, interface{}, *redis.FTSynUpdateOptions, []interface{}) *redis.StatusCmd) *MockCmdable_FTSynUpdateWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// FTTagVals provides a mock function with given fields: ctx, index, field +func (_m *MockCmdable) FTTagVals(ctx context.Context, index string, field string) *redis.StringSliceCmd { + ret := _m.Called(ctx, index, field) + + if len(ret) == 0 { + panic("no return value specified for FTTagVals") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, index, field) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_FTTagVals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FTTagVals' +type MockCmdable_FTTagVals_Call struct { + *mock.Call +} + +// FTTagVals is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - field string +func (_e *MockCmdable_Expecter) FTTagVals(ctx interface{}, index interface{}, field interface{}) *MockCmdable_FTTagVals_Call { + return &MockCmdable_FTTagVals_Call{Call: _e.mock.On("FTTagVals", ctx, index, field)} +} + +func (_c *MockCmdable_FTTagVals_Call) Run(run func(ctx context.Context, index string, field string)) *MockCmdable_FTTagVals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_FTTagVals_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_FTTagVals_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FTTagVals_Call) RunAndReturn(run func(context.Context, string, string) *redis.StringSliceCmd) *MockCmdable_FTTagVals_Call { + _c.Call.Return(run) + return _c +} + +// FT_List provides a mock function with given fields: ctx +func (_m *MockCmdable) FT_List(ctx context.Context) *redis.StringSliceCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FT_List") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringSliceCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_FT_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FT_List' +type MockCmdable_FT_List_Call struct { + *mock.Call +} + +// FT_List is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FT_List(ctx interface{}) *MockCmdable_FT_List_Call { + return &MockCmdable_FT_List_Call{Call: _e.mock.On("FT_List", ctx)} +} + +func (_c *MockCmdable_FT_List_Call) Run(run func(ctx context.Context)) *MockCmdable_FT_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FT_List_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_FT_List_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FT_List_Call) RunAndReturn(run func(context.Context) *redis.StringSliceCmd) *MockCmdable_FT_List_Call { + _c.Call.Return(run) + return _c +} + +// FlushAll provides a mock function with given fields: ctx +func (_m *MockCmdable) FlushAll(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FlushAll") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FlushAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushAll' +type MockCmdable_FlushAll_Call struct { + *mock.Call +} + +// FlushAll is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FlushAll(ctx interface{}) *MockCmdable_FlushAll_Call { + return &MockCmdable_FlushAll_Call{Call: _e.mock.On("FlushAll", ctx)} +} + +func (_c *MockCmdable_FlushAll_Call) Run(run func(ctx context.Context)) *MockCmdable_FlushAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FlushAll_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FlushAll_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FlushAll_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_FlushAll_Call { + _c.Call.Return(run) + return _c +} + +// FlushAllAsync provides a mock function with given fields: ctx +func (_m *MockCmdable) FlushAllAsync(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FlushAllAsync") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FlushAllAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushAllAsync' +type MockCmdable_FlushAllAsync_Call struct { + *mock.Call +} + +// FlushAllAsync is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FlushAllAsync(ctx interface{}) *MockCmdable_FlushAllAsync_Call { + return &MockCmdable_FlushAllAsync_Call{Call: _e.mock.On("FlushAllAsync", ctx)} +} + +func (_c *MockCmdable_FlushAllAsync_Call) Run(run func(ctx context.Context)) *MockCmdable_FlushAllAsync_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FlushAllAsync_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FlushAllAsync_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FlushAllAsync_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_FlushAllAsync_Call { + _c.Call.Return(run) + return _c +} + +// FlushDB provides a mock function with given fields: ctx +func (_m *MockCmdable) FlushDB(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FlushDB") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FlushDB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushDB' +type MockCmdable_FlushDB_Call struct { + *mock.Call +} + +// FlushDB is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FlushDB(ctx interface{}) *MockCmdable_FlushDB_Call { + return &MockCmdable_FlushDB_Call{Call: _e.mock.On("FlushDB", ctx)} +} + +func (_c *MockCmdable_FlushDB_Call) Run(run func(ctx context.Context)) *MockCmdable_FlushDB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FlushDB_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FlushDB_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FlushDB_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_FlushDB_Call { + _c.Call.Return(run) + return _c +} + +// FlushDBAsync provides a mock function with given fields: ctx +func (_m *MockCmdable) FlushDBAsync(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FlushDBAsync") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_FlushDBAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushDBAsync' +type MockCmdable_FlushDBAsync_Call struct { + *mock.Call +} + +// FlushDBAsync is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FlushDBAsync(ctx interface{}) *MockCmdable_FlushDBAsync_Call { + return &MockCmdable_FlushDBAsync_Call{Call: _e.mock.On("FlushDBAsync", ctx)} +} + +func (_c *MockCmdable_FlushDBAsync_Call) Run(run func(ctx context.Context)) *MockCmdable_FlushDBAsync_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FlushDBAsync_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_FlushDBAsync_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FlushDBAsync_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_FlushDBAsync_Call { + _c.Call.Return(run) + return _c +} + +// FunctionDelete provides a mock function with given fields: ctx, libName +func (_m *MockCmdable) FunctionDelete(ctx context.Context, libName string) *redis.StringCmd { + ret := _m.Called(ctx, libName) + + if len(ret) == 0 { + panic("no return value specified for FunctionDelete") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, libName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionDelete' +type MockCmdable_FunctionDelete_Call struct { + *mock.Call +} + +// FunctionDelete is a helper method to define mock.On call +// - ctx context.Context +// - libName string +func (_e *MockCmdable_Expecter) FunctionDelete(ctx interface{}, libName interface{}) *MockCmdable_FunctionDelete_Call { + return &MockCmdable_FunctionDelete_Call{Call: _e.mock.On("FunctionDelete", ctx, libName)} +} + +func (_c *MockCmdable_FunctionDelete_Call) Run(run func(ctx context.Context, libName string)) *MockCmdable_FunctionDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FunctionDelete_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FunctionDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionDelete_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_FunctionDelete_Call { + _c.Call.Return(run) + return _c +} + +// FunctionDump provides a mock function with given fields: ctx +func (_m *MockCmdable) FunctionDump(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FunctionDump") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionDump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionDump' +type MockCmdable_FunctionDump_Call struct { + *mock.Call +} + +// FunctionDump is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FunctionDump(ctx interface{}) *MockCmdable_FunctionDump_Call { + return &MockCmdable_FunctionDump_Call{Call: _e.mock.On("FunctionDump", ctx)} +} + +func (_c *MockCmdable_FunctionDump_Call) Run(run func(ctx context.Context)) *MockCmdable_FunctionDump_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FunctionDump_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FunctionDump_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionDump_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_FunctionDump_Call { + _c.Call.Return(run) + return _c +} + +// FunctionFlush provides a mock function with given fields: ctx +func (_m *MockCmdable) FunctionFlush(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FunctionFlush") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionFlush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionFlush' +type MockCmdable_FunctionFlush_Call struct { + *mock.Call +} + +// FunctionFlush is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FunctionFlush(ctx interface{}) *MockCmdable_FunctionFlush_Call { + return &MockCmdable_FunctionFlush_Call{Call: _e.mock.On("FunctionFlush", ctx)} +} + +func (_c *MockCmdable_FunctionFlush_Call) Run(run func(ctx context.Context)) *MockCmdable_FunctionFlush_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FunctionFlush_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FunctionFlush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionFlush_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_FunctionFlush_Call { + _c.Call.Return(run) + return _c +} + +// FunctionFlushAsync provides a mock function with given fields: ctx +func (_m *MockCmdable) FunctionFlushAsync(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FunctionFlushAsync") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionFlushAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionFlushAsync' +type MockCmdable_FunctionFlushAsync_Call struct { + *mock.Call +} + +// FunctionFlushAsync is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FunctionFlushAsync(ctx interface{}) *MockCmdable_FunctionFlushAsync_Call { + return &MockCmdable_FunctionFlushAsync_Call{Call: _e.mock.On("FunctionFlushAsync", ctx)} +} + +func (_c *MockCmdable_FunctionFlushAsync_Call) Run(run func(ctx context.Context)) *MockCmdable_FunctionFlushAsync_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FunctionFlushAsync_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FunctionFlushAsync_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionFlushAsync_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_FunctionFlushAsync_Call { + _c.Call.Return(run) + return _c +} + +// FunctionKill provides a mock function with given fields: ctx +func (_m *MockCmdable) FunctionKill(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FunctionKill") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionKill_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionKill' +type MockCmdable_FunctionKill_Call struct { + *mock.Call +} + +// FunctionKill is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FunctionKill(ctx interface{}) *MockCmdable_FunctionKill_Call { + return &MockCmdable_FunctionKill_Call{Call: _e.mock.On("FunctionKill", ctx)} +} + +func (_c *MockCmdable_FunctionKill_Call) Run(run func(ctx context.Context)) *MockCmdable_FunctionKill_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FunctionKill_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FunctionKill_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionKill_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_FunctionKill_Call { + _c.Call.Return(run) + return _c +} + +// FunctionList provides a mock function with given fields: ctx, q +func (_m *MockCmdable) FunctionList(ctx context.Context, q redis.FunctionListQuery) *redis.FunctionListCmd { + ret := _m.Called(ctx, q) + + if len(ret) == 0 { + panic("no return value specified for FunctionList") + } + + var r0 *redis.FunctionListCmd + if rf, ok := ret.Get(0).(func(context.Context, redis.FunctionListQuery) *redis.FunctionListCmd); ok { + r0 = rf(ctx, q) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FunctionListCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionList' +type MockCmdable_FunctionList_Call struct { + *mock.Call +} + +// FunctionList is a helper method to define mock.On call +// - ctx context.Context +// - q redis.FunctionListQuery +func (_e *MockCmdable_Expecter) FunctionList(ctx interface{}, q interface{}) *MockCmdable_FunctionList_Call { + return &MockCmdable_FunctionList_Call{Call: _e.mock.On("FunctionList", ctx, q)} +} + +func (_c *MockCmdable_FunctionList_Call) Run(run func(ctx context.Context, q redis.FunctionListQuery)) *MockCmdable_FunctionList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.FunctionListQuery)) + }) + return _c +} + +func (_c *MockCmdable_FunctionList_Call) Return(_a0 *redis.FunctionListCmd) *MockCmdable_FunctionList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionList_Call) RunAndReturn(run func(context.Context, redis.FunctionListQuery) *redis.FunctionListCmd) *MockCmdable_FunctionList_Call { + _c.Call.Return(run) + return _c +} + +// FunctionLoad provides a mock function with given fields: ctx, code +func (_m *MockCmdable) FunctionLoad(ctx context.Context, code string) *redis.StringCmd { + ret := _m.Called(ctx, code) + + if len(ret) == 0 { + panic("no return value specified for FunctionLoad") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, code) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionLoad_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionLoad' +type MockCmdable_FunctionLoad_Call struct { + *mock.Call +} + +// FunctionLoad is a helper method to define mock.On call +// - ctx context.Context +// - code string +func (_e *MockCmdable_Expecter) FunctionLoad(ctx interface{}, code interface{}) *MockCmdable_FunctionLoad_Call { + return &MockCmdable_FunctionLoad_Call{Call: _e.mock.On("FunctionLoad", ctx, code)} +} + +func (_c *MockCmdable_FunctionLoad_Call) Run(run func(ctx context.Context, code string)) *MockCmdable_FunctionLoad_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FunctionLoad_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FunctionLoad_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionLoad_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_FunctionLoad_Call { + _c.Call.Return(run) + return _c +} + +// FunctionLoadReplace provides a mock function with given fields: ctx, code +func (_m *MockCmdable) FunctionLoadReplace(ctx context.Context, code string) *redis.StringCmd { + ret := _m.Called(ctx, code) + + if len(ret) == 0 { + panic("no return value specified for FunctionLoadReplace") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, code) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionLoadReplace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionLoadReplace' +type MockCmdable_FunctionLoadReplace_Call struct { + *mock.Call +} + +// FunctionLoadReplace is a helper method to define mock.On call +// - ctx context.Context +// - code string +func (_e *MockCmdable_Expecter) FunctionLoadReplace(ctx interface{}, code interface{}) *MockCmdable_FunctionLoadReplace_Call { + return &MockCmdable_FunctionLoadReplace_Call{Call: _e.mock.On("FunctionLoadReplace", ctx, code)} +} + +func (_c *MockCmdable_FunctionLoadReplace_Call) Run(run func(ctx context.Context, code string)) *MockCmdable_FunctionLoadReplace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FunctionLoadReplace_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FunctionLoadReplace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionLoadReplace_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_FunctionLoadReplace_Call { + _c.Call.Return(run) + return _c +} + +// FunctionRestore provides a mock function with given fields: ctx, libDump +func (_m *MockCmdable) FunctionRestore(ctx context.Context, libDump string) *redis.StringCmd { + ret := _m.Called(ctx, libDump) + + if len(ret) == 0 { + panic("no return value specified for FunctionRestore") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, libDump) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionRestore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionRestore' +type MockCmdable_FunctionRestore_Call struct { + *mock.Call +} + +// FunctionRestore is a helper method to define mock.On call +// - ctx context.Context +// - libDump string +func (_e *MockCmdable_Expecter) FunctionRestore(ctx interface{}, libDump interface{}) *MockCmdable_FunctionRestore_Call { + return &MockCmdable_FunctionRestore_Call{Call: _e.mock.On("FunctionRestore", ctx, libDump)} +} + +func (_c *MockCmdable_FunctionRestore_Call) Run(run func(ctx context.Context, libDump string)) *MockCmdable_FunctionRestore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_FunctionRestore_Call) Return(_a0 *redis.StringCmd) *MockCmdable_FunctionRestore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionRestore_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_FunctionRestore_Call { + _c.Call.Return(run) + return _c +} + +// FunctionStats provides a mock function with given fields: ctx +func (_m *MockCmdable) FunctionStats(ctx context.Context) *redis.FunctionStatsCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for FunctionStats") + } + + var r0 *redis.FunctionStatsCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.FunctionStatsCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FunctionStatsCmd) + } + } + + return r0 +} + +// MockCmdable_FunctionStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionStats' +type MockCmdable_FunctionStats_Call struct { + *mock.Call +} + +// FunctionStats is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) FunctionStats(ctx interface{}) *MockCmdable_FunctionStats_Call { + return &MockCmdable_FunctionStats_Call{Call: _e.mock.On("FunctionStats", ctx)} +} + +func (_c *MockCmdable_FunctionStats_Call) Run(run func(ctx context.Context)) *MockCmdable_FunctionStats_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_FunctionStats_Call) Return(_a0 *redis.FunctionStatsCmd) *MockCmdable_FunctionStats_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_FunctionStats_Call) RunAndReturn(run func(context.Context) *redis.FunctionStatsCmd) *MockCmdable_FunctionStats_Call { + _c.Call.Return(run) + return _c +} + +// GeoAdd provides a mock function with given fields: ctx, key, geoLocation +func (_m *MockCmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd { + _va := make([]interface{}, len(geoLocation)) + for _i := range geoLocation { + _va[_i] = geoLocation[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GeoAdd") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...*redis.GeoLocation) *redis.IntCmd); ok { + r0 = rf(ctx, key, geoLocation...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_GeoAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoAdd' +type MockCmdable_GeoAdd_Call struct { + *mock.Call +} + +// GeoAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - geoLocation ...*redis.GeoLocation +func (_e *MockCmdable_Expecter) GeoAdd(ctx interface{}, key interface{}, geoLocation ...interface{}) *MockCmdable_GeoAdd_Call { + return &MockCmdable_GeoAdd_Call{Call: _e.mock.On("GeoAdd", + append([]interface{}{ctx, key}, geoLocation...)...)} +} + +func (_c *MockCmdable_GeoAdd_Call) Run(run func(ctx context.Context, key string, geoLocation ...*redis.GeoLocation)) *MockCmdable_GeoAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]*redis.GeoLocation, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(*redis.GeoLocation) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_GeoAdd_Call) Return(_a0 *redis.IntCmd) *MockCmdable_GeoAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoAdd_Call) RunAndReturn(run func(context.Context, string, ...*redis.GeoLocation) *redis.IntCmd) *MockCmdable_GeoAdd_Call { + _c.Call.Return(run) + return _c +} + +// GeoDist provides a mock function with given fields: ctx, key, member1, member2, unit +func (_m *MockCmdable) GeoDist(ctx context.Context, key string, member1 string, member2 string, unit string) *redis.FloatCmd { + ret := _m.Called(ctx, key, member1, member2, unit) + + if len(ret) == 0 { + panic("no return value specified for GeoDist") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) *redis.FloatCmd); ok { + r0 = rf(ctx, key, member1, member2, unit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_GeoDist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoDist' +type MockCmdable_GeoDist_Call struct { + *mock.Call +} + +// GeoDist is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member1 string +// - member2 string +// - unit string +func (_e *MockCmdable_Expecter) GeoDist(ctx interface{}, key interface{}, member1 interface{}, member2 interface{}, unit interface{}) *MockCmdable_GeoDist_Call { + return &MockCmdable_GeoDist_Call{Call: _e.mock.On("GeoDist", ctx, key, member1, member2, unit)} +} + +func (_c *MockCmdable_GeoDist_Call) Run(run func(ctx context.Context, key string, member1 string, member2 string, unit string)) *MockCmdable_GeoDist_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *MockCmdable_GeoDist_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_GeoDist_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoDist_Call) RunAndReturn(run func(context.Context, string, string, string, string) *redis.FloatCmd) *MockCmdable_GeoDist_Call { + _c.Call.Return(run) + return _c +} + +// GeoHash provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd { + _va := make([]interface{}, len(members)) + for _i := range members { + _va[_i] = members[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GeoHash") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_GeoHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoHash' +type MockCmdable_GeoHash_Call struct { + *mock.Call +} + +// GeoHash is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...string +func (_e *MockCmdable_Expecter) GeoHash(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_GeoHash_Call { + return &MockCmdable_GeoHash_Call{Call: _e.mock.On("GeoHash", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_GeoHash_Call) Run(run func(ctx context.Context, key string, members ...string)) *MockCmdable_GeoHash_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_GeoHash_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_GeoHash_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoHash_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.StringSliceCmd) *MockCmdable_GeoHash_Call { + _c.Call.Return(run) + return _c +} + +// GeoPos provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd { + _va := make([]interface{}, len(members)) + for _i := range members { + _va[_i] = members[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GeoPos") + } + + var r0 *redis.GeoPosCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.GeoPosCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.GeoPosCmd) + } + } + + return r0 +} + +// MockCmdable_GeoPos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoPos' +type MockCmdable_GeoPos_Call struct { + *mock.Call +} + +// GeoPos is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...string +func (_e *MockCmdable_Expecter) GeoPos(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_GeoPos_Call { + return &MockCmdable_GeoPos_Call{Call: _e.mock.On("GeoPos", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_GeoPos_Call) Run(run func(ctx context.Context, key string, members ...string)) *MockCmdable_GeoPos_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_GeoPos_Call) Return(_a0 *redis.GeoPosCmd) *MockCmdable_GeoPos_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoPos_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.GeoPosCmd) *MockCmdable_GeoPos_Call { + _c.Call.Return(run) + return _c +} + +// GeoRadius provides a mock function with given fields: ctx, key, longitude, latitude, query +func (_m *MockCmdable) GeoRadius(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + ret := _m.Called(ctx, key, longitude, latitude, query) + + if len(ret) == 0 { + panic("no return value specified for GeoRadius") + } + + var r0 *redis.GeoLocationCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, float64, *redis.GeoRadiusQuery) *redis.GeoLocationCmd); ok { + r0 = rf(ctx, key, longitude, latitude, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.GeoLocationCmd) + } + } + + return r0 +} + +// MockCmdable_GeoRadius_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoRadius' +type MockCmdable_GeoRadius_Call struct { + *mock.Call +} + +// GeoRadius is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - longitude float64 +// - latitude float64 +// - query *redis.GeoRadiusQuery +func (_e *MockCmdable_Expecter) GeoRadius(ctx interface{}, key interface{}, longitude interface{}, latitude interface{}, query interface{}) *MockCmdable_GeoRadius_Call { + return &MockCmdable_GeoRadius_Call{Call: _e.mock.On("GeoRadius", ctx, key, longitude, latitude, query)} +} + +func (_c *MockCmdable_GeoRadius_Call) Run(run func(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery)) *MockCmdable_GeoRadius_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(float64), args[4].(*redis.GeoRadiusQuery)) + }) + return _c +} + +func (_c *MockCmdable_GeoRadius_Call) Return(_a0 *redis.GeoLocationCmd) *MockCmdable_GeoRadius_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoRadius_Call) RunAndReturn(run func(context.Context, string, float64, float64, *redis.GeoRadiusQuery) *redis.GeoLocationCmd) *MockCmdable_GeoRadius_Call { + _c.Call.Return(run) + return _c +} + +// GeoRadiusByMember provides a mock function with given fields: ctx, key, member, query +func (_m *MockCmdable) GeoRadiusByMember(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + ret := _m.Called(ctx, key, member, query) + + if len(ret) == 0 { + panic("no return value specified for GeoRadiusByMember") + } + + var r0 *redis.GeoLocationCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.GeoRadiusQuery) *redis.GeoLocationCmd); ok { + r0 = rf(ctx, key, member, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.GeoLocationCmd) + } + } + + return r0 +} + +// MockCmdable_GeoRadiusByMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoRadiusByMember' +type MockCmdable_GeoRadiusByMember_Call struct { + *mock.Call +} + +// GeoRadiusByMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +// - query *redis.GeoRadiusQuery +func (_e *MockCmdable_Expecter) GeoRadiusByMember(ctx interface{}, key interface{}, member interface{}, query interface{}) *MockCmdable_GeoRadiusByMember_Call { + return &MockCmdable_GeoRadiusByMember_Call{Call: _e.mock.On("GeoRadiusByMember", ctx, key, member, query)} +} + +func (_c *MockCmdable_GeoRadiusByMember_Call) Run(run func(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery)) *MockCmdable_GeoRadiusByMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.GeoRadiusQuery)) + }) + return _c +} + +func (_c *MockCmdable_GeoRadiusByMember_Call) Return(_a0 *redis.GeoLocationCmd) *MockCmdable_GeoRadiusByMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoRadiusByMember_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoRadiusQuery) *redis.GeoLocationCmd) *MockCmdable_GeoRadiusByMember_Call { + _c.Call.Return(run) + return _c +} + +// GeoRadiusByMemberStore provides a mock function with given fields: ctx, key, member, query +func (_m *MockCmdable) GeoRadiusByMemberStore(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery) *redis.IntCmd { + ret := _m.Called(ctx, key, member, query) + + if len(ret) == 0 { + panic("no return value specified for GeoRadiusByMemberStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.GeoRadiusQuery) *redis.IntCmd); ok { + r0 = rf(ctx, key, member, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_GeoRadiusByMemberStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoRadiusByMemberStore' +type MockCmdable_GeoRadiusByMemberStore_Call struct { + *mock.Call +} + +// GeoRadiusByMemberStore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +// - query *redis.GeoRadiusQuery +func (_e *MockCmdable_Expecter) GeoRadiusByMemberStore(ctx interface{}, key interface{}, member interface{}, query interface{}) *MockCmdable_GeoRadiusByMemberStore_Call { + return &MockCmdable_GeoRadiusByMemberStore_Call{Call: _e.mock.On("GeoRadiusByMemberStore", ctx, key, member, query)} +} + +func (_c *MockCmdable_GeoRadiusByMemberStore_Call) Run(run func(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery)) *MockCmdable_GeoRadiusByMemberStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.GeoRadiusQuery)) + }) + return _c +} + +func (_c *MockCmdable_GeoRadiusByMemberStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_GeoRadiusByMemberStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoRadiusByMemberStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoRadiusQuery) *redis.IntCmd) *MockCmdable_GeoRadiusByMemberStore_Call { + _c.Call.Return(run) + return _c +} + +// GeoRadiusStore provides a mock function with given fields: ctx, key, longitude, latitude, query +func (_m *MockCmdable) GeoRadiusStore(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd { + ret := _m.Called(ctx, key, longitude, latitude, query) + + if len(ret) == 0 { + panic("no return value specified for GeoRadiusStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, float64, *redis.GeoRadiusQuery) *redis.IntCmd); ok { + r0 = rf(ctx, key, longitude, latitude, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_GeoRadiusStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoRadiusStore' +type MockCmdable_GeoRadiusStore_Call struct { + *mock.Call +} + +// GeoRadiusStore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - longitude float64 +// - latitude float64 +// - query *redis.GeoRadiusQuery +func (_e *MockCmdable_Expecter) GeoRadiusStore(ctx interface{}, key interface{}, longitude interface{}, latitude interface{}, query interface{}) *MockCmdable_GeoRadiusStore_Call { + return &MockCmdable_GeoRadiusStore_Call{Call: _e.mock.On("GeoRadiusStore", ctx, key, longitude, latitude, query)} +} + +func (_c *MockCmdable_GeoRadiusStore_Call) Run(run func(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery)) *MockCmdable_GeoRadiusStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(float64), args[4].(*redis.GeoRadiusQuery)) + }) + return _c +} + +func (_c *MockCmdable_GeoRadiusStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_GeoRadiusStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoRadiusStore_Call) RunAndReturn(run func(context.Context, string, float64, float64, *redis.GeoRadiusQuery) *redis.IntCmd) *MockCmdable_GeoRadiusStore_Call { + _c.Call.Return(run) + return _c +} + +// GeoSearch provides a mock function with given fields: ctx, key, q +func (_m *MockCmdable) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, q) + + if len(ret) == 0 { + panic("no return value specified for GeoSearch") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.GeoSearchQuery) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, q) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_GeoSearch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoSearch' +type MockCmdable_GeoSearch_Call struct { + *mock.Call +} + +// GeoSearch is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - q *redis.GeoSearchQuery +func (_e *MockCmdable_Expecter) GeoSearch(ctx interface{}, key interface{}, q interface{}) *MockCmdable_GeoSearch_Call { + return &MockCmdable_GeoSearch_Call{Call: _e.mock.On("GeoSearch", ctx, key, q)} +} + +func (_c *MockCmdable_GeoSearch_Call) Run(run func(ctx context.Context, key string, q *redis.GeoSearchQuery)) *MockCmdable_GeoSearch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.GeoSearchQuery)) + }) + return _c +} + +func (_c *MockCmdable_GeoSearch_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_GeoSearch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoSearch_Call) RunAndReturn(run func(context.Context, string, *redis.GeoSearchQuery) *redis.StringSliceCmd) *MockCmdable_GeoSearch_Call { + _c.Call.Return(run) + return _c +} + +// GeoSearchLocation provides a mock function with given fields: ctx, key, q +func (_m *MockCmdable) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { + ret := _m.Called(ctx, key, q) + + if len(ret) == 0 { + panic("no return value specified for GeoSearchLocation") + } + + var r0 *redis.GeoSearchLocationCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd); ok { + r0 = rf(ctx, key, q) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.GeoSearchLocationCmd) + } + } + + return r0 +} + +// MockCmdable_GeoSearchLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoSearchLocation' +type MockCmdable_GeoSearchLocation_Call struct { + *mock.Call +} + +// GeoSearchLocation is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - q *redis.GeoSearchLocationQuery +func (_e *MockCmdable_Expecter) GeoSearchLocation(ctx interface{}, key interface{}, q interface{}) *MockCmdable_GeoSearchLocation_Call { + return &MockCmdable_GeoSearchLocation_Call{Call: _e.mock.On("GeoSearchLocation", ctx, key, q)} +} + +func (_c *MockCmdable_GeoSearchLocation_Call) Run(run func(ctx context.Context, key string, q *redis.GeoSearchLocationQuery)) *MockCmdable_GeoSearchLocation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.GeoSearchLocationQuery)) + }) + return _c +} + +func (_c *MockCmdable_GeoSearchLocation_Call) Return(_a0 *redis.GeoSearchLocationCmd) *MockCmdable_GeoSearchLocation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoSearchLocation_Call) RunAndReturn(run func(context.Context, string, *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd) *MockCmdable_GeoSearchLocation_Call { + _c.Call.Return(run) + return _c +} + +// GeoSearchStore provides a mock function with given fields: ctx, key, store, q +func (_m *MockCmdable) GeoSearchStore(ctx context.Context, key string, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd { + ret := _m.Called(ctx, key, store, q) + + if len(ret) == 0 { + panic("no return value specified for GeoSearchStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.GeoSearchStoreQuery) *redis.IntCmd); ok { + r0 = rf(ctx, key, store, q) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_GeoSearchStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoSearchStore' +type MockCmdable_GeoSearchStore_Call struct { + *mock.Call +} + +// GeoSearchStore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - store string +// - q *redis.GeoSearchStoreQuery +func (_e *MockCmdable_Expecter) GeoSearchStore(ctx interface{}, key interface{}, store interface{}, q interface{}) *MockCmdable_GeoSearchStore_Call { + return &MockCmdable_GeoSearchStore_Call{Call: _e.mock.On("GeoSearchStore", ctx, key, store, q)} +} + +func (_c *MockCmdable_GeoSearchStore_Call) Run(run func(ctx context.Context, key string, store string, q *redis.GeoSearchStoreQuery)) *MockCmdable_GeoSearchStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.GeoSearchStoreQuery)) + }) + return _c +} + +func (_c *MockCmdable_GeoSearchStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_GeoSearchStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GeoSearchStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoSearchStoreQuery) *redis.IntCmd) *MockCmdable_GeoSearchStore_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: ctx, key +func (_m *MockCmdable) Get(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockCmdable_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) Get(ctx interface{}, key interface{}) *MockCmdable_Get_Call { + return &MockCmdable_Get_Call{Call: _e.mock.On("Get", ctx, key)} +} + +func (_c *MockCmdable_Get_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_Get_Call) Return(_a0 *redis.StringCmd) *MockCmdable_Get_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Get_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_Get_Call { + _c.Call.Return(run) + return _c +} + +// GetBit provides a mock function with given fields: ctx, key, offset +func (_m *MockCmdable) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd { + ret := _m.Called(ctx, key, offset) + + if len(ret) == 0 { + panic("no return value specified for GetBit") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, offset) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_GetBit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBit' +type MockCmdable_GetBit_Call struct { + *mock.Call +} + +// GetBit is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - offset int64 +func (_e *MockCmdable_Expecter) GetBit(ctx interface{}, key interface{}, offset interface{}) *MockCmdable_GetBit_Call { + return &MockCmdable_GetBit_Call{Call: _e.mock.On("GetBit", ctx, key, offset)} +} + +func (_c *MockCmdable_GetBit_Call) Run(run func(ctx context.Context, key string, offset int64)) *MockCmdable_GetBit_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_GetBit_Call) Return(_a0 *redis.IntCmd) *MockCmdable_GetBit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GetBit_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *MockCmdable_GetBit_Call { + _c.Call.Return(run) + return _c +} + +// GetDel provides a mock function with given fields: ctx, key +func (_m *MockCmdable) GetDel(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for GetDel") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_GetDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDel' +type MockCmdable_GetDel_Call struct { + *mock.Call +} + +// GetDel is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) GetDel(ctx interface{}, key interface{}) *MockCmdable_GetDel_Call { + return &MockCmdable_GetDel_Call{Call: _e.mock.On("GetDel", ctx, key)} +} + +func (_c *MockCmdable_GetDel_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_GetDel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_GetDel_Call) Return(_a0 *redis.StringCmd) *MockCmdable_GetDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GetDel_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_GetDel_Call { + _c.Call.Return(run) + return _c +} + +// GetEx provides a mock function with given fields: ctx, key, expiration +func (_m *MockCmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd { + ret := _m.Called(ctx, key, expiration) + + if len(ret) == 0 { + panic("no return value specified for GetEx") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) *redis.StringCmd); ok { + r0 = rf(ctx, key, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_GetEx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEx' +type MockCmdable_GetEx_Call struct { + *mock.Call +} + +// GetEx is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +func (_e *MockCmdable_Expecter) GetEx(ctx interface{}, key interface{}, expiration interface{}) *MockCmdable_GetEx_Call { + return &MockCmdable_GetEx_Call{Call: _e.mock.On("GetEx", ctx, key, expiration)} +} + +func (_c *MockCmdable_GetEx_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockCmdable_GetEx_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_GetEx_Call) Return(_a0 *redis.StringCmd) *MockCmdable_GetEx_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GetEx_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.StringCmd) *MockCmdable_GetEx_Call { + _c.Call.Return(run) + return _c +} + +// GetRange provides a mock function with given fields: ctx, key, start, end +func (_m *MockCmdable) GetRange(ctx context.Context, key string, start int64, end int64) *redis.StringCmd { + ret := _m.Called(ctx, key, start, end) + + if len(ret) == 0 { + panic("no return value specified for GetRange") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StringCmd); ok { + r0 = rf(ctx, key, start, end) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_GetRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRange' +type MockCmdable_GetRange_Call struct { + *mock.Call +} + +// GetRange is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - start int64 +// - end int64 +func (_e *MockCmdable_Expecter) GetRange(ctx interface{}, key interface{}, start interface{}, end interface{}) *MockCmdable_GetRange_Call { + return &MockCmdable_GetRange_Call{Call: _e.mock.On("GetRange", ctx, key, start, end)} +} + +func (_c *MockCmdable_GetRange_Call) Run(run func(ctx context.Context, key string, start int64, end int64)) *MockCmdable_GetRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_GetRange_Call) Return(_a0 *redis.StringCmd) *MockCmdable_GetRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GetRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringCmd) *MockCmdable_GetRange_Call { + _c.Call.Return(run) + return _c +} + +// GetSet provides a mock function with given fields: ctx, key, value +func (_m *MockCmdable) GetSet(ctx context.Context, key string, value interface{}) *redis.StringCmd { + ret := _m.Called(ctx, key, value) + + if len(ret) == 0 { + panic("no return value specified for GetSet") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.StringCmd); ok { + r0 = rf(ctx, key, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_GetSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSet' +type MockCmdable_GetSet_Call struct { + *mock.Call +} + +// GetSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +func (_e *MockCmdable_Expecter) GetSet(ctx interface{}, key interface{}, value interface{}) *MockCmdable_GetSet_Call { + return &MockCmdable_GetSet_Call{Call: _e.mock.On("GetSet", ctx, key, value)} +} + +func (_c *MockCmdable_GetSet_Call) Run(run func(ctx context.Context, key string, value interface{})) *MockCmdable_GetSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_GetSet_Call) Return(_a0 *redis.StringCmd) *MockCmdable_GetSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_GetSet_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.StringCmd) *MockCmdable_GetSet_Call { + _c.Call.Return(run) + return _c +} + +// HDel provides a mock function with given fields: ctx, key, fields +func (_m *MockCmdable) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HDel") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, key, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_HDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HDel' +type MockCmdable_HDel_Call struct { + *mock.Call +} + +// HDel is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *MockCmdable_Expecter) HDel(ctx interface{}, key interface{}, fields ...interface{}) *MockCmdable_HDel_Call { + return &MockCmdable_HDel_Call{Call: _e.mock.On("HDel", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *MockCmdable_HDel_Call) Run(run func(ctx context.Context, key string, fields ...string)) *MockCmdable_HDel_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HDel_Call) Return(_a0 *redis.IntCmd) *MockCmdable_HDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HDel_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_HDel_Call { + _c.Call.Return(run) + return _c +} + +// HExists provides a mock function with given fields: ctx, key, field +func (_m *MockCmdable) HExists(ctx context.Context, key string, field string) *redis.BoolCmd { + ret := _m.Called(ctx, key, field) + + if len(ret) == 0 { + panic("no return value specified for HExists") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.BoolCmd); ok { + r0 = rf(ctx, key, field) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_HExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HExists' +type MockCmdable_HExists_Call struct { + *mock.Call +} + +// HExists is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +func (_e *MockCmdable_Expecter) HExists(ctx interface{}, key interface{}, field interface{}) *MockCmdable_HExists_Call { + return &MockCmdable_HExists_Call{Call: _e.mock.On("HExists", ctx, key, field)} +} + +func (_c *MockCmdable_HExists_Call) Run(run func(ctx context.Context, key string, field string)) *MockCmdable_HExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_HExists_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_HExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HExists_Call) RunAndReturn(run func(context.Context, string, string) *redis.BoolCmd) *MockCmdable_HExists_Call { + _c.Call.Return(run) + return _c +} + +// HExpire provides a mock function with given fields: ctx, key, expiration, fields +func (_m *MockCmdable) HExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, expiration) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HExpire") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, expiration, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HExpire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HExpire' +type MockCmdable_HExpire_Call struct { + *mock.Call +} + +// HExpire is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +// - fields ...string +func (_e *MockCmdable_Expecter) HExpire(ctx interface{}, key interface{}, expiration interface{}, fields ...interface{}) *MockCmdable_HExpire_Call { + return &MockCmdable_HExpire_Call{Call: _e.mock.On("HExpire", + append([]interface{}{ctx, key, expiration}, fields...)...)} +} + +func (_c *MockCmdable_HExpire_Call) Run(run func(ctx context.Context, key string, expiration time.Duration, fields ...string)) *MockCmdable_HExpire_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HExpire_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HExpire_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HExpire_Call) RunAndReturn(run func(context.Context, string, time.Duration, ...string) *redis.IntSliceCmd) *MockCmdable_HExpire_Call { + _c.Call.Return(run) + return _c +} + +// HExpireAt provides a mock function with given fields: ctx, key, tm, fields +func (_m *MockCmdable) HExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, tm) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HExpireAt") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Time, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, tm, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HExpireAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HExpireAt' +type MockCmdable_HExpireAt_Call struct { + *mock.Call +} + +// HExpireAt is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - tm time.Time +// - fields ...string +func (_e *MockCmdable_Expecter) HExpireAt(ctx interface{}, key interface{}, tm interface{}, fields ...interface{}) *MockCmdable_HExpireAt_Call { + return &MockCmdable_HExpireAt_Call{Call: _e.mock.On("HExpireAt", + append([]interface{}{ctx, key, tm}, fields...)...)} +} + +func (_c *MockCmdable_HExpireAt_Call) Run(run func(ctx context.Context, key string, tm time.Time, fields ...string)) *MockCmdable_HExpireAt_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(time.Time), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HExpireAt_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HExpireAt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HExpireAt_Call) RunAndReturn(run func(context.Context, string, time.Time, ...string) *redis.IntSliceCmd) *MockCmdable_HExpireAt_Call { + _c.Call.Return(run) + return _c +} + +// HExpireAtWithArgs provides a mock function with given fields: ctx, key, tm, expirationArgs, fields +func (_m *MockCmdable) HExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, tm, expirationArgs) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HExpireAtWithArgs") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Time, redis.HExpireArgs, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, tm, expirationArgs, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HExpireAtWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HExpireAtWithArgs' +type MockCmdable_HExpireAtWithArgs_Call struct { + *mock.Call +} + +// HExpireAtWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - tm time.Time +// - expirationArgs redis.HExpireArgs +// - fields ...string +func (_e *MockCmdable_Expecter) HExpireAtWithArgs(ctx interface{}, key interface{}, tm interface{}, expirationArgs interface{}, fields ...interface{}) *MockCmdable_HExpireAtWithArgs_Call { + return &MockCmdable_HExpireAtWithArgs_Call{Call: _e.mock.On("HExpireAtWithArgs", + append([]interface{}{ctx, key, tm, expirationArgs}, fields...)...)} +} + +func (_c *MockCmdable_HExpireAtWithArgs_Call) Run(run func(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string)) *MockCmdable_HExpireAtWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(time.Time), args[3].(redis.HExpireArgs), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HExpireAtWithArgs_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HExpireAtWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HExpireAtWithArgs_Call) RunAndReturn(run func(context.Context, string, time.Time, redis.HExpireArgs, ...string) *redis.IntSliceCmd) *MockCmdable_HExpireAtWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// HExpireTime provides a mock function with given fields: ctx, key, fields +func (_m *MockCmdable) HExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HExpireTime") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HExpireTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HExpireTime' +type MockCmdable_HExpireTime_Call struct { + *mock.Call +} + +// HExpireTime is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *MockCmdable_Expecter) HExpireTime(ctx interface{}, key interface{}, fields ...interface{}) *MockCmdable_HExpireTime_Call { + return &MockCmdable_HExpireTime_Call{Call: _e.mock.On("HExpireTime", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *MockCmdable_HExpireTime_Call) Run(run func(ctx context.Context, key string, fields ...string)) *MockCmdable_HExpireTime_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HExpireTime_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HExpireTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HExpireTime_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntSliceCmd) *MockCmdable_HExpireTime_Call { + _c.Call.Return(run) + return _c +} + +// HExpireWithArgs provides a mock function with given fields: ctx, key, expiration, expirationArgs, fields +func (_m *MockCmdable) HExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, expiration, expirationArgs) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HExpireWithArgs") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, redis.HExpireArgs, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, expiration, expirationArgs, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HExpireWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HExpireWithArgs' +type MockCmdable_HExpireWithArgs_Call struct { + *mock.Call +} + +// HExpireWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +// - expirationArgs redis.HExpireArgs +// - fields ...string +func (_e *MockCmdable_Expecter) HExpireWithArgs(ctx interface{}, key interface{}, expiration interface{}, expirationArgs interface{}, fields ...interface{}) *MockCmdable_HExpireWithArgs_Call { + return &MockCmdable_HExpireWithArgs_Call{Call: _e.mock.On("HExpireWithArgs", + append([]interface{}{ctx, key, expiration, expirationArgs}, fields...)...)} +} + +func (_c *MockCmdable_HExpireWithArgs_Call) Run(run func(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string)) *MockCmdable_HExpireWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), args[3].(redis.HExpireArgs), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HExpireWithArgs_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HExpireWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HExpireWithArgs_Call) RunAndReturn(run func(context.Context, string, time.Duration, redis.HExpireArgs, ...string) *redis.IntSliceCmd) *MockCmdable_HExpireWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// HGet provides a mock function with given fields: ctx, key, field +func (_m *MockCmdable) HGet(ctx context.Context, key string, field string) *redis.StringCmd { + ret := _m.Called(ctx, key, field) + + if len(ret) == 0 { + panic("no return value specified for HGet") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StringCmd); ok { + r0 = rf(ctx, key, field) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_HGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HGet' +type MockCmdable_HGet_Call struct { + *mock.Call +} + +// HGet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +func (_e *MockCmdable_Expecter) HGet(ctx interface{}, key interface{}, field interface{}) *MockCmdable_HGet_Call { + return &MockCmdable_HGet_Call{Call: _e.mock.On("HGet", ctx, key, field)} +} + +func (_c *MockCmdable_HGet_Call) Run(run func(ctx context.Context, key string, field string)) *MockCmdable_HGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_HGet_Call) Return(_a0 *redis.StringCmd) *MockCmdable_HGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HGet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StringCmd) *MockCmdable_HGet_Call { + _c.Call.Return(run) + return _c +} + +// HGetAll provides a mock function with given fields: ctx, key +func (_m *MockCmdable) HGetAll(ctx context.Context, key string) *redis.MapStringStringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for HGetAll") + } + + var r0 *redis.MapStringStringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.MapStringStringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringStringCmd) + } + } + + return r0 +} + +// MockCmdable_HGetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HGetAll' +type MockCmdable_HGetAll_Call struct { + *mock.Call +} + +// HGetAll is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) HGetAll(ctx interface{}, key interface{}) *MockCmdable_HGetAll_Call { + return &MockCmdable_HGetAll_Call{Call: _e.mock.On("HGetAll", ctx, key)} +} + +func (_c *MockCmdable_HGetAll_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_HGetAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_HGetAll_Call) Return(_a0 *redis.MapStringStringCmd) *MockCmdable_HGetAll_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HGetAll_Call) RunAndReturn(run func(context.Context, string) *redis.MapStringStringCmd) *MockCmdable_HGetAll_Call { + _c.Call.Return(run) + return _c +} + +// HIncrBy provides a mock function with given fields: ctx, key, field, incr +func (_m *MockCmdable) HIncrBy(ctx context.Context, key string, field string, incr int64) *redis.IntCmd { + ret := _m.Called(ctx, key, field, incr) + + if len(ret) == 0 { + panic("no return value specified for HIncrBy") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, field, incr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_HIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HIncrBy' +type MockCmdable_HIncrBy_Call struct { + *mock.Call +} + +// HIncrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +// - incr int64 +func (_e *MockCmdable_Expecter) HIncrBy(ctx interface{}, key interface{}, field interface{}, incr interface{}) *MockCmdable_HIncrBy_Call { + return &MockCmdable_HIncrBy_Call{Call: _e.mock.On("HIncrBy", ctx, key, field, incr)} +} + +func (_c *MockCmdable_HIncrBy_Call) Run(run func(ctx context.Context, key string, field string, incr int64)) *MockCmdable_HIncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_HIncrBy_Call) Return(_a0 *redis.IntCmd) *MockCmdable_HIncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HIncrBy_Call) RunAndReturn(run func(context.Context, string, string, int64) *redis.IntCmd) *MockCmdable_HIncrBy_Call { + _c.Call.Return(run) + return _c +} + +// HIncrByFloat provides a mock function with given fields: ctx, key, field, incr +func (_m *MockCmdable) HIncrByFloat(ctx context.Context, key string, field string, incr float64) *redis.FloatCmd { + ret := _m.Called(ctx, key, field, incr) + + if len(ret) == 0 { + panic("no return value specified for HIncrByFloat") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, float64) *redis.FloatCmd); ok { + r0 = rf(ctx, key, field, incr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_HIncrByFloat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HIncrByFloat' +type MockCmdable_HIncrByFloat_Call struct { + *mock.Call +} + +// HIncrByFloat is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +// - incr float64 +func (_e *MockCmdable_Expecter) HIncrByFloat(ctx interface{}, key interface{}, field interface{}, incr interface{}) *MockCmdable_HIncrByFloat_Call { + return &MockCmdable_HIncrByFloat_Call{Call: _e.mock.On("HIncrByFloat", ctx, key, field, incr)} +} + +func (_c *MockCmdable_HIncrByFloat_Call) Run(run func(ctx context.Context, key string, field string, incr float64)) *MockCmdable_HIncrByFloat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(float64)) + }) + return _c +} + +func (_c *MockCmdable_HIncrByFloat_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_HIncrByFloat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HIncrByFloat_Call) RunAndReturn(run func(context.Context, string, string, float64) *redis.FloatCmd) *MockCmdable_HIncrByFloat_Call { + _c.Call.Return(run) + return _c +} + +// HKeys provides a mock function with given fields: ctx, key +func (_m *MockCmdable) HKeys(ctx context.Context, key string) *redis.StringSliceCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for HKeys") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HKeys' +type MockCmdable_HKeys_Call struct { + *mock.Call +} + +// HKeys is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) HKeys(ctx interface{}, key interface{}) *MockCmdable_HKeys_Call { + return &MockCmdable_HKeys_Call{Call: _e.mock.On("HKeys", ctx, key)} +} + +func (_c *MockCmdable_HKeys_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_HKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_HKeys_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_HKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HKeys_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_HKeys_Call { + _c.Call.Return(run) + return _c +} + +// HLen provides a mock function with given fields: ctx, key +func (_m *MockCmdable) HLen(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for HLen") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_HLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HLen' +type MockCmdable_HLen_Call struct { + *mock.Call +} + +// HLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) HLen(ctx interface{}, key interface{}) *MockCmdable_HLen_Call { + return &MockCmdable_HLen_Call{Call: _e.mock.On("HLen", ctx, key)} +} + +func (_c *MockCmdable_HLen_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_HLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_HLen_Call) Return(_a0 *redis.IntCmd) *MockCmdable_HLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_HLen_Call { + _c.Call.Return(run) + return _c +} + +// HMGet provides a mock function with given fields: ctx, key, fields +func (_m *MockCmdable) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HMGet") + } + + var r0 *redis.SliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.SliceCmd); ok { + r0 = rf(ctx, key, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.SliceCmd) + } + } + + return r0 +} + +// MockCmdable_HMGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HMGet' +type MockCmdable_HMGet_Call struct { + *mock.Call +} + +// HMGet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *MockCmdable_Expecter) HMGet(ctx interface{}, key interface{}, fields ...interface{}) *MockCmdable_HMGet_Call { + return &MockCmdable_HMGet_Call{Call: _e.mock.On("HMGet", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *MockCmdable_HMGet_Call) Run(run func(ctx context.Context, key string, fields ...string)) *MockCmdable_HMGet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HMGet_Call) Return(_a0 *redis.SliceCmd) *MockCmdable_HMGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HMGet_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.SliceCmd) *MockCmdable_HMGet_Call { + _c.Call.Return(run) + return _c +} + +// HMSet provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) HMSet(ctx context.Context, key string, values ...interface{}) *redis.BoolCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HMSet") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_HMSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HMSet' +type MockCmdable_HMSet_Call struct { + *mock.Call +} + +// HMSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *MockCmdable_Expecter) HMSet(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_HMSet_Call { + return &MockCmdable_HMSet_Call{Call: _e.mock.On("HMSet", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_HMSet_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *MockCmdable_HMSet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HMSet_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_HMSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HMSet_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolCmd) *MockCmdable_HMSet_Call { + _c.Call.Return(run) + return _c +} + +// HPExpire provides a mock function with given fields: ctx, key, expiration, fields +func (_m *MockCmdable) HPExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, expiration) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HPExpire") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, expiration, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HPExpire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HPExpire' +type MockCmdable_HPExpire_Call struct { + *mock.Call +} + +// HPExpire is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +// - fields ...string +func (_e *MockCmdable_Expecter) HPExpire(ctx interface{}, key interface{}, expiration interface{}, fields ...interface{}) *MockCmdable_HPExpire_Call { + return &MockCmdable_HPExpire_Call{Call: _e.mock.On("HPExpire", + append([]interface{}{ctx, key, expiration}, fields...)...)} +} + +func (_c *MockCmdable_HPExpire_Call) Run(run func(ctx context.Context, key string, expiration time.Duration, fields ...string)) *MockCmdable_HPExpire_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HPExpire_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HPExpire_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HPExpire_Call) RunAndReturn(run func(context.Context, string, time.Duration, ...string) *redis.IntSliceCmd) *MockCmdable_HPExpire_Call { + _c.Call.Return(run) + return _c +} + +// HPExpireAt provides a mock function with given fields: ctx, key, tm, fields +func (_m *MockCmdable) HPExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, tm) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HPExpireAt") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Time, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, tm, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HPExpireAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HPExpireAt' +type MockCmdable_HPExpireAt_Call struct { + *mock.Call +} + +// HPExpireAt is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - tm time.Time +// - fields ...string +func (_e *MockCmdable_Expecter) HPExpireAt(ctx interface{}, key interface{}, tm interface{}, fields ...interface{}) *MockCmdable_HPExpireAt_Call { + return &MockCmdable_HPExpireAt_Call{Call: _e.mock.On("HPExpireAt", + append([]interface{}{ctx, key, tm}, fields...)...)} +} + +func (_c *MockCmdable_HPExpireAt_Call) Run(run func(ctx context.Context, key string, tm time.Time, fields ...string)) *MockCmdable_HPExpireAt_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(time.Time), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HPExpireAt_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HPExpireAt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HPExpireAt_Call) RunAndReturn(run func(context.Context, string, time.Time, ...string) *redis.IntSliceCmd) *MockCmdable_HPExpireAt_Call { + _c.Call.Return(run) + return _c +} + +// HPExpireAtWithArgs provides a mock function with given fields: ctx, key, tm, expirationArgs, fields +func (_m *MockCmdable) HPExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, tm, expirationArgs) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HPExpireAtWithArgs") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Time, redis.HExpireArgs, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, tm, expirationArgs, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HPExpireAtWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HPExpireAtWithArgs' +type MockCmdable_HPExpireAtWithArgs_Call struct { + *mock.Call +} + +// HPExpireAtWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - tm time.Time +// - expirationArgs redis.HExpireArgs +// - fields ...string +func (_e *MockCmdable_Expecter) HPExpireAtWithArgs(ctx interface{}, key interface{}, tm interface{}, expirationArgs interface{}, fields ...interface{}) *MockCmdable_HPExpireAtWithArgs_Call { + return &MockCmdable_HPExpireAtWithArgs_Call{Call: _e.mock.On("HPExpireAtWithArgs", + append([]interface{}{ctx, key, tm, expirationArgs}, fields...)...)} +} + +func (_c *MockCmdable_HPExpireAtWithArgs_Call) Run(run func(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string)) *MockCmdable_HPExpireAtWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(time.Time), args[3].(redis.HExpireArgs), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HPExpireAtWithArgs_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HPExpireAtWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HPExpireAtWithArgs_Call) RunAndReturn(run func(context.Context, string, time.Time, redis.HExpireArgs, ...string) *redis.IntSliceCmd) *MockCmdable_HPExpireAtWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// HPExpireTime provides a mock function with given fields: ctx, key, fields +func (_m *MockCmdable) HPExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HPExpireTime") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HPExpireTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HPExpireTime' +type MockCmdable_HPExpireTime_Call struct { + *mock.Call +} + +// HPExpireTime is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *MockCmdable_Expecter) HPExpireTime(ctx interface{}, key interface{}, fields ...interface{}) *MockCmdable_HPExpireTime_Call { + return &MockCmdable_HPExpireTime_Call{Call: _e.mock.On("HPExpireTime", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *MockCmdable_HPExpireTime_Call) Run(run func(ctx context.Context, key string, fields ...string)) *MockCmdable_HPExpireTime_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HPExpireTime_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HPExpireTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HPExpireTime_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntSliceCmd) *MockCmdable_HPExpireTime_Call { + _c.Call.Return(run) + return _c +} + +// HPExpireWithArgs provides a mock function with given fields: ctx, key, expiration, expirationArgs, fields +func (_m *MockCmdable) HPExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, expiration, expirationArgs) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HPExpireWithArgs") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, redis.HExpireArgs, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, expiration, expirationArgs, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HPExpireWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HPExpireWithArgs' +type MockCmdable_HPExpireWithArgs_Call struct { + *mock.Call +} + +// HPExpireWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +// - expirationArgs redis.HExpireArgs +// - fields ...string +func (_e *MockCmdable_Expecter) HPExpireWithArgs(ctx interface{}, key interface{}, expiration interface{}, expirationArgs interface{}, fields ...interface{}) *MockCmdable_HPExpireWithArgs_Call { + return &MockCmdable_HPExpireWithArgs_Call{Call: _e.mock.On("HPExpireWithArgs", + append([]interface{}{ctx, key, expiration, expirationArgs}, fields...)...)} +} + +func (_c *MockCmdable_HPExpireWithArgs_Call) Run(run func(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string)) *MockCmdable_HPExpireWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), args[3].(redis.HExpireArgs), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HPExpireWithArgs_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HPExpireWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HPExpireWithArgs_Call) RunAndReturn(run func(context.Context, string, time.Duration, redis.HExpireArgs, ...string) *redis.IntSliceCmd) *MockCmdable_HPExpireWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// HPTTL provides a mock function with given fields: ctx, key, fields +func (_m *MockCmdable) HPTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HPTTL") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HPTTL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HPTTL' +type MockCmdable_HPTTL_Call struct { + *mock.Call +} + +// HPTTL is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *MockCmdable_Expecter) HPTTL(ctx interface{}, key interface{}, fields ...interface{}) *MockCmdable_HPTTL_Call { + return &MockCmdable_HPTTL_Call{Call: _e.mock.On("HPTTL", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *MockCmdable_HPTTL_Call) Run(run func(ctx context.Context, key string, fields ...string)) *MockCmdable_HPTTL_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HPTTL_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HPTTL_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HPTTL_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntSliceCmd) *MockCmdable_HPTTL_Call { + _c.Call.Return(run) + return _c +} + +// HPersist provides a mock function with given fields: ctx, key, fields +func (_m *MockCmdable) HPersist(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HPersist") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HPersist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HPersist' +type MockCmdable_HPersist_Call struct { + *mock.Call +} + +// HPersist is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *MockCmdable_Expecter) HPersist(ctx interface{}, key interface{}, fields ...interface{}) *MockCmdable_HPersist_Call { + return &MockCmdable_HPersist_Call{Call: _e.mock.On("HPersist", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *MockCmdable_HPersist_Call) Run(run func(ctx context.Context, key string, fields ...string)) *MockCmdable_HPersist_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HPersist_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HPersist_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HPersist_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntSliceCmd) *MockCmdable_HPersist_Call { + _c.Call.Return(run) + return _c +} + +// HRandField provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) HRandField(ctx context.Context, key string, count int) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for HRandField") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HRandField_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HRandField' +type MockCmdable_HRandField_Call struct { + *mock.Call +} + +// HRandField is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *MockCmdable_Expecter) HRandField(ctx interface{}, key interface{}, count interface{}) *MockCmdable_HRandField_Call { + return &MockCmdable_HRandField_Call{Call: _e.mock.On("HRandField", ctx, key, count)} +} + +func (_c *MockCmdable_HRandField_Call) Run(run func(ctx context.Context, key string, count int)) *MockCmdable_HRandField_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_HRandField_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_HRandField_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HRandField_Call) RunAndReturn(run func(context.Context, string, int) *redis.StringSliceCmd) *MockCmdable_HRandField_Call { + _c.Call.Return(run) + return _c +} + +// HRandFieldWithValues provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) HRandFieldWithValues(ctx context.Context, key string, count int) *redis.KeyValueSliceCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for HRandFieldWithValues") + } + + var r0 *redis.KeyValueSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.KeyValueSliceCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.KeyValueSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HRandFieldWithValues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HRandFieldWithValues' +type MockCmdable_HRandFieldWithValues_Call struct { + *mock.Call +} + +// HRandFieldWithValues is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *MockCmdable_Expecter) HRandFieldWithValues(ctx interface{}, key interface{}, count interface{}) *MockCmdable_HRandFieldWithValues_Call { + return &MockCmdable_HRandFieldWithValues_Call{Call: _e.mock.On("HRandFieldWithValues", ctx, key, count)} +} + +func (_c *MockCmdable_HRandFieldWithValues_Call) Run(run func(ctx context.Context, key string, count int)) *MockCmdable_HRandFieldWithValues_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_HRandFieldWithValues_Call) Return(_a0 *redis.KeyValueSliceCmd) *MockCmdable_HRandFieldWithValues_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HRandFieldWithValues_Call) RunAndReturn(run func(context.Context, string, int) *redis.KeyValueSliceCmd) *MockCmdable_HRandFieldWithValues_Call { + _c.Call.Return(run) + return _c +} + +// HScan provides a mock function with given fields: ctx, key, cursor, match, count +func (_m *MockCmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + ret := _m.Called(ctx, key, cursor, match, count) + + if len(ret) == 0 { + panic("no return value specified for HScan") + } + + var r0 *redis.ScanCmd + if rf, ok := ret.Get(0).(func(context.Context, string, uint64, string, int64) *redis.ScanCmd); ok { + r0 = rf(ctx, key, cursor, match, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ScanCmd) + } + } + + return r0 +} + +// MockCmdable_HScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HScan' +type MockCmdable_HScan_Call struct { + *mock.Call +} + +// HScan is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - cursor uint64 +// - match string +// - count int64 +func (_e *MockCmdable_Expecter) HScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *MockCmdable_HScan_Call { + return &MockCmdable_HScan_Call{Call: _e.mock.On("HScan", ctx, key, cursor, match, count)} +} + +func (_c *MockCmdable_HScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *MockCmdable_HScan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(uint64), args[3].(string), args[4].(int64)) + }) + return _c +} + +func (_c *MockCmdable_HScan_Call) Return(_a0 *redis.ScanCmd) *MockCmdable_HScan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *MockCmdable_HScan_Call { + _c.Call.Return(run) + return _c +} + +// HScanNoValues provides a mock function with given fields: ctx, key, cursor, match, count +func (_m *MockCmdable) HScanNoValues(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + ret := _m.Called(ctx, key, cursor, match, count) + + if len(ret) == 0 { + panic("no return value specified for HScanNoValues") + } + + var r0 *redis.ScanCmd + if rf, ok := ret.Get(0).(func(context.Context, string, uint64, string, int64) *redis.ScanCmd); ok { + r0 = rf(ctx, key, cursor, match, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ScanCmd) + } + } + + return r0 +} + +// MockCmdable_HScanNoValues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HScanNoValues' +type MockCmdable_HScanNoValues_Call struct { + *mock.Call +} + +// HScanNoValues is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - cursor uint64 +// - match string +// - count int64 +func (_e *MockCmdable_Expecter) HScanNoValues(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *MockCmdable_HScanNoValues_Call { + return &MockCmdable_HScanNoValues_Call{Call: _e.mock.On("HScanNoValues", ctx, key, cursor, match, count)} +} + +func (_c *MockCmdable_HScanNoValues_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *MockCmdable_HScanNoValues_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(uint64), args[3].(string), args[4].(int64)) + }) + return _c +} + +func (_c *MockCmdable_HScanNoValues_Call) Return(_a0 *redis.ScanCmd) *MockCmdable_HScanNoValues_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HScanNoValues_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *MockCmdable_HScanNoValues_Call { + _c.Call.Return(run) + return _c +} + +// HSet provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) HSet(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HSet") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_HSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HSet' +type MockCmdable_HSet_Call struct { + *mock.Call +} + +// HSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *MockCmdable_Expecter) HSet(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_HSet_Call { + return &MockCmdable_HSet_Call{Call: _e.mock.On("HSet", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_HSet_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *MockCmdable_HSet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HSet_Call) Return(_a0 *redis.IntCmd) *MockCmdable_HSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HSet_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_HSet_Call { + _c.Call.Return(run) + return _c +} + +// HSetNX provides a mock function with given fields: ctx, key, field, value +func (_m *MockCmdable) HSetNX(ctx context.Context, key string, field string, value interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, key, field, value) + + if len(ret) == 0 { + panic("no return value specified for HSetNX") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, field, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_HSetNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HSetNX' +type MockCmdable_HSetNX_Call struct { + *mock.Call +} + +// HSetNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +// - value interface{} +func (_e *MockCmdable_Expecter) HSetNX(ctx interface{}, key interface{}, field interface{}, value interface{}) *MockCmdable_HSetNX_Call { + return &MockCmdable_HSetNX_Call{Call: _e.mock.On("HSetNX", ctx, key, field, value)} +} + +func (_c *MockCmdable_HSetNX_Call) Run(run func(ctx context.Context, key string, field string, value interface{})) *MockCmdable_HSetNX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_HSetNX_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_HSetNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HSetNX_Call) RunAndReturn(run func(context.Context, string, string, interface{}) *redis.BoolCmd) *MockCmdable_HSetNX_Call { + _c.Call.Return(run) + return _c +} + +// HTTL provides a mock function with given fields: ctx, key, fields +func (_m *MockCmdable) HTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + _va := make([]interface{}, len(fields)) + for _i := range fields { + _va[_i] = fields[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for HTTL") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, fields...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HTTL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HTTL' +type MockCmdable_HTTL_Call struct { + *mock.Call +} + +// HTTL is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *MockCmdable_Expecter) HTTL(ctx interface{}, key interface{}, fields ...interface{}) *MockCmdable_HTTL_Call { + return &MockCmdable_HTTL_Call{Call: _e.mock.On("HTTL", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *MockCmdable_HTTL_Call) Run(run func(ctx context.Context, key string, fields ...string)) *MockCmdable_HTTL_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_HTTL_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_HTTL_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HTTL_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntSliceCmd) *MockCmdable_HTTL_Call { + _c.Call.Return(run) + return _c +} + +// HVals provides a mock function with given fields: ctx, key +func (_m *MockCmdable) HVals(ctx context.Context, key string) *redis.StringSliceCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for HVals") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_HVals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HVals' +type MockCmdable_HVals_Call struct { + *mock.Call +} + +// HVals is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) HVals(ctx interface{}, key interface{}) *MockCmdable_HVals_Call { + return &MockCmdable_HVals_Call{Call: _e.mock.On("HVals", ctx, key)} +} + +func (_c *MockCmdable_HVals_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_HVals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_HVals_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_HVals_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_HVals_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_HVals_Call { + _c.Call.Return(run) + return _c +} + +// Incr provides a mock function with given fields: ctx, key +func (_m *MockCmdable) Incr(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Incr") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Incr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Incr' +type MockCmdable_Incr_Call struct { + *mock.Call +} + +// Incr is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) Incr(ctx interface{}, key interface{}) *MockCmdable_Incr_Call { + return &MockCmdable_Incr_Call{Call: _e.mock.On("Incr", ctx, key)} +} + +func (_c *MockCmdable_Incr_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_Incr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_Incr_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Incr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Incr_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_Incr_Call { + _c.Call.Return(run) + return _c +} + +// IncrBy provides a mock function with given fields: ctx, key, value +func (_m *MockCmdable) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd { + ret := _m.Called(ctx, key, value) + + if len(ret) == 0 { + panic("no return value specified for IncrBy") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_IncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrBy' +type MockCmdable_IncrBy_Call struct { + *mock.Call +} + +// IncrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value int64 +func (_e *MockCmdable_Expecter) IncrBy(ctx interface{}, key interface{}, value interface{}) *MockCmdable_IncrBy_Call { + return &MockCmdable_IncrBy_Call{Call: _e.mock.On("IncrBy", ctx, key, value)} +} + +func (_c *MockCmdable_IncrBy_Call) Run(run func(ctx context.Context, key string, value int64)) *MockCmdable_IncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_IncrBy_Call) Return(_a0 *redis.IntCmd) *MockCmdable_IncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_IncrBy_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *MockCmdable_IncrBy_Call { + _c.Call.Return(run) + return _c +} + +// IncrByFloat provides a mock function with given fields: ctx, key, value +func (_m *MockCmdable) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd { + ret := _m.Called(ctx, key, value) + + if len(ret) == 0 { + panic("no return value specified for IncrByFloat") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64) *redis.FloatCmd); ok { + r0 = rf(ctx, key, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_IncrByFloat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrByFloat' +type MockCmdable_IncrByFloat_Call struct { + *mock.Call +} + +// IncrByFloat is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value float64 +func (_e *MockCmdable_Expecter) IncrByFloat(ctx interface{}, key interface{}, value interface{}) *MockCmdable_IncrByFloat_Call { + return &MockCmdable_IncrByFloat_Call{Call: _e.mock.On("IncrByFloat", ctx, key, value)} +} + +func (_c *MockCmdable_IncrByFloat_Call) Run(run func(ctx context.Context, key string, value float64)) *MockCmdable_IncrByFloat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64)) + }) + return _c +} + +func (_c *MockCmdable_IncrByFloat_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_IncrByFloat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_IncrByFloat_Call) RunAndReturn(run func(context.Context, string, float64) *redis.FloatCmd) *MockCmdable_IncrByFloat_Call { + _c.Call.Return(run) + return _c +} + +// Info provides a mock function with given fields: ctx, section +func (_m *MockCmdable) Info(ctx context.Context, section ...string) *redis.StringCmd { + _va := make([]interface{}, len(section)) + for _i := range section { + _va[_i] = section[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Info") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.StringCmd); ok { + r0 = rf(ctx, section...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info' +type MockCmdable_Info_Call struct { + *mock.Call +} + +// Info is a helper method to define mock.On call +// - ctx context.Context +// - section ...string +func (_e *MockCmdable_Expecter) Info(ctx interface{}, section ...interface{}) *MockCmdable_Info_Call { + return &MockCmdable_Info_Call{Call: _e.mock.On("Info", + append([]interface{}{ctx}, section...)...)} +} + +func (_c *MockCmdable_Info_Call) Run(run func(ctx context.Context, section ...string)) *MockCmdable_Info_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_Info_Call) Return(_a0 *redis.StringCmd) *MockCmdable_Info_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Info_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringCmd) *MockCmdable_Info_Call { + _c.Call.Return(run) + return _c +} + +// JSONArrAppend provides a mock function with given fields: ctx, key, path, values +func (_m *MockCmdable) JSONArrAppend(ctx context.Context, key string, path string, values ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key, path) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JSONArrAppend") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, path, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONArrAppend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONArrAppend' +type MockCmdable_JSONArrAppend_Call struct { + *mock.Call +} + +// JSONArrAppend is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - values ...interface{} +func (_e *MockCmdable_Expecter) JSONArrAppend(ctx interface{}, key interface{}, path interface{}, values ...interface{}) *MockCmdable_JSONArrAppend_Call { + return &MockCmdable_JSONArrAppend_Call{Call: _e.mock.On("JSONArrAppend", + append([]interface{}{ctx, key, path}, values...)...)} +} + +func (_c *MockCmdable_JSONArrAppend_Call) Run(run func(ctx context.Context, key string, path string, values ...interface{})) *MockCmdable_JSONArrAppend_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_JSONArrAppend_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_JSONArrAppend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONArrAppend_Call) RunAndReturn(run func(context.Context, string, string, ...interface{}) *redis.IntSliceCmd) *MockCmdable_JSONArrAppend_Call { + _c.Call.Return(run) + return _c +} + +// JSONArrIndex provides a mock function with given fields: ctx, key, path, value +func (_m *MockCmdable) JSONArrIndex(ctx context.Context, key string, path string, value ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key, path) + _ca = append(_ca, value...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JSONArrIndex") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, path, value...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONArrIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONArrIndex' +type MockCmdable_JSONArrIndex_Call struct { + *mock.Call +} + +// JSONArrIndex is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - value ...interface{} +func (_e *MockCmdable_Expecter) JSONArrIndex(ctx interface{}, key interface{}, path interface{}, value ...interface{}) *MockCmdable_JSONArrIndex_Call { + return &MockCmdable_JSONArrIndex_Call{Call: _e.mock.On("JSONArrIndex", + append([]interface{}{ctx, key, path}, value...)...)} +} + +func (_c *MockCmdable_JSONArrIndex_Call) Run(run func(ctx context.Context, key string, path string, value ...interface{})) *MockCmdable_JSONArrIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_JSONArrIndex_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_JSONArrIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONArrIndex_Call) RunAndReturn(run func(context.Context, string, string, ...interface{}) *redis.IntSliceCmd) *MockCmdable_JSONArrIndex_Call { + _c.Call.Return(run) + return _c +} + +// JSONArrIndexWithArgs provides a mock function with given fields: ctx, key, path, options, value +func (_m *MockCmdable) JSONArrIndexWithArgs(ctx context.Context, key string, path string, options *redis.JSONArrIndexArgs, value ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key, path, options) + _ca = append(_ca, value...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JSONArrIndexWithArgs") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.JSONArrIndexArgs, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, path, options, value...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONArrIndexWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONArrIndexWithArgs' +type MockCmdable_JSONArrIndexWithArgs_Call struct { + *mock.Call +} + +// JSONArrIndexWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - options *redis.JSONArrIndexArgs +// - value ...interface{} +func (_e *MockCmdable_Expecter) JSONArrIndexWithArgs(ctx interface{}, key interface{}, path interface{}, options interface{}, value ...interface{}) *MockCmdable_JSONArrIndexWithArgs_Call { + return &MockCmdable_JSONArrIndexWithArgs_Call{Call: _e.mock.On("JSONArrIndexWithArgs", + append([]interface{}{ctx, key, path, options}, value...)...)} +} + +func (_c *MockCmdable_JSONArrIndexWithArgs_Call) Run(run func(ctx context.Context, key string, path string, options *redis.JSONArrIndexArgs, value ...interface{})) *MockCmdable_JSONArrIndexWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.JSONArrIndexArgs), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_JSONArrIndexWithArgs_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_JSONArrIndexWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONArrIndexWithArgs_Call) RunAndReturn(run func(context.Context, string, string, *redis.JSONArrIndexArgs, ...interface{}) *redis.IntSliceCmd) *MockCmdable_JSONArrIndexWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// JSONArrInsert provides a mock function with given fields: ctx, key, path, index, values +func (_m *MockCmdable) JSONArrInsert(ctx context.Context, key string, path string, index int64, values ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key, path, index) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JSONArrInsert") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, path, index, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONArrInsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONArrInsert' +type MockCmdable_JSONArrInsert_Call struct { + *mock.Call +} + +// JSONArrInsert is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - index int64 +// - values ...interface{} +func (_e *MockCmdable_Expecter) JSONArrInsert(ctx interface{}, key interface{}, path interface{}, index interface{}, values ...interface{}) *MockCmdable_JSONArrInsert_Call { + return &MockCmdable_JSONArrInsert_Call{Call: _e.mock.On("JSONArrInsert", + append([]interface{}{ctx, key, path, index}, values...)...)} +} + +func (_c *MockCmdable_JSONArrInsert_Call) Run(run func(ctx context.Context, key string, path string, index int64, values ...interface{})) *MockCmdable_JSONArrInsert_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_JSONArrInsert_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_JSONArrInsert_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONArrInsert_Call) RunAndReturn(run func(context.Context, string, string, int64, ...interface{}) *redis.IntSliceCmd) *MockCmdable_JSONArrInsert_Call { + _c.Call.Return(run) + return _c +} + +// JSONArrLen provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONArrLen(ctx context.Context, key string, path string) *redis.IntSliceCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONArrLen") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONArrLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONArrLen' +type MockCmdable_JSONArrLen_Call struct { + *mock.Call +} + +// JSONArrLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONArrLen(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONArrLen_Call { + return &MockCmdable_JSONArrLen_Call{Call: _e.mock.On("JSONArrLen", ctx, key, path)} +} + +func (_c *MockCmdable_JSONArrLen_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONArrLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONArrLen_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_JSONArrLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONArrLen_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntSliceCmd) *MockCmdable_JSONArrLen_Call { + _c.Call.Return(run) + return _c +} + +// JSONArrPop provides a mock function with given fields: ctx, key, path, index +func (_m *MockCmdable) JSONArrPop(ctx context.Context, key string, path string, index int) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, path, index) + + if len(ret) == 0 { + panic("no return value specified for JSONArrPop") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, path, index) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONArrPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONArrPop' +type MockCmdable_JSONArrPop_Call struct { + *mock.Call +} + +// JSONArrPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - index int +func (_e *MockCmdable_Expecter) JSONArrPop(ctx interface{}, key interface{}, path interface{}, index interface{}) *MockCmdable_JSONArrPop_Call { + return &MockCmdable_JSONArrPop_Call{Call: _e.mock.On("JSONArrPop", ctx, key, path, index)} +} + +func (_c *MockCmdable_JSONArrPop_Call) Run(run func(ctx context.Context, key string, path string, index int)) *MockCmdable_JSONArrPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int)) + }) + return _c +} + +func (_c *MockCmdable_JSONArrPop_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_JSONArrPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONArrPop_Call) RunAndReturn(run func(context.Context, string, string, int) *redis.StringSliceCmd) *MockCmdable_JSONArrPop_Call { + _c.Call.Return(run) + return _c +} + +// JSONArrTrim provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONArrTrim(ctx context.Context, key string, path string) *redis.IntSliceCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONArrTrim") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONArrTrim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONArrTrim' +type MockCmdable_JSONArrTrim_Call struct { + *mock.Call +} + +// JSONArrTrim is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONArrTrim(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONArrTrim_Call { + return &MockCmdable_JSONArrTrim_Call{Call: _e.mock.On("JSONArrTrim", ctx, key, path)} +} + +func (_c *MockCmdable_JSONArrTrim_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONArrTrim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONArrTrim_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_JSONArrTrim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONArrTrim_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntSliceCmd) *MockCmdable_JSONArrTrim_Call { + _c.Call.Return(run) + return _c +} + +// JSONArrTrimWithArgs provides a mock function with given fields: ctx, key, path, options +func (_m *MockCmdable) JSONArrTrimWithArgs(ctx context.Context, key string, path string, options *redis.JSONArrTrimArgs) *redis.IntSliceCmd { + ret := _m.Called(ctx, key, path, options) + + if len(ret) == 0 { + panic("no return value specified for JSONArrTrimWithArgs") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.JSONArrTrimArgs) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, path, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONArrTrimWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONArrTrimWithArgs' +type MockCmdable_JSONArrTrimWithArgs_Call struct { + *mock.Call +} + +// JSONArrTrimWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - options *redis.JSONArrTrimArgs +func (_e *MockCmdable_Expecter) JSONArrTrimWithArgs(ctx interface{}, key interface{}, path interface{}, options interface{}) *MockCmdable_JSONArrTrimWithArgs_Call { + return &MockCmdable_JSONArrTrimWithArgs_Call{Call: _e.mock.On("JSONArrTrimWithArgs", ctx, key, path, options)} +} + +func (_c *MockCmdable_JSONArrTrimWithArgs_Call) Run(run func(ctx context.Context, key string, path string, options *redis.JSONArrTrimArgs)) *MockCmdable_JSONArrTrimWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.JSONArrTrimArgs)) + }) + return _c +} + +func (_c *MockCmdable_JSONArrTrimWithArgs_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_JSONArrTrimWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONArrTrimWithArgs_Call) RunAndReturn(run func(context.Context, string, string, *redis.JSONArrTrimArgs) *redis.IntSliceCmd) *MockCmdable_JSONArrTrimWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// JSONClear provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONClear(ctx context.Context, key string, path string) *redis.IntCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONClear") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_JSONClear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONClear' +type MockCmdable_JSONClear_Call struct { + *mock.Call +} + +// JSONClear is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONClear(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONClear_Call { + return &MockCmdable_JSONClear_Call{Call: _e.mock.On("JSONClear", ctx, key, path)} +} + +func (_c *MockCmdable_JSONClear_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONClear_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONClear_Call) Return(_a0 *redis.IntCmd) *MockCmdable_JSONClear_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONClear_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_JSONClear_Call { + _c.Call.Return(run) + return _c +} + +// JSONDebugMemory provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONDebugMemory(ctx context.Context, key string, path string) *redis.IntCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONDebugMemory") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_JSONDebugMemory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONDebugMemory' +type MockCmdable_JSONDebugMemory_Call struct { + *mock.Call +} + +// JSONDebugMemory is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONDebugMemory(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONDebugMemory_Call { + return &MockCmdable_JSONDebugMemory_Call{Call: _e.mock.On("JSONDebugMemory", ctx, key, path)} +} + +func (_c *MockCmdable_JSONDebugMemory_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONDebugMemory_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONDebugMemory_Call) Return(_a0 *redis.IntCmd) *MockCmdable_JSONDebugMemory_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONDebugMemory_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_JSONDebugMemory_Call { + _c.Call.Return(run) + return _c +} + +// JSONDel provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONDel(ctx context.Context, key string, path string) *redis.IntCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONDel") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_JSONDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONDel' +type MockCmdable_JSONDel_Call struct { + *mock.Call +} + +// JSONDel is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONDel(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONDel_Call { + return &MockCmdable_JSONDel_Call{Call: _e.mock.On("JSONDel", ctx, key, path)} +} + +func (_c *MockCmdable_JSONDel_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONDel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONDel_Call) Return(_a0 *redis.IntCmd) *MockCmdable_JSONDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONDel_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_JSONDel_Call { + _c.Call.Return(run) + return _c +} + +// JSONForget provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONForget(ctx context.Context, key string, path string) *redis.IntCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONForget") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_JSONForget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONForget' +type MockCmdable_JSONForget_Call struct { + *mock.Call +} + +// JSONForget is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONForget(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONForget_Call { + return &MockCmdable_JSONForget_Call{Call: _e.mock.On("JSONForget", ctx, key, path)} +} + +func (_c *MockCmdable_JSONForget_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONForget_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONForget_Call) Return(_a0 *redis.IntCmd) *MockCmdable_JSONForget_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONForget_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_JSONForget_Call { + _c.Call.Return(run) + return _c +} + +// JSONGet provides a mock function with given fields: ctx, key, paths +func (_m *MockCmdable) JSONGet(ctx context.Context, key string, paths ...string) *redis.JSONCmd { + _va := make([]interface{}, len(paths)) + for _i := range paths { + _va[_i] = paths[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JSONGet") + } + + var r0 *redis.JSONCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.JSONCmd); ok { + r0 = rf(ctx, key, paths...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.JSONCmd) + } + } + + return r0 +} + +// MockCmdable_JSONGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONGet' +type MockCmdable_JSONGet_Call struct { + *mock.Call +} + +// JSONGet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - paths ...string +func (_e *MockCmdable_Expecter) JSONGet(ctx interface{}, key interface{}, paths ...interface{}) *MockCmdable_JSONGet_Call { + return &MockCmdable_JSONGet_Call{Call: _e.mock.On("JSONGet", + append([]interface{}{ctx, key}, paths...)...)} +} + +func (_c *MockCmdable_JSONGet_Call) Run(run func(ctx context.Context, key string, paths ...string)) *MockCmdable_JSONGet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_JSONGet_Call) Return(_a0 *redis.JSONCmd) *MockCmdable_JSONGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONGet_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.JSONCmd) *MockCmdable_JSONGet_Call { + _c.Call.Return(run) + return _c +} + +// JSONGetWithArgs provides a mock function with given fields: ctx, key, options, paths +func (_m *MockCmdable) JSONGetWithArgs(ctx context.Context, key string, options *redis.JSONGetArgs, paths ...string) *redis.JSONCmd { + _va := make([]interface{}, len(paths)) + for _i := range paths { + _va[_i] = paths[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, options) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JSONGetWithArgs") + } + + var r0 *redis.JSONCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.JSONGetArgs, ...string) *redis.JSONCmd); ok { + r0 = rf(ctx, key, options, paths...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.JSONCmd) + } + } + + return r0 +} + +// MockCmdable_JSONGetWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONGetWithArgs' +type MockCmdable_JSONGetWithArgs_Call struct { + *mock.Call +} + +// JSONGetWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.JSONGetArgs +// - paths ...string +func (_e *MockCmdable_Expecter) JSONGetWithArgs(ctx interface{}, key interface{}, options interface{}, paths ...interface{}) *MockCmdable_JSONGetWithArgs_Call { + return &MockCmdable_JSONGetWithArgs_Call{Call: _e.mock.On("JSONGetWithArgs", + append([]interface{}{ctx, key, options}, paths...)...)} +} + +func (_c *MockCmdable_JSONGetWithArgs_Call) Run(run func(ctx context.Context, key string, options *redis.JSONGetArgs, paths ...string)) *MockCmdable_JSONGetWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*redis.JSONGetArgs), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_JSONGetWithArgs_Call) Return(_a0 *redis.JSONCmd) *MockCmdable_JSONGetWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONGetWithArgs_Call) RunAndReturn(run func(context.Context, string, *redis.JSONGetArgs, ...string) *redis.JSONCmd) *MockCmdable_JSONGetWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// JSONMGet provides a mock function with given fields: ctx, path, keys +func (_m *MockCmdable) JSONMGet(ctx context.Context, path string, keys ...string) *redis.JSONSliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, path) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JSONMGet") + } + + var r0 *redis.JSONSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.JSONSliceCmd); ok { + r0 = rf(ctx, path, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.JSONSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONMGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONMGet' +type MockCmdable_JSONMGet_Call struct { + *mock.Call +} + +// JSONMGet is a helper method to define mock.On call +// - ctx context.Context +// - path string +// - keys ...string +func (_e *MockCmdable_Expecter) JSONMGet(ctx interface{}, path interface{}, keys ...interface{}) *MockCmdable_JSONMGet_Call { + return &MockCmdable_JSONMGet_Call{Call: _e.mock.On("JSONMGet", + append([]interface{}{ctx, path}, keys...)...)} +} + +func (_c *MockCmdable_JSONMGet_Call) Run(run func(ctx context.Context, path string, keys ...string)) *MockCmdable_JSONMGet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_JSONMGet_Call) Return(_a0 *redis.JSONSliceCmd) *MockCmdable_JSONMGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONMGet_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.JSONSliceCmd) *MockCmdable_JSONMGet_Call { + _c.Call.Return(run) + return _c +} + +// JSONMSet provides a mock function with given fields: ctx, params +func (_m *MockCmdable) JSONMSet(ctx context.Context, params ...interface{}) *redis.StatusCmd { + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, params...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JSONMSet") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, ...interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, params...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_JSONMSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONMSet' +type MockCmdable_JSONMSet_Call struct { + *mock.Call +} + +// JSONMSet is a helper method to define mock.On call +// - ctx context.Context +// - params ...interface{} +func (_e *MockCmdable_Expecter) JSONMSet(ctx interface{}, params ...interface{}) *MockCmdable_JSONMSet_Call { + return &MockCmdable_JSONMSet_Call{Call: _e.mock.On("JSONMSet", + append([]interface{}{ctx}, params...)...)} +} + +func (_c *MockCmdable_JSONMSet_Call) Run(run func(ctx context.Context, params ...interface{})) *MockCmdable_JSONMSet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_JSONMSet_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_JSONMSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONMSet_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.StatusCmd) *MockCmdable_JSONMSet_Call { + _c.Call.Return(run) + return _c +} + +// JSONMSetArgs provides a mock function with given fields: ctx, docs +func (_m *MockCmdable) JSONMSetArgs(ctx context.Context, docs []redis.JSONSetArgs) *redis.StatusCmd { + ret := _m.Called(ctx, docs) + + if len(ret) == 0 { + panic("no return value specified for JSONMSetArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, []redis.JSONSetArgs) *redis.StatusCmd); ok { + r0 = rf(ctx, docs) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_JSONMSetArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONMSetArgs' +type MockCmdable_JSONMSetArgs_Call struct { + *mock.Call +} + +// JSONMSetArgs is a helper method to define mock.On call +// - ctx context.Context +// - docs []redis.JSONSetArgs +func (_e *MockCmdable_Expecter) JSONMSetArgs(ctx interface{}, docs interface{}) *MockCmdable_JSONMSetArgs_Call { + return &MockCmdable_JSONMSetArgs_Call{Call: _e.mock.On("JSONMSetArgs", ctx, docs)} +} + +func (_c *MockCmdable_JSONMSetArgs_Call) Run(run func(ctx context.Context, docs []redis.JSONSetArgs)) *MockCmdable_JSONMSetArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]redis.JSONSetArgs)) + }) + return _c +} + +func (_c *MockCmdable_JSONMSetArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_JSONMSetArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONMSetArgs_Call) RunAndReturn(run func(context.Context, []redis.JSONSetArgs) *redis.StatusCmd) *MockCmdable_JSONMSetArgs_Call { + _c.Call.Return(run) + return _c +} + +// JSONMerge provides a mock function with given fields: ctx, key, path, value +func (_m *MockCmdable) JSONMerge(ctx context.Context, key string, path string, value string) *redis.StatusCmd { + ret := _m.Called(ctx, key, path, value) + + if len(ret) == 0 { + panic("no return value specified for JSONMerge") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key, path, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_JSONMerge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONMerge' +type MockCmdable_JSONMerge_Call struct { + *mock.Call +} + +// JSONMerge is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - value string +func (_e *MockCmdable_Expecter) JSONMerge(ctx interface{}, key interface{}, path interface{}, value interface{}) *MockCmdable_JSONMerge_Call { + return &MockCmdable_JSONMerge_Call{Call: _e.mock.On("JSONMerge", ctx, key, path, value)} +} + +func (_c *MockCmdable_JSONMerge_Call) Run(run func(ctx context.Context, key string, path string, value string)) *MockCmdable_JSONMerge_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONMerge_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_JSONMerge_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONMerge_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *MockCmdable_JSONMerge_Call { + _c.Call.Return(run) + return _c +} + +// JSONNumIncrBy provides a mock function with given fields: ctx, key, path, value +func (_m *MockCmdable) JSONNumIncrBy(ctx context.Context, key string, path string, value float64) *redis.JSONCmd { + ret := _m.Called(ctx, key, path, value) + + if len(ret) == 0 { + panic("no return value specified for JSONNumIncrBy") + } + + var r0 *redis.JSONCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, float64) *redis.JSONCmd); ok { + r0 = rf(ctx, key, path, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.JSONCmd) + } + } + + return r0 +} + +// MockCmdable_JSONNumIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONNumIncrBy' +type MockCmdable_JSONNumIncrBy_Call struct { + *mock.Call +} + +// JSONNumIncrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - value float64 +func (_e *MockCmdable_Expecter) JSONNumIncrBy(ctx interface{}, key interface{}, path interface{}, value interface{}) *MockCmdable_JSONNumIncrBy_Call { + return &MockCmdable_JSONNumIncrBy_Call{Call: _e.mock.On("JSONNumIncrBy", ctx, key, path, value)} +} + +func (_c *MockCmdable_JSONNumIncrBy_Call) Run(run func(ctx context.Context, key string, path string, value float64)) *MockCmdable_JSONNumIncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(float64)) + }) + return _c +} + +func (_c *MockCmdable_JSONNumIncrBy_Call) Return(_a0 *redis.JSONCmd) *MockCmdable_JSONNumIncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONNumIncrBy_Call) RunAndReturn(run func(context.Context, string, string, float64) *redis.JSONCmd) *MockCmdable_JSONNumIncrBy_Call { + _c.Call.Return(run) + return _c +} + +// JSONObjKeys provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONObjKeys(ctx context.Context, key string, path string) *redis.SliceCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONObjKeys") + } + + var r0 *redis.SliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.SliceCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.SliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONObjKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONObjKeys' +type MockCmdable_JSONObjKeys_Call struct { + *mock.Call +} + +// JSONObjKeys is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONObjKeys(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONObjKeys_Call { + return &MockCmdable_JSONObjKeys_Call{Call: _e.mock.On("JSONObjKeys", ctx, key, path)} +} + +func (_c *MockCmdable_JSONObjKeys_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONObjKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONObjKeys_Call) Return(_a0 *redis.SliceCmd) *MockCmdable_JSONObjKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONObjKeys_Call) RunAndReturn(run func(context.Context, string, string) *redis.SliceCmd) *MockCmdable_JSONObjKeys_Call { + _c.Call.Return(run) + return _c +} + +// JSONObjLen provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONObjLen(ctx context.Context, key string, path string) *redis.IntPointerSliceCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONObjLen") + } + + var r0 *redis.IntPointerSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntPointerSliceCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntPointerSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONObjLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONObjLen' +type MockCmdable_JSONObjLen_Call struct { + *mock.Call +} + +// JSONObjLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONObjLen(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONObjLen_Call { + return &MockCmdable_JSONObjLen_Call{Call: _e.mock.On("JSONObjLen", ctx, key, path)} +} + +func (_c *MockCmdable_JSONObjLen_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONObjLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONObjLen_Call) Return(_a0 *redis.IntPointerSliceCmd) *MockCmdable_JSONObjLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONObjLen_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntPointerSliceCmd) *MockCmdable_JSONObjLen_Call { + _c.Call.Return(run) + return _c +} + +// JSONSet provides a mock function with given fields: ctx, key, path, value +func (_m *MockCmdable) JSONSet(ctx context.Context, key string, path string, value interface{}) *redis.StatusCmd { + ret := _m.Called(ctx, key, path, value) + + if len(ret) == 0 { + panic("no return value specified for JSONSet") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, key, path, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_JSONSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONSet' +type MockCmdable_JSONSet_Call struct { + *mock.Call +} + +// JSONSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - value interface{} +func (_e *MockCmdable_Expecter) JSONSet(ctx interface{}, key interface{}, path interface{}, value interface{}) *MockCmdable_JSONSet_Call { + return &MockCmdable_JSONSet_Call{Call: _e.mock.On("JSONSet", ctx, key, path, value)} +} + +func (_c *MockCmdable_JSONSet_Call) Run(run func(ctx context.Context, key string, path string, value interface{})) *MockCmdable_JSONSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_JSONSet_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_JSONSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONSet_Call) RunAndReturn(run func(context.Context, string, string, interface{}) *redis.StatusCmd) *MockCmdable_JSONSet_Call { + _c.Call.Return(run) + return _c +} + +// JSONSetMode provides a mock function with given fields: ctx, key, path, value, mode +func (_m *MockCmdable) JSONSetMode(ctx context.Context, key string, path string, value interface{}, mode string) *redis.StatusCmd { + ret := _m.Called(ctx, key, path, value, mode) + + if len(ret) == 0 { + panic("no return value specified for JSONSetMode") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key, path, value, mode) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_JSONSetMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONSetMode' +type MockCmdable_JSONSetMode_Call struct { + *mock.Call +} + +// JSONSetMode is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - value interface{} +// - mode string +func (_e *MockCmdable_Expecter) JSONSetMode(ctx interface{}, key interface{}, path interface{}, value interface{}, mode interface{}) *MockCmdable_JSONSetMode_Call { + return &MockCmdable_JSONSetMode_Call{Call: _e.mock.On("JSONSetMode", ctx, key, path, value, mode)} +} + +func (_c *MockCmdable_JSONSetMode_Call) Run(run func(ctx context.Context, key string, path string, value interface{}, mode string)) *MockCmdable_JSONSetMode_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(interface{}), args[4].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONSetMode_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_JSONSetMode_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONSetMode_Call) RunAndReturn(run func(context.Context, string, string, interface{}, string) *redis.StatusCmd) *MockCmdable_JSONSetMode_Call { + _c.Call.Return(run) + return _c +} + +// JSONStrAppend provides a mock function with given fields: ctx, key, path, value +func (_m *MockCmdable) JSONStrAppend(ctx context.Context, key string, path string, value string) *redis.IntPointerSliceCmd { + ret := _m.Called(ctx, key, path, value) + + if len(ret) == 0 { + panic("no return value specified for JSONStrAppend") + } + + var r0 *redis.IntPointerSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.IntPointerSliceCmd); ok { + r0 = rf(ctx, key, path, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntPointerSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONStrAppend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONStrAppend' +type MockCmdable_JSONStrAppend_Call struct { + *mock.Call +} + +// JSONStrAppend is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +// - value string +func (_e *MockCmdable_Expecter) JSONStrAppend(ctx interface{}, key interface{}, path interface{}, value interface{}) *MockCmdable_JSONStrAppend_Call { + return &MockCmdable_JSONStrAppend_Call{Call: _e.mock.On("JSONStrAppend", ctx, key, path, value)} +} + +func (_c *MockCmdable_JSONStrAppend_Call) Run(run func(ctx context.Context, key string, path string, value string)) *MockCmdable_JSONStrAppend_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONStrAppend_Call) Return(_a0 *redis.IntPointerSliceCmd) *MockCmdable_JSONStrAppend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONStrAppend_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntPointerSliceCmd) *MockCmdable_JSONStrAppend_Call { + _c.Call.Return(run) + return _c +} + +// JSONStrLen provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONStrLen(ctx context.Context, key string, path string) *redis.IntPointerSliceCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONStrLen") + } + + var r0 *redis.IntPointerSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntPointerSliceCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntPointerSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONStrLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONStrLen' +type MockCmdable_JSONStrLen_Call struct { + *mock.Call +} + +// JSONStrLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONStrLen(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONStrLen_Call { + return &MockCmdable_JSONStrLen_Call{Call: _e.mock.On("JSONStrLen", ctx, key, path)} +} + +func (_c *MockCmdable_JSONStrLen_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONStrLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONStrLen_Call) Return(_a0 *redis.IntPointerSliceCmd) *MockCmdable_JSONStrLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONStrLen_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntPointerSliceCmd) *MockCmdable_JSONStrLen_Call { + _c.Call.Return(run) + return _c +} + +// JSONToggle provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONToggle(ctx context.Context, key string, path string) *redis.IntPointerSliceCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONToggle") + } + + var r0 *redis.IntPointerSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntPointerSliceCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntPointerSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONToggle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONToggle' +type MockCmdable_JSONToggle_Call struct { + *mock.Call +} + +// JSONToggle is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONToggle(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONToggle_Call { + return &MockCmdable_JSONToggle_Call{Call: _e.mock.On("JSONToggle", ctx, key, path)} +} + +func (_c *MockCmdable_JSONToggle_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONToggle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONToggle_Call) Return(_a0 *redis.IntPointerSliceCmd) *MockCmdable_JSONToggle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONToggle_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntPointerSliceCmd) *MockCmdable_JSONToggle_Call { + _c.Call.Return(run) + return _c +} + +// JSONType provides a mock function with given fields: ctx, key, path +func (_m *MockCmdable) JSONType(ctx context.Context, key string, path string) *redis.JSONSliceCmd { + ret := _m.Called(ctx, key, path) + + if len(ret) == 0 { + panic("no return value specified for JSONType") + } + + var r0 *redis.JSONSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.JSONSliceCmd); ok { + r0 = rf(ctx, key, path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.JSONSliceCmd) + } + } + + return r0 +} + +// MockCmdable_JSONType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JSONType' +type MockCmdable_JSONType_Call struct { + *mock.Call +} + +// JSONType is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - path string +func (_e *MockCmdable_Expecter) JSONType(ctx interface{}, key interface{}, path interface{}) *MockCmdable_JSONType_Call { + return &MockCmdable_JSONType_Call{Call: _e.mock.On("JSONType", ctx, key, path)} +} + +func (_c *MockCmdable_JSONType_Call) Run(run func(ctx context.Context, key string, path string)) *MockCmdable_JSONType_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_JSONType_Call) Return(_a0 *redis.JSONSliceCmd) *MockCmdable_JSONType_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_JSONType_Call) RunAndReturn(run func(context.Context, string, string) *redis.JSONSliceCmd) *MockCmdable_JSONType_Call { + _c.Call.Return(run) + return _c +} + +// Keys provides a mock function with given fields: ctx, pattern +func (_m *MockCmdable) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd { + ret := _m.Called(ctx, pattern) + + if len(ret) == 0 { + panic("no return value specified for Keys") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, pattern) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_Keys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Keys' +type MockCmdable_Keys_Call struct { + *mock.Call +} + +// Keys is a helper method to define mock.On call +// - ctx context.Context +// - pattern string +func (_e *MockCmdable_Expecter) Keys(ctx interface{}, pattern interface{}) *MockCmdable_Keys_Call { + return &MockCmdable_Keys_Call{Call: _e.mock.On("Keys", ctx, pattern)} +} + +func (_c *MockCmdable_Keys_Call) Run(run func(ctx context.Context, pattern string)) *MockCmdable_Keys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_Keys_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_Keys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Keys_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_Keys_Call { + _c.Call.Return(run) + return _c +} + +// LCS provides a mock function with given fields: ctx, q +func (_m *MockCmdable) LCS(ctx context.Context, q *redis.LCSQuery) *redis.LCSCmd { + ret := _m.Called(ctx, q) + + if len(ret) == 0 { + panic("no return value specified for LCS") + } + + var r0 *redis.LCSCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.LCSQuery) *redis.LCSCmd); ok { + r0 = rf(ctx, q) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.LCSCmd) + } + } + + return r0 +} + +// MockCmdable_LCS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LCS' +type MockCmdable_LCS_Call struct { + *mock.Call +} + +// LCS is a helper method to define mock.On call +// - ctx context.Context +// - q *redis.LCSQuery +func (_e *MockCmdable_Expecter) LCS(ctx interface{}, q interface{}) *MockCmdable_LCS_Call { + return &MockCmdable_LCS_Call{Call: _e.mock.On("LCS", ctx, q)} +} + +func (_c *MockCmdable_LCS_Call) Run(run func(ctx context.Context, q *redis.LCSQuery)) *MockCmdable_LCS_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.LCSQuery)) + }) + return _c +} + +func (_c *MockCmdable_LCS_Call) Return(_a0 *redis.LCSCmd) *MockCmdable_LCS_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LCS_Call) RunAndReturn(run func(context.Context, *redis.LCSQuery) *redis.LCSCmd) *MockCmdable_LCS_Call { + _c.Call.Return(run) + return _c +} + +// LIndex provides a mock function with given fields: ctx, key, index +func (_m *MockCmdable) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd { + ret := _m.Called(ctx, key, index) + + if len(ret) == 0 { + panic("no return value specified for LIndex") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.StringCmd); ok { + r0 = rf(ctx, key, index) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_LIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LIndex' +type MockCmdable_LIndex_Call struct { + *mock.Call +} + +// LIndex is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - index int64 +func (_e *MockCmdable_Expecter) LIndex(ctx interface{}, key interface{}, index interface{}) *MockCmdable_LIndex_Call { + return &MockCmdable_LIndex_Call{Call: _e.mock.On("LIndex", ctx, key, index)} +} + +func (_c *MockCmdable_LIndex_Call) Run(run func(ctx context.Context, key string, index int64)) *MockCmdable_LIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_LIndex_Call) Return(_a0 *redis.StringCmd) *MockCmdable_LIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LIndex_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringCmd) *MockCmdable_LIndex_Call { + _c.Call.Return(run) + return _c +} + +// LInsert provides a mock function with given fields: ctx, key, op, pivot, value +func (_m *MockCmdable) LInsert(ctx context.Context, key string, op string, pivot interface{}, value interface{}) *redis.IntCmd { + ret := _m.Called(ctx, key, op, pivot, value) + + if len(ret) == 0 { + panic("no return value specified for LInsert") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}, interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, op, pivot, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LInsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LInsert' +type MockCmdable_LInsert_Call struct { + *mock.Call +} + +// LInsert is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - op string +// - pivot interface{} +// - value interface{} +func (_e *MockCmdable_Expecter) LInsert(ctx interface{}, key interface{}, op interface{}, pivot interface{}, value interface{}) *MockCmdable_LInsert_Call { + return &MockCmdable_LInsert_Call{Call: _e.mock.On("LInsert", ctx, key, op, pivot, value)} +} + +func (_c *MockCmdable_LInsert_Call) Run(run func(ctx context.Context, key string, op string, pivot interface{}, value interface{})) *MockCmdable_LInsert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(interface{}), args[4].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_LInsert_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LInsert_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LInsert_Call) RunAndReturn(run func(context.Context, string, string, interface{}, interface{}) *redis.IntCmd) *MockCmdable_LInsert_Call { + _c.Call.Return(run) + return _c +} + +// LInsertAfter provides a mock function with given fields: ctx, key, pivot, value +func (_m *MockCmdable) LInsertAfter(ctx context.Context, key string, pivot interface{}, value interface{}) *redis.IntCmd { + ret := _m.Called(ctx, key, pivot, value) + + if len(ret) == 0 { + panic("no return value specified for LInsertAfter") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, pivot, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LInsertAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LInsertAfter' +type MockCmdable_LInsertAfter_Call struct { + *mock.Call +} + +// LInsertAfter is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - pivot interface{} +// - value interface{} +func (_e *MockCmdable_Expecter) LInsertAfter(ctx interface{}, key interface{}, pivot interface{}, value interface{}) *MockCmdable_LInsertAfter_Call { + return &MockCmdable_LInsertAfter_Call{Call: _e.mock.On("LInsertAfter", ctx, key, pivot, value)} +} + +func (_c *MockCmdable_LInsertAfter_Call) Run(run func(ctx context.Context, key string, pivot interface{}, value interface{})) *MockCmdable_LInsertAfter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_LInsertAfter_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LInsertAfter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LInsertAfter_Call) RunAndReturn(run func(context.Context, string, interface{}, interface{}) *redis.IntCmd) *MockCmdable_LInsertAfter_Call { + _c.Call.Return(run) + return _c +} + +// LInsertBefore provides a mock function with given fields: ctx, key, pivot, value +func (_m *MockCmdable) LInsertBefore(ctx context.Context, key string, pivot interface{}, value interface{}) *redis.IntCmd { + ret := _m.Called(ctx, key, pivot, value) + + if len(ret) == 0 { + panic("no return value specified for LInsertBefore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, pivot, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LInsertBefore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LInsertBefore' +type MockCmdable_LInsertBefore_Call struct { + *mock.Call +} + +// LInsertBefore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - pivot interface{} +// - value interface{} +func (_e *MockCmdable_Expecter) LInsertBefore(ctx interface{}, key interface{}, pivot interface{}, value interface{}) *MockCmdable_LInsertBefore_Call { + return &MockCmdable_LInsertBefore_Call{Call: _e.mock.On("LInsertBefore", ctx, key, pivot, value)} +} + +func (_c *MockCmdable_LInsertBefore_Call) Run(run func(ctx context.Context, key string, pivot interface{}, value interface{})) *MockCmdable_LInsertBefore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_LInsertBefore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LInsertBefore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LInsertBefore_Call) RunAndReturn(run func(context.Context, string, interface{}, interface{}) *redis.IntCmd) *MockCmdable_LInsertBefore_Call { + _c.Call.Return(run) + return _c +} + +// LLen provides a mock function with given fields: ctx, key +func (_m *MockCmdable) LLen(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for LLen") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LLen' +type MockCmdable_LLen_Call struct { + *mock.Call +} + +// LLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) LLen(ctx interface{}, key interface{}) *MockCmdable_LLen_Call { + return &MockCmdable_LLen_Call{Call: _e.mock.On("LLen", ctx, key)} +} + +func (_c *MockCmdable_LLen_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_LLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_LLen_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_LLen_Call { + _c.Call.Return(run) + return _c +} + +// LMPop provides a mock function with given fields: ctx, direction, count, keys +func (_m *MockCmdable) LMPop(ctx context.Context, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, direction, count) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for LMPop") + } + + var r0 *redis.KeyValuesCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, ...string) *redis.KeyValuesCmd); ok { + r0 = rf(ctx, direction, count, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.KeyValuesCmd) + } + } + + return r0 +} + +// MockCmdable_LMPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LMPop' +type MockCmdable_LMPop_Call struct { + *mock.Call +} + +// LMPop is a helper method to define mock.On call +// - ctx context.Context +// - direction string +// - count int64 +// - keys ...string +func (_e *MockCmdable_Expecter) LMPop(ctx interface{}, direction interface{}, count interface{}, keys ...interface{}) *MockCmdable_LMPop_Call { + return &MockCmdable_LMPop_Call{Call: _e.mock.On("LMPop", + append([]interface{}{ctx, direction, count}, keys...)...)} +} + +func (_c *MockCmdable_LMPop_Call) Run(run func(ctx context.Context, direction string, count int64, keys ...string)) *MockCmdable_LMPop_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(int64), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_LMPop_Call) Return(_a0 *redis.KeyValuesCmd) *MockCmdable_LMPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LMPop_Call) RunAndReturn(run func(context.Context, string, int64, ...string) *redis.KeyValuesCmd) *MockCmdable_LMPop_Call { + _c.Call.Return(run) + return _c +} + +// LMove provides a mock function with given fields: ctx, source, destination, srcpos, destpos +func (_m *MockCmdable) LMove(ctx context.Context, source string, destination string, srcpos string, destpos string) *redis.StringCmd { + ret := _m.Called(ctx, source, destination, srcpos, destpos) + + if len(ret) == 0 { + panic("no return value specified for LMove") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) *redis.StringCmd); ok { + r0 = rf(ctx, source, destination, srcpos, destpos) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_LMove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LMove' +type MockCmdable_LMove_Call struct { + *mock.Call +} + +// LMove is a helper method to define mock.On call +// - ctx context.Context +// - source string +// - destination string +// - srcpos string +// - destpos string +func (_e *MockCmdable_Expecter) LMove(ctx interface{}, source interface{}, destination interface{}, srcpos interface{}, destpos interface{}) *MockCmdable_LMove_Call { + return &MockCmdable_LMove_Call{Call: _e.mock.On("LMove", ctx, source, destination, srcpos, destpos)} +} + +func (_c *MockCmdable_LMove_Call) Run(run func(ctx context.Context, source string, destination string, srcpos string, destpos string)) *MockCmdable_LMove_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *MockCmdable_LMove_Call) Return(_a0 *redis.StringCmd) *MockCmdable_LMove_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LMove_Call) RunAndReturn(run func(context.Context, string, string, string, string) *redis.StringCmd) *MockCmdable_LMove_Call { + _c.Call.Return(run) + return _c +} + +// LPop provides a mock function with given fields: ctx, key +func (_m *MockCmdable) LPop(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for LPop") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_LPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPop' +type MockCmdable_LPop_Call struct { + *mock.Call +} + +// LPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) LPop(ctx interface{}, key interface{}) *MockCmdable_LPop_Call { + return &MockCmdable_LPop_Call{Call: _e.mock.On("LPop", ctx, key)} +} + +func (_c *MockCmdable_LPop_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_LPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_LPop_Call) Return(_a0 *redis.StringCmd) *MockCmdable_LPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_LPop_Call { + _c.Call.Return(run) + return _c +} + +// LPopCount provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for LPopCount") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_LPopCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPopCount' +type MockCmdable_LPopCount_Call struct { + *mock.Call +} + +// LPopCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *MockCmdable_Expecter) LPopCount(ctx interface{}, key interface{}, count interface{}) *MockCmdable_LPopCount_Call { + return &MockCmdable_LPopCount_Call{Call: _e.mock.On("LPopCount", ctx, key, count)} +} + +func (_c *MockCmdable_LPopCount_Call) Run(run func(ctx context.Context, key string, count int)) *MockCmdable_LPopCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_LPopCount_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_LPopCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LPopCount_Call) RunAndReturn(run func(context.Context, string, int) *redis.StringSliceCmd) *MockCmdable_LPopCount_Call { + _c.Call.Return(run) + return _c +} + +// LPos provides a mock function with given fields: ctx, key, value, args +func (_m *MockCmdable) LPos(ctx context.Context, key string, value string, args redis.LPosArgs) *redis.IntCmd { + ret := _m.Called(ctx, key, value, args) + + if len(ret) == 0 { + panic("no return value specified for LPos") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, redis.LPosArgs) *redis.IntCmd); ok { + r0 = rf(ctx, key, value, args) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LPos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPos' +type MockCmdable_LPos_Call struct { + *mock.Call +} + +// LPos is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value string +// - args redis.LPosArgs +func (_e *MockCmdable_Expecter) LPos(ctx interface{}, key interface{}, value interface{}, args interface{}) *MockCmdable_LPos_Call { + return &MockCmdable_LPos_Call{Call: _e.mock.On("LPos", ctx, key, value, args)} +} + +func (_c *MockCmdable_LPos_Call) Run(run func(ctx context.Context, key string, value string, args redis.LPosArgs)) *MockCmdable_LPos_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(redis.LPosArgs)) + }) + return _c +} + +func (_c *MockCmdable_LPos_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LPos_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LPos_Call) RunAndReturn(run func(context.Context, string, string, redis.LPosArgs) *redis.IntCmd) *MockCmdable_LPos_Call { + _c.Call.Return(run) + return _c +} + +// LPosCount provides a mock function with given fields: ctx, key, value, count, args +func (_m *MockCmdable) LPosCount(ctx context.Context, key string, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd { + ret := _m.Called(ctx, key, value, count, args) + + if len(ret) == 0 { + panic("no return value specified for LPosCount") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64, redis.LPosArgs) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, value, count, args) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_LPosCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPosCount' +type MockCmdable_LPosCount_Call struct { + *mock.Call +} + +// LPosCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value string +// - count int64 +// - args redis.LPosArgs +func (_e *MockCmdable_Expecter) LPosCount(ctx interface{}, key interface{}, value interface{}, count interface{}, args interface{}) *MockCmdable_LPosCount_Call { + return &MockCmdable_LPosCount_Call{Call: _e.mock.On("LPosCount", ctx, key, value, count, args)} +} + +func (_c *MockCmdable_LPosCount_Call) Run(run func(ctx context.Context, key string, value string, count int64, args redis.LPosArgs)) *MockCmdable_LPosCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64), args[4].(redis.LPosArgs)) + }) + return _c +} + +func (_c *MockCmdable_LPosCount_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_LPosCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LPosCount_Call) RunAndReturn(run func(context.Context, string, string, int64, redis.LPosArgs) *redis.IntSliceCmd) *MockCmdable_LPosCount_Call { + _c.Call.Return(run) + return _c +} + +// LPush provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) LPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for LPush") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPush' +type MockCmdable_LPush_Call struct { + *mock.Call +} + +// LPush is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *MockCmdable_Expecter) LPush(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_LPush_Call { + return &MockCmdable_LPush_Call{Call: _e.mock.On("LPush", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_LPush_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *MockCmdable_LPush_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_LPush_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LPush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LPush_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_LPush_Call { + _c.Call.Return(run) + return _c +} + +// LPushX provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) LPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for LPushX") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LPushX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPushX' +type MockCmdable_LPushX_Call struct { + *mock.Call +} + +// LPushX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *MockCmdable_Expecter) LPushX(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_LPushX_Call { + return &MockCmdable_LPushX_Call{Call: _e.mock.On("LPushX", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_LPushX_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *MockCmdable_LPushX_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_LPushX_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LPushX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LPushX_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_LPushX_Call { + _c.Call.Return(run) + return _c +} + +// LRange provides a mock function with given fields: ctx, key, start, stop +func (_m *MockCmdable) LRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, start, stop) + + if len(ret) == 0 { + panic("no return value specified for LRange") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_LRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LRange' +type MockCmdable_LRange_Call struct { + *mock.Call +} + +// LRange is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - start int64 +// - stop int64 +func (_e *MockCmdable_Expecter) LRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *MockCmdable_LRange_Call { + return &MockCmdable_LRange_Call{Call: _e.mock.On("LRange", ctx, key, start, stop)} +} + +func (_c *MockCmdable_LRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *MockCmdable_LRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_LRange_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_LRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *MockCmdable_LRange_Call { + _c.Call.Return(run) + return _c +} + +// LRem provides a mock function with given fields: ctx, key, count, value +func (_m *MockCmdable) LRem(ctx context.Context, key string, count int64, value interface{}) *redis.IntCmd { + ret := _m.Called(ctx, key, count, value) + + if len(ret) == 0 { + panic("no return value specified for LRem") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, count, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LRem' +type MockCmdable_LRem_Call struct { + *mock.Call +} + +// LRem is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int64 +// - value interface{} +func (_e *MockCmdable_Expecter) LRem(ctx interface{}, key interface{}, count interface{}, value interface{}) *MockCmdable_LRem_Call { + return &MockCmdable_LRem_Call{Call: _e.mock.On("LRem", ctx, key, count, value)} +} + +func (_c *MockCmdable_LRem_Call) Run(run func(ctx context.Context, key string, count int64, value interface{})) *MockCmdable_LRem_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_LRem_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LRem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LRem_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) *redis.IntCmd) *MockCmdable_LRem_Call { + _c.Call.Return(run) + return _c +} + +// LSet provides a mock function with given fields: ctx, key, index, value +func (_m *MockCmdable) LSet(ctx context.Context, key string, index int64, value interface{}) *redis.StatusCmd { + ret := _m.Called(ctx, key, index, value) + + if len(ret) == 0 { + panic("no return value specified for LSet") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, key, index, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_LSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LSet' +type MockCmdable_LSet_Call struct { + *mock.Call +} + +// LSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - index int64 +// - value interface{} +func (_e *MockCmdable_Expecter) LSet(ctx interface{}, key interface{}, index interface{}, value interface{}) *MockCmdable_LSet_Call { + return &MockCmdable_LSet_Call{Call: _e.mock.On("LSet", ctx, key, index, value)} +} + +func (_c *MockCmdable_LSet_Call) Run(run func(ctx context.Context, key string, index int64, value interface{})) *MockCmdable_LSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_LSet_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_LSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LSet_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) *redis.StatusCmd) *MockCmdable_LSet_Call { + _c.Call.Return(run) + return _c +} + +// LTrim provides a mock function with given fields: ctx, key, start, stop +func (_m *MockCmdable) LTrim(ctx context.Context, key string, start int64, stop int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, start, stop) + + if len(ret) == 0 { + panic("no return value specified for LTrim") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_LTrim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LTrim' +type MockCmdable_LTrim_Call struct { + *mock.Call +} + +// LTrim is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - start int64 +// - stop int64 +func (_e *MockCmdable_Expecter) LTrim(ctx interface{}, key interface{}, start interface{}, stop interface{}) *MockCmdable_LTrim_Call { + return &MockCmdable_LTrim_Call{Call: _e.mock.On("LTrim", ctx, key, start, stop)} +} + +func (_c *MockCmdable_LTrim_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *MockCmdable_LTrim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_LTrim_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_LTrim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LTrim_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StatusCmd) *MockCmdable_LTrim_Call { + _c.Call.Return(run) + return _c +} + +// LastSave provides a mock function with given fields: ctx +func (_m *MockCmdable) LastSave(ctx context.Context) *redis.IntCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for LastSave") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.IntCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_LastSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastSave' +type MockCmdable_LastSave_Call struct { + *mock.Call +} + +// LastSave is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) LastSave(ctx interface{}) *MockCmdable_LastSave_Call { + return &MockCmdable_LastSave_Call{Call: _e.mock.On("LastSave", ctx)} +} + +func (_c *MockCmdable_LastSave_Call) Run(run func(ctx context.Context)) *MockCmdable_LastSave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_LastSave_Call) Return(_a0 *redis.IntCmd) *MockCmdable_LastSave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_LastSave_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *MockCmdable_LastSave_Call { + _c.Call.Return(run) + return _c +} + +// MGet provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) MGet(ctx context.Context, keys ...string) *redis.SliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for MGet") + } + + var r0 *redis.SliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.SliceCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.SliceCmd) + } + } + + return r0 +} + +// MockCmdable_MGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MGet' +type MockCmdable_MGet_Call struct { + *mock.Call +} + +// MGet is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) MGet(ctx interface{}, keys ...interface{}) *MockCmdable_MGet_Call { + return &MockCmdable_MGet_Call{Call: _e.mock.On("MGet", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_MGet_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_MGet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_MGet_Call) Return(_a0 *redis.SliceCmd) *MockCmdable_MGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_MGet_Call) RunAndReturn(run func(context.Context, ...string) *redis.SliceCmd) *MockCmdable_MGet_Call { + _c.Call.Return(run) + return _c +} + +// MSet provides a mock function with given fields: ctx, values +func (_m *MockCmdable) MSet(ctx context.Context, values ...interface{}) *redis.StatusCmd { + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for MSet") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, ...interface{}) *redis.StatusCmd); ok { + r0 = rf(ctx, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_MSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MSet' +type MockCmdable_MSet_Call struct { + *mock.Call +} + +// MSet is a helper method to define mock.On call +// - ctx context.Context +// - values ...interface{} +func (_e *MockCmdable_Expecter) MSet(ctx interface{}, values ...interface{}) *MockCmdable_MSet_Call { + return &MockCmdable_MSet_Call{Call: _e.mock.On("MSet", + append([]interface{}{ctx}, values...)...)} +} + +func (_c *MockCmdable_MSet_Call) Run(run func(ctx context.Context, values ...interface{})) *MockCmdable_MSet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_MSet_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_MSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_MSet_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.StatusCmd) *MockCmdable_MSet_Call { + _c.Call.Return(run) + return _c +} + +// MSetNX provides a mock function with given fields: ctx, values +func (_m *MockCmdable) MSetNX(ctx context.Context, values ...interface{}) *redis.BoolCmd { + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for MSetNX") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, ...interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_MSetNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MSetNX' +type MockCmdable_MSetNX_Call struct { + *mock.Call +} + +// MSetNX is a helper method to define mock.On call +// - ctx context.Context +// - values ...interface{} +func (_e *MockCmdable_Expecter) MSetNX(ctx interface{}, values ...interface{}) *MockCmdable_MSetNX_Call { + return &MockCmdable_MSetNX_Call{Call: _e.mock.On("MSetNX", + append([]interface{}{ctx}, values...)...)} +} + +func (_c *MockCmdable_MSetNX_Call) Run(run func(ctx context.Context, values ...interface{})) *MockCmdable_MSetNX_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_MSetNX_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_MSetNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_MSetNX_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.BoolCmd) *MockCmdable_MSetNX_Call { + _c.Call.Return(run) + return _c +} + +// MemoryUsage provides a mock function with given fields: ctx, key, samples +func (_m *MockCmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd { + _va := make([]interface{}, len(samples)) + for _i := range samples { + _va[_i] = samples[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for MemoryUsage") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...int) *redis.IntCmd); ok { + r0 = rf(ctx, key, samples...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_MemoryUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MemoryUsage' +type MockCmdable_MemoryUsage_Call struct { + *mock.Call +} + +// MemoryUsage is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - samples ...int +func (_e *MockCmdable_Expecter) MemoryUsage(ctx interface{}, key interface{}, samples ...interface{}) *MockCmdable_MemoryUsage_Call { + return &MockCmdable_MemoryUsage_Call{Call: _e.mock.On("MemoryUsage", + append([]interface{}{ctx, key}, samples...)...)} +} + +func (_c *MockCmdable_MemoryUsage_Call) Run(run func(ctx context.Context, key string, samples ...int)) *MockCmdable_MemoryUsage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]int, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(int) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_MemoryUsage_Call) Return(_a0 *redis.IntCmd) *MockCmdable_MemoryUsage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_MemoryUsage_Call) RunAndReturn(run func(context.Context, string, ...int) *redis.IntCmd) *MockCmdable_MemoryUsage_Call { + _c.Call.Return(run) + return _c +} + +// Migrate provides a mock function with given fields: ctx, host, port, key, db, timeout +func (_m *MockCmdable) Migrate(ctx context.Context, host string, port string, key string, db int, timeout time.Duration) *redis.StatusCmd { + ret := _m.Called(ctx, host, port, key, db, timeout) + + if len(ret) == 0 { + panic("no return value specified for Migrate") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int, time.Duration) *redis.StatusCmd); ok { + r0 = rf(ctx, host, port, key, db, timeout) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Migrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Migrate' +type MockCmdable_Migrate_Call struct { + *mock.Call +} + +// Migrate is a helper method to define mock.On call +// - ctx context.Context +// - host string +// - port string +// - key string +// - db int +// - timeout time.Duration +func (_e *MockCmdable_Expecter) Migrate(ctx interface{}, host interface{}, port interface{}, key interface{}, db interface{}, timeout interface{}) *MockCmdable_Migrate_Call { + return &MockCmdable_Migrate_Call{Call: _e.mock.On("Migrate", ctx, host, port, key, db, timeout)} +} + +func (_c *MockCmdable_Migrate_Call) Run(run func(ctx context.Context, host string, port string, key string, db int, timeout time.Duration)) *MockCmdable_Migrate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int), args[5].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_Migrate_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Migrate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Migrate_Call) RunAndReturn(run func(context.Context, string, string, string, int, time.Duration) *redis.StatusCmd) *MockCmdable_Migrate_Call { + _c.Call.Return(run) + return _c +} + +// ModuleLoadex provides a mock function with given fields: ctx, conf +func (_m *MockCmdable) ModuleLoadex(ctx context.Context, conf *redis.ModuleLoadexConfig) *redis.StringCmd { + ret := _m.Called(ctx, conf) + + if len(ret) == 0 { + panic("no return value specified for ModuleLoadex") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.ModuleLoadexConfig) *redis.StringCmd); ok { + r0 = rf(ctx, conf) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ModuleLoadex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModuleLoadex' +type MockCmdable_ModuleLoadex_Call struct { + *mock.Call +} + +// ModuleLoadex is a helper method to define mock.On call +// - ctx context.Context +// - conf *redis.ModuleLoadexConfig +func (_e *MockCmdable_Expecter) ModuleLoadex(ctx interface{}, conf interface{}) *MockCmdable_ModuleLoadex_Call { + return &MockCmdable_ModuleLoadex_Call{Call: _e.mock.On("ModuleLoadex", ctx, conf)} +} + +func (_c *MockCmdable_ModuleLoadex_Call) Run(run func(ctx context.Context, conf *redis.ModuleLoadexConfig)) *MockCmdable_ModuleLoadex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.ModuleLoadexConfig)) + }) + return _c +} + +func (_c *MockCmdable_ModuleLoadex_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ModuleLoadex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ModuleLoadex_Call) RunAndReturn(run func(context.Context, *redis.ModuleLoadexConfig) *redis.StringCmd) *MockCmdable_ModuleLoadex_Call { + _c.Call.Return(run) + return _c +} + +// Move provides a mock function with given fields: ctx, key, db +func (_m *MockCmdable) Move(ctx context.Context, key string, db int) *redis.BoolCmd { + ret := _m.Called(ctx, key, db) + + if len(ret) == 0 { + panic("no return value specified for Move") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.BoolCmd); ok { + r0 = rf(ctx, key, db) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_Move_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Move' +type MockCmdable_Move_Call struct { + *mock.Call +} + +// Move is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - db int +func (_e *MockCmdable_Expecter) Move(ctx interface{}, key interface{}, db interface{}) *MockCmdable_Move_Call { + return &MockCmdable_Move_Call{Call: _e.mock.On("Move", ctx, key, db)} +} + +func (_c *MockCmdable_Move_Call) Run(run func(ctx context.Context, key string, db int)) *MockCmdable_Move_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_Move_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_Move_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Move_Call) RunAndReturn(run func(context.Context, string, int) *redis.BoolCmd) *MockCmdable_Move_Call { + _c.Call.Return(run) + return _c +} + +// ObjectEncoding provides a mock function with given fields: ctx, key +func (_m *MockCmdable) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for ObjectEncoding") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ObjectEncoding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObjectEncoding' +type MockCmdable_ObjectEncoding_Call struct { + *mock.Call +} + +// ObjectEncoding is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) ObjectEncoding(ctx interface{}, key interface{}) *MockCmdable_ObjectEncoding_Call { + return &MockCmdable_ObjectEncoding_Call{Call: _e.mock.On("ObjectEncoding", ctx, key)} +} + +func (_c *MockCmdable_ObjectEncoding_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_ObjectEncoding_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ObjectEncoding_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ObjectEncoding_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ObjectEncoding_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_ObjectEncoding_Call { + _c.Call.Return(run) + return _c +} + +// ObjectFreq provides a mock function with given fields: ctx, key +func (_m *MockCmdable) ObjectFreq(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for ObjectFreq") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ObjectFreq_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObjectFreq' +type MockCmdable_ObjectFreq_Call struct { + *mock.Call +} + +// ObjectFreq is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) ObjectFreq(ctx interface{}, key interface{}) *MockCmdable_ObjectFreq_Call { + return &MockCmdable_ObjectFreq_Call{Call: _e.mock.On("ObjectFreq", ctx, key)} +} + +func (_c *MockCmdable_ObjectFreq_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_ObjectFreq_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ObjectFreq_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ObjectFreq_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ObjectFreq_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_ObjectFreq_Call { + _c.Call.Return(run) + return _c +} + +// ObjectIdleTime provides a mock function with given fields: ctx, key +func (_m *MockCmdable) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for ObjectIdleTime") + } + + var r0 *redis.DurationCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.DurationCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.DurationCmd) + } + } + + return r0 +} + +// MockCmdable_ObjectIdleTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObjectIdleTime' +type MockCmdable_ObjectIdleTime_Call struct { + *mock.Call +} + +// ObjectIdleTime is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) ObjectIdleTime(ctx interface{}, key interface{}) *MockCmdable_ObjectIdleTime_Call { + return &MockCmdable_ObjectIdleTime_Call{Call: _e.mock.On("ObjectIdleTime", ctx, key)} +} + +func (_c *MockCmdable_ObjectIdleTime_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_ObjectIdleTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ObjectIdleTime_Call) Return(_a0 *redis.DurationCmd) *MockCmdable_ObjectIdleTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ObjectIdleTime_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *MockCmdable_ObjectIdleTime_Call { + _c.Call.Return(run) + return _c +} + +// ObjectRefCount provides a mock function with given fields: ctx, key +func (_m *MockCmdable) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for ObjectRefCount") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ObjectRefCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObjectRefCount' +type MockCmdable_ObjectRefCount_Call struct { + *mock.Call +} + +// ObjectRefCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) ObjectRefCount(ctx interface{}, key interface{}) *MockCmdable_ObjectRefCount_Call { + return &MockCmdable_ObjectRefCount_Call{Call: _e.mock.On("ObjectRefCount", ctx, key)} +} + +func (_c *MockCmdable_ObjectRefCount_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_ObjectRefCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ObjectRefCount_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ObjectRefCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ObjectRefCount_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_ObjectRefCount_Call { + _c.Call.Return(run) + return _c +} + +// PExpire provides a mock function with given fields: ctx, key, expiration +func (_m *MockCmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, key, expiration) + + if len(ret) == 0 { + panic("no return value specified for PExpire") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, key, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_PExpire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PExpire' +type MockCmdable_PExpire_Call struct { + *mock.Call +} + +// PExpire is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - expiration time.Duration +func (_e *MockCmdable_Expecter) PExpire(ctx interface{}, key interface{}, expiration interface{}) *MockCmdable_PExpire_Call { + return &MockCmdable_PExpire_Call{Call: _e.mock.On("PExpire", ctx, key, expiration)} +} + +func (_c *MockCmdable_PExpire_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockCmdable_PExpire_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_PExpire_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_PExpire_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PExpire_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *MockCmdable_PExpire_Call { + _c.Call.Return(run) + return _c +} + +// PExpireAt provides a mock function with given fields: ctx, key, tm +func (_m *MockCmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + ret := _m.Called(ctx, key, tm) + + if len(ret) == 0 { + panic("no return value specified for PExpireAt") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Time) *redis.BoolCmd); ok { + r0 = rf(ctx, key, tm) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_PExpireAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PExpireAt' +type MockCmdable_PExpireAt_Call struct { + *mock.Call +} + +// PExpireAt is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - tm time.Time +func (_e *MockCmdable_Expecter) PExpireAt(ctx interface{}, key interface{}, tm interface{}) *MockCmdable_PExpireAt_Call { + return &MockCmdable_PExpireAt_Call{Call: _e.mock.On("PExpireAt", ctx, key, tm)} +} + +func (_c *MockCmdable_PExpireAt_Call) Run(run func(ctx context.Context, key string, tm time.Time)) *MockCmdable_PExpireAt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Time)) + }) + return _c +} + +func (_c *MockCmdable_PExpireAt_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_PExpireAt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PExpireAt_Call) RunAndReturn(run func(context.Context, string, time.Time) *redis.BoolCmd) *MockCmdable_PExpireAt_Call { + _c.Call.Return(run) + return _c +} + +// PExpireTime provides a mock function with given fields: ctx, key +func (_m *MockCmdable) PExpireTime(ctx context.Context, key string) *redis.DurationCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for PExpireTime") + } + + var r0 *redis.DurationCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.DurationCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.DurationCmd) + } + } + + return r0 +} + +// MockCmdable_PExpireTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PExpireTime' +type MockCmdable_PExpireTime_Call struct { + *mock.Call +} + +// PExpireTime is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) PExpireTime(ctx interface{}, key interface{}) *MockCmdable_PExpireTime_Call { + return &MockCmdable_PExpireTime_Call{Call: _e.mock.On("PExpireTime", ctx, key)} +} + +func (_c *MockCmdable_PExpireTime_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_PExpireTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_PExpireTime_Call) Return(_a0 *redis.DurationCmd) *MockCmdable_PExpireTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PExpireTime_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *MockCmdable_PExpireTime_Call { + _c.Call.Return(run) + return _c +} + +// PFAdd provides a mock function with given fields: ctx, key, els +func (_m *MockCmdable) PFAdd(ctx context.Context, key string, els ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, els...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for PFAdd") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, els...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_PFAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFAdd' +type MockCmdable_PFAdd_Call struct { + *mock.Call +} + +// PFAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - els ...interface{} +func (_e *MockCmdable_Expecter) PFAdd(ctx interface{}, key interface{}, els ...interface{}) *MockCmdable_PFAdd_Call { + return &MockCmdable_PFAdd_Call{Call: _e.mock.On("PFAdd", + append([]interface{}{ctx, key}, els...)...)} +} + +func (_c *MockCmdable_PFAdd_Call) Run(run func(ctx context.Context, key string, els ...interface{})) *MockCmdable_PFAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_PFAdd_Call) Return(_a0 *redis.IntCmd) *MockCmdable_PFAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PFAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_PFAdd_Call { + _c.Call.Return(run) + return _c +} + +// PFCount provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) PFCount(ctx context.Context, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for PFCount") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_PFCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFCount' +type MockCmdable_PFCount_Call struct { + *mock.Call +} + +// PFCount is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) PFCount(ctx interface{}, keys ...interface{}) *MockCmdable_PFCount_Call { + return &MockCmdable_PFCount_Call{Call: _e.mock.On("PFCount", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_PFCount_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_PFCount_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_PFCount_Call) Return(_a0 *redis.IntCmd) *MockCmdable_PFCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PFCount_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *MockCmdable_PFCount_Call { + _c.Call.Return(run) + return _c +} + +// PFMerge provides a mock function with given fields: ctx, dest, keys +func (_m *MockCmdable) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, dest) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for PFMerge") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.StatusCmd); ok { + r0 = rf(ctx, dest, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_PFMerge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFMerge' +type MockCmdable_PFMerge_Call struct { + *mock.Call +} + +// PFMerge is a helper method to define mock.On call +// - ctx context.Context +// - dest string +// - keys ...string +func (_e *MockCmdable_Expecter) PFMerge(ctx interface{}, dest interface{}, keys ...interface{}) *MockCmdable_PFMerge_Call { + return &MockCmdable_PFMerge_Call{Call: _e.mock.On("PFMerge", + append([]interface{}{ctx, dest}, keys...)...)} +} + +func (_c *MockCmdable_PFMerge_Call) Run(run func(ctx context.Context, dest string, keys ...string)) *MockCmdable_PFMerge_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_PFMerge_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_PFMerge_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PFMerge_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.StatusCmd) *MockCmdable_PFMerge_Call { + _c.Call.Return(run) + return _c +} + +// PTTL provides a mock function with given fields: ctx, key +func (_m *MockCmdable) PTTL(ctx context.Context, key string) *redis.DurationCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for PTTL") + } + + var r0 *redis.DurationCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.DurationCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.DurationCmd) + } + } + + return r0 +} + +// MockCmdable_PTTL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PTTL' +type MockCmdable_PTTL_Call struct { + *mock.Call +} + +// PTTL is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) PTTL(ctx interface{}, key interface{}) *MockCmdable_PTTL_Call { + return &MockCmdable_PTTL_Call{Call: _e.mock.On("PTTL", ctx, key)} +} + +func (_c *MockCmdable_PTTL_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_PTTL_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_PTTL_Call) Return(_a0 *redis.DurationCmd) *MockCmdable_PTTL_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PTTL_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *MockCmdable_PTTL_Call { + _c.Call.Return(run) + return _c +} + +// Persist provides a mock function with given fields: ctx, key +func (_m *MockCmdable) Persist(ctx context.Context, key string) *redis.BoolCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Persist") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.BoolCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_Persist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Persist' +type MockCmdable_Persist_Call struct { + *mock.Call +} + +// Persist is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) Persist(ctx interface{}, key interface{}) *MockCmdable_Persist_Call { + return &MockCmdable_Persist_Call{Call: _e.mock.On("Persist", ctx, key)} +} + +func (_c *MockCmdable_Persist_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_Persist_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_Persist_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_Persist_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Persist_Call) RunAndReturn(run func(context.Context, string) *redis.BoolCmd) *MockCmdable_Persist_Call { + _c.Call.Return(run) + return _c +} + +// Ping provides a mock function with given fields: ctx +func (_m *MockCmdable) Ping(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Ping") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Ping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ping' +type MockCmdable_Ping_Call struct { + *mock.Call +} + +// Ping is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) Ping(ctx interface{}) *MockCmdable_Ping_Call { + return &MockCmdable_Ping_Call{Call: _e.mock.On("Ping", ctx)} +} + +func (_c *MockCmdable_Ping_Call) Run(run func(ctx context.Context)) *MockCmdable_Ping_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_Ping_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Ping_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Ping_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_Ping_Call { + _c.Call.Return(run) + return _c +} + +// Pipeline provides a mock function with given fields: +func (_m *MockCmdable) Pipeline() redis.Pipeliner { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Pipeline") + } + + var r0 redis.Pipeliner + if rf, ok := ret.Get(0).(func() redis.Pipeliner); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(redis.Pipeliner) + } + } + + return r0 +} + +// MockCmdable_Pipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pipeline' +type MockCmdable_Pipeline_Call struct { + *mock.Call +} + +// Pipeline is a helper method to define mock.On call +func (_e *MockCmdable_Expecter) Pipeline() *MockCmdable_Pipeline_Call { + return &MockCmdable_Pipeline_Call{Call: _e.mock.On("Pipeline")} +} + +func (_c *MockCmdable_Pipeline_Call) Run(run func()) *MockCmdable_Pipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockCmdable_Pipeline_Call) Return(_a0 redis.Pipeliner) *MockCmdable_Pipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Pipeline_Call) RunAndReturn(run func() redis.Pipeliner) *MockCmdable_Pipeline_Call { + _c.Call.Return(run) + return _c +} + +// Pipelined provides a mock function with given fields: ctx, fn +func (_m *MockCmdable) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + ret := _m.Called(ctx, fn) + + if len(ret) == 0 { + panic("no return value specified for Pipelined") + } + + var r0 []redis.Cmder + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, func(redis.Pipeliner) error) ([]redis.Cmder, error)); ok { + return rf(ctx, fn) + } + if rf, ok := ret.Get(0).(func(context.Context, func(redis.Pipeliner) error) []redis.Cmder); ok { + r0 = rf(ctx, fn) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]redis.Cmder) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, func(redis.Pipeliner) error) error); ok { + r1 = rf(ctx, fn) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockCmdable_Pipelined_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pipelined' +type MockCmdable_Pipelined_Call struct { + *mock.Call +} + +// Pipelined is a helper method to define mock.On call +// - ctx context.Context +// - fn func(redis.Pipeliner) error +func (_e *MockCmdable_Expecter) Pipelined(ctx interface{}, fn interface{}) *MockCmdable_Pipelined_Call { + return &MockCmdable_Pipelined_Call{Call: _e.mock.On("Pipelined", ctx, fn)} +} + +func (_c *MockCmdable_Pipelined_Call) Run(run func(ctx context.Context, fn func(redis.Pipeliner) error)) *MockCmdable_Pipelined_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(func(redis.Pipeliner) error)) + }) + return _c +} + +func (_c *MockCmdable_Pipelined_Call) Return(_a0 []redis.Cmder, _a1 error) *MockCmdable_Pipelined_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockCmdable_Pipelined_Call) RunAndReturn(run func(context.Context, func(redis.Pipeliner) error) ([]redis.Cmder, error)) *MockCmdable_Pipelined_Call { + _c.Call.Return(run) + return _c +} + +// PubSubChannels provides a mock function with given fields: ctx, pattern +func (_m *MockCmdable) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + ret := _m.Called(ctx, pattern) + + if len(ret) == 0 { + panic("no return value specified for PubSubChannels") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, pattern) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_PubSubChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubSubChannels' +type MockCmdable_PubSubChannels_Call struct { + *mock.Call +} + +// PubSubChannels is a helper method to define mock.On call +// - ctx context.Context +// - pattern string +func (_e *MockCmdable_Expecter) PubSubChannels(ctx interface{}, pattern interface{}) *MockCmdable_PubSubChannels_Call { + return &MockCmdable_PubSubChannels_Call{Call: _e.mock.On("PubSubChannels", ctx, pattern)} +} + +func (_c *MockCmdable_PubSubChannels_Call) Run(run func(ctx context.Context, pattern string)) *MockCmdable_PubSubChannels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_PubSubChannels_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_PubSubChannels_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PubSubChannels_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_PubSubChannels_Call { + _c.Call.Return(run) + return _c +} + +// PubSubNumPat provides a mock function with given fields: ctx +func (_m *MockCmdable) PubSubNumPat(ctx context.Context) *redis.IntCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for PubSubNumPat") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.IntCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_PubSubNumPat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubSubNumPat' +type MockCmdable_PubSubNumPat_Call struct { + *mock.Call +} + +// PubSubNumPat is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) PubSubNumPat(ctx interface{}) *MockCmdable_PubSubNumPat_Call { + return &MockCmdable_PubSubNumPat_Call{Call: _e.mock.On("PubSubNumPat", ctx)} +} + +func (_c *MockCmdable_PubSubNumPat_Call) Run(run func(ctx context.Context)) *MockCmdable_PubSubNumPat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_PubSubNumPat_Call) Return(_a0 *redis.IntCmd) *MockCmdable_PubSubNumPat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PubSubNumPat_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *MockCmdable_PubSubNumPat_Call { + _c.Call.Return(run) + return _c +} + +// PubSubNumSub provides a mock function with given fields: ctx, channels +func (_m *MockCmdable) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + _va := make([]interface{}, len(channels)) + for _i := range channels { + _va[_i] = channels[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for PubSubNumSub") + } + + var r0 *redis.MapStringIntCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.MapStringIntCmd); ok { + r0 = rf(ctx, channels...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringIntCmd) + } + } + + return r0 +} + +// MockCmdable_PubSubNumSub_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubSubNumSub' +type MockCmdable_PubSubNumSub_Call struct { + *mock.Call +} + +// PubSubNumSub is a helper method to define mock.On call +// - ctx context.Context +// - channels ...string +func (_e *MockCmdable_Expecter) PubSubNumSub(ctx interface{}, channels ...interface{}) *MockCmdable_PubSubNumSub_Call { + return &MockCmdable_PubSubNumSub_Call{Call: _e.mock.On("PubSubNumSub", + append([]interface{}{ctx}, channels...)...)} +} + +func (_c *MockCmdable_PubSubNumSub_Call) Run(run func(ctx context.Context, channels ...string)) *MockCmdable_PubSubNumSub_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_PubSubNumSub_Call) Return(_a0 *redis.MapStringIntCmd) *MockCmdable_PubSubNumSub_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PubSubNumSub_Call) RunAndReturn(run func(context.Context, ...string) *redis.MapStringIntCmd) *MockCmdable_PubSubNumSub_Call { + _c.Call.Return(run) + return _c +} + +// PubSubShardChannels provides a mock function with given fields: ctx, pattern +func (_m *MockCmdable) PubSubShardChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + ret := _m.Called(ctx, pattern) + + if len(ret) == 0 { + panic("no return value specified for PubSubShardChannels") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, pattern) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_PubSubShardChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubSubShardChannels' +type MockCmdable_PubSubShardChannels_Call struct { + *mock.Call +} + +// PubSubShardChannels is a helper method to define mock.On call +// - ctx context.Context +// - pattern string +func (_e *MockCmdable_Expecter) PubSubShardChannels(ctx interface{}, pattern interface{}) *MockCmdable_PubSubShardChannels_Call { + return &MockCmdable_PubSubShardChannels_Call{Call: _e.mock.On("PubSubShardChannels", ctx, pattern)} +} + +func (_c *MockCmdable_PubSubShardChannels_Call) Run(run func(ctx context.Context, pattern string)) *MockCmdable_PubSubShardChannels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_PubSubShardChannels_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_PubSubShardChannels_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PubSubShardChannels_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_PubSubShardChannels_Call { + _c.Call.Return(run) + return _c +} + +// PubSubShardNumSub provides a mock function with given fields: ctx, channels +func (_m *MockCmdable) PubSubShardNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + _va := make([]interface{}, len(channels)) + for _i := range channels { + _va[_i] = channels[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for PubSubShardNumSub") + } + + var r0 *redis.MapStringIntCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.MapStringIntCmd); ok { + r0 = rf(ctx, channels...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringIntCmd) + } + } + + return r0 +} + +// MockCmdable_PubSubShardNumSub_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubSubShardNumSub' +type MockCmdable_PubSubShardNumSub_Call struct { + *mock.Call +} + +// PubSubShardNumSub is a helper method to define mock.On call +// - ctx context.Context +// - channels ...string +func (_e *MockCmdable_Expecter) PubSubShardNumSub(ctx interface{}, channels ...interface{}) *MockCmdable_PubSubShardNumSub_Call { + return &MockCmdable_PubSubShardNumSub_Call{Call: _e.mock.On("PubSubShardNumSub", + append([]interface{}{ctx}, channels...)...)} +} + +func (_c *MockCmdable_PubSubShardNumSub_Call) Run(run func(ctx context.Context, channels ...string)) *MockCmdable_PubSubShardNumSub_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_PubSubShardNumSub_Call) Return(_a0 *redis.MapStringIntCmd) *MockCmdable_PubSubShardNumSub_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_PubSubShardNumSub_Call) RunAndReturn(run func(context.Context, ...string) *redis.MapStringIntCmd) *MockCmdable_PubSubShardNumSub_Call { + _c.Call.Return(run) + return _c +} + +// Publish provides a mock function with given fields: ctx, channel, message +func (_m *MockCmdable) Publish(ctx context.Context, channel string, message interface{}) *redis.IntCmd { + ret := _m.Called(ctx, channel, message) + + if len(ret) == 0 { + panic("no return value specified for Publish") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, channel, message) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish' +type MockCmdable_Publish_Call struct { + *mock.Call +} + +// Publish is a helper method to define mock.On call +// - ctx context.Context +// - channel string +// - message interface{} +func (_e *MockCmdable_Expecter) Publish(ctx interface{}, channel interface{}, message interface{}) *MockCmdable_Publish_Call { + return &MockCmdable_Publish_Call{Call: _e.mock.On("Publish", ctx, channel, message)} +} + +func (_c *MockCmdable_Publish_Call) Run(run func(ctx context.Context, channel string, message interface{})) *MockCmdable_Publish_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_Publish_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Publish_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Publish_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.IntCmd) *MockCmdable_Publish_Call { + _c.Call.Return(run) + return _c +} + +// Quit provides a mock function with given fields: ctx +func (_m *MockCmdable) Quit(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Quit") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Quit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Quit' +type MockCmdable_Quit_Call struct { + *mock.Call +} + +// Quit is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) Quit(ctx interface{}) *MockCmdable_Quit_Call { + return &MockCmdable_Quit_Call{Call: _e.mock.On("Quit", ctx)} +} + +func (_c *MockCmdable_Quit_Call) Run(run func(ctx context.Context)) *MockCmdable_Quit_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_Quit_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Quit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Quit_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_Quit_Call { + _c.Call.Return(run) + return _c +} + +// RPop provides a mock function with given fields: ctx, key +func (_m *MockCmdable) RPop(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for RPop") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_RPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPop' +type MockCmdable_RPop_Call struct { + *mock.Call +} + +// RPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) RPop(ctx interface{}, key interface{}) *MockCmdable_RPop_Call { + return &MockCmdable_RPop_Call{Call: _e.mock.On("RPop", ctx, key)} +} + +func (_c *MockCmdable_RPop_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_RPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_RPop_Call) Return(_a0 *redis.StringCmd) *MockCmdable_RPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_RPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_RPop_Call { + _c.Call.Return(run) + return _c +} + +// RPopCount provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for RPopCount") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_RPopCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPopCount' +type MockCmdable_RPopCount_Call struct { + *mock.Call +} + +// RPopCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *MockCmdable_Expecter) RPopCount(ctx interface{}, key interface{}, count interface{}) *MockCmdable_RPopCount_Call { + return &MockCmdable_RPopCount_Call{Call: _e.mock.On("RPopCount", ctx, key, count)} +} + +func (_c *MockCmdable_RPopCount_Call) Run(run func(ctx context.Context, key string, count int)) *MockCmdable_RPopCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_RPopCount_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_RPopCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_RPopCount_Call) RunAndReturn(run func(context.Context, string, int) *redis.StringSliceCmd) *MockCmdable_RPopCount_Call { + _c.Call.Return(run) + return _c +} + +// RPopLPush provides a mock function with given fields: ctx, source, destination +func (_m *MockCmdable) RPopLPush(ctx context.Context, source string, destination string) *redis.StringCmd { + ret := _m.Called(ctx, source, destination) + + if len(ret) == 0 { + panic("no return value specified for RPopLPush") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StringCmd); ok { + r0 = rf(ctx, source, destination) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_RPopLPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPopLPush' +type MockCmdable_RPopLPush_Call struct { + *mock.Call +} + +// RPopLPush is a helper method to define mock.On call +// - ctx context.Context +// - source string +// - destination string +func (_e *MockCmdable_Expecter) RPopLPush(ctx interface{}, source interface{}, destination interface{}) *MockCmdable_RPopLPush_Call { + return &MockCmdable_RPopLPush_Call{Call: _e.mock.On("RPopLPush", ctx, source, destination)} +} + +func (_c *MockCmdable_RPopLPush_Call) Run(run func(ctx context.Context, source string, destination string)) *MockCmdable_RPopLPush_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_RPopLPush_Call) Return(_a0 *redis.StringCmd) *MockCmdable_RPopLPush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_RPopLPush_Call) RunAndReturn(run func(context.Context, string, string) *redis.StringCmd) *MockCmdable_RPopLPush_Call { + _c.Call.Return(run) + return _c +} + +// RPush provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) RPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RPush") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_RPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPush' +type MockCmdable_RPush_Call struct { + *mock.Call +} + +// RPush is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *MockCmdable_Expecter) RPush(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_RPush_Call { + return &MockCmdable_RPush_Call{Call: _e.mock.On("RPush", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_RPush_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *MockCmdable_RPush_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_RPush_Call) Return(_a0 *redis.IntCmd) *MockCmdable_RPush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_RPush_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_RPush_Call { + _c.Call.Return(run) + return _c +} + +// RPushX provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) RPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, values...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RPushX") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_RPushX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPushX' +type MockCmdable_RPushX_Call struct { + *mock.Call +} + +// RPushX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *MockCmdable_Expecter) RPushX(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_RPushX_Call { + return &MockCmdable_RPushX_Call{Call: _e.mock.On("RPushX", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_RPushX_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *MockCmdable_RPushX_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_RPushX_Call) Return(_a0 *redis.IntCmd) *MockCmdable_RPushX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_RPushX_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_RPushX_Call { + _c.Call.Return(run) + return _c +} + +// RandomKey provides a mock function with given fields: ctx +func (_m *MockCmdable) RandomKey(ctx context.Context) *redis.StringCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for RandomKey") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StringCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_RandomKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RandomKey' +type MockCmdable_RandomKey_Call struct { + *mock.Call +} + +// RandomKey is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) RandomKey(ctx interface{}) *MockCmdable_RandomKey_Call { + return &MockCmdable_RandomKey_Call{Call: _e.mock.On("RandomKey", ctx)} +} + +func (_c *MockCmdable_RandomKey_Call) Run(run func(ctx context.Context)) *MockCmdable_RandomKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_RandomKey_Call) Return(_a0 *redis.StringCmd) *MockCmdable_RandomKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_RandomKey_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *MockCmdable_RandomKey_Call { + _c.Call.Return(run) + return _c +} + +// ReadOnly provides a mock function with given fields: ctx +func (_m *MockCmdable) ReadOnly(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ReadOnly") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ReadOnly_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOnly' +type MockCmdable_ReadOnly_Call struct { + *mock.Call +} + +// ReadOnly is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ReadOnly(ctx interface{}) *MockCmdable_ReadOnly_Call { + return &MockCmdable_ReadOnly_Call{Call: _e.mock.On("ReadOnly", ctx)} +} + +func (_c *MockCmdable_ReadOnly_Call) Run(run func(ctx context.Context)) *MockCmdable_ReadOnly_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ReadOnly_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ReadOnly_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ReadOnly_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ReadOnly_Call { + _c.Call.Return(run) + return _c +} + +// ReadWrite provides a mock function with given fields: ctx +func (_m *MockCmdable) ReadWrite(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ReadWrite") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ReadWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadWrite' +type MockCmdable_ReadWrite_Call struct { + *mock.Call +} + +// ReadWrite is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ReadWrite(ctx interface{}) *MockCmdable_ReadWrite_Call { + return &MockCmdable_ReadWrite_Call{Call: _e.mock.On("ReadWrite", ctx)} +} + +func (_c *MockCmdable_ReadWrite_Call) Run(run func(ctx context.Context)) *MockCmdable_ReadWrite_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ReadWrite_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ReadWrite_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ReadWrite_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ReadWrite_Call { + _c.Call.Return(run) + return _c +} + +// Rename provides a mock function with given fields: ctx, key, newkey +func (_m *MockCmdable) Rename(ctx context.Context, key string, newkey string) *redis.StatusCmd { + ret := _m.Called(ctx, key, newkey) + + if len(ret) == 0 { + panic("no return value specified for Rename") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key, newkey) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Rename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Rename' +type MockCmdable_Rename_Call struct { + *mock.Call +} + +// Rename is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - newkey string +func (_e *MockCmdable_Expecter) Rename(ctx interface{}, key interface{}, newkey interface{}) *MockCmdable_Rename_Call { + return &MockCmdable_Rename_Call{Call: _e.mock.On("Rename", ctx, key, newkey)} +} + +func (_c *MockCmdable_Rename_Call) Run(run func(ctx context.Context, key string, newkey string)) *MockCmdable_Rename_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_Rename_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Rename_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Rename_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *MockCmdable_Rename_Call { + _c.Call.Return(run) + return _c +} + +// RenameNX provides a mock function with given fields: ctx, key, newkey +func (_m *MockCmdable) RenameNX(ctx context.Context, key string, newkey string) *redis.BoolCmd { + ret := _m.Called(ctx, key, newkey) + + if len(ret) == 0 { + panic("no return value specified for RenameNX") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.BoolCmd); ok { + r0 = rf(ctx, key, newkey) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_RenameNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameNX' +type MockCmdable_RenameNX_Call struct { + *mock.Call +} + +// RenameNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - newkey string +func (_e *MockCmdable_Expecter) RenameNX(ctx interface{}, key interface{}, newkey interface{}) *MockCmdable_RenameNX_Call { + return &MockCmdable_RenameNX_Call{Call: _e.mock.On("RenameNX", ctx, key, newkey)} +} + +func (_c *MockCmdable_RenameNX_Call) Run(run func(ctx context.Context, key string, newkey string)) *MockCmdable_RenameNX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_RenameNX_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_RenameNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_RenameNX_Call) RunAndReturn(run func(context.Context, string, string) *redis.BoolCmd) *MockCmdable_RenameNX_Call { + _c.Call.Return(run) + return _c +} + +// Restore provides a mock function with given fields: ctx, key, ttl, value +func (_m *MockCmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + ret := _m.Called(ctx, key, ttl, value) + + if len(ret) == 0 { + panic("no return value specified for Restore") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key, ttl, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Restore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Restore' +type MockCmdable_Restore_Call struct { + *mock.Call +} + +// Restore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - ttl time.Duration +// - value string +func (_e *MockCmdable_Expecter) Restore(ctx interface{}, key interface{}, ttl interface{}, value interface{}) *MockCmdable_Restore_Call { + return &MockCmdable_Restore_Call{Call: _e.mock.On("Restore", ctx, key, ttl, value)} +} + +func (_c *MockCmdable_Restore_Call) Run(run func(ctx context.Context, key string, ttl time.Duration, value string)) *MockCmdable_Restore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_Restore_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Restore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Restore_Call) RunAndReturn(run func(context.Context, string, time.Duration, string) *redis.StatusCmd) *MockCmdable_Restore_Call { + _c.Call.Return(run) + return _c +} + +// RestoreReplace provides a mock function with given fields: ctx, key, ttl, value +func (_m *MockCmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + ret := _m.Called(ctx, key, ttl, value) + + if len(ret) == 0 { + panic("no return value specified for RestoreReplace") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key, ttl, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_RestoreReplace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreReplace' +type MockCmdable_RestoreReplace_Call struct { + *mock.Call +} + +// RestoreReplace is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - ttl time.Duration +// - value string +func (_e *MockCmdable_Expecter) RestoreReplace(ctx interface{}, key interface{}, ttl interface{}, value interface{}) *MockCmdable_RestoreReplace_Call { + return &MockCmdable_RestoreReplace_Call{Call: _e.mock.On("RestoreReplace", ctx, key, ttl, value)} +} + +func (_c *MockCmdable_RestoreReplace_Call) Run(run func(ctx context.Context, key string, ttl time.Duration, value string)) *MockCmdable_RestoreReplace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_RestoreReplace_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_RestoreReplace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_RestoreReplace_Call) RunAndReturn(run func(context.Context, string, time.Duration, string) *redis.StatusCmd) *MockCmdable_RestoreReplace_Call { + _c.Call.Return(run) + return _c +} + +// SAdd provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) SAdd(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, members...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SAdd") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SAdd' +type MockCmdable_SAdd_Call struct { + *mock.Call +} + +// SAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...interface{} +func (_e *MockCmdable_Expecter) SAdd(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_SAdd_Call { + return &MockCmdable_SAdd_Call{Call: _e.mock.On("SAdd", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_SAdd_Call) Run(run func(ctx context.Context, key string, members ...interface{})) *MockCmdable_SAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SAdd_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_SAdd_Call { + _c.Call.Return(run) + return _c +} + +// SCard provides a mock function with given fields: ctx, key +func (_m *MockCmdable) SCard(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for SCard") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SCard' +type MockCmdable_SCard_Call struct { + *mock.Call +} + +// SCard is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) SCard(ctx interface{}, key interface{}) *MockCmdable_SCard_Call { + return &MockCmdable_SCard_Call{Call: _e.mock.On("SCard", ctx, key)} +} + +func (_c *MockCmdable_SCard_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_SCard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_SCard_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SCard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SCard_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_SCard_Call { + _c.Call.Return(run) + return _c +} + +// SDiff provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SDiff") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_SDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SDiff' +type MockCmdable_SDiff_Call struct { + *mock.Call +} + +// SDiff is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) SDiff(ctx interface{}, keys ...interface{}) *MockCmdable_SDiff_Call { + return &MockCmdable_SDiff_Call{Call: _e.mock.On("SDiff", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_SDiff_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_SDiff_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SDiff_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_SDiff_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SDiff_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *MockCmdable_SDiff_Call { + _c.Call.Return(run) + return _c +} + +// SDiffStore provides a mock function with given fields: ctx, destination, keys +func (_m *MockCmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destination) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SDiffStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, destination, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SDiffStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SDiffStore' +type MockCmdable_SDiffStore_Call struct { + *mock.Call +} + +// SDiffStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *MockCmdable_Expecter) SDiffStore(ctx interface{}, destination interface{}, keys ...interface{}) *MockCmdable_SDiffStore_Call { + return &MockCmdable_SDiffStore_Call{Call: _e.mock.On("SDiffStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *MockCmdable_SDiffStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *MockCmdable_SDiffStore_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SDiffStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SDiffStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SDiffStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_SDiffStore_Call { + _c.Call.Return(run) + return _c +} + +// SInter provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SInter") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_SInter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SInter' +type MockCmdable_SInter_Call struct { + *mock.Call +} + +// SInter is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) SInter(ctx interface{}, keys ...interface{}) *MockCmdable_SInter_Call { + return &MockCmdable_SInter_Call{Call: _e.mock.On("SInter", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_SInter_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_SInter_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SInter_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_SInter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SInter_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *MockCmdable_SInter_Call { + _c.Call.Return(run) + return _c +} + +// SInterCard provides a mock function with given fields: ctx, limit, keys +func (_m *MockCmdable) SInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, limit) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SInterCard") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, int64, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, limit, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SInterCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SInterCard' +type MockCmdable_SInterCard_Call struct { + *mock.Call +} + +// SInterCard is a helper method to define mock.On call +// - ctx context.Context +// - limit int64 +// - keys ...string +func (_e *MockCmdable_Expecter) SInterCard(ctx interface{}, limit interface{}, keys ...interface{}) *MockCmdable_SInterCard_Call { + return &MockCmdable_SInterCard_Call{Call: _e.mock.On("SInterCard", + append([]interface{}{ctx, limit}, keys...)...)} +} + +func (_c *MockCmdable_SInterCard_Call) Run(run func(ctx context.Context, limit int64, keys ...string)) *MockCmdable_SInterCard_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(int64), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SInterCard_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SInterCard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SInterCard_Call) RunAndReturn(run func(context.Context, int64, ...string) *redis.IntCmd) *MockCmdable_SInterCard_Call { + _c.Call.Return(run) + return _c +} + +// SInterStore provides a mock function with given fields: ctx, destination, keys +func (_m *MockCmdable) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destination) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SInterStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, destination, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SInterStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SInterStore' +type MockCmdable_SInterStore_Call struct { + *mock.Call +} + +// SInterStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *MockCmdable_Expecter) SInterStore(ctx interface{}, destination interface{}, keys ...interface{}) *MockCmdable_SInterStore_Call { + return &MockCmdable_SInterStore_Call{Call: _e.mock.On("SInterStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *MockCmdable_SInterStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *MockCmdable_SInterStore_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SInterStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SInterStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SInterStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_SInterStore_Call { + _c.Call.Return(run) + return _c +} + +// SIsMember provides a mock function with given fields: ctx, key, member +func (_m *MockCmdable) SIsMember(ctx context.Context, key string, member interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, key, member) + + if len(ret) == 0 { + panic("no return value specified for SIsMember") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, key, member) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_SIsMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SIsMember' +type MockCmdable_SIsMember_Call struct { + *mock.Call +} + +// SIsMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member interface{} +func (_e *MockCmdable_Expecter) SIsMember(ctx interface{}, key interface{}, member interface{}) *MockCmdable_SIsMember_Call { + return &MockCmdable_SIsMember_Call{Call: _e.mock.On("SIsMember", ctx, key, member)} +} + +func (_c *MockCmdable_SIsMember_Call) Run(run func(ctx context.Context, key string, member interface{})) *MockCmdable_SIsMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_SIsMember_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_SIsMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SIsMember_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *MockCmdable_SIsMember_Call { + _c.Call.Return(run) + return _c +} + +// SMIsMember provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) SMIsMember(ctx context.Context, key string, members ...interface{}) *redis.BoolSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, members...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SMIsMember") + } + + var r0 *redis.BoolSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.BoolSliceCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolSliceCmd) + } + } + + return r0 +} + +// MockCmdable_SMIsMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMIsMember' +type MockCmdable_SMIsMember_Call struct { + *mock.Call +} + +// SMIsMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...interface{} +func (_e *MockCmdable_Expecter) SMIsMember(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_SMIsMember_Call { + return &MockCmdable_SMIsMember_Call{Call: _e.mock.On("SMIsMember", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_SMIsMember_Call) Run(run func(ctx context.Context, key string, members ...interface{})) *MockCmdable_SMIsMember_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SMIsMember_Call) Return(_a0 *redis.BoolSliceCmd) *MockCmdable_SMIsMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SMIsMember_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolSliceCmd) *MockCmdable_SMIsMember_Call { + _c.Call.Return(run) + return _c +} + +// SMembers provides a mock function with given fields: ctx, key +func (_m *MockCmdable) SMembers(ctx context.Context, key string) *redis.StringSliceCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for SMembers") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_SMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMembers' +type MockCmdable_SMembers_Call struct { + *mock.Call +} + +// SMembers is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) SMembers(ctx interface{}, key interface{}) *MockCmdable_SMembers_Call { + return &MockCmdable_SMembers_Call{Call: _e.mock.On("SMembers", ctx, key)} +} + +func (_c *MockCmdable_SMembers_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_SMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_SMembers_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_SMembers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SMembers_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_SMembers_Call { + _c.Call.Return(run) + return _c +} + +// SMembersMap provides a mock function with given fields: ctx, key +func (_m *MockCmdable) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for SMembersMap") + } + + var r0 *redis.StringStructMapCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringStructMapCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringStructMapCmd) + } + } + + return r0 +} + +// MockCmdable_SMembersMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMembersMap' +type MockCmdable_SMembersMap_Call struct { + *mock.Call +} + +// SMembersMap is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) SMembersMap(ctx interface{}, key interface{}) *MockCmdable_SMembersMap_Call { + return &MockCmdable_SMembersMap_Call{Call: _e.mock.On("SMembersMap", ctx, key)} +} + +func (_c *MockCmdable_SMembersMap_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_SMembersMap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_SMembersMap_Call) Return(_a0 *redis.StringStructMapCmd) *MockCmdable_SMembersMap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SMembersMap_Call) RunAndReturn(run func(context.Context, string) *redis.StringStructMapCmd) *MockCmdable_SMembersMap_Call { + _c.Call.Return(run) + return _c +} + +// SMove provides a mock function with given fields: ctx, source, destination, member +func (_m *MockCmdable) SMove(ctx context.Context, source string, destination string, member interface{}) *redis.BoolCmd { + ret := _m.Called(ctx, source, destination, member) + + if len(ret) == 0 { + panic("no return value specified for SMove") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}) *redis.BoolCmd); ok { + r0 = rf(ctx, source, destination, member) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_SMove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMove' +type MockCmdable_SMove_Call struct { + *mock.Call +} + +// SMove is a helper method to define mock.On call +// - ctx context.Context +// - source string +// - destination string +// - member interface{} +func (_e *MockCmdable_Expecter) SMove(ctx interface{}, source interface{}, destination interface{}, member interface{}) *MockCmdable_SMove_Call { + return &MockCmdable_SMove_Call{Call: _e.mock.On("SMove", ctx, source, destination, member)} +} + +func (_c *MockCmdable_SMove_Call) Run(run func(ctx context.Context, source string, destination string, member interface{})) *MockCmdable_SMove_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_SMove_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_SMove_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SMove_Call) RunAndReturn(run func(context.Context, string, string, interface{}) *redis.BoolCmd) *MockCmdable_SMove_Call { + _c.Call.Return(run) + return _c +} + +// SPop provides a mock function with given fields: ctx, key +func (_m *MockCmdable) SPop(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for SPop") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_SPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SPop' +type MockCmdable_SPop_Call struct { + *mock.Call +} + +// SPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) SPop(ctx interface{}, key interface{}) *MockCmdable_SPop_Call { + return &MockCmdable_SPop_Call{Call: _e.mock.On("SPop", ctx, key)} +} + +func (_c *MockCmdable_SPop_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_SPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_SPop_Call) Return(_a0 *redis.StringCmd) *MockCmdable_SPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_SPop_Call { + _c.Call.Return(run) + return _c +} + +// SPopN provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for SPopN") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_SPopN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SPopN' +type MockCmdable_SPopN_Call struct { + *mock.Call +} + +// SPopN is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int64 +func (_e *MockCmdable_Expecter) SPopN(ctx interface{}, key interface{}, count interface{}) *MockCmdable_SPopN_Call { + return &MockCmdable_SPopN_Call{Call: _e.mock.On("SPopN", ctx, key, count)} +} + +func (_c *MockCmdable_SPopN_Call) Run(run func(ctx context.Context, key string, count int64)) *MockCmdable_SPopN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_SPopN_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_SPopN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SPopN_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringSliceCmd) *MockCmdable_SPopN_Call { + _c.Call.Return(run) + return _c +} + +// SPublish provides a mock function with given fields: ctx, channel, message +func (_m *MockCmdable) SPublish(ctx context.Context, channel string, message interface{}) *redis.IntCmd { + ret := _m.Called(ctx, channel, message) + + if len(ret) == 0 { + panic("no return value specified for SPublish") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, channel, message) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SPublish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SPublish' +type MockCmdable_SPublish_Call struct { + *mock.Call +} + +// SPublish is a helper method to define mock.On call +// - ctx context.Context +// - channel string +// - message interface{} +func (_e *MockCmdable_Expecter) SPublish(ctx interface{}, channel interface{}, message interface{}) *MockCmdable_SPublish_Call { + return &MockCmdable_SPublish_Call{Call: _e.mock.On("SPublish", ctx, channel, message)} +} + +func (_c *MockCmdable_SPublish_Call) Run(run func(ctx context.Context, channel string, message interface{})) *MockCmdable_SPublish_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *MockCmdable_SPublish_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SPublish_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SPublish_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.IntCmd) *MockCmdable_SPublish_Call { + _c.Call.Return(run) + return _c +} + +// SRandMember provides a mock function with given fields: ctx, key +func (_m *MockCmdable) SRandMember(ctx context.Context, key string) *redis.StringCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for SRandMember") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_SRandMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SRandMember' +type MockCmdable_SRandMember_Call struct { + *mock.Call +} + +// SRandMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) SRandMember(ctx interface{}, key interface{}) *MockCmdable_SRandMember_Call { + return &MockCmdable_SRandMember_Call{Call: _e.mock.On("SRandMember", ctx, key)} +} + +func (_c *MockCmdable_SRandMember_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_SRandMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_SRandMember_Call) Return(_a0 *redis.StringCmd) *MockCmdable_SRandMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SRandMember_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_SRandMember_Call { + _c.Call.Return(run) + return _c +} + +// SRandMemberN provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for SRandMemberN") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_SRandMemberN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SRandMemberN' +type MockCmdable_SRandMemberN_Call struct { + *mock.Call +} + +// SRandMemberN is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int64 +func (_e *MockCmdable_Expecter) SRandMemberN(ctx interface{}, key interface{}, count interface{}) *MockCmdable_SRandMemberN_Call { + return &MockCmdable_SRandMemberN_Call{Call: _e.mock.On("SRandMemberN", ctx, key, count)} +} + +func (_c *MockCmdable_SRandMemberN_Call) Run(run func(ctx context.Context, key string, count int64)) *MockCmdable_SRandMemberN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_SRandMemberN_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_SRandMemberN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SRandMemberN_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringSliceCmd) *MockCmdable_SRandMemberN_Call { + _c.Call.Return(run) + return _c +} + +// SRem provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) SRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, members...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SRem") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SRem' +type MockCmdable_SRem_Call struct { + *mock.Call +} + +// SRem is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...interface{} +func (_e *MockCmdable_Expecter) SRem(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_SRem_Call { + return &MockCmdable_SRem_Call{Call: _e.mock.On("SRem", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_SRem_Call) Run(run func(ctx context.Context, key string, members ...interface{})) *MockCmdable_SRem_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SRem_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SRem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SRem_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_SRem_Call { + _c.Call.Return(run) + return _c +} + +// SScan provides a mock function with given fields: ctx, key, cursor, match, count +func (_m *MockCmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + ret := _m.Called(ctx, key, cursor, match, count) + + if len(ret) == 0 { + panic("no return value specified for SScan") + } + + var r0 *redis.ScanCmd + if rf, ok := ret.Get(0).(func(context.Context, string, uint64, string, int64) *redis.ScanCmd); ok { + r0 = rf(ctx, key, cursor, match, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ScanCmd) + } + } + + return r0 +} + +// MockCmdable_SScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SScan' +type MockCmdable_SScan_Call struct { + *mock.Call +} + +// SScan is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - cursor uint64 +// - match string +// - count int64 +func (_e *MockCmdable_Expecter) SScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *MockCmdable_SScan_Call { + return &MockCmdable_SScan_Call{Call: _e.mock.On("SScan", ctx, key, cursor, match, count)} +} + +func (_c *MockCmdable_SScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *MockCmdable_SScan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(uint64), args[3].(string), args[4].(int64)) + }) + return _c +} + +func (_c *MockCmdable_SScan_Call) Return(_a0 *redis.ScanCmd) *MockCmdable_SScan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *MockCmdable_SScan_Call { + _c.Call.Return(run) + return _c +} + +// SUnion provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SUnion") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_SUnion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SUnion' +type MockCmdable_SUnion_Call struct { + *mock.Call +} + +// SUnion is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) SUnion(ctx interface{}, keys ...interface{}) *MockCmdable_SUnion_Call { + return &MockCmdable_SUnion_Call{Call: _e.mock.On("SUnion", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_SUnion_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_SUnion_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SUnion_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_SUnion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SUnion_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *MockCmdable_SUnion_Call { + _c.Call.Return(run) + return _c +} + +// SUnionStore provides a mock function with given fields: ctx, destination, keys +func (_m *MockCmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destination) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SUnionStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, destination, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SUnionStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SUnionStore' +type MockCmdable_SUnionStore_Call struct { + *mock.Call +} + +// SUnionStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *MockCmdable_Expecter) SUnionStore(ctx interface{}, destination interface{}, keys ...interface{}) *MockCmdable_SUnionStore_Call { + return &MockCmdable_SUnionStore_Call{Call: _e.mock.On("SUnionStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *MockCmdable_SUnionStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *MockCmdable_SUnionStore_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_SUnionStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SUnionStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SUnionStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_SUnionStore_Call { + _c.Call.Return(run) + return _c +} + +// Save provides a mock function with given fields: ctx +func (_m *MockCmdable) Save(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Save") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save' +type MockCmdable_Save_Call struct { + *mock.Call +} + +// Save is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) Save(ctx interface{}) *MockCmdable_Save_Call { + return &MockCmdable_Save_Call{Call: _e.mock.On("Save", ctx)} +} + +func (_c *MockCmdable_Save_Call) Run(run func(ctx context.Context)) *MockCmdable_Save_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_Save_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Save_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Save_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_Save_Call { + _c.Call.Return(run) + return _c +} + +// Scan provides a mock function with given fields: ctx, cursor, match, count +func (_m *MockCmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd { + ret := _m.Called(ctx, cursor, match, count) + + if len(ret) == 0 { + panic("no return value specified for Scan") + } + + var r0 *redis.ScanCmd + if rf, ok := ret.Get(0).(func(context.Context, uint64, string, int64) *redis.ScanCmd); ok { + r0 = rf(ctx, cursor, match, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ScanCmd) + } + } + + return r0 +} + +// MockCmdable_Scan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Scan' +type MockCmdable_Scan_Call struct { + *mock.Call +} + +// Scan is a helper method to define mock.On call +// - ctx context.Context +// - cursor uint64 +// - match string +// - count int64 +func (_e *MockCmdable_Expecter) Scan(ctx interface{}, cursor interface{}, match interface{}, count interface{}) *MockCmdable_Scan_Call { + return &MockCmdable_Scan_Call{Call: _e.mock.On("Scan", ctx, cursor, match, count)} +} + +func (_c *MockCmdable_Scan_Call) Run(run func(ctx context.Context, cursor uint64, match string, count int64)) *MockCmdable_Scan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(uint64), args[2].(string), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_Scan_Call) Return(_a0 *redis.ScanCmd) *MockCmdable_Scan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Scan_Call) RunAndReturn(run func(context.Context, uint64, string, int64) *redis.ScanCmd) *MockCmdable_Scan_Call { + _c.Call.Return(run) + return _c +} + +// ScanType provides a mock function with given fields: ctx, cursor, match, count, keyType +func (_m *MockCmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd { + ret := _m.Called(ctx, cursor, match, count, keyType) + + if len(ret) == 0 { + panic("no return value specified for ScanType") + } + + var r0 *redis.ScanCmd + if rf, ok := ret.Get(0).(func(context.Context, uint64, string, int64, string) *redis.ScanCmd); ok { + r0 = rf(ctx, cursor, match, count, keyType) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ScanCmd) + } + } + + return r0 +} + +// MockCmdable_ScanType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanType' +type MockCmdable_ScanType_Call struct { + *mock.Call +} + +// ScanType is a helper method to define mock.On call +// - ctx context.Context +// - cursor uint64 +// - match string +// - count int64 +// - keyType string +func (_e *MockCmdable_Expecter) ScanType(ctx interface{}, cursor interface{}, match interface{}, count interface{}, keyType interface{}) *MockCmdable_ScanType_Call { + return &MockCmdable_ScanType_Call{Call: _e.mock.On("ScanType", ctx, cursor, match, count, keyType)} +} + +func (_c *MockCmdable_ScanType_Call) Run(run func(ctx context.Context, cursor uint64, match string, count int64, keyType string)) *MockCmdable_ScanType_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(uint64), args[2].(string), args[3].(int64), args[4].(string)) + }) + return _c +} + +func (_c *MockCmdable_ScanType_Call) Return(_a0 *redis.ScanCmd) *MockCmdable_ScanType_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ScanType_Call) RunAndReturn(run func(context.Context, uint64, string, int64, string) *redis.ScanCmd) *MockCmdable_ScanType_Call { + _c.Call.Return(run) + return _c +} + +// ScriptExists provides a mock function with given fields: ctx, hashes +func (_m *MockCmdable) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd { + _va := make([]interface{}, len(hashes)) + for _i := range hashes { + _va[_i] = hashes[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ScriptExists") + } + + var r0 *redis.BoolSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.BoolSliceCmd); ok { + r0 = rf(ctx, hashes...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ScriptExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptExists' +type MockCmdable_ScriptExists_Call struct { + *mock.Call +} + +// ScriptExists is a helper method to define mock.On call +// - ctx context.Context +// - hashes ...string +func (_e *MockCmdable_Expecter) ScriptExists(ctx interface{}, hashes ...interface{}) *MockCmdable_ScriptExists_Call { + return &MockCmdable_ScriptExists_Call{Call: _e.mock.On("ScriptExists", + append([]interface{}{ctx}, hashes...)...)} +} + +func (_c *MockCmdable_ScriptExists_Call) Run(run func(ctx context.Context, hashes ...string)) *MockCmdable_ScriptExists_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ScriptExists_Call) Return(_a0 *redis.BoolSliceCmd) *MockCmdable_ScriptExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ScriptExists_Call) RunAndReturn(run func(context.Context, ...string) *redis.BoolSliceCmd) *MockCmdable_ScriptExists_Call { + _c.Call.Return(run) + return _c +} + +// ScriptFlush provides a mock function with given fields: ctx +func (_m *MockCmdable) ScriptFlush(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ScriptFlush") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ScriptFlush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptFlush' +type MockCmdable_ScriptFlush_Call struct { + *mock.Call +} + +// ScriptFlush is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ScriptFlush(ctx interface{}) *MockCmdable_ScriptFlush_Call { + return &MockCmdable_ScriptFlush_Call{Call: _e.mock.On("ScriptFlush", ctx)} +} + +func (_c *MockCmdable_ScriptFlush_Call) Run(run func(ctx context.Context)) *MockCmdable_ScriptFlush_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ScriptFlush_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ScriptFlush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ScriptFlush_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ScriptFlush_Call { + _c.Call.Return(run) + return _c +} + +// ScriptKill provides a mock function with given fields: ctx +func (_m *MockCmdable) ScriptKill(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ScriptKill") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ScriptKill_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptKill' +type MockCmdable_ScriptKill_Call struct { + *mock.Call +} + +// ScriptKill is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ScriptKill(ctx interface{}) *MockCmdable_ScriptKill_Call { + return &MockCmdable_ScriptKill_Call{Call: _e.mock.On("ScriptKill", ctx)} +} + +func (_c *MockCmdable_ScriptKill_Call) Run(run func(ctx context.Context)) *MockCmdable_ScriptKill_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ScriptKill_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ScriptKill_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ScriptKill_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ScriptKill_Call { + _c.Call.Return(run) + return _c +} + +// ScriptLoad provides a mock function with given fields: ctx, script +func (_m *MockCmdable) ScriptLoad(ctx context.Context, script string) *redis.StringCmd { + ret := _m.Called(ctx, script) + + if len(ret) == 0 { + panic("no return value specified for ScriptLoad") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringCmd); ok { + r0 = rf(ctx, script) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_ScriptLoad_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptLoad' +type MockCmdable_ScriptLoad_Call struct { + *mock.Call +} + +// ScriptLoad is a helper method to define mock.On call +// - ctx context.Context +// - script string +func (_e *MockCmdable_Expecter) ScriptLoad(ctx interface{}, script interface{}) *MockCmdable_ScriptLoad_Call { + return &MockCmdable_ScriptLoad_Call{Call: _e.mock.On("ScriptLoad", ctx, script)} +} + +func (_c *MockCmdable_ScriptLoad_Call) Run(run func(ctx context.Context, script string)) *MockCmdable_ScriptLoad_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ScriptLoad_Call) Return(_a0 *redis.StringCmd) *MockCmdable_ScriptLoad_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ScriptLoad_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *MockCmdable_ScriptLoad_Call { + _c.Call.Return(run) + return _c +} + +// Set provides a mock function with given fields: ctx, key, value, expiration +func (_m *MockCmdable) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd { + ret := _m.Called(ctx, key, value, expiration) + + if len(ret) == 0 { + panic("no return value specified for Set") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, time.Duration) *redis.StatusCmd); ok { + r0 = rf(ctx, key, value, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set' +type MockCmdable_Set_Call struct { + *mock.Call +} + +// Set is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +// - expiration time.Duration +func (_e *MockCmdable_Expecter) Set(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCmdable_Set_Call { + return &MockCmdable_Set_Call{Call: _e.mock.On("Set", ctx, key, value, expiration)} +} + +func (_c *MockCmdable_Set_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *MockCmdable_Set_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_Set_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Set_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Set_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.StatusCmd) *MockCmdable_Set_Call { + _c.Call.Return(run) + return _c +} + +// SetArgs provides a mock function with given fields: ctx, key, value, a +func (_m *MockCmdable) SetArgs(ctx context.Context, key string, value interface{}, a redis.SetArgs) *redis.StatusCmd { + ret := _m.Called(ctx, key, value, a) + + if len(ret) == 0 { + panic("no return value specified for SetArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, redis.SetArgs) *redis.StatusCmd); ok { + r0 = rf(ctx, key, value, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_SetArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetArgs' +type MockCmdable_SetArgs_Call struct { + *mock.Call +} + +// SetArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +// - a redis.SetArgs +func (_e *MockCmdable_Expecter) SetArgs(ctx interface{}, key interface{}, value interface{}, a interface{}) *MockCmdable_SetArgs_Call { + return &MockCmdable_SetArgs_Call{Call: _e.mock.On("SetArgs", ctx, key, value, a)} +} + +func (_c *MockCmdable_SetArgs_Call) Run(run func(ctx context.Context, key string, value interface{}, a redis.SetArgs)) *MockCmdable_SetArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(redis.SetArgs)) + }) + return _c +} + +func (_c *MockCmdable_SetArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_SetArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SetArgs_Call) RunAndReturn(run func(context.Context, string, interface{}, redis.SetArgs) *redis.StatusCmd) *MockCmdable_SetArgs_Call { + _c.Call.Return(run) + return _c +} + +// SetBit provides a mock function with given fields: ctx, key, offset, value +func (_m *MockCmdable) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd { + ret := _m.Called(ctx, key, offset, value) + + if len(ret) == 0 { + panic("no return value specified for SetBit") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int) *redis.IntCmd); ok { + r0 = rf(ctx, key, offset, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SetBit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBit' +type MockCmdable_SetBit_Call struct { + *mock.Call +} + +// SetBit is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - offset int64 +// - value int +func (_e *MockCmdable_Expecter) SetBit(ctx interface{}, key interface{}, offset interface{}, value interface{}) *MockCmdable_SetBit_Call { + return &MockCmdable_SetBit_Call{Call: _e.mock.On("SetBit", ctx, key, offset, value)} +} + +func (_c *MockCmdable_SetBit_Call) Run(run func(ctx context.Context, key string, offset int64, value int)) *MockCmdable_SetBit_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int)) + }) + return _c +} + +func (_c *MockCmdable_SetBit_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SetBit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SetBit_Call) RunAndReturn(run func(context.Context, string, int64, int) *redis.IntCmd) *MockCmdable_SetBit_Call { + _c.Call.Return(run) + return _c +} + +// SetEx provides a mock function with given fields: ctx, key, value, expiration +func (_m *MockCmdable) SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd { + ret := _m.Called(ctx, key, value, expiration) + + if len(ret) == 0 { + panic("no return value specified for SetEx") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, time.Duration) *redis.StatusCmd); ok { + r0 = rf(ctx, key, value, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_SetEx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEx' +type MockCmdable_SetEx_Call struct { + *mock.Call +} + +// SetEx is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +// - expiration time.Duration +func (_e *MockCmdable_Expecter) SetEx(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCmdable_SetEx_Call { + return &MockCmdable_SetEx_Call{Call: _e.mock.On("SetEx", ctx, key, value, expiration)} +} + +func (_c *MockCmdable_SetEx_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *MockCmdable_SetEx_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_SetEx_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_SetEx_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SetEx_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.StatusCmd) *MockCmdable_SetEx_Call { + _c.Call.Return(run) + return _c +} + +// SetNX provides a mock function with given fields: ctx, key, value, expiration +func (_m *MockCmdable) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, key, value, expiration) + + if len(ret) == 0 { + panic("no return value specified for SetNX") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, key, value, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_SetNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNX' +type MockCmdable_SetNX_Call struct { + *mock.Call +} + +// SetNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +// - expiration time.Duration +func (_e *MockCmdable_Expecter) SetNX(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCmdable_SetNX_Call { + return &MockCmdable_SetNX_Call{Call: _e.mock.On("SetNX", ctx, key, value, expiration)} +} + +func (_c *MockCmdable_SetNX_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *MockCmdable_SetNX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_SetNX_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_SetNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SetNX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.BoolCmd) *MockCmdable_SetNX_Call { + _c.Call.Return(run) + return _c +} + +// SetRange provides a mock function with given fields: ctx, key, offset, value +func (_m *MockCmdable) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd { + ret := _m.Called(ctx, key, offset, value) + + if len(ret) == 0 { + panic("no return value specified for SetRange") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, offset, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SetRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetRange' +type MockCmdable_SetRange_Call struct { + *mock.Call +} + +// SetRange is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - offset int64 +// - value string +func (_e *MockCmdable_Expecter) SetRange(ctx interface{}, key interface{}, offset interface{}, value interface{}) *MockCmdable_SetRange_Call { + return &MockCmdable_SetRange_Call{Call: _e.mock.On("SetRange", ctx, key, offset, value)} +} + +func (_c *MockCmdable_SetRange_Call) Run(run func(ctx context.Context, key string, offset int64, value string)) *MockCmdable_SetRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_SetRange_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SetRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SetRange_Call) RunAndReturn(run func(context.Context, string, int64, string) *redis.IntCmd) *MockCmdable_SetRange_Call { + _c.Call.Return(run) + return _c +} + +// SetXX provides a mock function with given fields: ctx, key, value, expiration +func (_m *MockCmdable) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd { + ret := _m.Called(ctx, key, value, expiration) + + if len(ret) == 0 { + panic("no return value specified for SetXX") + } + + var r0 *redis.BoolCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, time.Duration) *redis.BoolCmd); ok { + r0 = rf(ctx, key, value, expiration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolCmd) + } + } + + return r0 +} + +// MockCmdable_SetXX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetXX' +type MockCmdable_SetXX_Call struct { + *mock.Call +} + +// SetXX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +// - expiration time.Duration +func (_e *MockCmdable_Expecter) SetXX(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCmdable_SetXX_Call { + return &MockCmdable_SetXX_Call{Call: _e.mock.On("SetXX", ctx, key, value, expiration)} +} + +func (_c *MockCmdable_SetXX_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *MockCmdable_SetXX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(time.Duration)) + }) + return _c +} + +func (_c *MockCmdable_SetXX_Call) Return(_a0 *redis.BoolCmd) *MockCmdable_SetXX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SetXX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.BoolCmd) *MockCmdable_SetXX_Call { + _c.Call.Return(run) + return _c +} + +// Shutdown provides a mock function with given fields: ctx +func (_m *MockCmdable) Shutdown(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Shutdown") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown' +type MockCmdable_Shutdown_Call struct { + *mock.Call +} + +// Shutdown is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) Shutdown(ctx interface{}) *MockCmdable_Shutdown_Call { + return &MockCmdable_Shutdown_Call{Call: _e.mock.On("Shutdown", ctx)} +} + +func (_c *MockCmdable_Shutdown_Call) Run(run func(ctx context.Context)) *MockCmdable_Shutdown_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_Shutdown_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Shutdown_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Shutdown_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_Shutdown_Call { + _c.Call.Return(run) + return _c +} + +// ShutdownNoSave provides a mock function with given fields: ctx +func (_m *MockCmdable) ShutdownNoSave(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ShutdownNoSave") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ShutdownNoSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShutdownNoSave' +type MockCmdable_ShutdownNoSave_Call struct { + *mock.Call +} + +// ShutdownNoSave is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ShutdownNoSave(ctx interface{}) *MockCmdable_ShutdownNoSave_Call { + return &MockCmdable_ShutdownNoSave_Call{Call: _e.mock.On("ShutdownNoSave", ctx)} +} + +func (_c *MockCmdable_ShutdownNoSave_Call) Run(run func(ctx context.Context)) *MockCmdable_ShutdownNoSave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ShutdownNoSave_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ShutdownNoSave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ShutdownNoSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ShutdownNoSave_Call { + _c.Call.Return(run) + return _c +} + +// ShutdownSave provides a mock function with given fields: ctx +func (_m *MockCmdable) ShutdownSave(ctx context.Context) *redis.StatusCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ShutdownSave") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.StatusCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_ShutdownSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShutdownSave' +type MockCmdable_ShutdownSave_Call struct { + *mock.Call +} + +// ShutdownSave is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) ShutdownSave(ctx interface{}) *MockCmdable_ShutdownSave_Call { + return &MockCmdable_ShutdownSave_Call{Call: _e.mock.On("ShutdownSave", ctx)} +} + +func (_c *MockCmdable_ShutdownSave_Call) Run(run func(ctx context.Context)) *MockCmdable_ShutdownSave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_ShutdownSave_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_ShutdownSave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ShutdownSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *MockCmdable_ShutdownSave_Call { + _c.Call.Return(run) + return _c +} + +// SlaveOf provides a mock function with given fields: ctx, host, port +func (_m *MockCmdable) SlaveOf(ctx context.Context, host string, port string) *redis.StatusCmd { + ret := _m.Called(ctx, host, port) + + if len(ret) == 0 { + panic("no return value specified for SlaveOf") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, host, port) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_SlaveOf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlaveOf' +type MockCmdable_SlaveOf_Call struct { + *mock.Call +} + +// SlaveOf is a helper method to define mock.On call +// - ctx context.Context +// - host string +// - port string +func (_e *MockCmdable_Expecter) SlaveOf(ctx interface{}, host interface{}, port interface{}) *MockCmdable_SlaveOf_Call { + return &MockCmdable_SlaveOf_Call{Call: _e.mock.On("SlaveOf", ctx, host, port)} +} + +func (_c *MockCmdable_SlaveOf_Call) Run(run func(ctx context.Context, host string, port string)) *MockCmdable_SlaveOf_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_SlaveOf_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_SlaveOf_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SlaveOf_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *MockCmdable_SlaveOf_Call { + _c.Call.Return(run) + return _c +} + +// SlowLogGet provides a mock function with given fields: ctx, num +func (_m *MockCmdable) SlowLogGet(ctx context.Context, num int64) *redis.SlowLogCmd { + ret := _m.Called(ctx, num) + + if len(ret) == 0 { + panic("no return value specified for SlowLogGet") + } + + var r0 *redis.SlowLogCmd + if rf, ok := ret.Get(0).(func(context.Context, int64) *redis.SlowLogCmd); ok { + r0 = rf(ctx, num) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.SlowLogCmd) + } + } + + return r0 +} + +// MockCmdable_SlowLogGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlowLogGet' +type MockCmdable_SlowLogGet_Call struct { + *mock.Call +} + +// SlowLogGet is a helper method to define mock.On call +// - ctx context.Context +// - num int64 +func (_e *MockCmdable_Expecter) SlowLogGet(ctx interface{}, num interface{}) *MockCmdable_SlowLogGet_Call { + return &MockCmdable_SlowLogGet_Call{Call: _e.mock.On("SlowLogGet", ctx, num)} +} + +func (_c *MockCmdable_SlowLogGet_Call) Run(run func(ctx context.Context, num int64)) *MockCmdable_SlowLogGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64)) + }) + return _c +} + +func (_c *MockCmdable_SlowLogGet_Call) Return(_a0 *redis.SlowLogCmd) *MockCmdable_SlowLogGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SlowLogGet_Call) RunAndReturn(run func(context.Context, int64) *redis.SlowLogCmd) *MockCmdable_SlowLogGet_Call { + _c.Call.Return(run) + return _c +} + +// Sort provides a mock function with given fields: ctx, key, sort +func (_m *MockCmdable) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, sort) + + if len(ret) == 0 { + panic("no return value specified for Sort") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.Sort) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, sort) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_Sort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sort' +type MockCmdable_Sort_Call struct { + *mock.Call +} + +// Sort is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - sort *redis.Sort +func (_e *MockCmdable_Expecter) Sort(ctx interface{}, key interface{}, sort interface{}) *MockCmdable_Sort_Call { + return &MockCmdable_Sort_Call{Call: _e.mock.On("Sort", ctx, key, sort)} +} + +func (_c *MockCmdable_Sort_Call) Run(run func(ctx context.Context, key string, sort *redis.Sort)) *MockCmdable_Sort_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.Sort)) + }) + return _c +} + +func (_c *MockCmdable_Sort_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_Sort_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Sort_Call) RunAndReturn(run func(context.Context, string, *redis.Sort) *redis.StringSliceCmd) *MockCmdable_Sort_Call { + _c.Call.Return(run) + return _c +} + +// SortInterfaces provides a mock function with given fields: ctx, key, sort +func (_m *MockCmdable) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd { + ret := _m.Called(ctx, key, sort) + + if len(ret) == 0 { + panic("no return value specified for SortInterfaces") + } + + var r0 *redis.SliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.Sort) *redis.SliceCmd); ok { + r0 = rf(ctx, key, sort) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.SliceCmd) + } + } + + return r0 +} + +// MockCmdable_SortInterfaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SortInterfaces' +type MockCmdable_SortInterfaces_Call struct { + *mock.Call +} + +// SortInterfaces is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - sort *redis.Sort +func (_e *MockCmdable_Expecter) SortInterfaces(ctx interface{}, key interface{}, sort interface{}) *MockCmdable_SortInterfaces_Call { + return &MockCmdable_SortInterfaces_Call{Call: _e.mock.On("SortInterfaces", ctx, key, sort)} +} + +func (_c *MockCmdable_SortInterfaces_Call) Run(run func(ctx context.Context, key string, sort *redis.Sort)) *MockCmdable_SortInterfaces_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.Sort)) + }) + return _c +} + +func (_c *MockCmdable_SortInterfaces_Call) Return(_a0 *redis.SliceCmd) *MockCmdable_SortInterfaces_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SortInterfaces_Call) RunAndReturn(run func(context.Context, string, *redis.Sort) *redis.SliceCmd) *MockCmdable_SortInterfaces_Call { + _c.Call.Return(run) + return _c +} + +// SortRO provides a mock function with given fields: ctx, key, sort +func (_m *MockCmdable) SortRO(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, sort) + + if len(ret) == 0 { + panic("no return value specified for SortRO") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.Sort) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, sort) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_SortRO_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SortRO' +type MockCmdable_SortRO_Call struct { + *mock.Call +} + +// SortRO is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - sort *redis.Sort +func (_e *MockCmdable_Expecter) SortRO(ctx interface{}, key interface{}, sort interface{}) *MockCmdable_SortRO_Call { + return &MockCmdable_SortRO_Call{Call: _e.mock.On("SortRO", ctx, key, sort)} +} + +func (_c *MockCmdable_SortRO_Call) Run(run func(ctx context.Context, key string, sort *redis.Sort)) *MockCmdable_SortRO_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.Sort)) + }) + return _c +} + +func (_c *MockCmdable_SortRO_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_SortRO_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SortRO_Call) RunAndReturn(run func(context.Context, string, *redis.Sort) *redis.StringSliceCmd) *MockCmdable_SortRO_Call { + _c.Call.Return(run) + return _c +} + +// SortStore provides a mock function with given fields: ctx, key, store, sort +func (_m *MockCmdable) SortStore(ctx context.Context, key string, store string, sort *redis.Sort) *redis.IntCmd { + ret := _m.Called(ctx, key, store, sort) + + if len(ret) == 0 { + panic("no return value specified for SortStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, *redis.Sort) *redis.IntCmd); ok { + r0 = rf(ctx, key, store, sort) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_SortStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SortStore' +type MockCmdable_SortStore_Call struct { + *mock.Call +} + +// SortStore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - store string +// - sort *redis.Sort +func (_e *MockCmdable_Expecter) SortStore(ctx interface{}, key interface{}, store interface{}, sort interface{}) *MockCmdable_SortStore_Call { + return &MockCmdable_SortStore_Call{Call: _e.mock.On("SortStore", ctx, key, store, sort)} +} + +func (_c *MockCmdable_SortStore_Call) Run(run func(ctx context.Context, key string, store string, sort *redis.Sort)) *MockCmdable_SortStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*redis.Sort)) + }) + return _c +} + +func (_c *MockCmdable_SortStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_SortStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_SortStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.Sort) *redis.IntCmd) *MockCmdable_SortStore_Call { + _c.Call.Return(run) + return _c +} + +// StrLen provides a mock function with given fields: ctx, key +func (_m *MockCmdable) StrLen(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for StrLen") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_StrLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StrLen' +type MockCmdable_StrLen_Call struct { + *mock.Call +} + +// StrLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) StrLen(ctx interface{}, key interface{}) *MockCmdable_StrLen_Call { + return &MockCmdable_StrLen_Call{Call: _e.mock.On("StrLen", ctx, key)} +} + +func (_c *MockCmdable_StrLen_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_StrLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_StrLen_Call) Return(_a0 *redis.IntCmd) *MockCmdable_StrLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_StrLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_StrLen_Call { + _c.Call.Return(run) + return _c +} + +// TDigestAdd provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) TDigestAdd(ctx context.Context, key string, elements ...float64) *redis.StatusCmd { + _va := make([]interface{}, len(elements)) + for _i := range elements { + _va[_i] = elements[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TDigestAdd") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...float64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestAdd' +type MockCmdable_TDigestAdd_Call struct { + *mock.Call +} + +// TDigestAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...float64 +func (_e *MockCmdable_Expecter) TDigestAdd(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_TDigestAdd_Call { + return &MockCmdable_TDigestAdd_Call{Call: _e.mock.On("TDigestAdd", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_TDigestAdd_Call) Run(run func(ctx context.Context, key string, elements ...float64)) *MockCmdable_TDigestAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]float64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(float64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TDigestAdd_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TDigestAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestAdd_Call) RunAndReturn(run func(context.Context, string, ...float64) *redis.StatusCmd) *MockCmdable_TDigestAdd_Call { + _c.Call.Return(run) + return _c +} + +// TDigestByRank provides a mock function with given fields: ctx, key, rank +func (_m *MockCmdable) TDigestByRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + _va := make([]interface{}, len(rank)) + for _i := range rank { + _va[_i] = rank[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TDigestByRank") + } + + var r0 *redis.FloatSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...uint64) *redis.FloatSliceCmd); ok { + r0 = rf(ctx, key, rank...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestByRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestByRank' +type MockCmdable_TDigestByRank_Call struct { + *mock.Call +} + +// TDigestByRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - rank ...uint64 +func (_e *MockCmdable_Expecter) TDigestByRank(ctx interface{}, key interface{}, rank ...interface{}) *MockCmdable_TDigestByRank_Call { + return &MockCmdable_TDigestByRank_Call{Call: _e.mock.On("TDigestByRank", + append([]interface{}{ctx, key}, rank...)...)} +} + +func (_c *MockCmdable_TDigestByRank_Call) Run(run func(ctx context.Context, key string, rank ...uint64)) *MockCmdable_TDigestByRank_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]uint64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(uint64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TDigestByRank_Call) Return(_a0 *redis.FloatSliceCmd) *MockCmdable_TDigestByRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestByRank_Call) RunAndReturn(run func(context.Context, string, ...uint64) *redis.FloatSliceCmd) *MockCmdable_TDigestByRank_Call { + _c.Call.Return(run) + return _c +} + +// TDigestByRevRank provides a mock function with given fields: ctx, key, rank +func (_m *MockCmdable) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + _va := make([]interface{}, len(rank)) + for _i := range rank { + _va[_i] = rank[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TDigestByRevRank") + } + + var r0 *redis.FloatSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...uint64) *redis.FloatSliceCmd); ok { + r0 = rf(ctx, key, rank...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestByRevRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestByRevRank' +type MockCmdable_TDigestByRevRank_Call struct { + *mock.Call +} + +// TDigestByRevRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - rank ...uint64 +func (_e *MockCmdable_Expecter) TDigestByRevRank(ctx interface{}, key interface{}, rank ...interface{}) *MockCmdable_TDigestByRevRank_Call { + return &MockCmdable_TDigestByRevRank_Call{Call: _e.mock.On("TDigestByRevRank", + append([]interface{}{ctx, key}, rank...)...)} +} + +func (_c *MockCmdable_TDigestByRevRank_Call) Run(run func(ctx context.Context, key string, rank ...uint64)) *MockCmdable_TDigestByRevRank_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]uint64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(uint64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TDigestByRevRank_Call) Return(_a0 *redis.FloatSliceCmd) *MockCmdable_TDigestByRevRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestByRevRank_Call) RunAndReturn(run func(context.Context, string, ...uint64) *redis.FloatSliceCmd) *MockCmdable_TDigestByRevRank_Call { + _c.Call.Return(run) + return _c +} + +// TDigestCDF provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) TDigestCDF(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + _va := make([]interface{}, len(elements)) + for _i := range elements { + _va[_i] = elements[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TDigestCDF") + } + + var r0 *redis.FloatSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...float64) *redis.FloatSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestCDF_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestCDF' +type MockCmdable_TDigestCDF_Call struct { + *mock.Call +} + +// TDigestCDF is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...float64 +func (_e *MockCmdable_Expecter) TDigestCDF(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_TDigestCDF_Call { + return &MockCmdable_TDigestCDF_Call{Call: _e.mock.On("TDigestCDF", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_TDigestCDF_Call) Run(run func(ctx context.Context, key string, elements ...float64)) *MockCmdable_TDigestCDF_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]float64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(float64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TDigestCDF_Call) Return(_a0 *redis.FloatSliceCmd) *MockCmdable_TDigestCDF_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestCDF_Call) RunAndReturn(run func(context.Context, string, ...float64) *redis.FloatSliceCmd) *MockCmdable_TDigestCDF_Call { + _c.Call.Return(run) + return _c +} + +// TDigestCreate provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TDigestCreate(ctx context.Context, key string) *redis.StatusCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TDigestCreate") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestCreate' +type MockCmdable_TDigestCreate_Call struct { + *mock.Call +} + +// TDigestCreate is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TDigestCreate(ctx interface{}, key interface{}) *MockCmdable_TDigestCreate_Call { + return &MockCmdable_TDigestCreate_Call{Call: _e.mock.On("TDigestCreate", ctx, key)} +} + +func (_c *MockCmdable_TDigestCreate_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TDigestCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TDigestCreate_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TDigestCreate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestCreate_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_TDigestCreate_Call { + _c.Call.Return(run) + return _c +} + +// TDigestCreateWithCompression provides a mock function with given fields: ctx, key, compression +func (_m *MockCmdable) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, compression) + + if len(ret) == 0 { + panic("no return value specified for TDigestCreateWithCompression") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, compression) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestCreateWithCompression_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestCreateWithCompression' +type MockCmdable_TDigestCreateWithCompression_Call struct { + *mock.Call +} + +// TDigestCreateWithCompression is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - compression int64 +func (_e *MockCmdable_Expecter) TDigestCreateWithCompression(ctx interface{}, key interface{}, compression interface{}) *MockCmdable_TDigestCreateWithCompression_Call { + return &MockCmdable_TDigestCreateWithCompression_Call{Call: _e.mock.On("TDigestCreateWithCompression", ctx, key, compression)} +} + +func (_c *MockCmdable_TDigestCreateWithCompression_Call) Run(run func(ctx context.Context, key string, compression int64)) *MockCmdable_TDigestCreateWithCompression_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_TDigestCreateWithCompression_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TDigestCreateWithCompression_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestCreateWithCompression_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StatusCmd) *MockCmdable_TDigestCreateWithCompression_Call { + _c.Call.Return(run) + return _c +} + +// TDigestInfo provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TDigestInfo(ctx context.Context, key string) *redis.TDigestInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TDigestInfo") + } + + var r0 *redis.TDigestInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.TDigestInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TDigestInfoCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestInfo' +type MockCmdable_TDigestInfo_Call struct { + *mock.Call +} + +// TDigestInfo is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TDigestInfo(ctx interface{}, key interface{}) *MockCmdable_TDigestInfo_Call { + return &MockCmdable_TDigestInfo_Call{Call: _e.mock.On("TDigestInfo", ctx, key)} +} + +func (_c *MockCmdable_TDigestInfo_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TDigestInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TDigestInfo_Call) Return(_a0 *redis.TDigestInfoCmd) *MockCmdable_TDigestInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestInfo_Call) RunAndReturn(run func(context.Context, string) *redis.TDigestInfoCmd) *MockCmdable_TDigestInfo_Call { + _c.Call.Return(run) + return _c +} + +// TDigestMax provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TDigestMax(ctx context.Context, key string) *redis.FloatCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TDigestMax") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.FloatCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestMax' +type MockCmdable_TDigestMax_Call struct { + *mock.Call +} + +// TDigestMax is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TDigestMax(ctx interface{}, key interface{}) *MockCmdable_TDigestMax_Call { + return &MockCmdable_TDigestMax_Call{Call: _e.mock.On("TDigestMax", ctx, key)} +} + +func (_c *MockCmdable_TDigestMax_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TDigestMax_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TDigestMax_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_TDigestMax_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestMax_Call) RunAndReturn(run func(context.Context, string) *redis.FloatCmd) *MockCmdable_TDigestMax_Call { + _c.Call.Return(run) + return _c +} + +// TDigestMerge provides a mock function with given fields: ctx, destKey, options, sourceKeys +func (_m *MockCmdable) TDigestMerge(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string) *redis.StatusCmd { + _va := make([]interface{}, len(sourceKeys)) + for _i := range sourceKeys { + _va[_i] = sourceKeys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destKey, options) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TDigestMerge") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.TDigestMergeOptions, ...string) *redis.StatusCmd); ok { + r0 = rf(ctx, destKey, options, sourceKeys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestMerge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestMerge' +type MockCmdable_TDigestMerge_Call struct { + *mock.Call +} + +// TDigestMerge is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - options *redis.TDigestMergeOptions +// - sourceKeys ...string +func (_e *MockCmdable_Expecter) TDigestMerge(ctx interface{}, destKey interface{}, options interface{}, sourceKeys ...interface{}) *MockCmdable_TDigestMerge_Call { + return &MockCmdable_TDigestMerge_Call{Call: _e.mock.On("TDigestMerge", + append([]interface{}{ctx, destKey, options}, sourceKeys...)...)} +} + +func (_c *MockCmdable_TDigestMerge_Call) Run(run func(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string)) *MockCmdable_TDigestMerge_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*redis.TDigestMergeOptions), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TDigestMerge_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TDigestMerge_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestMerge_Call) RunAndReturn(run func(context.Context, string, *redis.TDigestMergeOptions, ...string) *redis.StatusCmd) *MockCmdable_TDigestMerge_Call { + _c.Call.Return(run) + return _c +} + +// TDigestMin provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TDigestMin(ctx context.Context, key string) *redis.FloatCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TDigestMin") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.FloatCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestMin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestMin' +type MockCmdable_TDigestMin_Call struct { + *mock.Call +} + +// TDigestMin is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TDigestMin(ctx interface{}, key interface{}) *MockCmdable_TDigestMin_Call { + return &MockCmdable_TDigestMin_Call{Call: _e.mock.On("TDigestMin", ctx, key)} +} + +func (_c *MockCmdable_TDigestMin_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TDigestMin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TDigestMin_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_TDigestMin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestMin_Call) RunAndReturn(run func(context.Context, string) *redis.FloatCmd) *MockCmdable_TDigestMin_Call { + _c.Call.Return(run) + return _c +} + +// TDigestQuantile provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) TDigestQuantile(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + _va := make([]interface{}, len(elements)) + for _i := range elements { + _va[_i] = elements[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TDigestQuantile") + } + + var r0 *redis.FloatSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...float64) *redis.FloatSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestQuantile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestQuantile' +type MockCmdable_TDigestQuantile_Call struct { + *mock.Call +} + +// TDigestQuantile is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...float64 +func (_e *MockCmdable_Expecter) TDigestQuantile(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_TDigestQuantile_Call { + return &MockCmdable_TDigestQuantile_Call{Call: _e.mock.On("TDigestQuantile", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_TDigestQuantile_Call) Run(run func(ctx context.Context, key string, elements ...float64)) *MockCmdable_TDigestQuantile_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]float64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(float64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TDigestQuantile_Call) Return(_a0 *redis.FloatSliceCmd) *MockCmdable_TDigestQuantile_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestQuantile_Call) RunAndReturn(run func(context.Context, string, ...float64) *redis.FloatSliceCmd) *MockCmdable_TDigestQuantile_Call { + _c.Call.Return(run) + return _c +} + +// TDigestRank provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) TDigestRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + _va := make([]interface{}, len(values)) + for _i := range values { + _va[_i] = values[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TDigestRank") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...float64) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestRank' +type MockCmdable_TDigestRank_Call struct { + *mock.Call +} + +// TDigestRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...float64 +func (_e *MockCmdable_Expecter) TDigestRank(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_TDigestRank_Call { + return &MockCmdable_TDigestRank_Call{Call: _e.mock.On("TDigestRank", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_TDigestRank_Call) Run(run func(ctx context.Context, key string, values ...float64)) *MockCmdable_TDigestRank_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]float64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(float64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TDigestRank_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_TDigestRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestRank_Call) RunAndReturn(run func(context.Context, string, ...float64) *redis.IntSliceCmd) *MockCmdable_TDigestRank_Call { + _c.Call.Return(run) + return _c +} + +// TDigestReset provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TDigestReset(ctx context.Context, key string) *redis.StatusCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TDigestReset") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestReset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestReset' +type MockCmdable_TDigestReset_Call struct { + *mock.Call +} + +// TDigestReset is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TDigestReset(ctx interface{}, key interface{}) *MockCmdable_TDigestReset_Call { + return &MockCmdable_TDigestReset_Call{Call: _e.mock.On("TDigestReset", ctx, key)} +} + +func (_c *MockCmdable_TDigestReset_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TDigestReset_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TDigestReset_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TDigestReset_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestReset_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_TDigestReset_Call { + _c.Call.Return(run) + return _c +} + +// TDigestRevRank provides a mock function with given fields: ctx, key, values +func (_m *MockCmdable) TDigestRevRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + _va := make([]interface{}, len(values)) + for _i := range values { + _va[_i] = values[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TDigestRevRank") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...float64) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, values...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestRevRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestRevRank' +type MockCmdable_TDigestRevRank_Call struct { + *mock.Call +} + +// TDigestRevRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...float64 +func (_e *MockCmdable_Expecter) TDigestRevRank(ctx interface{}, key interface{}, values ...interface{}) *MockCmdable_TDigestRevRank_Call { + return &MockCmdable_TDigestRevRank_Call{Call: _e.mock.On("TDigestRevRank", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *MockCmdable_TDigestRevRank_Call) Run(run func(ctx context.Context, key string, values ...float64)) *MockCmdable_TDigestRevRank_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]float64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(float64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TDigestRevRank_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_TDigestRevRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestRevRank_Call) RunAndReturn(run func(context.Context, string, ...float64) *redis.IntSliceCmd) *MockCmdable_TDigestRevRank_Call { + _c.Call.Return(run) + return _c +} + +// TDigestTrimmedMean provides a mock function with given fields: ctx, key, lowCutQuantile, highCutQuantile +func (_m *MockCmdable) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile float64, highCutQuantile float64) *redis.FloatCmd { + ret := _m.Called(ctx, key, lowCutQuantile, highCutQuantile) + + if len(ret) == 0 { + panic("no return value specified for TDigestTrimmedMean") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, float64) *redis.FloatCmd); ok { + r0 = rf(ctx, key, lowCutQuantile, highCutQuantile) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_TDigestTrimmedMean_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TDigestTrimmedMean' +type MockCmdable_TDigestTrimmedMean_Call struct { + *mock.Call +} + +// TDigestTrimmedMean is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - lowCutQuantile float64 +// - highCutQuantile float64 +func (_e *MockCmdable_Expecter) TDigestTrimmedMean(ctx interface{}, key interface{}, lowCutQuantile interface{}, highCutQuantile interface{}) *MockCmdable_TDigestTrimmedMean_Call { + return &MockCmdable_TDigestTrimmedMean_Call{Call: _e.mock.On("TDigestTrimmedMean", ctx, key, lowCutQuantile, highCutQuantile)} +} + +func (_c *MockCmdable_TDigestTrimmedMean_Call) Run(run func(ctx context.Context, key string, lowCutQuantile float64, highCutQuantile float64)) *MockCmdable_TDigestTrimmedMean_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(float64)) + }) + return _c +} + +func (_c *MockCmdable_TDigestTrimmedMean_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_TDigestTrimmedMean_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TDigestTrimmedMean_Call) RunAndReturn(run func(context.Context, string, float64, float64) *redis.FloatCmd) *MockCmdable_TDigestTrimmedMean_Call { + _c.Call.Return(run) + return _c +} + +// TFCall provides a mock function with given fields: ctx, libName, funcName, numKeys +func (_m *MockCmdable) TFCall(ctx context.Context, libName string, funcName string, numKeys int) *redis.Cmd { + ret := _m.Called(ctx, libName, funcName, numKeys) + + if len(ret) == 0 { + panic("no return value specified for TFCall") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int) *redis.Cmd); ok { + r0 = rf(ctx, libName, funcName, numKeys) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_TFCall_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFCall' +type MockCmdable_TFCall_Call struct { + *mock.Call +} + +// TFCall is a helper method to define mock.On call +// - ctx context.Context +// - libName string +// - funcName string +// - numKeys int +func (_e *MockCmdable_Expecter) TFCall(ctx interface{}, libName interface{}, funcName interface{}, numKeys interface{}) *MockCmdable_TFCall_Call { + return &MockCmdable_TFCall_Call{Call: _e.mock.On("TFCall", ctx, libName, funcName, numKeys)} +} + +func (_c *MockCmdable_TFCall_Call) Run(run func(ctx context.Context, libName string, funcName string, numKeys int)) *MockCmdable_TFCall_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int)) + }) + return _c +} + +func (_c *MockCmdable_TFCall_Call) Return(_a0 *redis.Cmd) *MockCmdable_TFCall_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFCall_Call) RunAndReturn(run func(context.Context, string, string, int) *redis.Cmd) *MockCmdable_TFCall_Call { + _c.Call.Return(run) + return _c +} + +// TFCallASYNC provides a mock function with given fields: ctx, libName, funcName, numKeys +func (_m *MockCmdable) TFCallASYNC(ctx context.Context, libName string, funcName string, numKeys int) *redis.Cmd { + ret := _m.Called(ctx, libName, funcName, numKeys) + + if len(ret) == 0 { + panic("no return value specified for TFCallASYNC") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int) *redis.Cmd); ok { + r0 = rf(ctx, libName, funcName, numKeys) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_TFCallASYNC_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFCallASYNC' +type MockCmdable_TFCallASYNC_Call struct { + *mock.Call +} + +// TFCallASYNC is a helper method to define mock.On call +// - ctx context.Context +// - libName string +// - funcName string +// - numKeys int +func (_e *MockCmdable_Expecter) TFCallASYNC(ctx interface{}, libName interface{}, funcName interface{}, numKeys interface{}) *MockCmdable_TFCallASYNC_Call { + return &MockCmdable_TFCallASYNC_Call{Call: _e.mock.On("TFCallASYNC", ctx, libName, funcName, numKeys)} +} + +func (_c *MockCmdable_TFCallASYNC_Call) Run(run func(ctx context.Context, libName string, funcName string, numKeys int)) *MockCmdable_TFCallASYNC_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int)) + }) + return _c +} + +func (_c *MockCmdable_TFCallASYNC_Call) Return(_a0 *redis.Cmd) *MockCmdable_TFCallASYNC_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFCallASYNC_Call) RunAndReturn(run func(context.Context, string, string, int) *redis.Cmd) *MockCmdable_TFCallASYNC_Call { + _c.Call.Return(run) + return _c +} + +// TFCallASYNCArgs provides a mock function with given fields: ctx, libName, funcName, numKeys, options +func (_m *MockCmdable) TFCallASYNCArgs(ctx context.Context, libName string, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + ret := _m.Called(ctx, libName, funcName, numKeys, options) + + if len(ret) == 0 { + panic("no return value specified for TFCallASYNCArgs") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int, *redis.TFCallOptions) *redis.Cmd); ok { + r0 = rf(ctx, libName, funcName, numKeys, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_TFCallASYNCArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFCallASYNCArgs' +type MockCmdable_TFCallASYNCArgs_Call struct { + *mock.Call +} + +// TFCallASYNCArgs is a helper method to define mock.On call +// - ctx context.Context +// - libName string +// - funcName string +// - numKeys int +// - options *redis.TFCallOptions +func (_e *MockCmdable_Expecter) TFCallASYNCArgs(ctx interface{}, libName interface{}, funcName interface{}, numKeys interface{}, options interface{}) *MockCmdable_TFCallASYNCArgs_Call { + return &MockCmdable_TFCallASYNCArgs_Call{Call: _e.mock.On("TFCallASYNCArgs", ctx, libName, funcName, numKeys, options)} +} + +func (_c *MockCmdable_TFCallASYNCArgs_Call) Run(run func(ctx context.Context, libName string, funcName string, numKeys int, options *redis.TFCallOptions)) *MockCmdable_TFCallASYNCArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int), args[4].(*redis.TFCallOptions)) + }) + return _c +} + +func (_c *MockCmdable_TFCallASYNCArgs_Call) Return(_a0 *redis.Cmd) *MockCmdable_TFCallASYNCArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFCallASYNCArgs_Call) RunAndReturn(run func(context.Context, string, string, int, *redis.TFCallOptions) *redis.Cmd) *MockCmdable_TFCallASYNCArgs_Call { + _c.Call.Return(run) + return _c +} + +// TFCallArgs provides a mock function with given fields: ctx, libName, funcName, numKeys, options +func (_m *MockCmdable) TFCallArgs(ctx context.Context, libName string, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + ret := _m.Called(ctx, libName, funcName, numKeys, options) + + if len(ret) == 0 { + panic("no return value specified for TFCallArgs") + } + + var r0 *redis.Cmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int, *redis.TFCallOptions) *redis.Cmd); ok { + r0 = rf(ctx, libName, funcName, numKeys, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.Cmd) + } + } + + return r0 +} + +// MockCmdable_TFCallArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFCallArgs' +type MockCmdable_TFCallArgs_Call struct { + *mock.Call +} + +// TFCallArgs is a helper method to define mock.On call +// - ctx context.Context +// - libName string +// - funcName string +// - numKeys int +// - options *redis.TFCallOptions +func (_e *MockCmdable_Expecter) TFCallArgs(ctx interface{}, libName interface{}, funcName interface{}, numKeys interface{}, options interface{}) *MockCmdable_TFCallArgs_Call { + return &MockCmdable_TFCallArgs_Call{Call: _e.mock.On("TFCallArgs", ctx, libName, funcName, numKeys, options)} +} + +func (_c *MockCmdable_TFCallArgs_Call) Run(run func(ctx context.Context, libName string, funcName string, numKeys int, options *redis.TFCallOptions)) *MockCmdable_TFCallArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int), args[4].(*redis.TFCallOptions)) + }) + return _c +} + +func (_c *MockCmdable_TFCallArgs_Call) Return(_a0 *redis.Cmd) *MockCmdable_TFCallArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFCallArgs_Call) RunAndReturn(run func(context.Context, string, string, int, *redis.TFCallOptions) *redis.Cmd) *MockCmdable_TFCallArgs_Call { + _c.Call.Return(run) + return _c +} + +// TFunctionDelete provides a mock function with given fields: ctx, libName +func (_m *MockCmdable) TFunctionDelete(ctx context.Context, libName string) *redis.StatusCmd { + ret := _m.Called(ctx, libName) + + if len(ret) == 0 { + panic("no return value specified for TFunctionDelete") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, libName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TFunctionDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFunctionDelete' +type MockCmdable_TFunctionDelete_Call struct { + *mock.Call +} + +// TFunctionDelete is a helper method to define mock.On call +// - ctx context.Context +// - libName string +func (_e *MockCmdable_Expecter) TFunctionDelete(ctx interface{}, libName interface{}) *MockCmdable_TFunctionDelete_Call { + return &MockCmdable_TFunctionDelete_Call{Call: _e.mock.On("TFunctionDelete", ctx, libName)} +} + +func (_c *MockCmdable_TFunctionDelete_Call) Run(run func(ctx context.Context, libName string)) *MockCmdable_TFunctionDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TFunctionDelete_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TFunctionDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFunctionDelete_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_TFunctionDelete_Call { + _c.Call.Return(run) + return _c +} + +// TFunctionList provides a mock function with given fields: ctx +func (_m *MockCmdable) TFunctionList(ctx context.Context) *redis.MapStringInterfaceSliceCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for TFunctionList") + } + + var r0 *redis.MapStringInterfaceSliceCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.MapStringInterfaceSliceCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringInterfaceSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TFunctionList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFunctionList' +type MockCmdable_TFunctionList_Call struct { + *mock.Call +} + +// TFunctionList is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) TFunctionList(ctx interface{}) *MockCmdable_TFunctionList_Call { + return &MockCmdable_TFunctionList_Call{Call: _e.mock.On("TFunctionList", ctx)} +} + +func (_c *MockCmdable_TFunctionList_Call) Run(run func(ctx context.Context)) *MockCmdable_TFunctionList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_TFunctionList_Call) Return(_a0 *redis.MapStringInterfaceSliceCmd) *MockCmdable_TFunctionList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFunctionList_Call) RunAndReturn(run func(context.Context) *redis.MapStringInterfaceSliceCmd) *MockCmdable_TFunctionList_Call { + _c.Call.Return(run) + return _c +} + +// TFunctionListArgs provides a mock function with given fields: ctx, options +func (_m *MockCmdable) TFunctionListArgs(ctx context.Context, options *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for TFunctionListArgs") + } + + var r0 *redis.MapStringInterfaceSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd); ok { + r0 = rf(ctx, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringInterfaceSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TFunctionListArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFunctionListArgs' +type MockCmdable_TFunctionListArgs_Call struct { + *mock.Call +} + +// TFunctionListArgs is a helper method to define mock.On call +// - ctx context.Context +// - options *redis.TFunctionListOptions +func (_e *MockCmdable_Expecter) TFunctionListArgs(ctx interface{}, options interface{}) *MockCmdable_TFunctionListArgs_Call { + return &MockCmdable_TFunctionListArgs_Call{Call: _e.mock.On("TFunctionListArgs", ctx, options)} +} + +func (_c *MockCmdable_TFunctionListArgs_Call) Run(run func(ctx context.Context, options *redis.TFunctionListOptions)) *MockCmdable_TFunctionListArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.TFunctionListOptions)) + }) + return _c +} + +func (_c *MockCmdable_TFunctionListArgs_Call) Return(_a0 *redis.MapStringInterfaceSliceCmd) *MockCmdable_TFunctionListArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFunctionListArgs_Call) RunAndReturn(run func(context.Context, *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd) *MockCmdable_TFunctionListArgs_Call { + _c.Call.Return(run) + return _c +} + +// TFunctionLoad provides a mock function with given fields: ctx, lib +func (_m *MockCmdable) TFunctionLoad(ctx context.Context, lib string) *redis.StatusCmd { + ret := _m.Called(ctx, lib) + + if len(ret) == 0 { + panic("no return value specified for TFunctionLoad") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, lib) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TFunctionLoad_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFunctionLoad' +type MockCmdable_TFunctionLoad_Call struct { + *mock.Call +} + +// TFunctionLoad is a helper method to define mock.On call +// - ctx context.Context +// - lib string +func (_e *MockCmdable_Expecter) TFunctionLoad(ctx interface{}, lib interface{}) *MockCmdable_TFunctionLoad_Call { + return &MockCmdable_TFunctionLoad_Call{Call: _e.mock.On("TFunctionLoad", ctx, lib)} +} + +func (_c *MockCmdable_TFunctionLoad_Call) Run(run func(ctx context.Context, lib string)) *MockCmdable_TFunctionLoad_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TFunctionLoad_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TFunctionLoad_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFunctionLoad_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_TFunctionLoad_Call { + _c.Call.Return(run) + return _c +} + +// TFunctionLoadArgs provides a mock function with given fields: ctx, lib, options +func (_m *MockCmdable) TFunctionLoadArgs(ctx context.Context, lib string, options *redis.TFunctionLoadOptions) *redis.StatusCmd { + ret := _m.Called(ctx, lib, options) + + if len(ret) == 0 { + panic("no return value specified for TFunctionLoadArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.TFunctionLoadOptions) *redis.StatusCmd); ok { + r0 = rf(ctx, lib, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TFunctionLoadArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TFunctionLoadArgs' +type MockCmdable_TFunctionLoadArgs_Call struct { + *mock.Call +} + +// TFunctionLoadArgs is a helper method to define mock.On call +// - ctx context.Context +// - lib string +// - options *redis.TFunctionLoadOptions +func (_e *MockCmdable_Expecter) TFunctionLoadArgs(ctx interface{}, lib interface{}, options interface{}) *MockCmdable_TFunctionLoadArgs_Call { + return &MockCmdable_TFunctionLoadArgs_Call{Call: _e.mock.On("TFunctionLoadArgs", ctx, lib, options)} +} + +func (_c *MockCmdable_TFunctionLoadArgs_Call) Run(run func(ctx context.Context, lib string, options *redis.TFunctionLoadOptions)) *MockCmdable_TFunctionLoadArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.TFunctionLoadOptions)) + }) + return _c +} + +func (_c *MockCmdable_TFunctionLoadArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TFunctionLoadArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TFunctionLoadArgs_Call) RunAndReturn(run func(context.Context, string, *redis.TFunctionLoadOptions) *redis.StatusCmd) *MockCmdable_TFunctionLoadArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSAdd provides a mock function with given fields: ctx, key, timestamp, value +func (_m *MockCmdable) TSAdd(ctx context.Context, key string, timestamp interface{}, value float64) *redis.IntCmd { + ret := _m.Called(ctx, key, timestamp, value) + + if len(ret) == 0 { + panic("no return value specified for TSAdd") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, float64) *redis.IntCmd); ok { + r0 = rf(ctx, key, timestamp, value) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_TSAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSAdd' +type MockCmdable_TSAdd_Call struct { + *mock.Call +} + +// TSAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - timestamp interface{} +// - value float64 +func (_e *MockCmdable_Expecter) TSAdd(ctx interface{}, key interface{}, timestamp interface{}, value interface{}) *MockCmdable_TSAdd_Call { + return &MockCmdable_TSAdd_Call{Call: _e.mock.On("TSAdd", ctx, key, timestamp, value)} +} + +func (_c *MockCmdable_TSAdd_Call) Run(run func(ctx context.Context, key string, timestamp interface{}, value float64)) *MockCmdable_TSAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(float64)) + }) + return _c +} + +func (_c *MockCmdable_TSAdd_Call) Return(_a0 *redis.IntCmd) *MockCmdable_TSAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSAdd_Call) RunAndReturn(run func(context.Context, string, interface{}, float64) *redis.IntCmd) *MockCmdable_TSAdd_Call { + _c.Call.Return(run) + return _c +} + +// TSAddWithArgs provides a mock function with given fields: ctx, key, timestamp, value, options +func (_m *MockCmdable) TSAddWithArgs(ctx context.Context, key string, timestamp interface{}, value float64, options *redis.TSOptions) *redis.IntCmd { + ret := _m.Called(ctx, key, timestamp, value, options) + + if len(ret) == 0 { + panic("no return value specified for TSAddWithArgs") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, interface{}, float64, *redis.TSOptions) *redis.IntCmd); ok { + r0 = rf(ctx, key, timestamp, value, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_TSAddWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSAddWithArgs' +type MockCmdable_TSAddWithArgs_Call struct { + *mock.Call +} + +// TSAddWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - timestamp interface{} +// - value float64 +// - options *redis.TSOptions +func (_e *MockCmdable_Expecter) TSAddWithArgs(ctx interface{}, key interface{}, timestamp interface{}, value interface{}, options interface{}) *MockCmdable_TSAddWithArgs_Call { + return &MockCmdable_TSAddWithArgs_Call{Call: _e.mock.On("TSAddWithArgs", ctx, key, timestamp, value, options)} +} + +func (_c *MockCmdable_TSAddWithArgs_Call) Run(run func(ctx context.Context, key string, timestamp interface{}, value float64, options *redis.TSOptions)) *MockCmdable_TSAddWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(float64), args[4].(*redis.TSOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSAddWithArgs_Call) Return(_a0 *redis.IntCmd) *MockCmdable_TSAddWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSAddWithArgs_Call) RunAndReturn(run func(context.Context, string, interface{}, float64, *redis.TSOptions) *redis.IntCmd) *MockCmdable_TSAddWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSAlter provides a mock function with given fields: ctx, key, options +func (_m *MockCmdable) TSAlter(ctx context.Context, key string, options *redis.TSAlterOptions) *redis.StatusCmd { + ret := _m.Called(ctx, key, options) + + if len(ret) == 0 { + panic("no return value specified for TSAlter") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.TSAlterOptions) *redis.StatusCmd); ok { + r0 = rf(ctx, key, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TSAlter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSAlter' +type MockCmdable_TSAlter_Call struct { + *mock.Call +} + +// TSAlter is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.TSAlterOptions +func (_e *MockCmdable_Expecter) TSAlter(ctx interface{}, key interface{}, options interface{}) *MockCmdable_TSAlter_Call { + return &MockCmdable_TSAlter_Call{Call: _e.mock.On("TSAlter", ctx, key, options)} +} + +func (_c *MockCmdable_TSAlter_Call) Run(run func(ctx context.Context, key string, options *redis.TSAlterOptions)) *MockCmdable_TSAlter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.TSAlterOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSAlter_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TSAlter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSAlter_Call) RunAndReturn(run func(context.Context, string, *redis.TSAlterOptions) *redis.StatusCmd) *MockCmdable_TSAlter_Call { + _c.Call.Return(run) + return _c +} + +// TSCreate provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TSCreate(ctx context.Context, key string) *redis.StatusCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TSCreate") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TSCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSCreate' +type MockCmdable_TSCreate_Call struct { + *mock.Call +} + +// TSCreate is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TSCreate(ctx interface{}, key interface{}) *MockCmdable_TSCreate_Call { + return &MockCmdable_TSCreate_Call{Call: _e.mock.On("TSCreate", ctx, key)} +} + +func (_c *MockCmdable_TSCreate_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TSCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TSCreate_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TSCreate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSCreate_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_TSCreate_Call { + _c.Call.Return(run) + return _c +} + +// TSCreateRule provides a mock function with given fields: ctx, sourceKey, destKey, aggregator, bucketDuration +func (_m *MockCmdable) TSCreateRule(ctx context.Context, sourceKey string, destKey string, aggregator redis.Aggregator, bucketDuration int) *redis.StatusCmd { + ret := _m.Called(ctx, sourceKey, destKey, aggregator, bucketDuration) + + if len(ret) == 0 { + panic("no return value specified for TSCreateRule") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, redis.Aggregator, int) *redis.StatusCmd); ok { + r0 = rf(ctx, sourceKey, destKey, aggregator, bucketDuration) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TSCreateRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSCreateRule' +type MockCmdable_TSCreateRule_Call struct { + *mock.Call +} + +// TSCreateRule is a helper method to define mock.On call +// - ctx context.Context +// - sourceKey string +// - destKey string +// - aggregator redis.Aggregator +// - bucketDuration int +func (_e *MockCmdable_Expecter) TSCreateRule(ctx interface{}, sourceKey interface{}, destKey interface{}, aggregator interface{}, bucketDuration interface{}) *MockCmdable_TSCreateRule_Call { + return &MockCmdable_TSCreateRule_Call{Call: _e.mock.On("TSCreateRule", ctx, sourceKey, destKey, aggregator, bucketDuration)} +} + +func (_c *MockCmdable_TSCreateRule_Call) Run(run func(ctx context.Context, sourceKey string, destKey string, aggregator redis.Aggregator, bucketDuration int)) *MockCmdable_TSCreateRule_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(redis.Aggregator), args[4].(int)) + }) + return _c +} + +func (_c *MockCmdable_TSCreateRule_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TSCreateRule_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSCreateRule_Call) RunAndReturn(run func(context.Context, string, string, redis.Aggregator, int) *redis.StatusCmd) *MockCmdable_TSCreateRule_Call { + _c.Call.Return(run) + return _c +} + +// TSCreateRuleWithArgs provides a mock function with given fields: ctx, sourceKey, destKey, aggregator, bucketDuration, options +func (_m *MockCmdable) TSCreateRuleWithArgs(ctx context.Context, sourceKey string, destKey string, aggregator redis.Aggregator, bucketDuration int, options *redis.TSCreateRuleOptions) *redis.StatusCmd { + ret := _m.Called(ctx, sourceKey, destKey, aggregator, bucketDuration, options) + + if len(ret) == 0 { + panic("no return value specified for TSCreateRuleWithArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, redis.Aggregator, int, *redis.TSCreateRuleOptions) *redis.StatusCmd); ok { + r0 = rf(ctx, sourceKey, destKey, aggregator, bucketDuration, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TSCreateRuleWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSCreateRuleWithArgs' +type MockCmdable_TSCreateRuleWithArgs_Call struct { + *mock.Call +} + +// TSCreateRuleWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - sourceKey string +// - destKey string +// - aggregator redis.Aggregator +// - bucketDuration int +// - options *redis.TSCreateRuleOptions +func (_e *MockCmdable_Expecter) TSCreateRuleWithArgs(ctx interface{}, sourceKey interface{}, destKey interface{}, aggregator interface{}, bucketDuration interface{}, options interface{}) *MockCmdable_TSCreateRuleWithArgs_Call { + return &MockCmdable_TSCreateRuleWithArgs_Call{Call: _e.mock.On("TSCreateRuleWithArgs", ctx, sourceKey, destKey, aggregator, bucketDuration, options)} +} + +func (_c *MockCmdable_TSCreateRuleWithArgs_Call) Run(run func(ctx context.Context, sourceKey string, destKey string, aggregator redis.Aggregator, bucketDuration int, options *redis.TSCreateRuleOptions)) *MockCmdable_TSCreateRuleWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(redis.Aggregator), args[4].(int), args[5].(*redis.TSCreateRuleOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSCreateRuleWithArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TSCreateRuleWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSCreateRuleWithArgs_Call) RunAndReturn(run func(context.Context, string, string, redis.Aggregator, int, *redis.TSCreateRuleOptions) *redis.StatusCmd) *MockCmdable_TSCreateRuleWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSCreateWithArgs provides a mock function with given fields: ctx, key, options +func (_m *MockCmdable) TSCreateWithArgs(ctx context.Context, key string, options *redis.TSOptions) *redis.StatusCmd { + ret := _m.Called(ctx, key, options) + + if len(ret) == 0 { + panic("no return value specified for TSCreateWithArgs") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.TSOptions) *redis.StatusCmd); ok { + r0 = rf(ctx, key, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TSCreateWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSCreateWithArgs' +type MockCmdable_TSCreateWithArgs_Call struct { + *mock.Call +} + +// TSCreateWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.TSOptions +func (_e *MockCmdable_Expecter) TSCreateWithArgs(ctx interface{}, key interface{}, options interface{}) *MockCmdable_TSCreateWithArgs_Call { + return &MockCmdable_TSCreateWithArgs_Call{Call: _e.mock.On("TSCreateWithArgs", ctx, key, options)} +} + +func (_c *MockCmdable_TSCreateWithArgs_Call) Run(run func(ctx context.Context, key string, options *redis.TSOptions)) *MockCmdable_TSCreateWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.TSOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSCreateWithArgs_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TSCreateWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSCreateWithArgs_Call) RunAndReturn(run func(context.Context, string, *redis.TSOptions) *redis.StatusCmd) *MockCmdable_TSCreateWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSDecrBy provides a mock function with given fields: ctx, Key, timestamp +func (_m *MockCmdable) TSDecrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd { + ret := _m.Called(ctx, Key, timestamp) + + if len(ret) == 0 { + panic("no return value specified for TSDecrBy") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64) *redis.IntCmd); ok { + r0 = rf(ctx, Key, timestamp) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_TSDecrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSDecrBy' +type MockCmdable_TSDecrBy_Call struct { + *mock.Call +} + +// TSDecrBy is a helper method to define mock.On call +// - ctx context.Context +// - Key string +// - timestamp float64 +func (_e *MockCmdable_Expecter) TSDecrBy(ctx interface{}, Key interface{}, timestamp interface{}) *MockCmdable_TSDecrBy_Call { + return &MockCmdable_TSDecrBy_Call{Call: _e.mock.On("TSDecrBy", ctx, Key, timestamp)} +} + +func (_c *MockCmdable_TSDecrBy_Call) Run(run func(ctx context.Context, Key string, timestamp float64)) *MockCmdable_TSDecrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64)) + }) + return _c +} + +func (_c *MockCmdable_TSDecrBy_Call) Return(_a0 *redis.IntCmd) *MockCmdable_TSDecrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSDecrBy_Call) RunAndReturn(run func(context.Context, string, float64) *redis.IntCmd) *MockCmdable_TSDecrBy_Call { + _c.Call.Return(run) + return _c +} + +// TSDecrByWithArgs provides a mock function with given fields: ctx, key, timestamp, options +func (_m *MockCmdable) TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd { + ret := _m.Called(ctx, key, timestamp, options) + + if len(ret) == 0 { + panic("no return value specified for TSDecrByWithArgs") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, *redis.TSIncrDecrOptions) *redis.IntCmd); ok { + r0 = rf(ctx, key, timestamp, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_TSDecrByWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSDecrByWithArgs' +type MockCmdable_TSDecrByWithArgs_Call struct { + *mock.Call +} + +// TSDecrByWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - timestamp float64 +// - options *redis.TSIncrDecrOptions +func (_e *MockCmdable_Expecter) TSDecrByWithArgs(ctx interface{}, key interface{}, timestamp interface{}, options interface{}) *MockCmdable_TSDecrByWithArgs_Call { + return &MockCmdable_TSDecrByWithArgs_Call{Call: _e.mock.On("TSDecrByWithArgs", ctx, key, timestamp, options)} +} + +func (_c *MockCmdable_TSDecrByWithArgs_Call) Run(run func(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions)) *MockCmdable_TSDecrByWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(*redis.TSIncrDecrOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSDecrByWithArgs_Call) Return(_a0 *redis.IntCmd) *MockCmdable_TSDecrByWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSDecrByWithArgs_Call) RunAndReturn(run func(context.Context, string, float64, *redis.TSIncrDecrOptions) *redis.IntCmd) *MockCmdable_TSDecrByWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSDel provides a mock function with given fields: ctx, Key, fromTimestamp, toTimestamp +func (_m *MockCmdable) TSDel(ctx context.Context, Key string, fromTimestamp int, toTimestamp int) *redis.IntCmd { + ret := _m.Called(ctx, Key, fromTimestamp, toTimestamp) + + if len(ret) == 0 { + panic("no return value specified for TSDel") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int, int) *redis.IntCmd); ok { + r0 = rf(ctx, Key, fromTimestamp, toTimestamp) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_TSDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSDel' +type MockCmdable_TSDel_Call struct { + *mock.Call +} + +// TSDel is a helper method to define mock.On call +// - ctx context.Context +// - Key string +// - fromTimestamp int +// - toTimestamp int +func (_e *MockCmdable_Expecter) TSDel(ctx interface{}, Key interface{}, fromTimestamp interface{}, toTimestamp interface{}) *MockCmdable_TSDel_Call { + return &MockCmdable_TSDel_Call{Call: _e.mock.On("TSDel", ctx, Key, fromTimestamp, toTimestamp)} +} + +func (_c *MockCmdable_TSDel_Call) Run(run func(ctx context.Context, Key string, fromTimestamp int, toTimestamp int)) *MockCmdable_TSDel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(int)) + }) + return _c +} + +func (_c *MockCmdable_TSDel_Call) Return(_a0 *redis.IntCmd) *MockCmdable_TSDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSDel_Call) RunAndReturn(run func(context.Context, string, int, int) *redis.IntCmd) *MockCmdable_TSDel_Call { + _c.Call.Return(run) + return _c +} + +// TSDeleteRule provides a mock function with given fields: ctx, sourceKey, destKey +func (_m *MockCmdable) TSDeleteRule(ctx context.Context, sourceKey string, destKey string) *redis.StatusCmd { + ret := _m.Called(ctx, sourceKey, destKey) + + if len(ret) == 0 { + panic("no return value specified for TSDeleteRule") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, sourceKey, destKey) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TSDeleteRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSDeleteRule' +type MockCmdable_TSDeleteRule_Call struct { + *mock.Call +} + +// TSDeleteRule is a helper method to define mock.On call +// - ctx context.Context +// - sourceKey string +// - destKey string +func (_e *MockCmdable_Expecter) TSDeleteRule(ctx interface{}, sourceKey interface{}, destKey interface{}) *MockCmdable_TSDeleteRule_Call { + return &MockCmdable_TSDeleteRule_Call{Call: _e.mock.On("TSDeleteRule", ctx, sourceKey, destKey)} +} + +func (_c *MockCmdable_TSDeleteRule_Call) Run(run func(ctx context.Context, sourceKey string, destKey string)) *MockCmdable_TSDeleteRule_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_TSDeleteRule_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TSDeleteRule_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSDeleteRule_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *MockCmdable_TSDeleteRule_Call { + _c.Call.Return(run) + return _c +} + +// TSGet provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TSGet(ctx context.Context, key string) *redis.TSTimestampValueCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TSGet") + } + + var r0 *redis.TSTimestampValueCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.TSTimestampValueCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TSTimestampValueCmd) + } + } + + return r0 +} + +// MockCmdable_TSGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSGet' +type MockCmdable_TSGet_Call struct { + *mock.Call +} + +// TSGet is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TSGet(ctx interface{}, key interface{}) *MockCmdable_TSGet_Call { + return &MockCmdable_TSGet_Call{Call: _e.mock.On("TSGet", ctx, key)} +} + +func (_c *MockCmdable_TSGet_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TSGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TSGet_Call) Return(_a0 *redis.TSTimestampValueCmd) *MockCmdable_TSGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSGet_Call) RunAndReturn(run func(context.Context, string) *redis.TSTimestampValueCmd) *MockCmdable_TSGet_Call { + _c.Call.Return(run) + return _c +} + +// TSGetWithArgs provides a mock function with given fields: ctx, key, options +func (_m *MockCmdable) TSGetWithArgs(ctx context.Context, key string, options *redis.TSGetOptions) *redis.TSTimestampValueCmd { + ret := _m.Called(ctx, key, options) + + if len(ret) == 0 { + panic("no return value specified for TSGetWithArgs") + } + + var r0 *redis.TSTimestampValueCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.TSGetOptions) *redis.TSTimestampValueCmd); ok { + r0 = rf(ctx, key, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TSTimestampValueCmd) + } + } + + return r0 +} + +// MockCmdable_TSGetWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSGetWithArgs' +type MockCmdable_TSGetWithArgs_Call struct { + *mock.Call +} + +// TSGetWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.TSGetOptions +func (_e *MockCmdable_Expecter) TSGetWithArgs(ctx interface{}, key interface{}, options interface{}) *MockCmdable_TSGetWithArgs_Call { + return &MockCmdable_TSGetWithArgs_Call{Call: _e.mock.On("TSGetWithArgs", ctx, key, options)} +} + +func (_c *MockCmdable_TSGetWithArgs_Call) Run(run func(ctx context.Context, key string, options *redis.TSGetOptions)) *MockCmdable_TSGetWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.TSGetOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSGetWithArgs_Call) Return(_a0 *redis.TSTimestampValueCmd) *MockCmdable_TSGetWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSGetWithArgs_Call) RunAndReturn(run func(context.Context, string, *redis.TSGetOptions) *redis.TSTimestampValueCmd) *MockCmdable_TSGetWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSIncrBy provides a mock function with given fields: ctx, Key, timestamp +func (_m *MockCmdable) TSIncrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd { + ret := _m.Called(ctx, Key, timestamp) + + if len(ret) == 0 { + panic("no return value specified for TSIncrBy") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64) *redis.IntCmd); ok { + r0 = rf(ctx, Key, timestamp) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_TSIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSIncrBy' +type MockCmdable_TSIncrBy_Call struct { + *mock.Call +} + +// TSIncrBy is a helper method to define mock.On call +// - ctx context.Context +// - Key string +// - timestamp float64 +func (_e *MockCmdable_Expecter) TSIncrBy(ctx interface{}, Key interface{}, timestamp interface{}) *MockCmdable_TSIncrBy_Call { + return &MockCmdable_TSIncrBy_Call{Call: _e.mock.On("TSIncrBy", ctx, Key, timestamp)} +} + +func (_c *MockCmdable_TSIncrBy_Call) Run(run func(ctx context.Context, Key string, timestamp float64)) *MockCmdable_TSIncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64)) + }) + return _c +} + +func (_c *MockCmdable_TSIncrBy_Call) Return(_a0 *redis.IntCmd) *MockCmdable_TSIncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSIncrBy_Call) RunAndReturn(run func(context.Context, string, float64) *redis.IntCmd) *MockCmdable_TSIncrBy_Call { + _c.Call.Return(run) + return _c +} + +// TSIncrByWithArgs provides a mock function with given fields: ctx, key, timestamp, options +func (_m *MockCmdable) TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd { + ret := _m.Called(ctx, key, timestamp, options) + + if len(ret) == 0 { + panic("no return value specified for TSIncrByWithArgs") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, *redis.TSIncrDecrOptions) *redis.IntCmd); ok { + r0 = rf(ctx, key, timestamp, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_TSIncrByWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSIncrByWithArgs' +type MockCmdable_TSIncrByWithArgs_Call struct { + *mock.Call +} + +// TSIncrByWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - timestamp float64 +// - options *redis.TSIncrDecrOptions +func (_e *MockCmdable_Expecter) TSIncrByWithArgs(ctx interface{}, key interface{}, timestamp interface{}, options interface{}) *MockCmdable_TSIncrByWithArgs_Call { + return &MockCmdable_TSIncrByWithArgs_Call{Call: _e.mock.On("TSIncrByWithArgs", ctx, key, timestamp, options)} +} + +func (_c *MockCmdable_TSIncrByWithArgs_Call) Run(run func(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions)) *MockCmdable_TSIncrByWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(*redis.TSIncrDecrOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSIncrByWithArgs_Call) Return(_a0 *redis.IntCmd) *MockCmdable_TSIncrByWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSIncrByWithArgs_Call) RunAndReturn(run func(context.Context, string, float64, *redis.TSIncrDecrOptions) *redis.IntCmd) *MockCmdable_TSIncrByWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSInfo provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TSInfo(ctx context.Context, key string) *redis.MapStringInterfaceCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TSInfo") + } + + var r0 *redis.MapStringInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.MapStringInterfaceCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_TSInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSInfo' +type MockCmdable_TSInfo_Call struct { + *mock.Call +} + +// TSInfo is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TSInfo(ctx interface{}, key interface{}) *MockCmdable_TSInfo_Call { + return &MockCmdable_TSInfo_Call{Call: _e.mock.On("TSInfo", ctx, key)} +} + +func (_c *MockCmdable_TSInfo_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TSInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TSInfo_Call) Return(_a0 *redis.MapStringInterfaceCmd) *MockCmdable_TSInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSInfo_Call) RunAndReturn(run func(context.Context, string) *redis.MapStringInterfaceCmd) *MockCmdable_TSInfo_Call { + _c.Call.Return(run) + return _c +} + +// TSInfoWithArgs provides a mock function with given fields: ctx, key, options +func (_m *MockCmdable) TSInfoWithArgs(ctx context.Context, key string, options *redis.TSInfoOptions) *redis.MapStringInterfaceCmd { + ret := _m.Called(ctx, key, options) + + if len(ret) == 0 { + panic("no return value specified for TSInfoWithArgs") + } + + var r0 *redis.MapStringInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.TSInfoOptions) *redis.MapStringInterfaceCmd); ok { + r0 = rf(ctx, key, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_TSInfoWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSInfoWithArgs' +type MockCmdable_TSInfoWithArgs_Call struct { + *mock.Call +} + +// TSInfoWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - options *redis.TSInfoOptions +func (_e *MockCmdable_Expecter) TSInfoWithArgs(ctx interface{}, key interface{}, options interface{}) *MockCmdable_TSInfoWithArgs_Call { + return &MockCmdable_TSInfoWithArgs_Call{Call: _e.mock.On("TSInfoWithArgs", ctx, key, options)} +} + +func (_c *MockCmdable_TSInfoWithArgs_Call) Run(run func(ctx context.Context, key string, options *redis.TSInfoOptions)) *MockCmdable_TSInfoWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.TSInfoOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSInfoWithArgs_Call) Return(_a0 *redis.MapStringInterfaceCmd) *MockCmdable_TSInfoWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSInfoWithArgs_Call) RunAndReturn(run func(context.Context, string, *redis.TSInfoOptions) *redis.MapStringInterfaceCmd) *MockCmdable_TSInfoWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSMAdd provides a mock function with given fields: ctx, ktvSlices +func (_m *MockCmdable) TSMAdd(ctx context.Context, ktvSlices [][]interface{}) *redis.IntSliceCmd { + ret := _m.Called(ctx, ktvSlices) + + if len(ret) == 0 { + panic("no return value specified for TSMAdd") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, [][]interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, ktvSlices) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TSMAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSMAdd' +type MockCmdable_TSMAdd_Call struct { + *mock.Call +} + +// TSMAdd is a helper method to define mock.On call +// - ctx context.Context +// - ktvSlices [][]interface{} +func (_e *MockCmdable_Expecter) TSMAdd(ctx interface{}, ktvSlices interface{}) *MockCmdable_TSMAdd_Call { + return &MockCmdable_TSMAdd_Call{Call: _e.mock.On("TSMAdd", ctx, ktvSlices)} +} + +func (_c *MockCmdable_TSMAdd_Call) Run(run func(ctx context.Context, ktvSlices [][]interface{})) *MockCmdable_TSMAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([][]interface{})) + }) + return _c +} + +func (_c *MockCmdable_TSMAdd_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_TSMAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSMAdd_Call) RunAndReturn(run func(context.Context, [][]interface{}) *redis.IntSliceCmd) *MockCmdable_TSMAdd_Call { + _c.Call.Return(run) + return _c +} + +// TSMGet provides a mock function with given fields: ctx, filters +func (_m *MockCmdable) TSMGet(ctx context.Context, filters []string) *redis.MapStringSliceInterfaceCmd { + ret := _m.Called(ctx, filters) + + if len(ret) == 0 { + panic("no return value specified for TSMGet") + } + + var r0 *redis.MapStringSliceInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, []string) *redis.MapStringSliceInterfaceCmd); ok { + r0 = rf(ctx, filters) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringSliceInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_TSMGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSMGet' +type MockCmdable_TSMGet_Call struct { + *mock.Call +} + +// TSMGet is a helper method to define mock.On call +// - ctx context.Context +// - filters []string +func (_e *MockCmdable_Expecter) TSMGet(ctx interface{}, filters interface{}) *MockCmdable_TSMGet_Call { + return &MockCmdable_TSMGet_Call{Call: _e.mock.On("TSMGet", ctx, filters)} +} + +func (_c *MockCmdable_TSMGet_Call) Run(run func(ctx context.Context, filters []string)) *MockCmdable_TSMGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockCmdable_TSMGet_Call) Return(_a0 *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSMGet_Call) RunAndReturn(run func(context.Context, []string) *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMGet_Call { + _c.Call.Return(run) + return _c +} + +// TSMGetWithArgs provides a mock function with given fields: ctx, filters, options +func (_m *MockCmdable) TSMGetWithArgs(ctx context.Context, filters []string, options *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd { + ret := _m.Called(ctx, filters, options) + + if len(ret) == 0 { + panic("no return value specified for TSMGetWithArgs") + } + + var r0 *redis.MapStringSliceInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, []string, *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd); ok { + r0 = rf(ctx, filters, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringSliceInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_TSMGetWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSMGetWithArgs' +type MockCmdable_TSMGetWithArgs_Call struct { + *mock.Call +} + +// TSMGetWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - filters []string +// - options *redis.TSMGetOptions +func (_e *MockCmdable_Expecter) TSMGetWithArgs(ctx interface{}, filters interface{}, options interface{}) *MockCmdable_TSMGetWithArgs_Call { + return &MockCmdable_TSMGetWithArgs_Call{Call: _e.mock.On("TSMGetWithArgs", ctx, filters, options)} +} + +func (_c *MockCmdable_TSMGetWithArgs_Call) Run(run func(ctx context.Context, filters []string, options *redis.TSMGetOptions)) *MockCmdable_TSMGetWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string), args[2].(*redis.TSMGetOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSMGetWithArgs_Call) Return(_a0 *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMGetWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSMGetWithArgs_Call) RunAndReturn(run func(context.Context, []string, *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMGetWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSMRange provides a mock function with given fields: ctx, fromTimestamp, toTimestamp, filterExpr +func (_m *MockCmdable) TSMRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd { + ret := _m.Called(ctx, fromTimestamp, toTimestamp, filterExpr) + + if len(ret) == 0 { + panic("no return value specified for TSMRange") + } + + var r0 *redis.MapStringSliceInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, int, int, []string) *redis.MapStringSliceInterfaceCmd); ok { + r0 = rf(ctx, fromTimestamp, toTimestamp, filterExpr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringSliceInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_TSMRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSMRange' +type MockCmdable_TSMRange_Call struct { + *mock.Call +} + +// TSMRange is a helper method to define mock.On call +// - ctx context.Context +// - fromTimestamp int +// - toTimestamp int +// - filterExpr []string +func (_e *MockCmdable_Expecter) TSMRange(ctx interface{}, fromTimestamp interface{}, toTimestamp interface{}, filterExpr interface{}) *MockCmdable_TSMRange_Call { + return &MockCmdable_TSMRange_Call{Call: _e.mock.On("TSMRange", ctx, fromTimestamp, toTimestamp, filterExpr)} +} + +func (_c *MockCmdable_TSMRange_Call) Run(run func(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string)) *MockCmdable_TSMRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int), args[3].([]string)) + }) + return _c +} + +func (_c *MockCmdable_TSMRange_Call) Return(_a0 *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSMRange_Call) RunAndReturn(run func(context.Context, int, int, []string) *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMRange_Call { + _c.Call.Return(run) + return _c +} + +// TSMRangeWithArgs provides a mock function with given fields: ctx, fromTimestamp, toTimestamp, filterExpr, options +func (_m *MockCmdable) TSMRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd { + ret := _m.Called(ctx, fromTimestamp, toTimestamp, filterExpr, options) + + if len(ret) == 0 { + panic("no return value specified for TSMRangeWithArgs") + } + + var r0 *redis.MapStringSliceInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, int, int, []string, *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd); ok { + r0 = rf(ctx, fromTimestamp, toTimestamp, filterExpr, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringSliceInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_TSMRangeWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSMRangeWithArgs' +type MockCmdable_TSMRangeWithArgs_Call struct { + *mock.Call +} + +// TSMRangeWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - fromTimestamp int +// - toTimestamp int +// - filterExpr []string +// - options *redis.TSMRangeOptions +func (_e *MockCmdable_Expecter) TSMRangeWithArgs(ctx interface{}, fromTimestamp interface{}, toTimestamp interface{}, filterExpr interface{}, options interface{}) *MockCmdable_TSMRangeWithArgs_Call { + return &MockCmdable_TSMRangeWithArgs_Call{Call: _e.mock.On("TSMRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options)} +} + +func (_c *MockCmdable_TSMRangeWithArgs_Call) Run(run func(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *redis.TSMRangeOptions)) *MockCmdable_TSMRangeWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int), args[3].([]string), args[4].(*redis.TSMRangeOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSMRangeWithArgs_Call) Return(_a0 *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMRangeWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSMRangeWithArgs_Call) RunAndReturn(run func(context.Context, int, int, []string, *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMRangeWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSMRevRange provides a mock function with given fields: ctx, fromTimestamp, toTimestamp, filterExpr +func (_m *MockCmdable) TSMRevRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd { + ret := _m.Called(ctx, fromTimestamp, toTimestamp, filterExpr) + + if len(ret) == 0 { + panic("no return value specified for TSMRevRange") + } + + var r0 *redis.MapStringSliceInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, int, int, []string) *redis.MapStringSliceInterfaceCmd); ok { + r0 = rf(ctx, fromTimestamp, toTimestamp, filterExpr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringSliceInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_TSMRevRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSMRevRange' +type MockCmdable_TSMRevRange_Call struct { + *mock.Call +} + +// TSMRevRange is a helper method to define mock.On call +// - ctx context.Context +// - fromTimestamp int +// - toTimestamp int +// - filterExpr []string +func (_e *MockCmdable_Expecter) TSMRevRange(ctx interface{}, fromTimestamp interface{}, toTimestamp interface{}, filterExpr interface{}) *MockCmdable_TSMRevRange_Call { + return &MockCmdable_TSMRevRange_Call{Call: _e.mock.On("TSMRevRange", ctx, fromTimestamp, toTimestamp, filterExpr)} +} + +func (_c *MockCmdable_TSMRevRange_Call) Run(run func(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string)) *MockCmdable_TSMRevRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int), args[3].([]string)) + }) + return _c +} + +func (_c *MockCmdable_TSMRevRange_Call) Return(_a0 *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMRevRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSMRevRange_Call) RunAndReturn(run func(context.Context, int, int, []string) *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMRevRange_Call { + _c.Call.Return(run) + return _c +} + +// TSMRevRangeWithArgs provides a mock function with given fields: ctx, fromTimestamp, toTimestamp, filterExpr, options +func (_m *MockCmdable) TSMRevRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd { + ret := _m.Called(ctx, fromTimestamp, toTimestamp, filterExpr, options) + + if len(ret) == 0 { + panic("no return value specified for TSMRevRangeWithArgs") + } + + var r0 *redis.MapStringSliceInterfaceCmd + if rf, ok := ret.Get(0).(func(context.Context, int, int, []string, *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd); ok { + r0 = rf(ctx, fromTimestamp, toTimestamp, filterExpr, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringSliceInterfaceCmd) + } + } + + return r0 +} + +// MockCmdable_TSMRevRangeWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSMRevRangeWithArgs' +type MockCmdable_TSMRevRangeWithArgs_Call struct { + *mock.Call +} + +// TSMRevRangeWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - fromTimestamp int +// - toTimestamp int +// - filterExpr []string +// - options *redis.TSMRevRangeOptions +func (_e *MockCmdable_Expecter) TSMRevRangeWithArgs(ctx interface{}, fromTimestamp interface{}, toTimestamp interface{}, filterExpr interface{}, options interface{}) *MockCmdable_TSMRevRangeWithArgs_Call { + return &MockCmdable_TSMRevRangeWithArgs_Call{Call: _e.mock.On("TSMRevRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options)} +} + +func (_c *MockCmdable_TSMRevRangeWithArgs_Call) Run(run func(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *redis.TSMRevRangeOptions)) *MockCmdable_TSMRevRangeWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int), args[3].([]string), args[4].(*redis.TSMRevRangeOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSMRevRangeWithArgs_Call) Return(_a0 *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMRevRangeWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSMRevRangeWithArgs_Call) RunAndReturn(run func(context.Context, int, int, []string, *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd) *MockCmdable_TSMRevRangeWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSQueryIndex provides a mock function with given fields: ctx, filterExpr +func (_m *MockCmdable) TSQueryIndex(ctx context.Context, filterExpr []string) *redis.StringSliceCmd { + ret := _m.Called(ctx, filterExpr) + + if len(ret) == 0 { + panic("no return value specified for TSQueryIndex") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, []string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, filterExpr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TSQueryIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSQueryIndex' +type MockCmdable_TSQueryIndex_Call struct { + *mock.Call +} + +// TSQueryIndex is a helper method to define mock.On call +// - ctx context.Context +// - filterExpr []string +func (_e *MockCmdable_Expecter) TSQueryIndex(ctx interface{}, filterExpr interface{}) *MockCmdable_TSQueryIndex_Call { + return &MockCmdable_TSQueryIndex_Call{Call: _e.mock.On("TSQueryIndex", ctx, filterExpr)} +} + +func (_c *MockCmdable_TSQueryIndex_Call) Run(run func(ctx context.Context, filterExpr []string)) *MockCmdable_TSQueryIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockCmdable_TSQueryIndex_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_TSQueryIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSQueryIndex_Call) RunAndReturn(run func(context.Context, []string) *redis.StringSliceCmd) *MockCmdable_TSQueryIndex_Call { + _c.Call.Return(run) + return _c +} + +// TSRange provides a mock function with given fields: ctx, key, fromTimestamp, toTimestamp +func (_m *MockCmdable) TSRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *redis.TSTimestampValueSliceCmd { + ret := _m.Called(ctx, key, fromTimestamp, toTimestamp) + + if len(ret) == 0 { + panic("no return value specified for TSRange") + } + + var r0 *redis.TSTimestampValueSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int, int) *redis.TSTimestampValueSliceCmd); ok { + r0 = rf(ctx, key, fromTimestamp, toTimestamp) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TSTimestampValueSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TSRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSRange' +type MockCmdable_TSRange_Call struct { + *mock.Call +} + +// TSRange is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fromTimestamp int +// - toTimestamp int +func (_e *MockCmdable_Expecter) TSRange(ctx interface{}, key interface{}, fromTimestamp interface{}, toTimestamp interface{}) *MockCmdable_TSRange_Call { + return &MockCmdable_TSRange_Call{Call: _e.mock.On("TSRange", ctx, key, fromTimestamp, toTimestamp)} +} + +func (_c *MockCmdable_TSRange_Call) Run(run func(ctx context.Context, key string, fromTimestamp int, toTimestamp int)) *MockCmdable_TSRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(int)) + }) + return _c +} + +func (_c *MockCmdable_TSRange_Call) Return(_a0 *redis.TSTimestampValueSliceCmd) *MockCmdable_TSRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSRange_Call) RunAndReturn(run func(context.Context, string, int, int) *redis.TSTimestampValueSliceCmd) *MockCmdable_TSRange_Call { + _c.Call.Return(run) + return _c +} + +// TSRangeWithArgs provides a mock function with given fields: ctx, key, fromTimestamp, toTimestamp, options +func (_m *MockCmdable) TSRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd { + ret := _m.Called(ctx, key, fromTimestamp, toTimestamp, options) + + if len(ret) == 0 { + panic("no return value specified for TSRangeWithArgs") + } + + var r0 *redis.TSTimestampValueSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int, int, *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd); ok { + r0 = rf(ctx, key, fromTimestamp, toTimestamp, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TSTimestampValueSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TSRangeWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSRangeWithArgs' +type MockCmdable_TSRangeWithArgs_Call struct { + *mock.Call +} + +// TSRangeWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fromTimestamp int +// - toTimestamp int +// - options *redis.TSRangeOptions +func (_e *MockCmdable_Expecter) TSRangeWithArgs(ctx interface{}, key interface{}, fromTimestamp interface{}, toTimestamp interface{}, options interface{}) *MockCmdable_TSRangeWithArgs_Call { + return &MockCmdable_TSRangeWithArgs_Call{Call: _e.mock.On("TSRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options)} +} + +func (_c *MockCmdable_TSRangeWithArgs_Call) Run(run func(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *redis.TSRangeOptions)) *MockCmdable_TSRangeWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(int), args[4].(*redis.TSRangeOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSRangeWithArgs_Call) Return(_a0 *redis.TSTimestampValueSliceCmd) *MockCmdable_TSRangeWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSRangeWithArgs_Call) RunAndReturn(run func(context.Context, string, int, int, *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd) *MockCmdable_TSRangeWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TSRevRange provides a mock function with given fields: ctx, key, fromTimestamp, toTimestamp +func (_m *MockCmdable) TSRevRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *redis.TSTimestampValueSliceCmd { + ret := _m.Called(ctx, key, fromTimestamp, toTimestamp) + + if len(ret) == 0 { + panic("no return value specified for TSRevRange") + } + + var r0 *redis.TSTimestampValueSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int, int) *redis.TSTimestampValueSliceCmd); ok { + r0 = rf(ctx, key, fromTimestamp, toTimestamp) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TSTimestampValueSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TSRevRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSRevRange' +type MockCmdable_TSRevRange_Call struct { + *mock.Call +} + +// TSRevRange is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fromTimestamp int +// - toTimestamp int +func (_e *MockCmdable_Expecter) TSRevRange(ctx interface{}, key interface{}, fromTimestamp interface{}, toTimestamp interface{}) *MockCmdable_TSRevRange_Call { + return &MockCmdable_TSRevRange_Call{Call: _e.mock.On("TSRevRange", ctx, key, fromTimestamp, toTimestamp)} +} + +func (_c *MockCmdable_TSRevRange_Call) Run(run func(ctx context.Context, key string, fromTimestamp int, toTimestamp int)) *MockCmdable_TSRevRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(int)) + }) + return _c +} + +func (_c *MockCmdable_TSRevRange_Call) Return(_a0 *redis.TSTimestampValueSliceCmd) *MockCmdable_TSRevRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSRevRange_Call) RunAndReturn(run func(context.Context, string, int, int) *redis.TSTimestampValueSliceCmd) *MockCmdable_TSRevRange_Call { + _c.Call.Return(run) + return _c +} + +// TSRevRangeWithArgs provides a mock function with given fields: ctx, key, fromTimestamp, toTimestamp, options +func (_m *MockCmdable) TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd { + ret := _m.Called(ctx, key, fromTimestamp, toTimestamp, options) + + if len(ret) == 0 { + panic("no return value specified for TSRevRangeWithArgs") + } + + var r0 *redis.TSTimestampValueSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int, int, *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd); ok { + r0 = rf(ctx, key, fromTimestamp, toTimestamp, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TSTimestampValueSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TSRevRangeWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TSRevRangeWithArgs' +type MockCmdable_TSRevRangeWithArgs_Call struct { + *mock.Call +} + +// TSRevRangeWithArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fromTimestamp int +// - toTimestamp int +// - options *redis.TSRevRangeOptions +func (_e *MockCmdable_Expecter) TSRevRangeWithArgs(ctx interface{}, key interface{}, fromTimestamp interface{}, toTimestamp interface{}, options interface{}) *MockCmdable_TSRevRangeWithArgs_Call { + return &MockCmdable_TSRevRangeWithArgs_Call{Call: _e.mock.On("TSRevRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options)} +} + +func (_c *MockCmdable_TSRevRangeWithArgs_Call) Run(run func(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *redis.TSRevRangeOptions)) *MockCmdable_TSRevRangeWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(int), args[4].(*redis.TSRevRangeOptions)) + }) + return _c +} + +func (_c *MockCmdable_TSRevRangeWithArgs_Call) Return(_a0 *redis.TSTimestampValueSliceCmd) *MockCmdable_TSRevRangeWithArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TSRevRangeWithArgs_Call) RunAndReturn(run func(context.Context, string, int, int, *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd) *MockCmdable_TSRevRangeWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// TTL provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TTL(ctx context.Context, key string) *redis.DurationCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TTL") + } + + var r0 *redis.DurationCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.DurationCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.DurationCmd) + } + } + + return r0 +} + +// MockCmdable_TTL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TTL' +type MockCmdable_TTL_Call struct { + *mock.Call +} + +// TTL is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TTL(ctx interface{}, key interface{}) *MockCmdable_TTL_Call { + return &MockCmdable_TTL_Call{Call: _e.mock.On("TTL", ctx, key)} +} + +func (_c *MockCmdable_TTL_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TTL_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TTL_Call) Return(_a0 *redis.DurationCmd) *MockCmdable_TTL_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TTL_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *MockCmdable_TTL_Call { + _c.Call.Return(run) + return _c +} + +// Time provides a mock function with given fields: ctx +func (_m *MockCmdable) Time(ctx context.Context) *redis.TimeCmd { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Time") + } + + var r0 *redis.TimeCmd + if rf, ok := ret.Get(0).(func(context.Context) *redis.TimeCmd); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TimeCmd) + } + } + + return r0 +} + +// MockCmdable_Time_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Time' +type MockCmdable_Time_Call struct { + *mock.Call +} + +// Time is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockCmdable_Expecter) Time(ctx interface{}) *MockCmdable_Time_Call { + return &MockCmdable_Time_Call{Call: _e.mock.On("Time", ctx)} +} + +func (_c *MockCmdable_Time_Call) Run(run func(ctx context.Context)) *MockCmdable_Time_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockCmdable_Time_Call) Return(_a0 *redis.TimeCmd) *MockCmdable_Time_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Time_Call) RunAndReturn(run func(context.Context) *redis.TimeCmd) *MockCmdable_Time_Call { + _c.Call.Return(run) + return _c +} + +// TopKAdd provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) TopKAdd(ctx context.Context, key string, elements ...interface{}) *redis.StringSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TopKAdd") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TopKAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKAdd' +type MockCmdable_TopKAdd_Call struct { + *mock.Call +} + +// TopKAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) TopKAdd(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_TopKAdd_Call { + return &MockCmdable_TopKAdd_Call{Call: _e.mock.On("TopKAdd", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_TopKAdd_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_TopKAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TopKAdd_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_TopKAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.StringSliceCmd) *MockCmdable_TopKAdd_Call { + _c.Call.Return(run) + return _c +} + +// TopKCount provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) TopKCount(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TopKCount") + } + + var r0 *redis.IntSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TopKCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKCount' +type MockCmdable_TopKCount_Call struct { + *mock.Call +} + +// TopKCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) TopKCount(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_TopKCount_Call { + return &MockCmdable_TopKCount_Call{Call: _e.mock.On("TopKCount", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_TopKCount_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_TopKCount_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TopKCount_Call) Return(_a0 *redis.IntSliceCmd) *MockCmdable_TopKCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKCount_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntSliceCmd) *MockCmdable_TopKCount_Call { + _c.Call.Return(run) + return _c +} + +// TopKIncrBy provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) TopKIncrBy(ctx context.Context, key string, elements ...interface{}) *redis.StringSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TopKIncrBy") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TopKIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKIncrBy' +type MockCmdable_TopKIncrBy_Call struct { + *mock.Call +} + +// TopKIncrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) TopKIncrBy(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_TopKIncrBy_Call { + return &MockCmdable_TopKIncrBy_Call{Call: _e.mock.On("TopKIncrBy", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_TopKIncrBy_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_TopKIncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TopKIncrBy_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_TopKIncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKIncrBy_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.StringSliceCmd) *MockCmdable_TopKIncrBy_Call { + _c.Call.Return(run) + return _c +} + +// TopKInfo provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TopKInfo") + } + + var r0 *redis.TopKInfoCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.TopKInfoCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.TopKInfoCmd) + } + } + + return r0 +} + +// MockCmdable_TopKInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKInfo' +type MockCmdable_TopKInfo_Call struct { + *mock.Call +} + +// TopKInfo is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TopKInfo(ctx interface{}, key interface{}) *MockCmdable_TopKInfo_Call { + return &MockCmdable_TopKInfo_Call{Call: _e.mock.On("TopKInfo", ctx, key)} +} + +func (_c *MockCmdable_TopKInfo_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TopKInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TopKInfo_Call) Return(_a0 *redis.TopKInfoCmd) *MockCmdable_TopKInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKInfo_Call) RunAndReturn(run func(context.Context, string) *redis.TopKInfoCmd) *MockCmdable_TopKInfo_Call { + _c.Call.Return(run) + return _c +} + +// TopKList provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TopKList(ctx context.Context, key string) *redis.StringSliceCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TopKList") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TopKList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKList' +type MockCmdable_TopKList_Call struct { + *mock.Call +} + +// TopKList is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TopKList(ctx interface{}, key interface{}) *MockCmdable_TopKList_Call { + return &MockCmdable_TopKList_Call{Call: _e.mock.On("TopKList", ctx, key)} +} + +func (_c *MockCmdable_TopKList_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TopKList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TopKList_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_TopKList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKList_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *MockCmdable_TopKList_Call { + _c.Call.Return(run) + return _c +} + +// TopKListWithCount provides a mock function with given fields: ctx, key +func (_m *MockCmdable) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for TopKListWithCount") + } + + var r0 *redis.MapStringIntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.MapStringIntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.MapStringIntCmd) + } + } + + return r0 +} + +// MockCmdable_TopKListWithCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKListWithCount' +type MockCmdable_TopKListWithCount_Call struct { + *mock.Call +} + +// TopKListWithCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) TopKListWithCount(ctx interface{}, key interface{}) *MockCmdable_TopKListWithCount_Call { + return &MockCmdable_TopKListWithCount_Call{Call: _e.mock.On("TopKListWithCount", ctx, key)} +} + +func (_c *MockCmdable_TopKListWithCount_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_TopKListWithCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_TopKListWithCount_Call) Return(_a0 *redis.MapStringIntCmd) *MockCmdable_TopKListWithCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKListWithCount_Call) RunAndReturn(run func(context.Context, string) *redis.MapStringIntCmd) *MockCmdable_TopKListWithCount_Call { + _c.Call.Return(run) + return _c +} + +// TopKQuery provides a mock function with given fields: ctx, key, elements +func (_m *MockCmdable) TopKQuery(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, elements...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TopKQuery") + } + + var r0 *redis.BoolSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.BoolSliceCmd); ok { + r0 = rf(ctx, key, elements...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.BoolSliceCmd) + } + } + + return r0 +} + +// MockCmdable_TopKQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKQuery' +type MockCmdable_TopKQuery_Call struct { + *mock.Call +} + +// TopKQuery is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - elements ...interface{} +func (_e *MockCmdable_Expecter) TopKQuery(ctx interface{}, key interface{}, elements ...interface{}) *MockCmdable_TopKQuery_Call { + return &MockCmdable_TopKQuery_Call{Call: _e.mock.On("TopKQuery", + append([]interface{}{ctx, key}, elements...)...)} +} + +func (_c *MockCmdable_TopKQuery_Call) Run(run func(ctx context.Context, key string, elements ...interface{})) *MockCmdable_TopKQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_TopKQuery_Call) Return(_a0 *redis.BoolSliceCmd) *MockCmdable_TopKQuery_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKQuery_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolSliceCmd) *MockCmdable_TopKQuery_Call { + _c.Call.Return(run) + return _c +} + +// TopKReserve provides a mock function with given fields: ctx, key, k +func (_m *MockCmdable) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd { + ret := _m.Called(ctx, key, k) + + if len(ret) == 0 { + panic("no return value specified for TopKReserve") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, k) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TopKReserve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKReserve' +type MockCmdable_TopKReserve_Call struct { + *mock.Call +} + +// TopKReserve is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - k int64 +func (_e *MockCmdable_Expecter) TopKReserve(ctx interface{}, key interface{}, k interface{}) *MockCmdable_TopKReserve_Call { + return &MockCmdable_TopKReserve_Call{Call: _e.mock.On("TopKReserve", ctx, key, k)} +} + +func (_c *MockCmdable_TopKReserve_Call) Run(run func(ctx context.Context, key string, k int64)) *MockCmdable_TopKReserve_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_TopKReserve_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TopKReserve_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKReserve_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StatusCmd) *MockCmdable_TopKReserve_Call { + _c.Call.Return(run) + return _c +} + +// TopKReserveWithOptions provides a mock function with given fields: ctx, key, k, width, depth, decay +func (_m *MockCmdable) TopKReserveWithOptions(ctx context.Context, key string, k int64, width int64, depth int64, decay float64) *redis.StatusCmd { + ret := _m.Called(ctx, key, k, width, depth, decay) + + if len(ret) == 0 { + panic("no return value specified for TopKReserveWithOptions") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64, int64, float64) *redis.StatusCmd); ok { + r0 = rf(ctx, key, k, width, depth, decay) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_TopKReserveWithOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopKReserveWithOptions' +type MockCmdable_TopKReserveWithOptions_Call struct { + *mock.Call +} + +// TopKReserveWithOptions is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - k int64 +// - width int64 +// - depth int64 +// - decay float64 +func (_e *MockCmdable_Expecter) TopKReserveWithOptions(ctx interface{}, key interface{}, k interface{}, width interface{}, depth interface{}, decay interface{}) *MockCmdable_TopKReserveWithOptions_Call { + return &MockCmdable_TopKReserveWithOptions_Call{Call: _e.mock.On("TopKReserveWithOptions", ctx, key, k, width, depth, decay)} +} + +func (_c *MockCmdable_TopKReserveWithOptions_Call) Run(run func(ctx context.Context, key string, k int64, width int64, depth int64, decay float64)) *MockCmdable_TopKReserveWithOptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64), args[4].(int64), args[5].(float64)) + }) + return _c +} + +func (_c *MockCmdable_TopKReserveWithOptions_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_TopKReserveWithOptions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TopKReserveWithOptions_Call) RunAndReturn(run func(context.Context, string, int64, int64, int64, float64) *redis.StatusCmd) *MockCmdable_TopKReserveWithOptions_Call { + _c.Call.Return(run) + return _c +} + +// Touch provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) Touch(ctx context.Context, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Touch") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Touch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Touch' +type MockCmdable_Touch_Call struct { + *mock.Call +} + +// Touch is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) Touch(ctx interface{}, keys ...interface{}) *MockCmdable_Touch_Call { + return &MockCmdable_Touch_Call{Call: _e.mock.On("Touch", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_Touch_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_Touch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_Touch_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Touch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Touch_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *MockCmdable_Touch_Call { + _c.Call.Return(run) + return _c +} + +// TxPipeline provides a mock function with given fields: +func (_m *MockCmdable) TxPipeline() redis.Pipeliner { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for TxPipeline") + } + + var r0 redis.Pipeliner + if rf, ok := ret.Get(0).(func() redis.Pipeliner); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(redis.Pipeliner) + } + } + + return r0 +} + +// MockCmdable_TxPipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxPipeline' +type MockCmdable_TxPipeline_Call struct { + *mock.Call +} + +// TxPipeline is a helper method to define mock.On call +func (_e *MockCmdable_Expecter) TxPipeline() *MockCmdable_TxPipeline_Call { + return &MockCmdable_TxPipeline_Call{Call: _e.mock.On("TxPipeline")} +} + +func (_c *MockCmdable_TxPipeline_Call) Run(run func()) *MockCmdable_TxPipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockCmdable_TxPipeline_Call) Return(_a0 redis.Pipeliner) *MockCmdable_TxPipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_TxPipeline_Call) RunAndReturn(run func() redis.Pipeliner) *MockCmdable_TxPipeline_Call { + _c.Call.Return(run) + return _c +} + +// TxPipelined provides a mock function with given fields: ctx, fn +func (_m *MockCmdable) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + ret := _m.Called(ctx, fn) + + if len(ret) == 0 { + panic("no return value specified for TxPipelined") + } + + var r0 []redis.Cmder + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, func(redis.Pipeliner) error) ([]redis.Cmder, error)); ok { + return rf(ctx, fn) + } + if rf, ok := ret.Get(0).(func(context.Context, func(redis.Pipeliner) error) []redis.Cmder); ok { + r0 = rf(ctx, fn) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]redis.Cmder) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, func(redis.Pipeliner) error) error); ok { + r1 = rf(ctx, fn) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockCmdable_TxPipelined_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxPipelined' +type MockCmdable_TxPipelined_Call struct { + *mock.Call +} + +// TxPipelined is a helper method to define mock.On call +// - ctx context.Context +// - fn func(redis.Pipeliner) error +func (_e *MockCmdable_Expecter) TxPipelined(ctx interface{}, fn interface{}) *MockCmdable_TxPipelined_Call { + return &MockCmdable_TxPipelined_Call{Call: _e.mock.On("TxPipelined", ctx, fn)} +} + +func (_c *MockCmdable_TxPipelined_Call) Run(run func(ctx context.Context, fn func(redis.Pipeliner) error)) *MockCmdable_TxPipelined_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(func(redis.Pipeliner) error)) + }) + return _c +} + +func (_c *MockCmdable_TxPipelined_Call) Return(_a0 []redis.Cmder, _a1 error) *MockCmdable_TxPipelined_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockCmdable_TxPipelined_Call) RunAndReturn(run func(context.Context, func(redis.Pipeliner) error) ([]redis.Cmder, error)) *MockCmdable_TxPipelined_Call { + _c.Call.Return(run) + return _c +} + +// Type provides a mock function with given fields: ctx, key +func (_m *MockCmdable) Type(ctx context.Context, key string) *redis.StatusCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Type") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.StatusCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type' +type MockCmdable_Type_Call struct { + *mock.Call +} + +// Type is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) Type(ctx interface{}, key interface{}) *MockCmdable_Type_Call { + return &MockCmdable_Type_Call{Call: _e.mock.On("Type", ctx, key)} +} + +func (_c *MockCmdable_Type_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_Type_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_Type_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_Type_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Type_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *MockCmdable_Type_Call { + _c.Call.Return(run) + return _c +} + +// Unlink provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Unlink") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_Unlink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unlink' +type MockCmdable_Unlink_Call struct { + *mock.Call +} + +// Unlink is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) Unlink(ctx interface{}, keys ...interface{}) *MockCmdable_Unlink_Call { + return &MockCmdable_Unlink_Call{Call: _e.mock.On("Unlink", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_Unlink_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_Unlink_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_Unlink_Call) Return(_a0 *redis.IntCmd) *MockCmdable_Unlink_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_Unlink_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *MockCmdable_Unlink_Call { + _c.Call.Return(run) + return _c +} + +// XAck provides a mock function with given fields: ctx, stream, group, ids +func (_m *MockCmdable) XAck(ctx context.Context, stream string, group string, ids ...string) *redis.IntCmd { + _va := make([]interface{}, len(ids)) + for _i := range ids { + _va[_i] = ids[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, stream, group) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for XAck") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, stream, group, ids...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XAck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XAck' +type MockCmdable_XAck_Call struct { + *mock.Call +} + +// XAck is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +// - ids ...string +func (_e *MockCmdable_Expecter) XAck(ctx interface{}, stream interface{}, group interface{}, ids ...interface{}) *MockCmdable_XAck_Call { + return &MockCmdable_XAck_Call{Call: _e.mock.On("XAck", + append([]interface{}{ctx, stream, group}, ids...)...)} +} + +func (_c *MockCmdable_XAck_Call) Run(run func(ctx context.Context, stream string, group string, ids ...string)) *MockCmdable_XAck_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_XAck_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XAck_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XAck_Call) RunAndReturn(run func(context.Context, string, string, ...string) *redis.IntCmd) *MockCmdable_XAck_Call { + _c.Call.Return(run) + return _c +} + +// XAdd provides a mock function with given fields: ctx, a +func (_m *MockCmdable) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd { + ret := _m.Called(ctx, a) + + if len(ret) == 0 { + panic("no return value specified for XAdd") + } + + var r0 *redis.StringCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.XAddArgs) *redis.StringCmd); ok { + r0 = rf(ctx, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringCmd) + } + } + + return r0 +} + +// MockCmdable_XAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XAdd' +type MockCmdable_XAdd_Call struct { + *mock.Call +} + +// XAdd is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XAddArgs +func (_e *MockCmdable_Expecter) XAdd(ctx interface{}, a interface{}) *MockCmdable_XAdd_Call { + return &MockCmdable_XAdd_Call{Call: _e.mock.On("XAdd", ctx, a)} +} + +func (_c *MockCmdable_XAdd_Call) Run(run func(ctx context.Context, a *redis.XAddArgs)) *MockCmdable_XAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XAddArgs)) + }) + return _c +} + +func (_c *MockCmdable_XAdd_Call) Return(_a0 *redis.StringCmd) *MockCmdable_XAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XAdd_Call) RunAndReturn(run func(context.Context, *redis.XAddArgs) *redis.StringCmd) *MockCmdable_XAdd_Call { + _c.Call.Return(run) + return _c +} + +// XAutoClaim provides a mock function with given fields: ctx, a +func (_m *MockCmdable) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { + ret := _m.Called(ctx, a) + + if len(ret) == 0 { + panic("no return value specified for XAutoClaim") + } + + var r0 *redis.XAutoClaimCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.XAutoClaimArgs) *redis.XAutoClaimCmd); ok { + r0 = rf(ctx, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XAutoClaimCmd) + } + } + + return r0 +} + +// MockCmdable_XAutoClaim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XAutoClaim' +type MockCmdable_XAutoClaim_Call struct { + *mock.Call +} + +// XAutoClaim is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XAutoClaimArgs +func (_e *MockCmdable_Expecter) XAutoClaim(ctx interface{}, a interface{}) *MockCmdable_XAutoClaim_Call { + return &MockCmdable_XAutoClaim_Call{Call: _e.mock.On("XAutoClaim", ctx, a)} +} + +func (_c *MockCmdable_XAutoClaim_Call) Run(run func(ctx context.Context, a *redis.XAutoClaimArgs)) *MockCmdable_XAutoClaim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XAutoClaimArgs)) + }) + return _c +} + +func (_c *MockCmdable_XAutoClaim_Call) Return(_a0 *redis.XAutoClaimCmd) *MockCmdable_XAutoClaim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XAutoClaim_Call) RunAndReturn(run func(context.Context, *redis.XAutoClaimArgs) *redis.XAutoClaimCmd) *MockCmdable_XAutoClaim_Call { + _c.Call.Return(run) + return _c +} + +// XAutoClaimJustID provides a mock function with given fields: ctx, a +func (_m *MockCmdable) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { + ret := _m.Called(ctx, a) + + if len(ret) == 0 { + panic("no return value specified for XAutoClaimJustID") + } + + var r0 *redis.XAutoClaimJustIDCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd); ok { + r0 = rf(ctx, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XAutoClaimJustIDCmd) + } + } + + return r0 +} + +// MockCmdable_XAutoClaimJustID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XAutoClaimJustID' +type MockCmdable_XAutoClaimJustID_Call struct { + *mock.Call +} + +// XAutoClaimJustID is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XAutoClaimArgs +func (_e *MockCmdable_Expecter) XAutoClaimJustID(ctx interface{}, a interface{}) *MockCmdable_XAutoClaimJustID_Call { + return &MockCmdable_XAutoClaimJustID_Call{Call: _e.mock.On("XAutoClaimJustID", ctx, a)} +} + +func (_c *MockCmdable_XAutoClaimJustID_Call) Run(run func(ctx context.Context, a *redis.XAutoClaimArgs)) *MockCmdable_XAutoClaimJustID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XAutoClaimArgs)) + }) + return _c +} + +func (_c *MockCmdable_XAutoClaimJustID_Call) Return(_a0 *redis.XAutoClaimJustIDCmd) *MockCmdable_XAutoClaimJustID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XAutoClaimJustID_Call) RunAndReturn(run func(context.Context, *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd) *MockCmdable_XAutoClaimJustID_Call { + _c.Call.Return(run) + return _c +} + +// XClaim provides a mock function with given fields: ctx, a +func (_m *MockCmdable) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd { + ret := _m.Called(ctx, a) + + if len(ret) == 0 { + panic("no return value specified for XClaim") + } + + var r0 *redis.XMessageSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.XClaimArgs) *redis.XMessageSliceCmd); ok { + r0 = rf(ctx, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XMessageSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XClaim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XClaim' +type MockCmdable_XClaim_Call struct { + *mock.Call +} + +// XClaim is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XClaimArgs +func (_e *MockCmdable_Expecter) XClaim(ctx interface{}, a interface{}) *MockCmdable_XClaim_Call { + return &MockCmdable_XClaim_Call{Call: _e.mock.On("XClaim", ctx, a)} +} + +func (_c *MockCmdable_XClaim_Call) Run(run func(ctx context.Context, a *redis.XClaimArgs)) *MockCmdable_XClaim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XClaimArgs)) + }) + return _c +} + +func (_c *MockCmdable_XClaim_Call) Return(_a0 *redis.XMessageSliceCmd) *MockCmdable_XClaim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XClaim_Call) RunAndReturn(run func(context.Context, *redis.XClaimArgs) *redis.XMessageSliceCmd) *MockCmdable_XClaim_Call { + _c.Call.Return(run) + return _c +} + +// XClaimJustID provides a mock function with given fields: ctx, a +func (_m *MockCmdable) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd { + ret := _m.Called(ctx, a) + + if len(ret) == 0 { + panic("no return value specified for XClaimJustID") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.XClaimArgs) *redis.StringSliceCmd); ok { + r0 = rf(ctx, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XClaimJustID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XClaimJustID' +type MockCmdable_XClaimJustID_Call struct { + *mock.Call +} + +// XClaimJustID is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XClaimArgs +func (_e *MockCmdable_Expecter) XClaimJustID(ctx interface{}, a interface{}) *MockCmdable_XClaimJustID_Call { + return &MockCmdable_XClaimJustID_Call{Call: _e.mock.On("XClaimJustID", ctx, a)} +} + +func (_c *MockCmdable_XClaimJustID_Call) Run(run func(ctx context.Context, a *redis.XClaimArgs)) *MockCmdable_XClaimJustID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XClaimArgs)) + }) + return _c +} + +func (_c *MockCmdable_XClaimJustID_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_XClaimJustID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XClaimJustID_Call) RunAndReturn(run func(context.Context, *redis.XClaimArgs) *redis.StringSliceCmd) *MockCmdable_XClaimJustID_Call { + _c.Call.Return(run) + return _c +} + +// XDel provides a mock function with given fields: ctx, stream, ids +func (_m *MockCmdable) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd { + _va := make([]interface{}, len(ids)) + for _i := range ids { + _va[_i] = ids[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, stream) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for XDel") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, stream, ids...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XDel' +type MockCmdable_XDel_Call struct { + *mock.Call +} + +// XDel is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - ids ...string +func (_e *MockCmdable_Expecter) XDel(ctx interface{}, stream interface{}, ids ...interface{}) *MockCmdable_XDel_Call { + return &MockCmdable_XDel_Call{Call: _e.mock.On("XDel", + append([]interface{}{ctx, stream}, ids...)...)} +} + +func (_c *MockCmdable_XDel_Call) Run(run func(ctx context.Context, stream string, ids ...string)) *MockCmdable_XDel_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_XDel_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XDel_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_XDel_Call { + _c.Call.Return(run) + return _c +} + +// XGroupCreate provides a mock function with given fields: ctx, stream, group, start +func (_m *MockCmdable) XGroupCreate(ctx context.Context, stream string, group string, start string) *redis.StatusCmd { + ret := _m.Called(ctx, stream, group, start) + + if len(ret) == 0 { + panic("no return value specified for XGroupCreate") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, stream, group, start) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_XGroupCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupCreate' +type MockCmdable_XGroupCreate_Call struct { + *mock.Call +} + +// XGroupCreate is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +// - start string +func (_e *MockCmdable_Expecter) XGroupCreate(ctx interface{}, stream interface{}, group interface{}, start interface{}) *MockCmdable_XGroupCreate_Call { + return &MockCmdable_XGroupCreate_Call{Call: _e.mock.On("XGroupCreate", ctx, stream, group, start)} +} + +func (_c *MockCmdable_XGroupCreate_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *MockCmdable_XGroupCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_XGroupCreate_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_XGroupCreate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XGroupCreate_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *MockCmdable_XGroupCreate_Call { + _c.Call.Return(run) + return _c +} + +// XGroupCreateConsumer provides a mock function with given fields: ctx, stream, group, consumer +func (_m *MockCmdable) XGroupCreateConsumer(ctx context.Context, stream string, group string, consumer string) *redis.IntCmd { + ret := _m.Called(ctx, stream, group, consumer) + + if len(ret) == 0 { + panic("no return value specified for XGroupCreateConsumer") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, stream, group, consumer) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XGroupCreateConsumer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupCreateConsumer' +type MockCmdable_XGroupCreateConsumer_Call struct { + *mock.Call +} + +// XGroupCreateConsumer is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +// - consumer string +func (_e *MockCmdable_Expecter) XGroupCreateConsumer(ctx interface{}, stream interface{}, group interface{}, consumer interface{}) *MockCmdable_XGroupCreateConsumer_Call { + return &MockCmdable_XGroupCreateConsumer_Call{Call: _e.mock.On("XGroupCreateConsumer", ctx, stream, group, consumer)} +} + +func (_c *MockCmdable_XGroupCreateConsumer_Call) Run(run func(ctx context.Context, stream string, group string, consumer string)) *MockCmdable_XGroupCreateConsumer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_XGroupCreateConsumer_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XGroupCreateConsumer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XGroupCreateConsumer_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *MockCmdable_XGroupCreateConsumer_Call { + _c.Call.Return(run) + return _c +} + +// XGroupCreateMkStream provides a mock function with given fields: ctx, stream, group, start +func (_m *MockCmdable) XGroupCreateMkStream(ctx context.Context, stream string, group string, start string) *redis.StatusCmd { + ret := _m.Called(ctx, stream, group, start) + + if len(ret) == 0 { + panic("no return value specified for XGroupCreateMkStream") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, stream, group, start) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_XGroupCreateMkStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupCreateMkStream' +type MockCmdable_XGroupCreateMkStream_Call struct { + *mock.Call +} + +// XGroupCreateMkStream is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +// - start string +func (_e *MockCmdable_Expecter) XGroupCreateMkStream(ctx interface{}, stream interface{}, group interface{}, start interface{}) *MockCmdable_XGroupCreateMkStream_Call { + return &MockCmdable_XGroupCreateMkStream_Call{Call: _e.mock.On("XGroupCreateMkStream", ctx, stream, group, start)} +} + +func (_c *MockCmdable_XGroupCreateMkStream_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *MockCmdable_XGroupCreateMkStream_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_XGroupCreateMkStream_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_XGroupCreateMkStream_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XGroupCreateMkStream_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *MockCmdable_XGroupCreateMkStream_Call { + _c.Call.Return(run) + return _c +} + +// XGroupDelConsumer provides a mock function with given fields: ctx, stream, group, consumer +func (_m *MockCmdable) XGroupDelConsumer(ctx context.Context, stream string, group string, consumer string) *redis.IntCmd { + ret := _m.Called(ctx, stream, group, consumer) + + if len(ret) == 0 { + panic("no return value specified for XGroupDelConsumer") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, stream, group, consumer) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XGroupDelConsumer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupDelConsumer' +type MockCmdable_XGroupDelConsumer_Call struct { + *mock.Call +} + +// XGroupDelConsumer is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +// - consumer string +func (_e *MockCmdable_Expecter) XGroupDelConsumer(ctx interface{}, stream interface{}, group interface{}, consumer interface{}) *MockCmdable_XGroupDelConsumer_Call { + return &MockCmdable_XGroupDelConsumer_Call{Call: _e.mock.On("XGroupDelConsumer", ctx, stream, group, consumer)} +} + +func (_c *MockCmdable_XGroupDelConsumer_Call) Run(run func(ctx context.Context, stream string, group string, consumer string)) *MockCmdable_XGroupDelConsumer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_XGroupDelConsumer_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XGroupDelConsumer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XGroupDelConsumer_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *MockCmdable_XGroupDelConsumer_Call { + _c.Call.Return(run) + return _c +} + +// XGroupDestroy provides a mock function with given fields: ctx, stream, group +func (_m *MockCmdable) XGroupDestroy(ctx context.Context, stream string, group string) *redis.IntCmd { + ret := _m.Called(ctx, stream, group) + + if len(ret) == 0 { + panic("no return value specified for XGroupDestroy") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, stream, group) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XGroupDestroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupDestroy' +type MockCmdable_XGroupDestroy_Call struct { + *mock.Call +} + +// XGroupDestroy is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +func (_e *MockCmdable_Expecter) XGroupDestroy(ctx interface{}, stream interface{}, group interface{}) *MockCmdable_XGroupDestroy_Call { + return &MockCmdable_XGroupDestroy_Call{Call: _e.mock.On("XGroupDestroy", ctx, stream, group)} +} + +func (_c *MockCmdable_XGroupDestroy_Call) Run(run func(ctx context.Context, stream string, group string)) *MockCmdable_XGroupDestroy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_XGroupDestroy_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XGroupDestroy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XGroupDestroy_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_XGroupDestroy_Call { + _c.Call.Return(run) + return _c +} + +// XGroupSetID provides a mock function with given fields: ctx, stream, group, start +func (_m *MockCmdable) XGroupSetID(ctx context.Context, stream string, group string, start string) *redis.StatusCmd { + ret := _m.Called(ctx, stream, group, start) + + if len(ret) == 0 { + panic("no return value specified for XGroupSetID") + } + + var r0 *redis.StatusCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.StatusCmd); ok { + r0 = rf(ctx, stream, group, start) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StatusCmd) + } + } + + return r0 +} + +// MockCmdable_XGroupSetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupSetID' +type MockCmdable_XGroupSetID_Call struct { + *mock.Call +} + +// XGroupSetID is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +// - start string +func (_e *MockCmdable_Expecter) XGroupSetID(ctx interface{}, stream interface{}, group interface{}, start interface{}) *MockCmdable_XGroupSetID_Call { + return &MockCmdable_XGroupSetID_Call{Call: _e.mock.On("XGroupSetID", ctx, stream, group, start)} +} + +func (_c *MockCmdable_XGroupSetID_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *MockCmdable_XGroupSetID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_XGroupSetID_Call) Return(_a0 *redis.StatusCmd) *MockCmdable_XGroupSetID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XGroupSetID_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *MockCmdable_XGroupSetID_Call { + _c.Call.Return(run) + return _c +} + +// XInfoConsumers provides a mock function with given fields: ctx, key, group +func (_m *MockCmdable) XInfoConsumers(ctx context.Context, key string, group string) *redis.XInfoConsumersCmd { + ret := _m.Called(ctx, key, group) + + if len(ret) == 0 { + panic("no return value specified for XInfoConsumers") + } + + var r0 *redis.XInfoConsumersCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.XInfoConsumersCmd); ok { + r0 = rf(ctx, key, group) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XInfoConsumersCmd) + } + } + + return r0 +} + +// MockCmdable_XInfoConsumers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XInfoConsumers' +type MockCmdable_XInfoConsumers_Call struct { + *mock.Call +} + +// XInfoConsumers is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - group string +func (_e *MockCmdable_Expecter) XInfoConsumers(ctx interface{}, key interface{}, group interface{}) *MockCmdable_XInfoConsumers_Call { + return &MockCmdable_XInfoConsumers_Call{Call: _e.mock.On("XInfoConsumers", ctx, key, group)} +} + +func (_c *MockCmdable_XInfoConsumers_Call) Run(run func(ctx context.Context, key string, group string)) *MockCmdable_XInfoConsumers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_XInfoConsumers_Call) Return(_a0 *redis.XInfoConsumersCmd) *MockCmdable_XInfoConsumers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XInfoConsumers_Call) RunAndReturn(run func(context.Context, string, string) *redis.XInfoConsumersCmd) *MockCmdable_XInfoConsumers_Call { + _c.Call.Return(run) + return _c +} + +// XInfoGroups provides a mock function with given fields: ctx, key +func (_m *MockCmdable) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for XInfoGroups") + } + + var r0 *redis.XInfoGroupsCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.XInfoGroupsCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XInfoGroupsCmd) + } + } + + return r0 +} + +// MockCmdable_XInfoGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XInfoGroups' +type MockCmdable_XInfoGroups_Call struct { + *mock.Call +} + +// XInfoGroups is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) XInfoGroups(ctx interface{}, key interface{}) *MockCmdable_XInfoGroups_Call { + return &MockCmdable_XInfoGroups_Call{Call: _e.mock.On("XInfoGroups", ctx, key)} +} + +func (_c *MockCmdable_XInfoGroups_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_XInfoGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_XInfoGroups_Call) Return(_a0 *redis.XInfoGroupsCmd) *MockCmdable_XInfoGroups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XInfoGroups_Call) RunAndReturn(run func(context.Context, string) *redis.XInfoGroupsCmd) *MockCmdable_XInfoGroups_Call { + _c.Call.Return(run) + return _c +} + +// XInfoStream provides a mock function with given fields: ctx, key +func (_m *MockCmdable) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for XInfoStream") + } + + var r0 *redis.XInfoStreamCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.XInfoStreamCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XInfoStreamCmd) + } + } + + return r0 +} + +// MockCmdable_XInfoStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XInfoStream' +type MockCmdable_XInfoStream_Call struct { + *mock.Call +} + +// XInfoStream is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) XInfoStream(ctx interface{}, key interface{}) *MockCmdable_XInfoStream_Call { + return &MockCmdable_XInfoStream_Call{Call: _e.mock.On("XInfoStream", ctx, key)} +} + +func (_c *MockCmdable_XInfoStream_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_XInfoStream_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_XInfoStream_Call) Return(_a0 *redis.XInfoStreamCmd) *MockCmdable_XInfoStream_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XInfoStream_Call) RunAndReturn(run func(context.Context, string) *redis.XInfoStreamCmd) *MockCmdable_XInfoStream_Call { + _c.Call.Return(run) + return _c +} + +// XInfoStreamFull provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for XInfoStreamFull") + } + + var r0 *redis.XInfoStreamFullCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.XInfoStreamFullCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XInfoStreamFullCmd) + } + } + + return r0 +} + +// MockCmdable_XInfoStreamFull_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XInfoStreamFull' +type MockCmdable_XInfoStreamFull_Call struct { + *mock.Call +} + +// XInfoStreamFull is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *MockCmdable_Expecter) XInfoStreamFull(ctx interface{}, key interface{}, count interface{}) *MockCmdable_XInfoStreamFull_Call { + return &MockCmdable_XInfoStreamFull_Call{Call: _e.mock.On("XInfoStreamFull", ctx, key, count)} +} + +func (_c *MockCmdable_XInfoStreamFull_Call) Run(run func(ctx context.Context, key string, count int)) *MockCmdable_XInfoStreamFull_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_XInfoStreamFull_Call) Return(_a0 *redis.XInfoStreamFullCmd) *MockCmdable_XInfoStreamFull_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XInfoStreamFull_Call) RunAndReturn(run func(context.Context, string, int) *redis.XInfoStreamFullCmd) *MockCmdable_XInfoStreamFull_Call { + _c.Call.Return(run) + return _c +} + +// XLen provides a mock function with given fields: ctx, stream +func (_m *MockCmdable) XLen(ctx context.Context, stream string) *redis.IntCmd { + ret := _m.Called(ctx, stream) + + if len(ret) == 0 { + panic("no return value specified for XLen") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, stream) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XLen' +type MockCmdable_XLen_Call struct { + *mock.Call +} + +// XLen is a helper method to define mock.On call +// - ctx context.Context +// - stream string +func (_e *MockCmdable_Expecter) XLen(ctx interface{}, stream interface{}) *MockCmdable_XLen_Call { + return &MockCmdable_XLen_Call{Call: _e.mock.On("XLen", ctx, stream)} +} + +func (_c *MockCmdable_XLen_Call) Run(run func(ctx context.Context, stream string)) *MockCmdable_XLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_XLen_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_XLen_Call { + _c.Call.Return(run) + return _c +} + +// XPending provides a mock function with given fields: ctx, stream, group +func (_m *MockCmdable) XPending(ctx context.Context, stream string, group string) *redis.XPendingCmd { + ret := _m.Called(ctx, stream, group) + + if len(ret) == 0 { + panic("no return value specified for XPending") + } + + var r0 *redis.XPendingCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.XPendingCmd); ok { + r0 = rf(ctx, stream, group) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XPendingCmd) + } + } + + return r0 +} + +// MockCmdable_XPending_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XPending' +type MockCmdable_XPending_Call struct { + *mock.Call +} + +// XPending is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +func (_e *MockCmdable_Expecter) XPending(ctx interface{}, stream interface{}, group interface{}) *MockCmdable_XPending_Call { + return &MockCmdable_XPending_Call{Call: _e.mock.On("XPending", ctx, stream, group)} +} + +func (_c *MockCmdable_XPending_Call) Run(run func(ctx context.Context, stream string, group string)) *MockCmdable_XPending_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_XPending_Call) Return(_a0 *redis.XPendingCmd) *MockCmdable_XPending_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XPending_Call) RunAndReturn(run func(context.Context, string, string) *redis.XPendingCmd) *MockCmdable_XPending_Call { + _c.Call.Return(run) + return _c +} + +// XPendingExt provides a mock function with given fields: ctx, a +func (_m *MockCmdable) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd { + ret := _m.Called(ctx, a) + + if len(ret) == 0 { + panic("no return value specified for XPendingExt") + } + + var r0 *redis.XPendingExtCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.XPendingExtArgs) *redis.XPendingExtCmd); ok { + r0 = rf(ctx, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XPendingExtCmd) + } + } + + return r0 +} + +// MockCmdable_XPendingExt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XPendingExt' +type MockCmdable_XPendingExt_Call struct { + *mock.Call +} + +// XPendingExt is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XPendingExtArgs +func (_e *MockCmdable_Expecter) XPendingExt(ctx interface{}, a interface{}) *MockCmdable_XPendingExt_Call { + return &MockCmdable_XPendingExt_Call{Call: _e.mock.On("XPendingExt", ctx, a)} +} + +func (_c *MockCmdable_XPendingExt_Call) Run(run func(ctx context.Context, a *redis.XPendingExtArgs)) *MockCmdable_XPendingExt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XPendingExtArgs)) + }) + return _c +} + +func (_c *MockCmdable_XPendingExt_Call) Return(_a0 *redis.XPendingExtCmd) *MockCmdable_XPendingExt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XPendingExt_Call) RunAndReturn(run func(context.Context, *redis.XPendingExtArgs) *redis.XPendingExtCmd) *MockCmdable_XPendingExt_Call { + _c.Call.Return(run) + return _c +} + +// XRange provides a mock function with given fields: ctx, stream, start, stop +func (_m *MockCmdable) XRange(ctx context.Context, stream string, start string, stop string) *redis.XMessageSliceCmd { + ret := _m.Called(ctx, stream, start, stop) + + if len(ret) == 0 { + panic("no return value specified for XRange") + } + + var r0 *redis.XMessageSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.XMessageSliceCmd); ok { + r0 = rf(ctx, stream, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XMessageSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRange' +type MockCmdable_XRange_Call struct { + *mock.Call +} + +// XRange is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - start string +// - stop string +func (_e *MockCmdable_Expecter) XRange(ctx interface{}, stream interface{}, start interface{}, stop interface{}) *MockCmdable_XRange_Call { + return &MockCmdable_XRange_Call{Call: _e.mock.On("XRange", ctx, stream, start, stop)} +} + +func (_c *MockCmdable_XRange_Call) Run(run func(ctx context.Context, stream string, start string, stop string)) *MockCmdable_XRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_XRange_Call) Return(_a0 *redis.XMessageSliceCmd) *MockCmdable_XRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XRange_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.XMessageSliceCmd) *MockCmdable_XRange_Call { + _c.Call.Return(run) + return _c +} + +// XRangeN provides a mock function with given fields: ctx, stream, start, stop, count +func (_m *MockCmdable) XRangeN(ctx context.Context, stream string, start string, stop string, count int64) *redis.XMessageSliceCmd { + ret := _m.Called(ctx, stream, start, stop, count) + + if len(ret) == 0 { + panic("no return value specified for XRangeN") + } + + var r0 *redis.XMessageSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int64) *redis.XMessageSliceCmd); ok { + r0 = rf(ctx, stream, start, stop, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XMessageSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XRangeN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRangeN' +type MockCmdable_XRangeN_Call struct { + *mock.Call +} + +// XRangeN is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - start string +// - stop string +// - count int64 +func (_e *MockCmdable_Expecter) XRangeN(ctx interface{}, stream interface{}, start interface{}, stop interface{}, count interface{}) *MockCmdable_XRangeN_Call { + return &MockCmdable_XRangeN_Call{Call: _e.mock.On("XRangeN", ctx, stream, start, stop, count)} +} + +func (_c *MockCmdable_XRangeN_Call) Run(run func(ctx context.Context, stream string, start string, stop string, count int64)) *MockCmdable_XRangeN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int64)) + }) + return _c +} + +func (_c *MockCmdable_XRangeN_Call) Return(_a0 *redis.XMessageSliceCmd) *MockCmdable_XRangeN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XRangeN_Call) RunAndReturn(run func(context.Context, string, string, string, int64) *redis.XMessageSliceCmd) *MockCmdable_XRangeN_Call { + _c.Call.Return(run) + return _c +} + +// XRead provides a mock function with given fields: ctx, a +func (_m *MockCmdable) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd { + ret := _m.Called(ctx, a) + + if len(ret) == 0 { + panic("no return value specified for XRead") + } + + var r0 *redis.XStreamSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.XReadArgs) *redis.XStreamSliceCmd); ok { + r0 = rf(ctx, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XStreamSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRead' +type MockCmdable_XRead_Call struct { + *mock.Call +} + +// XRead is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XReadArgs +func (_e *MockCmdable_Expecter) XRead(ctx interface{}, a interface{}) *MockCmdable_XRead_Call { + return &MockCmdable_XRead_Call{Call: _e.mock.On("XRead", ctx, a)} +} + +func (_c *MockCmdable_XRead_Call) Run(run func(ctx context.Context, a *redis.XReadArgs)) *MockCmdable_XRead_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XReadArgs)) + }) + return _c +} + +func (_c *MockCmdable_XRead_Call) Return(_a0 *redis.XStreamSliceCmd) *MockCmdable_XRead_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XRead_Call) RunAndReturn(run func(context.Context, *redis.XReadArgs) *redis.XStreamSliceCmd) *MockCmdable_XRead_Call { + _c.Call.Return(run) + return _c +} + +// XReadGroup provides a mock function with given fields: ctx, a +func (_m *MockCmdable) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd { + ret := _m.Called(ctx, a) + + if len(ret) == 0 { + panic("no return value specified for XReadGroup") + } + + var r0 *redis.XStreamSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.XReadGroupArgs) *redis.XStreamSliceCmd); ok { + r0 = rf(ctx, a) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XStreamSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XReadGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XReadGroup' +type MockCmdable_XReadGroup_Call struct { + *mock.Call +} + +// XReadGroup is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XReadGroupArgs +func (_e *MockCmdable_Expecter) XReadGroup(ctx interface{}, a interface{}) *MockCmdable_XReadGroup_Call { + return &MockCmdable_XReadGroup_Call{Call: _e.mock.On("XReadGroup", ctx, a)} +} + +func (_c *MockCmdable_XReadGroup_Call) Run(run func(ctx context.Context, a *redis.XReadGroupArgs)) *MockCmdable_XReadGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XReadGroupArgs)) + }) + return _c +} + +func (_c *MockCmdable_XReadGroup_Call) Return(_a0 *redis.XStreamSliceCmd) *MockCmdable_XReadGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XReadGroup_Call) RunAndReturn(run func(context.Context, *redis.XReadGroupArgs) *redis.XStreamSliceCmd) *MockCmdable_XReadGroup_Call { + _c.Call.Return(run) + return _c +} + +// XReadStreams provides a mock function with given fields: ctx, streams +func (_m *MockCmdable) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd { + _va := make([]interface{}, len(streams)) + for _i := range streams { + _va[_i] = streams[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for XReadStreams") + } + + var r0 *redis.XStreamSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.XStreamSliceCmd); ok { + r0 = rf(ctx, streams...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XStreamSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XReadStreams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XReadStreams' +type MockCmdable_XReadStreams_Call struct { + *mock.Call +} + +// XReadStreams is a helper method to define mock.On call +// - ctx context.Context +// - streams ...string +func (_e *MockCmdable_Expecter) XReadStreams(ctx interface{}, streams ...interface{}) *MockCmdable_XReadStreams_Call { + return &MockCmdable_XReadStreams_Call{Call: _e.mock.On("XReadStreams", + append([]interface{}{ctx}, streams...)...)} +} + +func (_c *MockCmdable_XReadStreams_Call) Run(run func(ctx context.Context, streams ...string)) *MockCmdable_XReadStreams_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_XReadStreams_Call) Return(_a0 *redis.XStreamSliceCmd) *MockCmdable_XReadStreams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XReadStreams_Call) RunAndReturn(run func(context.Context, ...string) *redis.XStreamSliceCmd) *MockCmdable_XReadStreams_Call { + _c.Call.Return(run) + return _c +} + +// XRevRange provides a mock function with given fields: ctx, stream, start, stop +func (_m *MockCmdable) XRevRange(ctx context.Context, stream string, start string, stop string) *redis.XMessageSliceCmd { + ret := _m.Called(ctx, stream, start, stop) + + if len(ret) == 0 { + panic("no return value specified for XRevRange") + } + + var r0 *redis.XMessageSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.XMessageSliceCmd); ok { + r0 = rf(ctx, stream, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XMessageSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XRevRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRevRange' +type MockCmdable_XRevRange_Call struct { + *mock.Call +} + +// XRevRange is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - start string +// - stop string +func (_e *MockCmdable_Expecter) XRevRange(ctx interface{}, stream interface{}, start interface{}, stop interface{}) *MockCmdable_XRevRange_Call { + return &MockCmdable_XRevRange_Call{Call: _e.mock.On("XRevRange", ctx, stream, start, stop)} +} + +func (_c *MockCmdable_XRevRange_Call) Run(run func(ctx context.Context, stream string, start string, stop string)) *MockCmdable_XRevRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_XRevRange_Call) Return(_a0 *redis.XMessageSliceCmd) *MockCmdable_XRevRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XRevRange_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.XMessageSliceCmd) *MockCmdable_XRevRange_Call { + _c.Call.Return(run) + return _c +} + +// XRevRangeN provides a mock function with given fields: ctx, stream, start, stop, count +func (_m *MockCmdable) XRevRangeN(ctx context.Context, stream string, start string, stop string, count int64) *redis.XMessageSliceCmd { + ret := _m.Called(ctx, stream, start, stop, count) + + if len(ret) == 0 { + panic("no return value specified for XRevRangeN") + } + + var r0 *redis.XMessageSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int64) *redis.XMessageSliceCmd); ok { + r0 = rf(ctx, stream, start, stop, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.XMessageSliceCmd) + } + } + + return r0 +} + +// MockCmdable_XRevRangeN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRevRangeN' +type MockCmdable_XRevRangeN_Call struct { + *mock.Call +} + +// XRevRangeN is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - start string +// - stop string +// - count int64 +func (_e *MockCmdable_Expecter) XRevRangeN(ctx interface{}, stream interface{}, start interface{}, stop interface{}, count interface{}) *MockCmdable_XRevRangeN_Call { + return &MockCmdable_XRevRangeN_Call{Call: _e.mock.On("XRevRangeN", ctx, stream, start, stop, count)} +} + +func (_c *MockCmdable_XRevRangeN_Call) Run(run func(ctx context.Context, stream string, start string, stop string, count int64)) *MockCmdable_XRevRangeN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int64)) + }) + return _c +} + +func (_c *MockCmdable_XRevRangeN_Call) Return(_a0 *redis.XMessageSliceCmd) *MockCmdable_XRevRangeN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XRevRangeN_Call) RunAndReturn(run func(context.Context, string, string, string, int64) *redis.XMessageSliceCmd) *MockCmdable_XRevRangeN_Call { + _c.Call.Return(run) + return _c +} + +// XTrimMaxLen provides a mock function with given fields: ctx, key, maxLen +func (_m *MockCmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd { + ret := _m.Called(ctx, key, maxLen) + + if len(ret) == 0 { + panic("no return value specified for XTrimMaxLen") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, maxLen) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XTrimMaxLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimMaxLen' +type MockCmdable_XTrimMaxLen_Call struct { + *mock.Call +} + +// XTrimMaxLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - maxLen int64 +func (_e *MockCmdable_Expecter) XTrimMaxLen(ctx interface{}, key interface{}, maxLen interface{}) *MockCmdable_XTrimMaxLen_Call { + return &MockCmdable_XTrimMaxLen_Call{Call: _e.mock.On("XTrimMaxLen", ctx, key, maxLen)} +} + +func (_c *MockCmdable_XTrimMaxLen_Call) Run(run func(ctx context.Context, key string, maxLen int64)) *MockCmdable_XTrimMaxLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockCmdable_XTrimMaxLen_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XTrimMaxLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XTrimMaxLen_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *MockCmdable_XTrimMaxLen_Call { + _c.Call.Return(run) + return _c +} + +// XTrimMaxLenApprox provides a mock function with given fields: ctx, key, maxLen, limit +func (_m *MockCmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen int64, limit int64) *redis.IntCmd { + ret := _m.Called(ctx, key, maxLen, limit) + + if len(ret) == 0 { + panic("no return value specified for XTrimMaxLenApprox") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, maxLen, limit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XTrimMaxLenApprox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimMaxLenApprox' +type MockCmdable_XTrimMaxLenApprox_Call struct { + *mock.Call +} + +// XTrimMaxLenApprox is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - maxLen int64 +// - limit int64 +func (_e *MockCmdable_Expecter) XTrimMaxLenApprox(ctx interface{}, key interface{}, maxLen interface{}, limit interface{}) *MockCmdable_XTrimMaxLenApprox_Call { + return &MockCmdable_XTrimMaxLenApprox_Call{Call: _e.mock.On("XTrimMaxLenApprox", ctx, key, maxLen, limit)} +} + +func (_c *MockCmdable_XTrimMaxLenApprox_Call) Run(run func(ctx context.Context, key string, maxLen int64, limit int64)) *MockCmdable_XTrimMaxLenApprox_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_XTrimMaxLenApprox_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XTrimMaxLenApprox_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XTrimMaxLenApprox_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.IntCmd) *MockCmdable_XTrimMaxLenApprox_Call { + _c.Call.Return(run) + return _c +} + +// XTrimMinID provides a mock function with given fields: ctx, key, minID +func (_m *MockCmdable) XTrimMinID(ctx context.Context, key string, minID string) *redis.IntCmd { + ret := _m.Called(ctx, key, minID) + + if len(ret) == 0 { + panic("no return value specified for XTrimMinID") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, minID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XTrimMinID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimMinID' +type MockCmdable_XTrimMinID_Call struct { + *mock.Call +} + +// XTrimMinID is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - minID string +func (_e *MockCmdable_Expecter) XTrimMinID(ctx interface{}, key interface{}, minID interface{}) *MockCmdable_XTrimMinID_Call { + return &MockCmdable_XTrimMinID_Call{Call: _e.mock.On("XTrimMinID", ctx, key, minID)} +} + +func (_c *MockCmdable_XTrimMinID_Call) Run(run func(ctx context.Context, key string, minID string)) *MockCmdable_XTrimMinID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_XTrimMinID_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XTrimMinID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XTrimMinID_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_XTrimMinID_Call { + _c.Call.Return(run) + return _c +} + +// XTrimMinIDApprox provides a mock function with given fields: ctx, key, minID, limit +func (_m *MockCmdable) XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *redis.IntCmd { + ret := _m.Called(ctx, key, minID, limit) + + if len(ret) == 0 { + panic("no return value specified for XTrimMinIDApprox") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, minID, limit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_XTrimMinIDApprox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimMinIDApprox' +type MockCmdable_XTrimMinIDApprox_Call struct { + *mock.Call +} + +// XTrimMinIDApprox is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - minID string +// - limit int64 +func (_e *MockCmdable_Expecter) XTrimMinIDApprox(ctx interface{}, key interface{}, minID interface{}, limit interface{}) *MockCmdable_XTrimMinIDApprox_Call { + return &MockCmdable_XTrimMinIDApprox_Call{Call: _e.mock.On("XTrimMinIDApprox", ctx, key, minID, limit)} +} + +func (_c *MockCmdable_XTrimMinIDApprox_Call) Run(run func(ctx context.Context, key string, minID string, limit int64)) *MockCmdable_XTrimMinIDApprox_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_XTrimMinIDApprox_Call) Return(_a0 *redis.IntCmd) *MockCmdable_XTrimMinIDApprox_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_XTrimMinIDApprox_Call) RunAndReturn(run func(context.Context, string, string, int64) *redis.IntCmd) *MockCmdable_XTrimMinIDApprox_Call { + _c.Call.Return(run) + return _c +} + +// ZAdd provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) ZAdd(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + _va := make([]interface{}, len(members)) + for _i := range members { + _va[_i] = members[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZAdd") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...redis.Z) *redis.IntCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAdd' +type MockCmdable_ZAdd_Call struct { + *mock.Call +} + +// ZAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...redis.Z +func (_e *MockCmdable_Expecter) ZAdd(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_ZAdd_Call { + return &MockCmdable_ZAdd_Call{Call: _e.mock.On("ZAdd", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_ZAdd_Call) Run(run func(ctx context.Context, key string, members ...redis.Z)) *MockCmdable_ZAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]redis.Z, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(redis.Z) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZAdd_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZAdd_Call) RunAndReturn(run func(context.Context, string, ...redis.Z) *redis.IntCmd) *MockCmdable_ZAdd_Call { + _c.Call.Return(run) + return _c +} + +// ZAddArgs provides a mock function with given fields: ctx, key, args +func (_m *MockCmdable) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd { + ret := _m.Called(ctx, key, args) + + if len(ret) == 0 { + panic("no return value specified for ZAddArgs") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, redis.ZAddArgs) *redis.IntCmd); ok { + r0 = rf(ctx, key, args) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZAddArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddArgs' +type MockCmdable_ZAddArgs_Call struct { + *mock.Call +} + +// ZAddArgs is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - args redis.ZAddArgs +func (_e *MockCmdable_Expecter) ZAddArgs(ctx interface{}, key interface{}, args interface{}) *MockCmdable_ZAddArgs_Call { + return &MockCmdable_ZAddArgs_Call{Call: _e.mock.On("ZAddArgs", ctx, key, args)} +} + +func (_c *MockCmdable_ZAddArgs_Call) Run(run func(ctx context.Context, key string, args redis.ZAddArgs)) *MockCmdable_ZAddArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(redis.ZAddArgs)) + }) + return _c +} + +func (_c *MockCmdable_ZAddArgs_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZAddArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZAddArgs_Call) RunAndReturn(run func(context.Context, string, redis.ZAddArgs) *redis.IntCmd) *MockCmdable_ZAddArgs_Call { + _c.Call.Return(run) + return _c +} + +// ZAddArgsIncr provides a mock function with given fields: ctx, key, args +func (_m *MockCmdable) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd { + ret := _m.Called(ctx, key, args) + + if len(ret) == 0 { + panic("no return value specified for ZAddArgsIncr") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string, redis.ZAddArgs) *redis.FloatCmd); ok { + r0 = rf(ctx, key, args) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_ZAddArgsIncr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddArgsIncr' +type MockCmdable_ZAddArgsIncr_Call struct { + *mock.Call +} + +// ZAddArgsIncr is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - args redis.ZAddArgs +func (_e *MockCmdable_Expecter) ZAddArgsIncr(ctx interface{}, key interface{}, args interface{}) *MockCmdable_ZAddArgsIncr_Call { + return &MockCmdable_ZAddArgsIncr_Call{Call: _e.mock.On("ZAddArgsIncr", ctx, key, args)} +} + +func (_c *MockCmdable_ZAddArgsIncr_Call) Run(run func(ctx context.Context, key string, args redis.ZAddArgs)) *MockCmdable_ZAddArgsIncr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(redis.ZAddArgs)) + }) + return _c +} + +func (_c *MockCmdable_ZAddArgsIncr_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_ZAddArgsIncr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZAddArgsIncr_Call) RunAndReturn(run func(context.Context, string, redis.ZAddArgs) *redis.FloatCmd) *MockCmdable_ZAddArgsIncr_Call { + _c.Call.Return(run) + return _c +} + +// ZAddGT provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) ZAddGT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + _va := make([]interface{}, len(members)) + for _i := range members { + _va[_i] = members[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZAddGT") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...redis.Z) *redis.IntCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZAddGT_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddGT' +type MockCmdable_ZAddGT_Call struct { + *mock.Call +} + +// ZAddGT is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...redis.Z +func (_e *MockCmdable_Expecter) ZAddGT(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_ZAddGT_Call { + return &MockCmdable_ZAddGT_Call{Call: _e.mock.On("ZAddGT", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_ZAddGT_Call) Run(run func(ctx context.Context, key string, members ...redis.Z)) *MockCmdable_ZAddGT_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]redis.Z, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(redis.Z) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZAddGT_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZAddGT_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZAddGT_Call) RunAndReturn(run func(context.Context, string, ...redis.Z) *redis.IntCmd) *MockCmdable_ZAddGT_Call { + _c.Call.Return(run) + return _c +} + +// ZAddLT provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) ZAddLT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + _va := make([]interface{}, len(members)) + for _i := range members { + _va[_i] = members[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZAddLT") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...redis.Z) *redis.IntCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZAddLT_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddLT' +type MockCmdable_ZAddLT_Call struct { + *mock.Call +} + +// ZAddLT is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...redis.Z +func (_e *MockCmdable_Expecter) ZAddLT(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_ZAddLT_Call { + return &MockCmdable_ZAddLT_Call{Call: _e.mock.On("ZAddLT", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_ZAddLT_Call) Run(run func(ctx context.Context, key string, members ...redis.Z)) *MockCmdable_ZAddLT_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]redis.Z, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(redis.Z) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZAddLT_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZAddLT_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZAddLT_Call) RunAndReturn(run func(context.Context, string, ...redis.Z) *redis.IntCmd) *MockCmdable_ZAddLT_Call { + _c.Call.Return(run) + return _c +} + +// ZAddNX provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) ZAddNX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + _va := make([]interface{}, len(members)) + for _i := range members { + _va[_i] = members[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZAddNX") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...redis.Z) *redis.IntCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZAddNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddNX' +type MockCmdable_ZAddNX_Call struct { + *mock.Call +} + +// ZAddNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...redis.Z +func (_e *MockCmdable_Expecter) ZAddNX(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_ZAddNX_Call { + return &MockCmdable_ZAddNX_Call{Call: _e.mock.On("ZAddNX", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_ZAddNX_Call) Run(run func(ctx context.Context, key string, members ...redis.Z)) *MockCmdable_ZAddNX_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]redis.Z, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(redis.Z) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZAddNX_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZAddNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZAddNX_Call) RunAndReturn(run func(context.Context, string, ...redis.Z) *redis.IntCmd) *MockCmdable_ZAddNX_Call { + _c.Call.Return(run) + return _c +} + +// ZAddXX provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) ZAddXX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + _va := make([]interface{}, len(members)) + for _i := range members { + _va[_i] = members[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZAddXX") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...redis.Z) *redis.IntCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZAddXX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddXX' +type MockCmdable_ZAddXX_Call struct { + *mock.Call +} + +// ZAddXX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...redis.Z +func (_e *MockCmdable_Expecter) ZAddXX(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_ZAddXX_Call { + return &MockCmdable_ZAddXX_Call{Call: _e.mock.On("ZAddXX", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_ZAddXX_Call) Run(run func(ctx context.Context, key string, members ...redis.Z)) *MockCmdable_ZAddXX_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]redis.Z, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(redis.Z) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZAddXX_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZAddXX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZAddXX_Call) RunAndReturn(run func(context.Context, string, ...redis.Z) *redis.IntCmd) *MockCmdable_ZAddXX_Call { + _c.Call.Return(run) + return _c +} + +// ZCard provides a mock function with given fields: ctx, key +func (_m *MockCmdable) ZCard(ctx context.Context, key string) *redis.IntCmd { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for ZCard") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string) *redis.IntCmd); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZCard' +type MockCmdable_ZCard_Call struct { + *mock.Call +} + +// ZCard is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *MockCmdable_Expecter) ZCard(ctx interface{}, key interface{}) *MockCmdable_ZCard_Call { + return &MockCmdable_ZCard_Call{Call: _e.mock.On("ZCard", ctx, key)} +} + +func (_c *MockCmdable_ZCard_Call) Run(run func(ctx context.Context, key string)) *MockCmdable_ZCard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZCard_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZCard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZCard_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *MockCmdable_ZCard_Call { + _c.Call.Return(run) + return _c +} + +// ZCount provides a mock function with given fields: ctx, key, min, max +func (_m *MockCmdable) ZCount(ctx context.Context, key string, min string, max string) *redis.IntCmd { + ret := _m.Called(ctx, key, min, max) + + if len(ret) == 0 { + panic("no return value specified for ZCount") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, min, max) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZCount' +type MockCmdable_ZCount_Call struct { + *mock.Call +} + +// ZCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - min string +// - max string +func (_e *MockCmdable_Expecter) ZCount(ctx interface{}, key interface{}, min interface{}, max interface{}) *MockCmdable_ZCount_Call { + return &MockCmdable_ZCount_Call{Call: _e.mock.On("ZCount", ctx, key, min, max)} +} + +func (_c *MockCmdable_ZCount_Call) Run(run func(ctx context.Context, key string, min string, max string)) *MockCmdable_ZCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZCount_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZCount_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *MockCmdable_ZCount_Call { + _c.Call.Return(run) + return _c +} + +// ZDiff provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZDiff") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.StringSliceCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZDiff' +type MockCmdable_ZDiff_Call struct { + *mock.Call +} + +// ZDiff is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) ZDiff(ctx interface{}, keys ...interface{}) *MockCmdable_ZDiff_Call { + return &MockCmdable_ZDiff_Call{Call: _e.mock.On("ZDiff", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_ZDiff_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_ZDiff_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZDiff_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZDiff_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZDiff_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *MockCmdable_ZDiff_Call { + _c.Call.Return(run) + return _c +} + +// ZDiffStore provides a mock function with given fields: ctx, destination, keys +func (_m *MockCmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, destination) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZDiffStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, destination, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZDiffStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZDiffStore' +type MockCmdable_ZDiffStore_Call struct { + *mock.Call +} + +// ZDiffStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *MockCmdable_Expecter) ZDiffStore(ctx interface{}, destination interface{}, keys ...interface{}) *MockCmdable_ZDiffStore_Call { + return &MockCmdable_ZDiffStore_Call{Call: _e.mock.On("ZDiffStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *MockCmdable_ZDiffStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *MockCmdable_ZDiffStore_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZDiffStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZDiffStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZDiffStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *MockCmdable_ZDiffStore_Call { + _c.Call.Return(run) + return _c +} + +// ZDiffWithScores provides a mock function with given fields: ctx, keys +func (_m *MockCmdable) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZDiffWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, ...string) *redis.ZSliceCmd); ok { + r0 = rf(ctx, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZDiffWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZDiffWithScores' +type MockCmdable_ZDiffWithScores_Call struct { + *mock.Call +} + +// ZDiffWithScores is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *MockCmdable_Expecter) ZDiffWithScores(ctx interface{}, keys ...interface{}) *MockCmdable_ZDiffWithScores_Call { + return &MockCmdable_ZDiffWithScores_Call{Call: _e.mock.On("ZDiffWithScores", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *MockCmdable_ZDiffWithScores_Call) Run(run func(ctx context.Context, keys ...string)) *MockCmdable_ZDiffWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZDiffWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZDiffWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZDiffWithScores_Call) RunAndReturn(run func(context.Context, ...string) *redis.ZSliceCmd) *MockCmdable_ZDiffWithScores_Call { + _c.Call.Return(run) + return _c +} + +// ZIncrBy provides a mock function with given fields: ctx, key, increment, member +func (_m *MockCmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd { + ret := _m.Called(ctx, key, increment, member) + + if len(ret) == 0 { + panic("no return value specified for ZIncrBy") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string, float64, string) *redis.FloatCmd); ok { + r0 = rf(ctx, key, increment, member) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_ZIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZIncrBy' +type MockCmdable_ZIncrBy_Call struct { + *mock.Call +} + +// ZIncrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - increment float64 +// - member string +func (_e *MockCmdable_Expecter) ZIncrBy(ctx interface{}, key interface{}, increment interface{}, member interface{}) *MockCmdable_ZIncrBy_Call { + return &MockCmdable_ZIncrBy_Call{Call: _e.mock.On("ZIncrBy", ctx, key, increment, member)} +} + +func (_c *MockCmdable_ZIncrBy_Call) Run(run func(ctx context.Context, key string, increment float64, member string)) *MockCmdable_ZIncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZIncrBy_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_ZIncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZIncrBy_Call) RunAndReturn(run func(context.Context, string, float64, string) *redis.FloatCmd) *MockCmdable_ZIncrBy_Call { + _c.Call.Return(run) + return _c +} + +// ZInter provides a mock function with given fields: ctx, store +func (_m *MockCmdable) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd { + ret := _m.Called(ctx, store) + + if len(ret) == 0 { + panic("no return value specified for ZInter") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.ZStore) *redis.StringSliceCmd); ok { + r0 = rf(ctx, store) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZInter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZInter' +type MockCmdable_ZInter_Call struct { + *mock.Call +} + +// ZInter is a helper method to define mock.On call +// - ctx context.Context +// - store *redis.ZStore +func (_e *MockCmdable_Expecter) ZInter(ctx interface{}, store interface{}) *MockCmdable_ZInter_Call { + return &MockCmdable_ZInter_Call{Call: _e.mock.On("ZInter", ctx, store)} +} + +func (_c *MockCmdable_ZInter_Call) Run(run func(ctx context.Context, store *redis.ZStore)) *MockCmdable_ZInter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.ZStore)) + }) + return _c +} + +func (_c *MockCmdable_ZInter_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZInter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZInter_Call) RunAndReturn(run func(context.Context, *redis.ZStore) *redis.StringSliceCmd) *MockCmdable_ZInter_Call { + _c.Call.Return(run) + return _c +} + +// ZInterCard provides a mock function with given fields: ctx, limit, keys +func (_m *MockCmdable) ZInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, limit) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZInterCard") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, int64, ...string) *redis.IntCmd); ok { + r0 = rf(ctx, limit, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZInterCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZInterCard' +type MockCmdable_ZInterCard_Call struct { + *mock.Call +} + +// ZInterCard is a helper method to define mock.On call +// - ctx context.Context +// - limit int64 +// - keys ...string +func (_e *MockCmdable_Expecter) ZInterCard(ctx interface{}, limit interface{}, keys ...interface{}) *MockCmdable_ZInterCard_Call { + return &MockCmdable_ZInterCard_Call{Call: _e.mock.On("ZInterCard", + append([]interface{}{ctx, limit}, keys...)...)} +} + +func (_c *MockCmdable_ZInterCard_Call) Run(run func(ctx context.Context, limit int64, keys ...string)) *MockCmdable_ZInterCard_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(int64), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZInterCard_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZInterCard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZInterCard_Call) RunAndReturn(run func(context.Context, int64, ...string) *redis.IntCmd) *MockCmdable_ZInterCard_Call { + _c.Call.Return(run) + return _c +} + +// ZInterStore provides a mock function with given fields: ctx, destination, store +func (_m *MockCmdable) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd { + ret := _m.Called(ctx, destination, store) + + if len(ret) == 0 { + panic("no return value specified for ZInterStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.ZStore) *redis.IntCmd); ok { + r0 = rf(ctx, destination, store) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZInterStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZInterStore' +type MockCmdable_ZInterStore_Call struct { + *mock.Call +} + +// ZInterStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - store *redis.ZStore +func (_e *MockCmdable_Expecter) ZInterStore(ctx interface{}, destination interface{}, store interface{}) *MockCmdable_ZInterStore_Call { + return &MockCmdable_ZInterStore_Call{Call: _e.mock.On("ZInterStore", ctx, destination, store)} +} + +func (_c *MockCmdable_ZInterStore_Call) Run(run func(ctx context.Context, destination string, store *redis.ZStore)) *MockCmdable_ZInterStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.ZStore)) + }) + return _c +} + +func (_c *MockCmdable_ZInterStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZInterStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZInterStore_Call) RunAndReturn(run func(context.Context, string, *redis.ZStore) *redis.IntCmd) *MockCmdable_ZInterStore_Call { + _c.Call.Return(run) + return _c +} + +// ZInterWithScores provides a mock function with given fields: ctx, store +func (_m *MockCmdable) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd { + ret := _m.Called(ctx, store) + + if len(ret) == 0 { + panic("no return value specified for ZInterWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, *redis.ZStore) *redis.ZSliceCmd); ok { + r0 = rf(ctx, store) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZInterWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZInterWithScores' +type MockCmdable_ZInterWithScores_Call struct { + *mock.Call +} + +// ZInterWithScores is a helper method to define mock.On call +// - ctx context.Context +// - store *redis.ZStore +func (_e *MockCmdable_Expecter) ZInterWithScores(ctx interface{}, store interface{}) *MockCmdable_ZInterWithScores_Call { + return &MockCmdable_ZInterWithScores_Call{Call: _e.mock.On("ZInterWithScores", ctx, store)} +} + +func (_c *MockCmdable_ZInterWithScores_Call) Run(run func(ctx context.Context, store *redis.ZStore)) *MockCmdable_ZInterWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.ZStore)) + }) + return _c +} + +func (_c *MockCmdable_ZInterWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZInterWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZInterWithScores_Call) RunAndReturn(run func(context.Context, *redis.ZStore) *redis.ZSliceCmd) *MockCmdable_ZInterWithScores_Call { + _c.Call.Return(run) + return _c +} + +// ZLexCount provides a mock function with given fields: ctx, key, min, max +func (_m *MockCmdable) ZLexCount(ctx context.Context, key string, min string, max string) *redis.IntCmd { + ret := _m.Called(ctx, key, min, max) + + if len(ret) == 0 { + panic("no return value specified for ZLexCount") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, min, max) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZLexCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZLexCount' +type MockCmdable_ZLexCount_Call struct { + *mock.Call +} + +// ZLexCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - min string +// - max string +func (_e *MockCmdable_Expecter) ZLexCount(ctx interface{}, key interface{}, min interface{}, max interface{}) *MockCmdable_ZLexCount_Call { + return &MockCmdable_ZLexCount_Call{Call: _e.mock.On("ZLexCount", ctx, key, min, max)} +} + +func (_c *MockCmdable_ZLexCount_Call) Run(run func(ctx context.Context, key string, min string, max string)) *MockCmdable_ZLexCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZLexCount_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZLexCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZLexCount_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *MockCmdable_ZLexCount_Call { + _c.Call.Return(run) + return _c +} + +// ZMPop provides a mock function with given fields: ctx, order, count, keys +func (_m *MockCmdable) ZMPop(ctx context.Context, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + _va := make([]interface{}, len(keys)) + for _i := range keys { + _va[_i] = keys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, order, count) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZMPop") + } + + var r0 *redis.ZSliceWithKeyCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, ...string) *redis.ZSliceWithKeyCmd); ok { + r0 = rf(ctx, order, count, keys...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceWithKeyCmd) + } + } + + return r0 +} + +// MockCmdable_ZMPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZMPop' +type MockCmdable_ZMPop_Call struct { + *mock.Call +} + +// ZMPop is a helper method to define mock.On call +// - ctx context.Context +// - order string +// - count int64 +// - keys ...string +func (_e *MockCmdable_Expecter) ZMPop(ctx interface{}, order interface{}, count interface{}, keys ...interface{}) *MockCmdable_ZMPop_Call { + return &MockCmdable_ZMPop_Call{Call: _e.mock.On("ZMPop", + append([]interface{}{ctx, order, count}, keys...)...)} +} + +func (_c *MockCmdable_ZMPop_Call) Run(run func(ctx context.Context, order string, count int64, keys ...string)) *MockCmdable_ZMPop_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(int64), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZMPop_Call) Return(_a0 *redis.ZSliceWithKeyCmd) *MockCmdable_ZMPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZMPop_Call) RunAndReturn(run func(context.Context, string, int64, ...string) *redis.ZSliceWithKeyCmd) *MockCmdable_ZMPop_Call { + _c.Call.Return(run) + return _c +} + +// ZMScore provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd { + _va := make([]interface{}, len(members)) + for _i := range members { + _va[_i] = members[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZMScore") + } + + var r0 *redis.FloatSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *redis.FloatSliceCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZMScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZMScore' +type MockCmdable_ZMScore_Call struct { + *mock.Call +} + +// ZMScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...string +func (_e *MockCmdable_Expecter) ZMScore(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_ZMScore_Call { + return &MockCmdable_ZMScore_Call{Call: _e.mock.On("ZMScore", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_ZMScore_Call) Run(run func(ctx context.Context, key string, members ...string)) *MockCmdable_ZMScore_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZMScore_Call) Return(_a0 *redis.FloatSliceCmd) *MockCmdable_ZMScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZMScore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.FloatSliceCmd) *MockCmdable_ZMScore_Call { + _c.Call.Return(run) + return _c +} + +// ZPopMax provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + _va := make([]interface{}, len(count)) + for _i := range count { + _va[_i] = count[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZPopMax") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...int64) *redis.ZSliceCmd); ok { + r0 = rf(ctx, key, count...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZPopMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZPopMax' +type MockCmdable_ZPopMax_Call struct { + *mock.Call +} + +// ZPopMax is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count ...int64 +func (_e *MockCmdable_Expecter) ZPopMax(ctx interface{}, key interface{}, count ...interface{}) *MockCmdable_ZPopMax_Call { + return &MockCmdable_ZPopMax_Call{Call: _e.mock.On("ZPopMax", + append([]interface{}{ctx, key}, count...)...)} +} + +func (_c *MockCmdable_ZPopMax_Call) Run(run func(ctx context.Context, key string, count ...int64)) *MockCmdable_ZPopMax_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]int64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(int64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZPopMax_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZPopMax_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZPopMax_Call) RunAndReturn(run func(context.Context, string, ...int64) *redis.ZSliceCmd) *MockCmdable_ZPopMax_Call { + _c.Call.Return(run) + return _c +} + +// ZPopMin provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + _va := make([]interface{}, len(count)) + for _i := range count { + _va[_i] = count[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZPopMin") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...int64) *redis.ZSliceCmd); ok { + r0 = rf(ctx, key, count...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZPopMin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZPopMin' +type MockCmdable_ZPopMin_Call struct { + *mock.Call +} + +// ZPopMin is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count ...int64 +func (_e *MockCmdable_Expecter) ZPopMin(ctx interface{}, key interface{}, count ...interface{}) *MockCmdable_ZPopMin_Call { + return &MockCmdable_ZPopMin_Call{Call: _e.mock.On("ZPopMin", + append([]interface{}{ctx, key}, count...)...)} +} + +func (_c *MockCmdable_ZPopMin_Call) Run(run func(ctx context.Context, key string, count ...int64)) *MockCmdable_ZPopMin_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]int64, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(int64) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZPopMin_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZPopMin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZPopMin_Call) RunAndReturn(run func(context.Context, string, ...int64) *redis.ZSliceCmd) *MockCmdable_ZPopMin_Call { + _c.Call.Return(run) + return _c +} + +// ZRandMember provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) ZRandMember(ctx context.Context, key string, count int) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for ZRandMember") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRandMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRandMember' +type MockCmdable_ZRandMember_Call struct { + *mock.Call +} + +// ZRandMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *MockCmdable_Expecter) ZRandMember(ctx interface{}, key interface{}, count interface{}) *MockCmdable_ZRandMember_Call { + return &MockCmdable_ZRandMember_Call{Call: _e.mock.On("ZRandMember", ctx, key, count)} +} + +func (_c *MockCmdable_ZRandMember_Call) Run(run func(ctx context.Context, key string, count int)) *MockCmdable_ZRandMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_ZRandMember_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZRandMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRandMember_Call) RunAndReturn(run func(context.Context, string, int) *redis.StringSliceCmd) *MockCmdable_ZRandMember_Call { + _c.Call.Return(run) + return _c +} + +// ZRandMemberWithScores provides a mock function with given fields: ctx, key, count +func (_m *MockCmdable) ZRandMemberWithScores(ctx context.Context, key string, count int) *redis.ZSliceCmd { + ret := _m.Called(ctx, key, count) + + if len(ret) == 0 { + panic("no return value specified for ZRandMemberWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int) *redis.ZSliceCmd); ok { + r0 = rf(ctx, key, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRandMemberWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRandMemberWithScores' +type MockCmdable_ZRandMemberWithScores_Call struct { + *mock.Call +} + +// ZRandMemberWithScores is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *MockCmdable_Expecter) ZRandMemberWithScores(ctx interface{}, key interface{}, count interface{}) *MockCmdable_ZRandMemberWithScores_Call { + return &MockCmdable_ZRandMemberWithScores_Call{Call: _e.mock.On("ZRandMemberWithScores", ctx, key, count)} +} + +func (_c *MockCmdable_ZRandMemberWithScores_Call) Run(run func(ctx context.Context, key string, count int)) *MockCmdable_ZRandMemberWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *MockCmdable_ZRandMemberWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZRandMemberWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRandMemberWithScores_Call) RunAndReturn(run func(context.Context, string, int) *redis.ZSliceCmd) *MockCmdable_ZRandMemberWithScores_Call { + _c.Call.Return(run) + return _c +} + +// ZRange provides a mock function with given fields: ctx, key, start, stop +func (_m *MockCmdable) ZRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, start, stop) + + if len(ret) == 0 { + panic("no return value specified for ZRange") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRange' +type MockCmdable_ZRange_Call struct { + *mock.Call +} + +// ZRange is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - start int64 +// - stop int64 +func (_e *MockCmdable_Expecter) ZRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *MockCmdable_ZRange_Call { + return &MockCmdable_ZRange_Call{Call: _e.mock.On("ZRange", ctx, key, start, stop)} +} + +func (_c *MockCmdable_ZRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *MockCmdable_ZRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ZRange_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *MockCmdable_ZRange_Call { + _c.Call.Return(run) + return _c +} + +// ZRangeArgs provides a mock function with given fields: ctx, z +func (_m *MockCmdable) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd { + ret := _m.Called(ctx, z) + + if len(ret) == 0 { + panic("no return value specified for ZRangeArgs") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, redis.ZRangeArgs) *redis.StringSliceCmd); ok { + r0 = rf(ctx, z) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRangeArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeArgs' +type MockCmdable_ZRangeArgs_Call struct { + *mock.Call +} + +// ZRangeArgs is a helper method to define mock.On call +// - ctx context.Context +// - z redis.ZRangeArgs +func (_e *MockCmdable_Expecter) ZRangeArgs(ctx interface{}, z interface{}) *MockCmdable_ZRangeArgs_Call { + return &MockCmdable_ZRangeArgs_Call{Call: _e.mock.On("ZRangeArgs", ctx, z)} +} + +func (_c *MockCmdable_ZRangeArgs_Call) Run(run func(ctx context.Context, z redis.ZRangeArgs)) *MockCmdable_ZRangeArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZRangeArgs)) + }) + return _c +} + +func (_c *MockCmdable_ZRangeArgs_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZRangeArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRangeArgs_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) *redis.StringSliceCmd) *MockCmdable_ZRangeArgs_Call { + _c.Call.Return(run) + return _c +} + +// ZRangeArgsWithScores provides a mock function with given fields: ctx, z +func (_m *MockCmdable) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd { + ret := _m.Called(ctx, z) + + if len(ret) == 0 { + panic("no return value specified for ZRangeArgsWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, redis.ZRangeArgs) *redis.ZSliceCmd); ok { + r0 = rf(ctx, z) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRangeArgsWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeArgsWithScores' +type MockCmdable_ZRangeArgsWithScores_Call struct { + *mock.Call +} + +// ZRangeArgsWithScores is a helper method to define mock.On call +// - ctx context.Context +// - z redis.ZRangeArgs +func (_e *MockCmdable_Expecter) ZRangeArgsWithScores(ctx interface{}, z interface{}) *MockCmdable_ZRangeArgsWithScores_Call { + return &MockCmdable_ZRangeArgsWithScores_Call{Call: _e.mock.On("ZRangeArgsWithScores", ctx, z)} +} + +func (_c *MockCmdable_ZRangeArgsWithScores_Call) Run(run func(ctx context.Context, z redis.ZRangeArgs)) *MockCmdable_ZRangeArgsWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZRangeArgs)) + }) + return _c +} + +func (_c *MockCmdable_ZRangeArgsWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZRangeArgsWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRangeArgsWithScores_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) *redis.ZSliceCmd) *MockCmdable_ZRangeArgsWithScores_Call { + _c.Call.Return(run) + return _c +} + +// ZRangeByLex provides a mock function with given fields: ctx, key, opt +func (_m *MockCmdable) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, opt) + + if len(ret) == 0 { + panic("no return value specified for ZRangeByLex") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, opt) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRangeByLex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeByLex' +type MockCmdable_ZRangeByLex_Call struct { + *mock.Call +} + +// ZRangeByLex is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - opt *redis.ZRangeBy +func (_e *MockCmdable_Expecter) ZRangeByLex(ctx interface{}, key interface{}, opt interface{}) *MockCmdable_ZRangeByLex_Call { + return &MockCmdable_ZRangeByLex_Call{Call: _e.mock.On("ZRangeByLex", ctx, key, opt)} +} + +func (_c *MockCmdable_ZRangeByLex_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *MockCmdable_ZRangeByLex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.ZRangeBy)) + }) + return _c +} + +func (_c *MockCmdable_ZRangeByLex_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZRangeByLex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRangeByLex_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *MockCmdable_ZRangeByLex_Call { + _c.Call.Return(run) + return _c +} + +// ZRangeByScore provides a mock function with given fields: ctx, key, opt +func (_m *MockCmdable) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, opt) + + if len(ret) == 0 { + panic("no return value specified for ZRangeByScore") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, opt) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRangeByScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeByScore' +type MockCmdable_ZRangeByScore_Call struct { + *mock.Call +} + +// ZRangeByScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - opt *redis.ZRangeBy +func (_e *MockCmdable_Expecter) ZRangeByScore(ctx interface{}, key interface{}, opt interface{}) *MockCmdable_ZRangeByScore_Call { + return &MockCmdable_ZRangeByScore_Call{Call: _e.mock.On("ZRangeByScore", ctx, key, opt)} +} + +func (_c *MockCmdable_ZRangeByScore_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *MockCmdable_ZRangeByScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.ZRangeBy)) + }) + return _c +} + +func (_c *MockCmdable_ZRangeByScore_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZRangeByScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRangeByScore_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *MockCmdable_ZRangeByScore_Call { + _c.Call.Return(run) + return _c +} + +// ZRangeByScoreWithScores provides a mock function with given fields: ctx, key, opt +func (_m *MockCmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + ret := _m.Called(ctx, key, opt) + + if len(ret) == 0 { + panic("no return value specified for ZRangeByScoreWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.ZRangeBy) *redis.ZSliceCmd); ok { + r0 = rf(ctx, key, opt) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRangeByScoreWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeByScoreWithScores' +type MockCmdable_ZRangeByScoreWithScores_Call struct { + *mock.Call +} + +// ZRangeByScoreWithScores is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - opt *redis.ZRangeBy +func (_e *MockCmdable_Expecter) ZRangeByScoreWithScores(ctx interface{}, key interface{}, opt interface{}) *MockCmdable_ZRangeByScoreWithScores_Call { + return &MockCmdable_ZRangeByScoreWithScores_Call{Call: _e.mock.On("ZRangeByScoreWithScores", ctx, key, opt)} +} + +func (_c *MockCmdable_ZRangeByScoreWithScores_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *MockCmdable_ZRangeByScoreWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.ZRangeBy)) + }) + return _c +} + +func (_c *MockCmdable_ZRangeByScoreWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZRangeByScoreWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRangeByScoreWithScores_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.ZSliceCmd) *MockCmdable_ZRangeByScoreWithScores_Call { + _c.Call.Return(run) + return _c +} + +// ZRangeStore provides a mock function with given fields: ctx, dst, z +func (_m *MockCmdable) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd { + ret := _m.Called(ctx, dst, z) + + if len(ret) == 0 { + panic("no return value specified for ZRangeStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, redis.ZRangeArgs) *redis.IntCmd); ok { + r0 = rf(ctx, dst, z) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZRangeStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeStore' +type MockCmdable_ZRangeStore_Call struct { + *mock.Call +} + +// ZRangeStore is a helper method to define mock.On call +// - ctx context.Context +// - dst string +// - z redis.ZRangeArgs +func (_e *MockCmdable_Expecter) ZRangeStore(ctx interface{}, dst interface{}, z interface{}) *MockCmdable_ZRangeStore_Call { + return &MockCmdable_ZRangeStore_Call{Call: _e.mock.On("ZRangeStore", ctx, dst, z)} +} + +func (_c *MockCmdable_ZRangeStore_Call) Run(run func(ctx context.Context, dst string, z redis.ZRangeArgs)) *MockCmdable_ZRangeStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(redis.ZRangeArgs)) + }) + return _c +} + +func (_c *MockCmdable_ZRangeStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZRangeStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRangeStore_Call) RunAndReturn(run func(context.Context, string, redis.ZRangeArgs) *redis.IntCmd) *MockCmdable_ZRangeStore_Call { + _c.Call.Return(run) + return _c +} + +// ZRangeWithScores provides a mock function with given fields: ctx, key, start, stop +func (_m *MockCmdable) ZRangeWithScores(ctx context.Context, key string, start int64, stop int64) *redis.ZSliceCmd { + ret := _m.Called(ctx, key, start, stop) + + if len(ret) == 0 { + panic("no return value specified for ZRangeWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.ZSliceCmd); ok { + r0 = rf(ctx, key, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRangeWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeWithScores' +type MockCmdable_ZRangeWithScores_Call struct { + *mock.Call +} + +// ZRangeWithScores is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - start int64 +// - stop int64 +func (_e *MockCmdable_Expecter) ZRangeWithScores(ctx interface{}, key interface{}, start interface{}, stop interface{}) *MockCmdable_ZRangeWithScores_Call { + return &MockCmdable_ZRangeWithScores_Call{Call: _e.mock.On("ZRangeWithScores", ctx, key, start, stop)} +} + +func (_c *MockCmdable_ZRangeWithScores_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *MockCmdable_ZRangeWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ZRangeWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZRangeWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRangeWithScores_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.ZSliceCmd) *MockCmdable_ZRangeWithScores_Call { + _c.Call.Return(run) + return _c +} + +// ZRank provides a mock function with given fields: ctx, key, member +func (_m *MockCmdable) ZRank(ctx context.Context, key string, member string) *redis.IntCmd { + ret := _m.Called(ctx, key, member) + + if len(ret) == 0 { + panic("no return value specified for ZRank") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, member) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRank' +type MockCmdable_ZRank_Call struct { + *mock.Call +} + +// ZRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *MockCmdable_Expecter) ZRank(ctx interface{}, key interface{}, member interface{}) *MockCmdable_ZRank_Call { + return &MockCmdable_ZRank_Call{Call: _e.mock.On("ZRank", ctx, key, member)} +} + +func (_c *MockCmdable_ZRank_Call) Run(run func(ctx context.Context, key string, member string)) *MockCmdable_ZRank_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZRank_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRank_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_ZRank_Call { + _c.Call.Return(run) + return _c +} + +// ZRankWithScore provides a mock function with given fields: ctx, key, member +func (_m *MockCmdable) ZRankWithScore(ctx context.Context, key string, member string) *redis.RankWithScoreCmd { + ret := _m.Called(ctx, key, member) + + if len(ret) == 0 { + panic("no return value specified for ZRankWithScore") + } + + var r0 *redis.RankWithScoreCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.RankWithScoreCmd); ok { + r0 = rf(ctx, key, member) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.RankWithScoreCmd) + } + } + + return r0 +} + +// MockCmdable_ZRankWithScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRankWithScore' +type MockCmdable_ZRankWithScore_Call struct { + *mock.Call +} + +// ZRankWithScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *MockCmdable_Expecter) ZRankWithScore(ctx interface{}, key interface{}, member interface{}) *MockCmdable_ZRankWithScore_Call { + return &MockCmdable_ZRankWithScore_Call{Call: _e.mock.On("ZRankWithScore", ctx, key, member)} +} + +func (_c *MockCmdable_ZRankWithScore_Call) Run(run func(ctx context.Context, key string, member string)) *MockCmdable_ZRankWithScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZRankWithScore_Call) Return(_a0 *redis.RankWithScoreCmd) *MockCmdable_ZRankWithScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRankWithScore_Call) RunAndReturn(run func(context.Context, string, string) *redis.RankWithScoreCmd) *MockCmdable_ZRankWithScore_Call { + _c.Call.Return(run) + return _c +} + +// ZRem provides a mock function with given fields: ctx, key, members +func (_m *MockCmdable) ZRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + var _ca []interface{} + _ca = append(_ca, ctx, key) + _ca = append(_ca, members...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ZRem") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) *redis.IntCmd); ok { + r0 = rf(ctx, key, members...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRem' +type MockCmdable_ZRem_Call struct { + *mock.Call +} + +// ZRem is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...interface{} +func (_e *MockCmdable_Expecter) ZRem(ctx interface{}, key interface{}, members ...interface{}) *MockCmdable_ZRem_Call { + return &MockCmdable_ZRem_Call{Call: _e.mock.On("ZRem", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *MockCmdable_ZRem_Call) Run(run func(ctx context.Context, key string, members ...interface{})) *MockCmdable_ZRem_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockCmdable_ZRem_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZRem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRem_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *MockCmdable_ZRem_Call { + _c.Call.Return(run) + return _c +} + +// ZRemRangeByLex provides a mock function with given fields: ctx, key, min, max +func (_m *MockCmdable) ZRemRangeByLex(ctx context.Context, key string, min string, max string) *redis.IntCmd { + ret := _m.Called(ctx, key, min, max) + + if len(ret) == 0 { + panic("no return value specified for ZRemRangeByLex") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, min, max) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZRemRangeByLex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRemRangeByLex' +type MockCmdable_ZRemRangeByLex_Call struct { + *mock.Call +} + +// ZRemRangeByLex is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - min string +// - max string +func (_e *MockCmdable_Expecter) ZRemRangeByLex(ctx interface{}, key interface{}, min interface{}, max interface{}) *MockCmdable_ZRemRangeByLex_Call { + return &MockCmdable_ZRemRangeByLex_Call{Call: _e.mock.On("ZRemRangeByLex", ctx, key, min, max)} +} + +func (_c *MockCmdable_ZRemRangeByLex_Call) Run(run func(ctx context.Context, key string, min string, max string)) *MockCmdable_ZRemRangeByLex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZRemRangeByLex_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZRemRangeByLex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRemRangeByLex_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *MockCmdable_ZRemRangeByLex_Call { + _c.Call.Return(run) + return _c +} + +// ZRemRangeByRank provides a mock function with given fields: ctx, key, start, stop +func (_m *MockCmdable) ZRemRangeByRank(ctx context.Context, key string, start int64, stop int64) *redis.IntCmd { + ret := _m.Called(ctx, key, start, stop) + + if len(ret) == 0 { + panic("no return value specified for ZRemRangeByRank") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.IntCmd); ok { + r0 = rf(ctx, key, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZRemRangeByRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRemRangeByRank' +type MockCmdable_ZRemRangeByRank_Call struct { + *mock.Call +} + +// ZRemRangeByRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - start int64 +// - stop int64 +func (_e *MockCmdable_Expecter) ZRemRangeByRank(ctx interface{}, key interface{}, start interface{}, stop interface{}) *MockCmdable_ZRemRangeByRank_Call { + return &MockCmdable_ZRemRangeByRank_Call{Call: _e.mock.On("ZRemRangeByRank", ctx, key, start, stop)} +} + +func (_c *MockCmdable_ZRemRangeByRank_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *MockCmdable_ZRemRangeByRank_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ZRemRangeByRank_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZRemRangeByRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRemRangeByRank_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.IntCmd) *MockCmdable_ZRemRangeByRank_Call { + _c.Call.Return(run) + return _c +} + +// ZRemRangeByScore provides a mock function with given fields: ctx, key, min, max +func (_m *MockCmdable) ZRemRangeByScore(ctx context.Context, key string, min string, max string) *redis.IntCmd { + ret := _m.Called(ctx, key, min, max) + + if len(ret) == 0 { + panic("no return value specified for ZRemRangeByScore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, min, max) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZRemRangeByScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRemRangeByScore' +type MockCmdable_ZRemRangeByScore_Call struct { + *mock.Call +} + +// ZRemRangeByScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - min string +// - max string +func (_e *MockCmdable_Expecter) ZRemRangeByScore(ctx interface{}, key interface{}, min interface{}, max interface{}) *MockCmdable_ZRemRangeByScore_Call { + return &MockCmdable_ZRemRangeByScore_Call{Call: _e.mock.On("ZRemRangeByScore", ctx, key, min, max)} +} + +func (_c *MockCmdable_ZRemRangeByScore_Call) Run(run func(ctx context.Context, key string, min string, max string)) *MockCmdable_ZRemRangeByScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZRemRangeByScore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZRemRangeByScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRemRangeByScore_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *MockCmdable_ZRemRangeByScore_Call { + _c.Call.Return(run) + return _c +} + +// ZRevRange provides a mock function with given fields: ctx, key, start, stop +func (_m *MockCmdable) ZRevRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, start, stop) + + if len(ret) == 0 { + panic("no return value specified for ZRevRange") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRevRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRange' +type MockCmdable_ZRevRange_Call struct { + *mock.Call +} + +// ZRevRange is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - start int64 +// - stop int64 +func (_e *MockCmdable_Expecter) ZRevRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *MockCmdable_ZRevRange_Call { + return &MockCmdable_ZRevRange_Call{Call: _e.mock.On("ZRevRange", ctx, key, start, stop)} +} + +func (_c *MockCmdable_ZRevRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *MockCmdable_ZRevRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ZRevRange_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZRevRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRevRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *MockCmdable_ZRevRange_Call { + _c.Call.Return(run) + return _c +} + +// ZRevRangeByLex provides a mock function with given fields: ctx, key, opt +func (_m *MockCmdable) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, opt) + + if len(ret) == 0 { + panic("no return value specified for ZRevRangeByLex") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, opt) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRevRangeByLex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRangeByLex' +type MockCmdable_ZRevRangeByLex_Call struct { + *mock.Call +} + +// ZRevRangeByLex is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - opt *redis.ZRangeBy +func (_e *MockCmdable_Expecter) ZRevRangeByLex(ctx interface{}, key interface{}, opt interface{}) *MockCmdable_ZRevRangeByLex_Call { + return &MockCmdable_ZRevRangeByLex_Call{Call: _e.mock.On("ZRevRangeByLex", ctx, key, opt)} +} + +func (_c *MockCmdable_ZRevRangeByLex_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *MockCmdable_ZRevRangeByLex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.ZRangeBy)) + }) + return _c +} + +func (_c *MockCmdable_ZRevRangeByLex_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZRevRangeByLex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRevRangeByLex_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *MockCmdable_ZRevRangeByLex_Call { + _c.Call.Return(run) + return _c +} + +// ZRevRangeByScore provides a mock function with given fields: ctx, key, opt +func (_m *MockCmdable) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + ret := _m.Called(ctx, key, opt) + + if len(ret) == 0 { + panic("no return value specified for ZRevRangeByScore") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd); ok { + r0 = rf(ctx, key, opt) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRevRangeByScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRangeByScore' +type MockCmdable_ZRevRangeByScore_Call struct { + *mock.Call +} + +// ZRevRangeByScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - opt *redis.ZRangeBy +func (_e *MockCmdable_Expecter) ZRevRangeByScore(ctx interface{}, key interface{}, opt interface{}) *MockCmdable_ZRevRangeByScore_Call { + return &MockCmdable_ZRevRangeByScore_Call{Call: _e.mock.On("ZRevRangeByScore", ctx, key, opt)} +} + +func (_c *MockCmdable_ZRevRangeByScore_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *MockCmdable_ZRevRangeByScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.ZRangeBy)) + }) + return _c +} + +func (_c *MockCmdable_ZRevRangeByScore_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZRevRangeByScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRevRangeByScore_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *MockCmdable_ZRevRangeByScore_Call { + _c.Call.Return(run) + return _c +} + +// ZRevRangeByScoreWithScores provides a mock function with given fields: ctx, key, opt +func (_m *MockCmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + ret := _m.Called(ctx, key, opt) + + if len(ret) == 0 { + panic("no return value specified for ZRevRangeByScoreWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.ZRangeBy) *redis.ZSliceCmd); ok { + r0 = rf(ctx, key, opt) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRevRangeByScoreWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRangeByScoreWithScores' +type MockCmdable_ZRevRangeByScoreWithScores_Call struct { + *mock.Call +} + +// ZRevRangeByScoreWithScores is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - opt *redis.ZRangeBy +func (_e *MockCmdable_Expecter) ZRevRangeByScoreWithScores(ctx interface{}, key interface{}, opt interface{}) *MockCmdable_ZRevRangeByScoreWithScores_Call { + return &MockCmdable_ZRevRangeByScoreWithScores_Call{Call: _e.mock.On("ZRevRangeByScoreWithScores", ctx, key, opt)} +} + +func (_c *MockCmdable_ZRevRangeByScoreWithScores_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *MockCmdable_ZRevRangeByScoreWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.ZRangeBy)) + }) + return _c +} + +func (_c *MockCmdable_ZRevRangeByScoreWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZRevRangeByScoreWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRevRangeByScoreWithScores_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.ZSliceCmd) *MockCmdable_ZRevRangeByScoreWithScores_Call { + _c.Call.Return(run) + return _c +} + +// ZRevRangeWithScores provides a mock function with given fields: ctx, key, start, stop +func (_m *MockCmdable) ZRevRangeWithScores(ctx context.Context, key string, start int64, stop int64) *redis.ZSliceCmd { + ret := _m.Called(ctx, key, start, stop) + + if len(ret) == 0 { + panic("no return value specified for ZRevRangeWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) *redis.ZSliceCmd); ok { + r0 = rf(ctx, key, start, stop) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZRevRangeWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRangeWithScores' +type MockCmdable_ZRevRangeWithScores_Call struct { + *mock.Call +} + +// ZRevRangeWithScores is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - start int64 +// - stop int64 +func (_e *MockCmdable_Expecter) ZRevRangeWithScores(ctx interface{}, key interface{}, start interface{}, stop interface{}) *MockCmdable_ZRevRangeWithScores_Call { + return &MockCmdable_ZRevRangeWithScores_Call{Call: _e.mock.On("ZRevRangeWithScores", ctx, key, start, stop)} +} + +func (_c *MockCmdable_ZRevRangeWithScores_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *MockCmdable_ZRevRangeWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ZRevRangeWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZRevRangeWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRevRangeWithScores_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.ZSliceCmd) *MockCmdable_ZRevRangeWithScores_Call { + _c.Call.Return(run) + return _c +} + +// ZRevRank provides a mock function with given fields: ctx, key, member +func (_m *MockCmdable) ZRevRank(ctx context.Context, key string, member string) *redis.IntCmd { + ret := _m.Called(ctx, key, member) + + if len(ret) == 0 { + panic("no return value specified for ZRevRank") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.IntCmd); ok { + r0 = rf(ctx, key, member) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZRevRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRank' +type MockCmdable_ZRevRank_Call struct { + *mock.Call +} + +// ZRevRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *MockCmdable_Expecter) ZRevRank(ctx interface{}, key interface{}, member interface{}) *MockCmdable_ZRevRank_Call { + return &MockCmdable_ZRevRank_Call{Call: _e.mock.On("ZRevRank", ctx, key, member)} +} + +func (_c *MockCmdable_ZRevRank_Call) Run(run func(ctx context.Context, key string, member string)) *MockCmdable_ZRevRank_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZRevRank_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZRevRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRevRank_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *MockCmdable_ZRevRank_Call { + _c.Call.Return(run) + return _c +} + +// ZRevRankWithScore provides a mock function with given fields: ctx, key, member +func (_m *MockCmdable) ZRevRankWithScore(ctx context.Context, key string, member string) *redis.RankWithScoreCmd { + ret := _m.Called(ctx, key, member) + + if len(ret) == 0 { + panic("no return value specified for ZRevRankWithScore") + } + + var r0 *redis.RankWithScoreCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.RankWithScoreCmd); ok { + r0 = rf(ctx, key, member) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.RankWithScoreCmd) + } + } + + return r0 +} + +// MockCmdable_ZRevRankWithScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRankWithScore' +type MockCmdable_ZRevRankWithScore_Call struct { + *mock.Call +} + +// ZRevRankWithScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *MockCmdable_Expecter) ZRevRankWithScore(ctx interface{}, key interface{}, member interface{}) *MockCmdable_ZRevRankWithScore_Call { + return &MockCmdable_ZRevRankWithScore_Call{Call: _e.mock.On("ZRevRankWithScore", ctx, key, member)} +} + +func (_c *MockCmdable_ZRevRankWithScore_Call) Run(run func(ctx context.Context, key string, member string)) *MockCmdable_ZRevRankWithScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZRevRankWithScore_Call) Return(_a0 *redis.RankWithScoreCmd) *MockCmdable_ZRevRankWithScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZRevRankWithScore_Call) RunAndReturn(run func(context.Context, string, string) *redis.RankWithScoreCmd) *MockCmdable_ZRevRankWithScore_Call { + _c.Call.Return(run) + return _c +} + +// ZScan provides a mock function with given fields: ctx, key, cursor, match, count +func (_m *MockCmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + ret := _m.Called(ctx, key, cursor, match, count) + + if len(ret) == 0 { + panic("no return value specified for ZScan") + } + + var r0 *redis.ScanCmd + if rf, ok := ret.Get(0).(func(context.Context, string, uint64, string, int64) *redis.ScanCmd); ok { + r0 = rf(ctx, key, cursor, match, count) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ScanCmd) + } + } + + return r0 +} + +// MockCmdable_ZScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZScan' +type MockCmdable_ZScan_Call struct { + *mock.Call +} + +// ZScan is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - cursor uint64 +// - match string +// - count int64 +func (_e *MockCmdable_Expecter) ZScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *MockCmdable_ZScan_Call { + return &MockCmdable_ZScan_Call{Call: _e.mock.On("ZScan", ctx, key, cursor, match, count)} +} + +func (_c *MockCmdable_ZScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *MockCmdable_ZScan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(uint64), args[3].(string), args[4].(int64)) + }) + return _c +} + +func (_c *MockCmdable_ZScan_Call) Return(_a0 *redis.ScanCmd) *MockCmdable_ZScan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *MockCmdable_ZScan_Call { + _c.Call.Return(run) + return _c +} + +// ZScore provides a mock function with given fields: ctx, key, member +func (_m *MockCmdable) ZScore(ctx context.Context, key string, member string) *redis.FloatCmd { + ret := _m.Called(ctx, key, member) + + if len(ret) == 0 { + panic("no return value specified for ZScore") + } + + var r0 *redis.FloatCmd + if rf, ok := ret.Get(0).(func(context.Context, string, string) *redis.FloatCmd); ok { + r0 = rf(ctx, key, member) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.FloatCmd) + } + } + + return r0 +} + +// MockCmdable_ZScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZScore' +type MockCmdable_ZScore_Call struct { + *mock.Call +} + +// ZScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *MockCmdable_Expecter) ZScore(ctx interface{}, key interface{}, member interface{}) *MockCmdable_ZScore_Call { + return &MockCmdable_ZScore_Call{Call: _e.mock.On("ZScore", ctx, key, member)} +} + +func (_c *MockCmdable_ZScore_Call) Run(run func(ctx context.Context, key string, member string)) *MockCmdable_ZScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockCmdable_ZScore_Call) Return(_a0 *redis.FloatCmd) *MockCmdable_ZScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZScore_Call) RunAndReturn(run func(context.Context, string, string) *redis.FloatCmd) *MockCmdable_ZScore_Call { + _c.Call.Return(run) + return _c +} + +// ZUnion provides a mock function with given fields: ctx, store +func (_m *MockCmdable) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd { + ret := _m.Called(ctx, store) + + if len(ret) == 0 { + panic("no return value specified for ZUnion") + } + + var r0 *redis.StringSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, redis.ZStore) *redis.StringSliceCmd); ok { + r0 = rf(ctx, store) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.StringSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZUnion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZUnion' +type MockCmdable_ZUnion_Call struct { + *mock.Call +} + +// ZUnion is a helper method to define mock.On call +// - ctx context.Context +// - store redis.ZStore +func (_e *MockCmdable_Expecter) ZUnion(ctx interface{}, store interface{}) *MockCmdable_ZUnion_Call { + return &MockCmdable_ZUnion_Call{Call: _e.mock.On("ZUnion", ctx, store)} +} + +func (_c *MockCmdable_ZUnion_Call) Run(run func(ctx context.Context, store redis.ZStore)) *MockCmdable_ZUnion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZStore)) + }) + return _c +} + +func (_c *MockCmdable_ZUnion_Call) Return(_a0 *redis.StringSliceCmd) *MockCmdable_ZUnion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZUnion_Call) RunAndReturn(run func(context.Context, redis.ZStore) *redis.StringSliceCmd) *MockCmdable_ZUnion_Call { + _c.Call.Return(run) + return _c +} + +// ZUnionStore provides a mock function with given fields: ctx, dest, store +func (_m *MockCmdable) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd { + ret := _m.Called(ctx, dest, store) + + if len(ret) == 0 { + panic("no return value specified for ZUnionStore") + } + + var r0 *redis.IntCmd + if rf, ok := ret.Get(0).(func(context.Context, string, *redis.ZStore) *redis.IntCmd); ok { + r0 = rf(ctx, dest, store) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.IntCmd) + } + } + + return r0 +} + +// MockCmdable_ZUnionStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZUnionStore' +type MockCmdable_ZUnionStore_Call struct { + *mock.Call +} + +// ZUnionStore is a helper method to define mock.On call +// - ctx context.Context +// - dest string +// - store *redis.ZStore +func (_e *MockCmdable_Expecter) ZUnionStore(ctx interface{}, dest interface{}, store interface{}) *MockCmdable_ZUnionStore_Call { + return &MockCmdable_ZUnionStore_Call{Call: _e.mock.On("ZUnionStore", ctx, dest, store)} +} + +func (_c *MockCmdable_ZUnionStore_Call) Run(run func(ctx context.Context, dest string, store *redis.ZStore)) *MockCmdable_ZUnionStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.ZStore)) + }) + return _c +} + +func (_c *MockCmdable_ZUnionStore_Call) Return(_a0 *redis.IntCmd) *MockCmdable_ZUnionStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZUnionStore_Call) RunAndReturn(run func(context.Context, string, *redis.ZStore) *redis.IntCmd) *MockCmdable_ZUnionStore_Call { + _c.Call.Return(run) + return _c +} + +// ZUnionWithScores provides a mock function with given fields: ctx, store +func (_m *MockCmdable) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd { + ret := _m.Called(ctx, store) + + if len(ret) == 0 { + panic("no return value specified for ZUnionWithScores") + } + + var r0 *redis.ZSliceCmd + if rf, ok := ret.Get(0).(func(context.Context, redis.ZStore) *redis.ZSliceCmd); ok { + r0 = rf(ctx, store) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*redis.ZSliceCmd) + } + } + + return r0 +} + +// MockCmdable_ZUnionWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZUnionWithScores' +type MockCmdable_ZUnionWithScores_Call struct { + *mock.Call +} + +// ZUnionWithScores is a helper method to define mock.On call +// - ctx context.Context +// - store redis.ZStore +func (_e *MockCmdable_Expecter) ZUnionWithScores(ctx interface{}, store interface{}) *MockCmdable_ZUnionWithScores_Call { + return &MockCmdable_ZUnionWithScores_Call{Call: _e.mock.On("ZUnionWithScores", ctx, store)} +} + +func (_c *MockCmdable_ZUnionWithScores_Call) Run(run func(ctx context.Context, store redis.ZStore)) *MockCmdable_ZUnionWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZStore)) + }) + return _c +} + +func (_c *MockCmdable_ZUnionWithScores_Call) Return(_a0 *redis.ZSliceCmd) *MockCmdable_ZUnionWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCmdable_ZUnionWithScores_Call) RunAndReturn(run func(context.Context, redis.ZStore) *redis.ZSliceCmd) *MockCmdable_ZUnionWithScores_Call { + _c.Call.Return(run) + return _c +} + +// NewMockCmdable creates a new instance of MockCmdable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockCmdable(t interface { + mock.TestingT + Cleanup(func()) +}) *MockCmdable { + mock := &MockCmdable{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/pkg/agent/agent.go b/pkg/agent/agent.go index a4f1208..50feca3 100644 --- a/pkg/agent/agent.go +++ b/pkg/agent/agent.go @@ -247,7 +247,7 @@ func (a *Agent) onMachineUpdate(msg *protocol.WebsocketMessage) error { return err } - recon := reconciliation.NewMachineReconciler(a.commander) + recon := reconciliation.NewMachineReconciler(a.commander, a.client) return recon.Reconcile(machine) } else { if msg.Source == protocol.ManualSource && a.config.Ignore { @@ -259,7 +259,7 @@ func (a *Agent) onMachineUpdate(msg *protocol.WebsocketMessage) error { } } - recon := reconciliation.NewMachineReconciler(a.commander) + recon := reconciliation.NewMachineReconciler(a.commander, a.client) return recon.Reconcile(machine) } diff --git a/pkg/agent/reconciliation/commands.go b/pkg/agent/reconciliation/commands.go index 1cca9da..2378bfe 100644 --- a/pkg/agent/reconciliation/commands.go +++ b/pkg/agent/reconciliation/commands.go @@ -7,14 +7,16 @@ import ( "github.com/sirupsen/logrus" ) -func (mr *MachineReconciler) commands(commands types.Commands) error { +func (mr *MachineReconciler) commands(commands types.Commands) { for _, cmd := range commands { // command.Command // command.Check - _, _, err := mr.commander.Run(cmd.Check) // dont run command if check did not exit 0 - if err != nil { - continue + if cmd.Check != "" { + _, _, err := mr.commander.Run(cmd.Check) // dont run command if check did not exit 0 + if err != nil { + continue + } } // TODO report errors back to master or with local metrics? @@ -26,5 +28,4 @@ func (mr *MachineReconciler) commands(commands types.Commands) error { fmt.Println("stdout", stdOut) fmt.Println("stderr", stdErr) } - return nil } diff --git a/pkg/agent/reconciliation/files.go b/pkg/agent/reconciliation/files.go index 75edc99..b5880cc 100644 --- a/pkg/agent/reconciliation/files.go +++ b/pkg/agent/reconciliation/files.go @@ -21,7 +21,7 @@ import ( "github.com/sirupsen/logrus" ) -func (mr *MachineReconciler) files(files types.Files) error { +func (mr *MachineReconciler) files(files types.Files) { for _, file := range files { if file.URL != "" && file.Content != "" { logrus.Error(fmt.Errorf("file can only have Content or URL, not both")) @@ -52,7 +52,6 @@ func (mr *MachineReconciler) files(files types.Files) error { continue } } - return nil } func writeContentIfNeeded(file *types.File) (bool, error) { diff --git a/pkg/agent/reconciliation/line.go b/pkg/agent/reconciliation/line.go index 9985976..783abeb 100644 --- a/pkg/agent/reconciliation/line.go +++ b/pkg/agent/reconciliation/line.go @@ -11,7 +11,7 @@ import ( "github.com/sirupsen/logrus" ) -func (mr *MachineReconciler) lines(lines types.Lines) error { +func (mr *MachineReconciler) lines(lines types.Lines) { for _, line := range lines { err := applyLine(line) if err != nil { @@ -19,7 +19,6 @@ func (mr *MachineReconciler) lines(lines types.Lines) error { continue } } - return nil } func applyLine(line *types.Line) error { diff --git a/pkg/agent/reconciliation/packages.go b/pkg/agent/reconciliation/packages.go index f326e77..340ad23 100644 --- a/pkg/agent/reconciliation/packages.go +++ b/pkg/agent/reconciliation/packages.go @@ -9,7 +9,7 @@ import ( ) // Only yum for now. -func (mr *MachineReconciler) packages(packages types.Packages) error { +func (mr *MachineReconciler) packages(packages types.Packages) { for _, pkg := range packages { err := mr.installPackage(pkg) if err != nil { @@ -17,7 +17,6 @@ func (mr *MachineReconciler) packages(packages types.Packages) error { continue } } - return nil } func (mr *MachineReconciler) installPackage(pkg *types.Package) error { diff --git a/pkg/agent/reconciliation/reconciliation.go b/pkg/agent/reconciliation/reconciliation.go index 83517f9..d4ca769 100644 --- a/pkg/agent/reconciliation/reconciliation.go +++ b/pkg/agent/reconciliation/reconciliation.go @@ -4,7 +4,9 @@ import ( "fmt" "github.com/fortnoxab/gitmachinecontroller/pkg/agent/command" + "github.com/fortnoxab/gitmachinecontroller/pkg/api/v1/protocol" "github.com/fortnoxab/gitmachinecontroller/pkg/api/v1/types" + "github.com/fortnoxab/gitmachinecontroller/pkg/websocket" "github.com/sirupsen/logrus" ) @@ -12,34 +14,57 @@ type MachineReconciler struct { restartUnits map[string]string daemonReloadNeeded bool commander command.Commander + wsClient websocket.Websocket } -func NewMachineReconciler(c command.Commander) *MachineReconciler { - return &MachineReconciler{commander: c} +func NewMachineReconciler(c command.Commander, wsClient websocket.Websocket) *MachineReconciler { + return &MachineReconciler{ + commander: c, + wsClient: wsClient, + } } func (mr *MachineReconciler) Reconcile(machine *types.Machine) error { mr.restartUnits = make(map[string]string) // map[unit]action - err := mr.commands(machine.Spec.Commands) - if err != nil { - return err - } + for _, task := range machine.Spec.Tasks { + clear(mr.restartUnits) // reset on each task run - err = mr.files(machine.Spec.Files) - if err != nil { - return err - } - err = mr.lines(machine.Spec.Lines) - if err != nil { - return err - } - err = mr.packages(machine.Spec.Packages) - if err != nil { - return err + if task.Lock != nil { + msg, _ := protocol.NewMessage("agent-aqure-lock", task.Lock) + response, err := mr.wsClient.WriteAndWait(msg) + if err != nil { + logrus.Errorf("error aquire lock: %s", err) + continue + } + + if response.Type != "agent-aqured-lock" { + logrus.Info("failed to aquire lock: ", task.Lock.Key) + continue + } + } + + mr.commands(task.Commands) + mr.files(task.Files) + mr.lines(task.Lines) + mr.packages(task.Packages) + + err := mr.runSystemdTriggers() + if err != nil { + logrus.Errorf("error running systemd: %s", err) + } + if task.Lock != nil { + msg, _ := protocol.NewMessage("agent-release-lock", task.Lock) + err := mr.wsClient.WriteJSON(msg) + if err != nil { + logrus.Errorf("error aquire lock: %s", err) + continue + } + // no need to wait for response here + } } - return mr.runSystemdTriggers() + return nil } func (mr *MachineReconciler) unitNeedsTrigger(systemd *types.SystemdReference) { diff --git a/pkg/agent/reconciliation/reconciliation_test.go b/pkg/agent/reconciliation/reconciliation_test.go index de8850e..b1652a0 100644 --- a/pkg/agent/reconciliation/reconciliation_test.go +++ b/pkg/agent/reconciliation/reconciliation_test.go @@ -14,14 +14,18 @@ func TestFilesContent(t *testing.T) { machine := &types.Machine{ Spec: &types.Spec{ - Files: types.Files{ - &types.File{ - Path: "testfil1", - Content: "test", - Systemd: &types.SystemdReference{ - DaemonReload: true, - Name: "service1", - Action: "restart", + Tasks: types.Tasks{ + { + Files: types.Files{ + &types.File{ + Path: "testfil1", + Content: "test", + Systemd: &types.SystemdReference{ + DaemonReload: true, + Name: "service1", + Action: "restart", + }, + }, }, }, }, @@ -33,7 +37,7 @@ func TestFilesContent(t *testing.T) { mockedCommander.Mock.On("Run", "systemctl restart service1").Return("", "", nil).Once() mockedCommander.Mock.On("Run", "systemctl daemon reload").Return("", "", nil).Once() - recon := NewMachineReconciler(mockedCommander) + recon := NewMachineReconciler(mockedCommander, nil) //TODO no redis in those tests yet. Its tested in e2e err := recon.Reconcile(machine) assert.NoError(t, err) @@ -86,10 +90,14 @@ func TestInstallPackages(t *testing.T) { t.Run(tt.name, func(t *testing.T) { machine := &types.Machine{ Spec: &types.Spec{ - Packages: types.Packages{ + Tasks: types.Tasks{ { - Name: tt.packageName, - Version: tt.packageVersion, + Packages: types.Packages{ + { + Name: tt.packageName, + Version: tt.packageVersion, + }, + }, }, }, }, @@ -104,7 +112,7 @@ func TestInstallPackages(t *testing.T) { mockedCommander.Mock.On("Run", fmt.Sprintf("yum install -y %s", tt.providesIt)).Return("", "", nil).Once() } - recon := NewMachineReconciler(mockedCommander) + recon := NewMachineReconciler(mockedCommander, nil) err := recon.Reconcile(machine) assert.NoError(t, err) }) diff --git a/pkg/api/v1/protocol/websocket.go b/pkg/api/v1/protocol/websocket.go index 2e7ab63..b4bd76e 100644 --- a/pkg/api/v1/protocol/websocket.go +++ b/pkg/api/v1/protocol/websocket.go @@ -2,6 +2,8 @@ package protocol import ( "encoding/json" + "errors" + "time" "github.com/fortnoxab/gitmachinecontroller/pkg/api/v1/types" ) @@ -98,3 +100,36 @@ type RunCommandRequest struct { LabelSelector string Regexp string } + +type AgentLock struct { + Key string + ID string + TTL Duration +} + +type Duration time.Duration + +func (d Duration) MarshalJSON() ([]byte, error) { + return json.Marshal(time.Duration(d).String()) +} + +func (d *Duration) UnmarshalJSON(b []byte) error { + var v interface{} + if err := json.Unmarshal(b, &v); err != nil { + return err + } + switch value := v.(type) { + case float64: + *d = Duration(time.Duration(value)) + return nil + case string: + tmp, err := time.ParseDuration(value) + if err != nil { + return err + } + *d = Duration(tmp) + return nil + default: + return errors.New("invalid duration") + } +} diff --git a/pkg/api/v1/types/types.go b/pkg/api/v1/types/types.go index ccd2be3..e9d6f91 100644 --- a/pkg/api/v1/types/types.go +++ b/pkg/api/v1/types/types.go @@ -54,26 +54,38 @@ func (l Labels) Get(label string) (value string) { } type Spec struct { - Commands Commands `json:"commands"` - Files Files `json:"files"` + Tasks Tasks IP string `json:"ip"` - Lines Lines `json:"lines"` - Packages Packages `json:"packages"` Provision Provision `json:"provision"` } +type Task struct { + Name string `json:"name"` + // Depends on other task to happen before + Depends string `json:"depends"` + + Commands Commands `json:"commands,omitempty"` + Files Files `json:"files,omitempty"` + Lines Lines `json:"lines,omitempty"` + Packages Packages `json:"packages,omitempty"` + + Lock *Lock `json:"lock,omitempty"` +} +type Tasks []*Task + type Packages []*Package type Package struct { - Name string + Name string `json:"name"` // Version where "*" means latest - Version string + Version string `json:"version"` } type Command struct { Command string `json:"command"` Check string `json:"check"` + //TODO add Shell to specify in what shell to run? } type Commands []*Command @@ -119,6 +131,12 @@ type Provision struct { // Type string `json:"type"` // dont need this unless we have multiple Provision providers. but we could use label selectors instead? } +type Lock struct { + Key string `json:"key"` + GracePeriod time.Duration `json:"gracePeriod"` + TTL time.Duration `json:"ttl"` +} + // MachineState is used internall in master to keep track of current state. type MachineState struct { Metadata *Metadata diff --git a/pkg/master/master.go b/pkg/master/master.go index 7d36e4c..664b861 100644 --- a/pkg/master/master.go +++ b/pkg/master/master.go @@ -8,7 +8,6 @@ import ( "os" "path/filepath" "regexp" - "strings" "sync" "time" @@ -21,6 +20,7 @@ import ( "github.com/fortnoxab/gitmachinecontroller/pkg/master/webserver" "github.com/fortnoxab/gitmachinecontroller/pkg/secrets" "github.com/olahol/melody" + "github.com/redis/go-redis/v9" "github.com/sirupsen/logrus" "github.com/urfave/cli/v2" "gopkg.in/yaml.v3" @@ -30,6 +30,9 @@ import ( /* TODO Think about HA? +HA +* clients connect to prefered master +* admin command knows all masters * do we want leaderelection so only one syncs from git? Probably! * how to ensure clients fetches from the current leader? @@ -84,9 +87,11 @@ type Master struct { webserver *webserver.Webserver machineStateCh chan types.MachineStateQuestion secretHandler *secrets.Handler + RedisClient redis.Cmdable } func NewMasterFromContext(c *cli.Context) *Master { + m := &Master{ GitURL: c.String("git-url"), GitBranch: c.String("git-branch"), @@ -101,15 +106,28 @@ func NewMasterFromContext(c *cli.Context) *Master { WsPort: c.String("port"), EnableMetrics: true, } + if c.String("redis-url") != "" { + opt, err := redis.ParseURL(c.String("redis-url")) + if err != nil { + logrus.Fatalf("error parsing redis url, err: %s", err) + return nil + } + m.RedisClient = redis.NewClient(opt) + } masters := config.Masters{} for _, m := range c.StringSlice("master") { - tmp := strings.Split(m, ";") + u, err := url.Parse(m) + if err != nil { + logrus.Fatalf("error parsing master url, err: %s", err) + return nil + } - fmt.Println(tmp) - master := &config.Master{URL: tmp[0]} - if len(tmp) > 1 { - master.Zone = tmp[1] + z := u.Query().Get("zone") + u.RawQuery = "" + master := &config.Master{ + URL: u.String(), + Zone: z, } masters = append(masters, master) } @@ -171,7 +189,7 @@ func (m *Master) run(ctx context.Context) error { select { case update := <-machineUpdateCh: syncCh <- update.Machine - err = m.secretHandler.DecryptFilesContent(update.Machine.Spec.Files) + err = m.secretHandler.DecryptTasksFilesContent(update.Machine.Spec.Tasks) if err != nil { logrus.Error(err) continue @@ -353,19 +371,6 @@ func (m *Master) handleRequest(ctx context.Context, machines map[string]*types.M return err } - logrus.Infof("we will run command: %s", cmdReq.Command) - - msg, err := protocol.NewMessage("run-command", cmdReq.Command) - if err != nil { - return err - } - - msg.RequestID = r.Request.RequestID - b, err := msg.Encode() - if err != nil { - return err - } - sendTo, offline, err := m.filterSessions(machines, cmdReq.Regexp, cmdReq.LabelSelector) if err != nil { return err @@ -375,13 +380,13 @@ func (m *Master) handleRequest(ctx context.Context, machines map[string]*types.M logrus.Debugf("will send command request to cnt: %d", onlineLen) logrus.Debugf("offline machines: %#v", offline) - if len(sendTo)+len(offline) == 0 { + if onlineLen+len(offline) == 0 { sendIsLast(sess, r.Request.RequestID) return fmt.Errorf("found zero hosts to send command to") } for _, host := range offline { - b, err := protocol.NewCommandResult(msg.RequestID, &protocol.CommandResult{ + b, err := protocol.NewCommandResult(r.Request.RequestID, &protocol.CommandResult{ Online: false, }) if err != nil { @@ -422,7 +427,18 @@ func (m *Master) handleRequest(ctx context.Context, machines map[string]*types.M } } }() + logrus.Infof("we will run command: %s", cmdReq.Command) + msg, err := protocol.NewMessage("run-command", cmdReq.Command) + if err != nil { + return err + } + + msg.RequestID = r.Request.RequestID + b, err := msg.Encode() + if err != nil { + return err + } requestResponseStore.WaitForResponse(r.Request.RequestID) err = m.webserver.Websocket.BroadcastMultiple(b, sendTo) if err != nil { @@ -447,10 +463,84 @@ func (m *Master) handleRequest(ctx context.Context, machines map[string]*types.M } logrus.Info("sending admin-apply-spec from master") machineUpdateCh <- machineUpdate{Machine: machine, Source: protocol.ManualSource} + + case "agent-aqure-lock": + if admin, _ := sess.Get("allowed"); !admin.(bool) { + return fmt.Errorf("agent-aqure-lock permission denied") + } + l := &protocol.AgentLock{} + err := json.Unmarshal(r.Request.Body, l) + if err != nil { + return err + } + + hasLock, err := aquireLock(ctx, m.RedisClient, l.Key, r.Request.From, time.Duration(l.TTL)) + if err != nil { + return err + } + + response := &protocol.WebsocketMessage{ + Type: "agent-aqured-lock", + RequestID: r.Request.RequestID, + } + if !hasLock { + response.Type = "agent-failed-lock" + } + + b, err := response.Encode() + if err != nil { + return err + } + + err = sess.Write(b) + if err != nil { + return err + } + case "agent-release-lock": + if admin, _ := sess.Get("allowed"); !admin.(bool) { + return fmt.Errorf("agent-release-lock permission denied") + } + l := &protocol.AgentLock{} + err := json.Unmarshal(r.Request.Body, l) + if err != nil { + return err + } + err = releaseLock(ctx, m.RedisClient, l.Key) + if err != nil { + return err + } + + err = sess.Write([]byte(`{"hasLock":false}`)) + if err != nil { + return err + } } return nil } +func releaseLock(ctx context.Context, redisClient redis.Cmdable, key string) error { + _, err := redisClient.Del(ctx, "gmc.lock"+key).Result() + if err == redis.Nil { + return err + } + return err +} +func aquireLock(ctx context.Context, redisClient redis.Cmdable, key, id string, ttl time.Duration) (bool, error) { + isLeader, err := redisClient.SetNX(ctx, "gmc.lock"+key, id, ttl).Result() + + if err == nil && isLeader { + logrus.Debug("aquired new leader lock") + return true, nil + } + + lockId, err := redisClient.Get(ctx, "gmc.lock"+key).Result() + if err != nil { + return false, err + } + logrus.Debugf("current leader is: %s", lockId) + return lockId == id, nil +} + func sendIsLast(sess *melody.Session, reqID string) { msg := &protocol.WebsocketMessage{ Type: "last_message", @@ -513,8 +603,9 @@ func (m *Master) clone(ctx context.Context, authOpts *git.AuthOptions, cloneOpts } defer gitClient.Close() - // TODO context timeout here. - commit, err := gitClient.Clone(ctx, m.GitURL, cloneOpts) + ctx1, cancel := context.WithTimeout(ctx, time.Minute*1) // TODO make this configurable? + defer cancel() + commit, err := gitClient.Clone(ctx1, m.GitURL, cloneOpts) if err != nil { return err } diff --git a/pkg/secrets/secret.go b/pkg/secrets/secret.go index 28a1a59..fdb9746 100644 --- a/pkg/secrets/secret.go +++ b/pkg/secrets/secret.go @@ -21,6 +21,15 @@ func NewHandler(key string) *Handler { return &Handler{key: key} } +func (s *Handler) DecryptTasksFilesContent(tasks types.Tasks) error { + for _, task := range tasks { + err := s.DecryptFilesContent(task.Files) + if err != nil { + return err + } + } + return nil +} func (s *Handler) DecryptFilesContent(files types.Files) error { for _, file := range files { if file.Content != "" { diff --git a/pkg/websocket/websocketclient.go b/pkg/websocket/websocketclient.go index 1e4b61f..e25c427 100644 --- a/pkg/websocket/websocketclient.go +++ b/pkg/websocket/websocketclient.go @@ -3,11 +3,14 @@ package websocket import ( "context" "crypto/tls" + "encoding/json" "fmt" "net/http" "sync" "time" + "github.com/fortnoxab/gitmachinecontroller/pkg/api/v1/protocol" + "github.com/google/uuid" "github.com/gorilla/websocket" "github.com/sirupsen/logrus" ) @@ -21,8 +24,6 @@ const ( // Send pings to peer with this period. Must be less than pongWait. pingPeriod = (pongWait * 9) / 10 - - reconnectWait = 2 * time.Second ) // Websocket implements a websocket client. @@ -37,6 +38,7 @@ type Websocket interface { WriteJSON(v interface{}) error WriteMessage(messageType int, data []byte) error SetTLSConfig(c *tls.Config) + WriteAndWait(msg *protocol.WebsocketMessage) (*protocol.WebsocketMessage, error) } type writeCh struct { body interface{} @@ -55,6 +57,8 @@ type websocketClient struct { disconnected chan error connected chan struct{} onConnect func() + list map[string]chan []byte + listMutex sync.RWMutex sync.RWMutex } @@ -67,6 +71,7 @@ func NewWebsocketClient() Websocket { wg: &sync.WaitGroup{}, disconnected: make(chan error), connected: make(chan struct{}), + list: make(map[string]chan []byte), } } @@ -155,9 +160,58 @@ func (ws *websocketClient) WriteJSON(v interface{}) error { } return <-errCh } +func (ws *websocketClient) WriteAndWait(msg *protocol.WebsocketMessage) (*protocol.WebsocketMessage, error) { + + msg.RequestID = uuid.New().String() + + waitCh := ws.WaitForResponse(msg.RequestID) + errCh := make(chan error) + delay := time.NewTimer(time.Millisecond * 10) + select { + case ws.writeJSON <- writeCh{errCh: errCh, body: msg}: + if !delay.Stop() { + <-delay.C + } + case <-delay.C: + errCh <- fmt.Errorf("websocket: no one listening on write channel") + } + err := <-errCh + if err != nil { + return nil, err + } + + rawJson := <-waitCh + + return protocol.ParseMessage(rawJson) +} + +func (ws *websocketClient) WaitForResponse(reqID string) chan []byte { + if ch := ws.Ch(reqID); ch != nil { + return ch + } + ch := make(chan []byte) + ws.listMutex.Lock() + ws.list[reqID] = ch + ws.listMutex.Unlock() + return ch +} +func (ws *websocketClient) Ch(reqID string) chan []byte { + ws.listMutex.RLock() + defer ws.listMutex.RUnlock() + return ws.list[reqID] +} +func (ws *websocketClient) Done(reqID string) { + ws.listMutex.Lock() + delete(ws.list, reqID) + ws.listMutex.Unlock() +} func (ws *websocketClient) readPump(conn *websocket.Conn) { ws.wg.Add(1) + type msgWithId struct { + RequestID string `json:"requestId"` + } + go func() { defer ws.wg.Done() conn.SetReadDeadline(time.Now().Add(pongWait)) @@ -169,6 +223,20 @@ func (ws *websocketClient) readPump(conn *websocket.Conn) { return } logrus.Debugf("websocket: readPump got msg: %s", message) + + id := &msgWithId{} + err = json.Unmarshal(message, id) + if err != nil { + logrus.Errorf("error parsing RequestID from message: %s", err) + continue + } + + if ch := ws.Ch(id.RequestID); ch != nil { + ch <- message + ws.Done(id.RequestID) + continue + } + select { case ws.read <- message: default: