From 7733180c2357655751689388f14eae7d57defd8a Mon Sep 17 00:00:00 2001 From: Anselm Jonas Scholl Date: Tue, 4 Jul 2023 16:56:57 +0200 Subject: [PATCH] mocks: regenerate mocks again with added configuration for expected calls and added CI job to ensure we don't miss mocks in the future; --- .github/workflows/go.yml | 47 +- .mockery.yml | 5 + pkg/apiserver/auth/mocks/Authenticator.go | 36 + pkg/apiserver/auth/mocks/JwtTokenHandler.go | 64 + pkg/apiserver/auth/mocks/TokenInfoProvider.go | 36 + pkg/apiserver/crud/mocks/BaseCreateHandler.go | 65 + pkg/apiserver/crud/mocks/BaseHandler.go | 92 + pkg/apiserver/crud/mocks/BaseListHandler.go | 38 + pkg/apiserver/crud/mocks/BaseUpdateHandler.go | 65 + pkg/apiserver/crud/mocks/CreateHandler.go | 149 + pkg/apiserver/crud/mocks/Handler.go | 236 + pkg/apiserver/crud/mocks/ListHandler.go | 122 + pkg/apiserver/crud/mocks/Repository.go | 212 + pkg/apiserver/crud/mocks/UpdateHandler.go | 149 + pkg/apiserver/mocks/HandlerWithInput.go | 64 + .../mocks/HandlerWithMultipleBindings.go | 91 + pkg/apiserver/mocks/HandlerWithStream.go | 65 + pkg/apiserver/mocks/HandlerWithoutInput.go | 37 + pkg/blob/mocks/BatchRunner.go | 36 + pkg/blob/mocks/ReadCloser.go | 63 + pkg/blob/mocks/ReadSeekerCloser.go | 92 + pkg/blob/mocks/Store.go | 315 + pkg/blob/mocks/Stream.go | 62 + pkg/cache/mocks/Cache.go | 209 + pkg/cfg/mocks/Config.go | 595 ++ pkg/cfg/mocks/GosoConf.go | 630 ++ pkg/cfg/mocks/Sentry.go | 38 + pkg/clock/mocks/Clock.go | 175 + pkg/clock/mocks/FakeClock.go | 287 + pkg/clock/mocks/Ticker.go | 90 + pkg/clock/mocks/Timer.go | 90 + pkg/cloud/aws/cloudwatch/mocks/Client.go | 82 + pkg/cloud/aws/dynamodb/mocks/Client.go | 563 + pkg/cloud/aws/ec2/mocks/Client.go | 45 + pkg/cloud/aws/ecs/mocks/Client.go | 82 + pkg/cloud/aws/kinesis/mocks/Checkpoint.go | 147 + .../kinesis/mocks/CheckpointWithoutRelease.go | 119 + pkg/cloud/aws/kinesis/mocks/Client.go | 1081 ++ pkg/cloud/aws/kinesis/mocks/Kinsumer.go | 64 + pkg/cloud/aws/kinesis/mocks/MessageHandler.go | 63 + .../aws/kinesis/mocks/MetadataRepository.go | 122 + pkg/cloud/aws/kinesis/mocks/RecordWriter.go | 66 + pkg/cloud/aws/kinesis/mocks/ShardReader.go | 37 + pkg/cloud/aws/mocks/Executor.go | 37 + pkg/cloud/aws/rds/mocks/Client.go | 45 + .../resourcegroupstaggingapi/mocks/Client.go | 45 + .../resourcegroupstaggingapi/mocks/Service.go | 37 + pkg/cloud/aws/s3/mocks/Client.go | 563 + pkg/cloud/aws/sns/mocks/Client.go | 267 + pkg/cloud/aws/sns/mocks/Topic.go | 105 + pkg/cloud/aws/sqs/mocks/Client.go | 378 + pkg/cloud/aws/sqs/mocks/Queue.go | 235 + pkg/cloud/aws/sqs/mocks/Service.go | 211 + pkg/cloud/aws/ssm/mocks/Client.go | 82 + .../aws/ssm/mocks/SimpleSystemsManager.go | 66 + pkg/cloud/mocks/LambdaApi.go | 6985 +++++++++++- pkg/conc/ddb/mocks/LeaderElection.go | 66 + pkg/conc/mocks/DistributedLock.go | 64 + pkg/conc/mocks/DistributedLockProvider.go | 37 + pkg/conc/mocks/PoisonedLock.go | 144 + pkg/conc/mocks/SignalOnce.go | 89 + pkg/currency/mocks/Service.go | 252 + pkg/currency/mocks/UpdaterService.go | 64 + pkg/db-repo/mocks/ModelBased.go | 91 + pkg/db-repo/mocks/Repository.go | 266 + pkg/db-repo/mocks/RepositoryReadOnly.go | 179 + pkg/db-repo/mocks/TimeStampable.go | 64 + pkg/db/mocks/Client.go | 365 + pkg/db/mocks/QueryBuilder.go | 193 + pkg/db/mocks/SqlResult.go | 62 + pkg/ddb/mocks/BatchGetItemsBuilder.go | 210 + pkg/ddb/mocks/ConditionCheckBuilder.go | 209 + pkg/ddb/mocks/DeleteItemBuilder.go | 174 + pkg/ddb/mocks/GetItemBuilder.go | 210 + pkg/ddb/mocks/PutItemBuilder.go | 118 + pkg/ddb/mocks/QueryBuilder.go | 483 + pkg/ddb/mocks/Repository.go | 492 + pkg/ddb/mocks/ScanBuilder.go | 260 + pkg/ddb/mocks/TransactGetItemBuilder.go | 62 + pkg/ddb/mocks/TransactWriteItemBuilder.go | 62 + pkg/ddb/mocks/TransactionRepository.go | 66 + pkg/ddb/mocks/UpdateItemBuilder.go | 462 + pkg/guard/mocks/Guard.go | 203 + pkg/guard/mocks/Manager.go | 233 + pkg/http/mocks/Client.go | 430 + pkg/ipread/mocks/Reader.go | 36 + pkg/kafka/consumer/consumer_offset_manager.go | 3 +- pkg/kafka/consumer/mocks/Batcher.go | 36 + pkg/kafka/consumer/mocks/OffsetManager.go | 127 + pkg/kafka/consumer/mocks/Reader.go | 154 + pkg/kafka/producer/writer.go | 2 +- pkg/kernel/mocks/FullModule.go | 117 + pkg/kernel/mocks/Kernel.go | 90 + pkg/kernel/mocks/Module.go | 36 + pkg/kernel/mocks/StagedModule.go | 35 + pkg/kernel/mocks/TypedModule.go | 62 + pkg/kvstore/mocks/KvStore.go | 214 + pkg/kvstore/mocks/SizedStore.go | 241 + pkg/log/mocks/Logger.go | 236 + pkg/log/mocks/SentryHub.go | 120 + pkg/log/status/mocks/Manager.go | 123 + pkg/log/status/mocks/WorkItem.go | 120 + pkg/mdlsub/mocks/ModelTransformer.go | 64 + pkg/mdlsub/mocks/Publisher.go | 86 + pkg/metric/mocks/Writer.go | 91 + pkg/oauth2/mocks/Service.go | 66 + pkg/parquet/mocks/FileRecorder.go | 121 + pkg/parquet/mocks/Partitioner.go | 199 + pkg/parquet/mocks/Reader.go | 101 + pkg/parquet/mocks/Writer.go | 68 + pkg/redis/mocks/Client.go | 2089 +++- pkg/redis/mocks/Pipeliner.go | 9366 ++++++++++++++++- pkg/stream/mocks/AcknowledgeableInput.go | 150 + pkg/stream/mocks/BatchConsumerCallback.go | 66 + pkg/stream/mocks/ConsumerCallback.go | 66 + pkg/stream/mocks/Input.go | 90 + pkg/stream/mocks/MessageEncoder.go | 75 + pkg/stream/mocks/Output.go | 66 + pkg/stream/mocks/PartitionedOutput.go | 93 + pkg/stream/mocks/PartitionerRand.go | 36 + pkg/stream/mocks/Producer.go | 82 + pkg/stream/mocks/ProducerDaemonAggregator.go | 64 + pkg/stream/mocks/ProducerDaemonBatcher.go | 63 + pkg/stream/mocks/RetryHandler.go | 119 + .../mocks/RunnableBatchConsumerCallback.go | 94 + pkg/stream/mocks/RunnableCallback.go | 36 + pkg/stream/mocks/RunnableConsumerCallback.go | 94 + pkg/stream/mocks/SizeRestrictedOutput.go | 120 + pkg/tracing/mocks/Span.go | 175 + pkg/tracing/mocks/TraceAble.go | 35 + pkg/tracing/mocks/Tracer.go | 122 + pkg/uuid/mocks/Uuid.go | 35 + 132 files changed, 37012 insertions(+), 64 deletions(-) create mode 100644 .mockery.yml diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 852225183..220b076f6 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -26,7 +26,7 @@ jobs: - name: Set up Go 1.18 uses: actions/setup-go@v3 with: - go-version: 1.18 + go-version: "1.18" - name: Check out code into the Go module directory uses: actions/checkout@v3 @@ -37,6 +37,37 @@ jobs: - name: Execute test -z $(gofmt -l .) run: test -z $(gofmt -l .) + mockery: + name: mockery + runs-on: ubuntu-20.04 + steps: + - name: Set up Go 1.20 + uses: actions/setup-go@v3 + with: + go-version: "1.20" + + - name: Check out code into the Go module directory + uses: actions/checkout@v3 + + - name: Install mockery + run: go install github.com/vektra/mockery/v2@v2.22.1 + + - name: Execute mockery + run: go generate -run='mockery' ./... + + - name: Check for empty diff + run: | + git add -A * + changes=$(git status -s | grep -E '^[ ]?M|A') || true + if [ "0" != $(echo -n $changes | wc -c) ]; then + git status -s | grep -E '^[ ]?M|A' + echo "please check the file list above and (re-)create those mocks locally with the mockery version v2.22.1!" + echo "here's the diff:" + git diff HEAD~0 + echo "end of diff" + exit 1 + fi + build: name: go build runs-on: ubuntu-20.04 @@ -44,7 +75,7 @@ jobs: - name: Set up Go 1.18 uses: actions/setup-go@v3 with: - go-version: 1.18 + go-version: "1.18" - name: Check out code into the Go module directory uses: actions/checkout@v3 @@ -62,7 +93,7 @@ jobs: - name: Set up Go 1.18 uses: actions/setup-go@v3 with: - go-version: 1.18 + go-version: "1.18" - name: Check out code into the Go module directory uses: actions/checkout@v3 @@ -80,7 +111,7 @@ jobs: - name: Set up Go 1.18 uses: actions/setup-go@v3 with: - go-version: 1.18 + go-version: "1.18" - name: Check out code into the Go module directory uses: actions/checkout@v3 @@ -98,7 +129,7 @@ jobs: - name: Set up Go 1.18 uses: actions/setup-go@v3 with: - go-version: 1.18 + go-version: "1.18" - name: Check out code into the Go module directory uses: actions/checkout@v3 @@ -116,7 +147,7 @@ jobs: - name: Set up Go 1.18 uses: actions/setup-go@v3 with: - go-version: 1.18 + go-version: "1.18" - name: Check out code into the Go module directory uses: actions/checkout@v3 @@ -134,7 +165,7 @@ jobs: - name: Set up Go 1.18 uses: actions/setup-go@v3 with: - go-version: 1.18 + go-version: "1.18" - name: Check out code into the Go module directory uses: actions/checkout@v3 @@ -152,7 +183,7 @@ jobs: - name: Set up Go 1.18 uses: actions/setup-go@v3 with: - go-version: 1.18 + go-version: "1.18" - name: Check out code into the Go module directory uses: actions/checkout@v3 diff --git a/.mockery.yml b/.mockery.yml new file mode 100644 index 000000000..aee371f07 --- /dev/null +++ b/.mockery.yml @@ -0,0 +1,5 @@ +inpackage: false +testonly: false +with-expecter: true +keeptree: true +unroll-variadic: true diff --git a/pkg/apiserver/auth/mocks/Authenticator.go b/pkg/apiserver/auth/mocks/Authenticator.go index 04d7b5ad9..44aebc470 100644 --- a/pkg/apiserver/auth/mocks/Authenticator.go +++ b/pkg/apiserver/auth/mocks/Authenticator.go @@ -12,6 +12,14 @@ type Authenticator struct { mock.Mock } +type Authenticator_Expecter struct { + mock *mock.Mock +} + +func (_m *Authenticator) EXPECT() *Authenticator_Expecter { + return &Authenticator_Expecter{mock: &_m.Mock} +} + // IsValid provides a mock function with given fields: ginCtx func (_m *Authenticator) IsValid(ginCtx *gin.Context) (bool, error) { ret := _m.Called(ginCtx) @@ -36,6 +44,34 @@ func (_m *Authenticator) IsValid(ginCtx *gin.Context) (bool, error) { return r0, r1 } +// Authenticator_IsValid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsValid' +type Authenticator_IsValid_Call struct { + *mock.Call +} + +// IsValid is a helper method to define mock.On call +// - ginCtx *gin.Context +func (_e *Authenticator_Expecter) IsValid(ginCtx interface{}) *Authenticator_IsValid_Call { + return &Authenticator_IsValid_Call{Call: _e.mock.On("IsValid", ginCtx)} +} + +func (_c *Authenticator_IsValid_Call) Run(run func(ginCtx *gin.Context)) *Authenticator_IsValid_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*gin.Context)) + }) + return _c +} + +func (_c *Authenticator_IsValid_Call) Return(_a0 bool, _a1 error) *Authenticator_IsValid_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Authenticator_IsValid_Call) RunAndReturn(run func(*gin.Context) (bool, error)) *Authenticator_IsValid_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewAuthenticator interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/auth/mocks/JwtTokenHandler.go b/pkg/apiserver/auth/mocks/JwtTokenHandler.go index f8f30b90c..b929fed00 100644 --- a/pkg/apiserver/auth/mocks/JwtTokenHandler.go +++ b/pkg/apiserver/auth/mocks/JwtTokenHandler.go @@ -14,6 +14,14 @@ type JwtTokenHandler struct { mock.Mock } +type JwtTokenHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *JwtTokenHandler) EXPECT() *JwtTokenHandler_Expecter { + return &JwtTokenHandler_Expecter{mock: &_m.Mock} +} + // Sign provides a mock function with given fields: user func (_m *JwtTokenHandler) Sign(user auth.SignUserInput) (*string, error) { ret := _m.Called(user) @@ -40,6 +48,34 @@ func (_m *JwtTokenHandler) Sign(user auth.SignUserInput) (*string, error) { return r0, r1 } +// JwtTokenHandler_Sign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sign' +type JwtTokenHandler_Sign_Call struct { + *mock.Call +} + +// Sign is a helper method to define mock.On call +// - user auth.SignUserInput +func (_e *JwtTokenHandler_Expecter) Sign(user interface{}) *JwtTokenHandler_Sign_Call { + return &JwtTokenHandler_Sign_Call{Call: _e.mock.On("Sign", user)} +} + +func (_c *JwtTokenHandler_Sign_Call) Run(run func(user auth.SignUserInput)) *JwtTokenHandler_Sign_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(auth.SignUserInput)) + }) + return _c +} + +func (_c *JwtTokenHandler_Sign_Call) Return(_a0 *string, _a1 error) *JwtTokenHandler_Sign_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *JwtTokenHandler_Sign_Call) RunAndReturn(run func(auth.SignUserInput) (*string, error)) *JwtTokenHandler_Sign_Call { + _c.Call.Return(run) + return _c +} + // Valid provides a mock function with given fields: jwtToken func (_m *JwtTokenHandler) Valid(jwtToken string) (bool, *jwt.Token, error) { ret := _m.Called(jwtToken) @@ -73,6 +109,34 @@ func (_m *JwtTokenHandler) Valid(jwtToken string) (bool, *jwt.Token, error) { return r0, r1, r2 } +// JwtTokenHandler_Valid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Valid' +type JwtTokenHandler_Valid_Call struct { + *mock.Call +} + +// Valid is a helper method to define mock.On call +// - jwtToken string +func (_e *JwtTokenHandler_Expecter) Valid(jwtToken interface{}) *JwtTokenHandler_Valid_Call { + return &JwtTokenHandler_Valid_Call{Call: _e.mock.On("Valid", jwtToken)} +} + +func (_c *JwtTokenHandler_Valid_Call) Run(run func(jwtToken string)) *JwtTokenHandler_Valid_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *JwtTokenHandler_Valid_Call) Return(_a0 bool, _a1 *jwt.Token, _a2 error) *JwtTokenHandler_Valid_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *JwtTokenHandler_Valid_Call) RunAndReturn(run func(string) (bool, *jwt.Token, error)) *JwtTokenHandler_Valid_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewJwtTokenHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/auth/mocks/TokenInfoProvider.go b/pkg/apiserver/auth/mocks/TokenInfoProvider.go index 3551c4aee..d5768d3e7 100644 --- a/pkg/apiserver/auth/mocks/TokenInfoProvider.go +++ b/pkg/apiserver/auth/mocks/TokenInfoProvider.go @@ -12,6 +12,14 @@ type TokenInfoProvider struct { mock.Mock } +type TokenInfoProvider_Expecter struct { + mock *mock.Mock +} + +func (_m *TokenInfoProvider) EXPECT() *TokenInfoProvider_Expecter { + return &TokenInfoProvider_Expecter{mock: &_m.Mock} +} + // GetTokenInfo provides a mock function with given fields: _a0 func (_m *TokenInfoProvider) GetTokenInfo(_a0 string) (*oauth2.Tokeninfo, error) { ret := _m.Called(_a0) @@ -38,6 +46,34 @@ func (_m *TokenInfoProvider) GetTokenInfo(_a0 string) (*oauth2.Tokeninfo, error) return r0, r1 } +// TokenInfoProvider_GetTokenInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTokenInfo' +type TokenInfoProvider_GetTokenInfo_Call struct { + *mock.Call +} + +// GetTokenInfo is a helper method to define mock.On call +// - _a0 string +func (_e *TokenInfoProvider_Expecter) GetTokenInfo(_a0 interface{}) *TokenInfoProvider_GetTokenInfo_Call { + return &TokenInfoProvider_GetTokenInfo_Call{Call: _e.mock.On("GetTokenInfo", _a0)} +} + +func (_c *TokenInfoProvider_GetTokenInfo_Call) Run(run func(_a0 string)) *TokenInfoProvider_GetTokenInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *TokenInfoProvider_GetTokenInfo_Call) Return(_a0 *oauth2.Tokeninfo, _a1 error) *TokenInfoProvider_GetTokenInfo_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TokenInfoProvider_GetTokenInfo_Call) RunAndReturn(run func(string) (*oauth2.Tokeninfo, error)) *TokenInfoProvider_GetTokenInfo_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTokenInfoProvider interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/BaseCreateHandler.go b/pkg/apiserver/crud/mocks/BaseCreateHandler.go index e2ad09c3f..6fed439aa 100644 --- a/pkg/apiserver/crud/mocks/BaseCreateHandler.go +++ b/pkg/apiserver/crud/mocks/BaseCreateHandler.go @@ -15,6 +15,14 @@ type BaseCreateHandler struct { mock.Mock } +type BaseCreateHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *BaseCreateHandler) EXPECT() *BaseCreateHandler_Expecter { + return &BaseCreateHandler_Expecter{mock: &_m.Mock} +} + // GetCreateInput provides a mock function with given fields: func (_m *BaseCreateHandler) GetCreateInput() interface{} { ret := _m.Called() @@ -31,6 +39,33 @@ func (_m *BaseCreateHandler) GetCreateInput() interface{} { return r0 } +// BaseCreateHandler_GetCreateInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCreateInput' +type BaseCreateHandler_GetCreateInput_Call struct { + *mock.Call +} + +// GetCreateInput is a helper method to define mock.On call +func (_e *BaseCreateHandler_Expecter) GetCreateInput() *BaseCreateHandler_GetCreateInput_Call { + return &BaseCreateHandler_GetCreateInput_Call{Call: _e.mock.On("GetCreateInput")} +} + +func (_c *BaseCreateHandler_GetCreateInput_Call) Run(run func()) *BaseCreateHandler_GetCreateInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *BaseCreateHandler_GetCreateInput_Call) Return(_a0 interface{}) *BaseCreateHandler_GetCreateInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BaseCreateHandler_GetCreateInput_Call) RunAndReturn(run func() interface{}) *BaseCreateHandler_GetCreateInput_Call { + _c.Call.Return(run) + return _c +} + // TransformCreate provides a mock function with given fields: ctx, input, model func (_m *BaseCreateHandler) TransformCreate(ctx context.Context, input interface{}, model db_repo.ModelBased) error { ret := _m.Called(ctx, input, model) @@ -45,6 +80,36 @@ func (_m *BaseCreateHandler) TransformCreate(ctx context.Context, input interfac return r0 } +// BaseCreateHandler_TransformCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformCreate' +type BaseCreateHandler_TransformCreate_Call struct { + *mock.Call +} + +// TransformCreate is a helper method to define mock.On call +// - ctx context.Context +// - input interface{} +// - model db_repo.ModelBased +func (_e *BaseCreateHandler_Expecter) TransformCreate(ctx interface{}, input interface{}, model interface{}) *BaseCreateHandler_TransformCreate_Call { + return &BaseCreateHandler_TransformCreate_Call{Call: _e.mock.On("TransformCreate", ctx, input, model)} +} + +func (_c *BaseCreateHandler_TransformCreate_Call) Run(run func(ctx context.Context, input interface{}, model db_repo.ModelBased)) *BaseCreateHandler_TransformCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *BaseCreateHandler_TransformCreate_Call) Return(err error) *BaseCreateHandler_TransformCreate_Call { + _c.Call.Return(err) + return _c +} + +func (_c *BaseCreateHandler_TransformCreate_Call) RunAndReturn(run func(context.Context, interface{}, db_repo.ModelBased) error) *BaseCreateHandler_TransformCreate_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewBaseCreateHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/BaseHandler.go b/pkg/apiserver/crud/mocks/BaseHandler.go index 53195b4c9..bd61173a6 100644 --- a/pkg/apiserver/crud/mocks/BaseHandler.go +++ b/pkg/apiserver/crud/mocks/BaseHandler.go @@ -16,6 +16,14 @@ type BaseHandler struct { mock.Mock } +type BaseHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *BaseHandler) EXPECT() *BaseHandler_Expecter { + return &BaseHandler_Expecter{mock: &_m.Mock} +} + // GetModel provides a mock function with given fields: func (_m *BaseHandler) GetModel() db_repo.ModelBased { ret := _m.Called() @@ -32,6 +40,33 @@ func (_m *BaseHandler) GetModel() db_repo.ModelBased { return r0 } +// BaseHandler_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type BaseHandler_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +func (_e *BaseHandler_Expecter) GetModel() *BaseHandler_GetModel_Call { + return &BaseHandler_GetModel_Call{Call: _e.mock.On("GetModel")} +} + +func (_c *BaseHandler_GetModel_Call) Run(run func()) *BaseHandler_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *BaseHandler_GetModel_Call) Return(_a0 db_repo.ModelBased) *BaseHandler_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BaseHandler_GetModel_Call) RunAndReturn(run func() db_repo.ModelBased) *BaseHandler_GetModel_Call { + _c.Call.Return(run) + return _c +} + // GetRepository provides a mock function with given fields: func (_m *BaseHandler) GetRepository() crud.Repository { ret := _m.Called() @@ -48,6 +83,33 @@ func (_m *BaseHandler) GetRepository() crud.Repository { return r0 } +// BaseHandler_GetRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepository' +type BaseHandler_GetRepository_Call struct { + *mock.Call +} + +// GetRepository is a helper method to define mock.On call +func (_e *BaseHandler_Expecter) GetRepository() *BaseHandler_GetRepository_Call { + return &BaseHandler_GetRepository_Call{Call: _e.mock.On("GetRepository")} +} + +func (_c *BaseHandler_GetRepository_Call) Run(run func()) *BaseHandler_GetRepository_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *BaseHandler_GetRepository_Call) Return(_a0 crud.Repository) *BaseHandler_GetRepository_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BaseHandler_GetRepository_Call) RunAndReturn(run func() crud.Repository) *BaseHandler_GetRepository_Call { + _c.Call.Return(run) + return _c +} + // TransformOutput provides a mock function with given fields: ctx, model, apiView func (_m *BaseHandler) TransformOutput(ctx context.Context, model db_repo.ModelBased, apiView string) (interface{}, error) { ret := _m.Called(ctx, model, apiView) @@ -74,6 +136,36 @@ func (_m *BaseHandler) TransformOutput(ctx context.Context, model db_repo.ModelB return r0, r1 } +// BaseHandler_TransformOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformOutput' +type BaseHandler_TransformOutput_Call struct { + *mock.Call +} + +// TransformOutput is a helper method to define mock.On call +// - ctx context.Context +// - model db_repo.ModelBased +// - apiView string +func (_e *BaseHandler_Expecter) TransformOutput(ctx interface{}, model interface{}, apiView interface{}) *BaseHandler_TransformOutput_Call { + return &BaseHandler_TransformOutput_Call{Call: _e.mock.On("TransformOutput", ctx, model, apiView)} +} + +func (_c *BaseHandler_TransformOutput_Call) Run(run func(ctx context.Context, model db_repo.ModelBased, apiView string)) *BaseHandler_TransformOutput_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased), args[2].(string)) + }) + return _c +} + +func (_c *BaseHandler_TransformOutput_Call) Return(output interface{}, err error) *BaseHandler_TransformOutput_Call { + _c.Call.Return(output, err) + return _c +} + +func (_c *BaseHandler_TransformOutput_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased, string) (interface{}, error)) *BaseHandler_TransformOutput_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewBaseHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/BaseListHandler.go b/pkg/apiserver/crud/mocks/BaseListHandler.go index 2db5a72d2..cf0866f3f 100644 --- a/pkg/apiserver/crud/mocks/BaseListHandler.go +++ b/pkg/apiserver/crud/mocks/BaseListHandler.go @@ -15,6 +15,14 @@ type BaseListHandler struct { mock.Mock } +type BaseListHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *BaseListHandler) EXPECT() *BaseListHandler_Expecter { + return &BaseListHandler_Expecter{mock: &_m.Mock} +} + // List provides a mock function with given fields: ctx, qb, apiView func (_m *BaseListHandler) List(ctx context.Context, qb *db_repo.QueryBuilder, apiView string) (interface{}, error) { ret := _m.Called(ctx, qb, apiView) @@ -41,6 +49,36 @@ func (_m *BaseListHandler) List(ctx context.Context, qb *db_repo.QueryBuilder, a return r0, r1 } +// BaseListHandler_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type BaseListHandler_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - apiView string +func (_e *BaseListHandler_Expecter) List(ctx interface{}, qb interface{}, apiView interface{}) *BaseListHandler_List_Call { + return &BaseListHandler_List_Call{Call: _e.mock.On("List", ctx, qb, apiView)} +} + +func (_c *BaseListHandler_List_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, apiView string)) *BaseListHandler_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(string)) + }) + return _c +} + +func (_c *BaseListHandler_List_Call) Return(out interface{}, err error) *BaseListHandler_List_Call { + _c.Call.Return(out, err) + return _c +} + +func (_c *BaseListHandler_List_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, string) (interface{}, error)) *BaseListHandler_List_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewBaseListHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/BaseUpdateHandler.go b/pkg/apiserver/crud/mocks/BaseUpdateHandler.go index af862543a..ebbf971ab 100644 --- a/pkg/apiserver/crud/mocks/BaseUpdateHandler.go +++ b/pkg/apiserver/crud/mocks/BaseUpdateHandler.go @@ -15,6 +15,14 @@ type BaseUpdateHandler struct { mock.Mock } +type BaseUpdateHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *BaseUpdateHandler) EXPECT() *BaseUpdateHandler_Expecter { + return &BaseUpdateHandler_Expecter{mock: &_m.Mock} +} + // GetUpdateInput provides a mock function with given fields: func (_m *BaseUpdateHandler) GetUpdateInput() interface{} { ret := _m.Called() @@ -31,6 +39,33 @@ func (_m *BaseUpdateHandler) GetUpdateInput() interface{} { return r0 } +// BaseUpdateHandler_GetUpdateInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUpdateInput' +type BaseUpdateHandler_GetUpdateInput_Call struct { + *mock.Call +} + +// GetUpdateInput is a helper method to define mock.On call +func (_e *BaseUpdateHandler_Expecter) GetUpdateInput() *BaseUpdateHandler_GetUpdateInput_Call { + return &BaseUpdateHandler_GetUpdateInput_Call{Call: _e.mock.On("GetUpdateInput")} +} + +func (_c *BaseUpdateHandler_GetUpdateInput_Call) Run(run func()) *BaseUpdateHandler_GetUpdateInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *BaseUpdateHandler_GetUpdateInput_Call) Return(_a0 interface{}) *BaseUpdateHandler_GetUpdateInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BaseUpdateHandler_GetUpdateInput_Call) RunAndReturn(run func() interface{}) *BaseUpdateHandler_GetUpdateInput_Call { + _c.Call.Return(run) + return _c +} + // TransformUpdate provides a mock function with given fields: ctx, input, model func (_m *BaseUpdateHandler) TransformUpdate(ctx context.Context, input interface{}, model db_repo.ModelBased) error { ret := _m.Called(ctx, input, model) @@ -45,6 +80,36 @@ func (_m *BaseUpdateHandler) TransformUpdate(ctx context.Context, input interfac return r0 } +// BaseUpdateHandler_TransformUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformUpdate' +type BaseUpdateHandler_TransformUpdate_Call struct { + *mock.Call +} + +// TransformUpdate is a helper method to define mock.On call +// - ctx context.Context +// - input interface{} +// - model db_repo.ModelBased +func (_e *BaseUpdateHandler_Expecter) TransformUpdate(ctx interface{}, input interface{}, model interface{}) *BaseUpdateHandler_TransformUpdate_Call { + return &BaseUpdateHandler_TransformUpdate_Call{Call: _e.mock.On("TransformUpdate", ctx, input, model)} +} + +func (_c *BaseUpdateHandler_TransformUpdate_Call) Run(run func(ctx context.Context, input interface{}, model db_repo.ModelBased)) *BaseUpdateHandler_TransformUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *BaseUpdateHandler_TransformUpdate_Call) Return(err error) *BaseUpdateHandler_TransformUpdate_Call { + _c.Call.Return(err) + return _c +} + +func (_c *BaseUpdateHandler_TransformUpdate_Call) RunAndReturn(run func(context.Context, interface{}, db_repo.ModelBased) error) *BaseUpdateHandler_TransformUpdate_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewBaseUpdateHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/CreateHandler.go b/pkg/apiserver/crud/mocks/CreateHandler.go index 3e9888ff5..417c53fdc 100644 --- a/pkg/apiserver/crud/mocks/CreateHandler.go +++ b/pkg/apiserver/crud/mocks/CreateHandler.go @@ -16,6 +16,14 @@ type CreateHandler struct { mock.Mock } +type CreateHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *CreateHandler) EXPECT() *CreateHandler_Expecter { + return &CreateHandler_Expecter{mock: &_m.Mock} +} + // GetCreateInput provides a mock function with given fields: func (_m *CreateHandler) GetCreateInput() interface{} { ret := _m.Called() @@ -32,6 +40,33 @@ func (_m *CreateHandler) GetCreateInput() interface{} { return r0 } +// CreateHandler_GetCreateInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCreateInput' +type CreateHandler_GetCreateInput_Call struct { + *mock.Call +} + +// GetCreateInput is a helper method to define mock.On call +func (_e *CreateHandler_Expecter) GetCreateInput() *CreateHandler_GetCreateInput_Call { + return &CreateHandler_GetCreateInput_Call{Call: _e.mock.On("GetCreateInput")} +} + +func (_c *CreateHandler_GetCreateInput_Call) Run(run func()) *CreateHandler_GetCreateInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *CreateHandler_GetCreateInput_Call) Return(_a0 interface{}) *CreateHandler_GetCreateInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CreateHandler_GetCreateInput_Call) RunAndReturn(run func() interface{}) *CreateHandler_GetCreateInput_Call { + _c.Call.Return(run) + return _c +} + // GetModel provides a mock function with given fields: func (_m *CreateHandler) GetModel() db_repo.ModelBased { ret := _m.Called() @@ -48,6 +83,33 @@ func (_m *CreateHandler) GetModel() db_repo.ModelBased { return r0 } +// CreateHandler_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type CreateHandler_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +func (_e *CreateHandler_Expecter) GetModel() *CreateHandler_GetModel_Call { + return &CreateHandler_GetModel_Call{Call: _e.mock.On("GetModel")} +} + +func (_c *CreateHandler_GetModel_Call) Run(run func()) *CreateHandler_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *CreateHandler_GetModel_Call) Return(_a0 db_repo.ModelBased) *CreateHandler_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CreateHandler_GetModel_Call) RunAndReturn(run func() db_repo.ModelBased) *CreateHandler_GetModel_Call { + _c.Call.Return(run) + return _c +} + // GetRepository provides a mock function with given fields: func (_m *CreateHandler) GetRepository() crud.Repository { ret := _m.Called() @@ -64,6 +126,33 @@ func (_m *CreateHandler) GetRepository() crud.Repository { return r0 } +// CreateHandler_GetRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepository' +type CreateHandler_GetRepository_Call struct { + *mock.Call +} + +// GetRepository is a helper method to define mock.On call +func (_e *CreateHandler_Expecter) GetRepository() *CreateHandler_GetRepository_Call { + return &CreateHandler_GetRepository_Call{Call: _e.mock.On("GetRepository")} +} + +func (_c *CreateHandler_GetRepository_Call) Run(run func()) *CreateHandler_GetRepository_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *CreateHandler_GetRepository_Call) Return(_a0 crud.Repository) *CreateHandler_GetRepository_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CreateHandler_GetRepository_Call) RunAndReturn(run func() crud.Repository) *CreateHandler_GetRepository_Call { + _c.Call.Return(run) + return _c +} + // TransformCreate provides a mock function with given fields: ctx, input, model func (_m *CreateHandler) TransformCreate(ctx context.Context, input interface{}, model db_repo.ModelBased) error { ret := _m.Called(ctx, input, model) @@ -78,6 +167,36 @@ func (_m *CreateHandler) TransformCreate(ctx context.Context, input interface{}, return r0 } +// CreateHandler_TransformCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformCreate' +type CreateHandler_TransformCreate_Call struct { + *mock.Call +} + +// TransformCreate is a helper method to define mock.On call +// - ctx context.Context +// - input interface{} +// - model db_repo.ModelBased +func (_e *CreateHandler_Expecter) TransformCreate(ctx interface{}, input interface{}, model interface{}) *CreateHandler_TransformCreate_Call { + return &CreateHandler_TransformCreate_Call{Call: _e.mock.On("TransformCreate", ctx, input, model)} +} + +func (_c *CreateHandler_TransformCreate_Call) Run(run func(ctx context.Context, input interface{}, model db_repo.ModelBased)) *CreateHandler_TransformCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *CreateHandler_TransformCreate_Call) Return(err error) *CreateHandler_TransformCreate_Call { + _c.Call.Return(err) + return _c +} + +func (_c *CreateHandler_TransformCreate_Call) RunAndReturn(run func(context.Context, interface{}, db_repo.ModelBased) error) *CreateHandler_TransformCreate_Call { + _c.Call.Return(run) + return _c +} + // TransformOutput provides a mock function with given fields: ctx, model, apiView func (_m *CreateHandler) TransformOutput(ctx context.Context, model db_repo.ModelBased, apiView string) (interface{}, error) { ret := _m.Called(ctx, model, apiView) @@ -104,6 +223,36 @@ func (_m *CreateHandler) TransformOutput(ctx context.Context, model db_repo.Mode return r0, r1 } +// CreateHandler_TransformOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformOutput' +type CreateHandler_TransformOutput_Call struct { + *mock.Call +} + +// TransformOutput is a helper method to define mock.On call +// - ctx context.Context +// - model db_repo.ModelBased +// - apiView string +func (_e *CreateHandler_Expecter) TransformOutput(ctx interface{}, model interface{}, apiView interface{}) *CreateHandler_TransformOutput_Call { + return &CreateHandler_TransformOutput_Call{Call: _e.mock.On("TransformOutput", ctx, model, apiView)} +} + +func (_c *CreateHandler_TransformOutput_Call) Run(run func(ctx context.Context, model db_repo.ModelBased, apiView string)) *CreateHandler_TransformOutput_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased), args[2].(string)) + }) + return _c +} + +func (_c *CreateHandler_TransformOutput_Call) Return(output interface{}, err error) *CreateHandler_TransformOutput_Call { + _c.Call.Return(output, err) + return _c +} + +func (_c *CreateHandler_TransformOutput_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased, string) (interface{}, error)) *CreateHandler_TransformOutput_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewCreateHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/Handler.go b/pkg/apiserver/crud/mocks/Handler.go index c2a168d62..05726729a 100644 --- a/pkg/apiserver/crud/mocks/Handler.go +++ b/pkg/apiserver/crud/mocks/Handler.go @@ -16,6 +16,14 @@ type Handler struct { mock.Mock } +type Handler_Expecter struct { + mock *mock.Mock +} + +func (_m *Handler) EXPECT() *Handler_Expecter { + return &Handler_Expecter{mock: &_m.Mock} +} + // GetCreateInput provides a mock function with given fields: func (_m *Handler) GetCreateInput() interface{} { ret := _m.Called() @@ -32,6 +40,33 @@ func (_m *Handler) GetCreateInput() interface{} { return r0 } +// Handler_GetCreateInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCreateInput' +type Handler_GetCreateInput_Call struct { + *mock.Call +} + +// GetCreateInput is a helper method to define mock.On call +func (_e *Handler_Expecter) GetCreateInput() *Handler_GetCreateInput_Call { + return &Handler_GetCreateInput_Call{Call: _e.mock.On("GetCreateInput")} +} + +func (_c *Handler_GetCreateInput_Call) Run(run func()) *Handler_GetCreateInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Handler_GetCreateInput_Call) Return(_a0 interface{}) *Handler_GetCreateInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Handler_GetCreateInput_Call) RunAndReturn(run func() interface{}) *Handler_GetCreateInput_Call { + _c.Call.Return(run) + return _c +} + // GetModel provides a mock function with given fields: func (_m *Handler) GetModel() db_repo.ModelBased { ret := _m.Called() @@ -48,6 +83,33 @@ func (_m *Handler) GetModel() db_repo.ModelBased { return r0 } +// Handler_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type Handler_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +func (_e *Handler_Expecter) GetModel() *Handler_GetModel_Call { + return &Handler_GetModel_Call{Call: _e.mock.On("GetModel")} +} + +func (_c *Handler_GetModel_Call) Run(run func()) *Handler_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Handler_GetModel_Call) Return(_a0 db_repo.ModelBased) *Handler_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Handler_GetModel_Call) RunAndReturn(run func() db_repo.ModelBased) *Handler_GetModel_Call { + _c.Call.Return(run) + return _c +} + // GetRepository provides a mock function with given fields: func (_m *Handler) GetRepository() crud.Repository { ret := _m.Called() @@ -64,6 +126,33 @@ func (_m *Handler) GetRepository() crud.Repository { return r0 } +// Handler_GetRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepository' +type Handler_GetRepository_Call struct { + *mock.Call +} + +// GetRepository is a helper method to define mock.On call +func (_e *Handler_Expecter) GetRepository() *Handler_GetRepository_Call { + return &Handler_GetRepository_Call{Call: _e.mock.On("GetRepository")} +} + +func (_c *Handler_GetRepository_Call) Run(run func()) *Handler_GetRepository_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Handler_GetRepository_Call) Return(_a0 crud.Repository) *Handler_GetRepository_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Handler_GetRepository_Call) RunAndReturn(run func() crud.Repository) *Handler_GetRepository_Call { + _c.Call.Return(run) + return _c +} + // GetUpdateInput provides a mock function with given fields: func (_m *Handler) GetUpdateInput() interface{} { ret := _m.Called() @@ -80,6 +169,33 @@ func (_m *Handler) GetUpdateInput() interface{} { return r0 } +// Handler_GetUpdateInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUpdateInput' +type Handler_GetUpdateInput_Call struct { + *mock.Call +} + +// GetUpdateInput is a helper method to define mock.On call +func (_e *Handler_Expecter) GetUpdateInput() *Handler_GetUpdateInput_Call { + return &Handler_GetUpdateInput_Call{Call: _e.mock.On("GetUpdateInput")} +} + +func (_c *Handler_GetUpdateInput_Call) Run(run func()) *Handler_GetUpdateInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Handler_GetUpdateInput_Call) Return(_a0 interface{}) *Handler_GetUpdateInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Handler_GetUpdateInput_Call) RunAndReturn(run func() interface{}) *Handler_GetUpdateInput_Call { + _c.Call.Return(run) + return _c +} + // List provides a mock function with given fields: ctx, qb, apiView func (_m *Handler) List(ctx context.Context, qb *db_repo.QueryBuilder, apiView string) (interface{}, error) { ret := _m.Called(ctx, qb, apiView) @@ -106,6 +222,36 @@ func (_m *Handler) List(ctx context.Context, qb *db_repo.QueryBuilder, apiView s return r0, r1 } +// Handler_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type Handler_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - apiView string +func (_e *Handler_Expecter) List(ctx interface{}, qb interface{}, apiView interface{}) *Handler_List_Call { + return &Handler_List_Call{Call: _e.mock.On("List", ctx, qb, apiView)} +} + +func (_c *Handler_List_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, apiView string)) *Handler_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(string)) + }) + return _c +} + +func (_c *Handler_List_Call) Return(out interface{}, err error) *Handler_List_Call { + _c.Call.Return(out, err) + return _c +} + +func (_c *Handler_List_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, string) (interface{}, error)) *Handler_List_Call { + _c.Call.Return(run) + return _c +} + // TransformCreate provides a mock function with given fields: ctx, input, model func (_m *Handler) TransformCreate(ctx context.Context, input interface{}, model db_repo.ModelBased) error { ret := _m.Called(ctx, input, model) @@ -120,6 +266,36 @@ func (_m *Handler) TransformCreate(ctx context.Context, input interface{}, model return r0 } +// Handler_TransformCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformCreate' +type Handler_TransformCreate_Call struct { + *mock.Call +} + +// TransformCreate is a helper method to define mock.On call +// - ctx context.Context +// - input interface{} +// - model db_repo.ModelBased +func (_e *Handler_Expecter) TransformCreate(ctx interface{}, input interface{}, model interface{}) *Handler_TransformCreate_Call { + return &Handler_TransformCreate_Call{Call: _e.mock.On("TransformCreate", ctx, input, model)} +} + +func (_c *Handler_TransformCreate_Call) Run(run func(ctx context.Context, input interface{}, model db_repo.ModelBased)) *Handler_TransformCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Handler_TransformCreate_Call) Return(err error) *Handler_TransformCreate_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Handler_TransformCreate_Call) RunAndReturn(run func(context.Context, interface{}, db_repo.ModelBased) error) *Handler_TransformCreate_Call { + _c.Call.Return(run) + return _c +} + // TransformOutput provides a mock function with given fields: ctx, model, apiView func (_m *Handler) TransformOutput(ctx context.Context, model db_repo.ModelBased, apiView string) (interface{}, error) { ret := _m.Called(ctx, model, apiView) @@ -146,6 +322,36 @@ func (_m *Handler) TransformOutput(ctx context.Context, model db_repo.ModelBased return r0, r1 } +// Handler_TransformOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformOutput' +type Handler_TransformOutput_Call struct { + *mock.Call +} + +// TransformOutput is a helper method to define mock.On call +// - ctx context.Context +// - model db_repo.ModelBased +// - apiView string +func (_e *Handler_Expecter) TransformOutput(ctx interface{}, model interface{}, apiView interface{}) *Handler_TransformOutput_Call { + return &Handler_TransformOutput_Call{Call: _e.mock.On("TransformOutput", ctx, model, apiView)} +} + +func (_c *Handler_TransformOutput_Call) Run(run func(ctx context.Context, model db_repo.ModelBased, apiView string)) *Handler_TransformOutput_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased), args[2].(string)) + }) + return _c +} + +func (_c *Handler_TransformOutput_Call) Return(output interface{}, err error) *Handler_TransformOutput_Call { + _c.Call.Return(output, err) + return _c +} + +func (_c *Handler_TransformOutput_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased, string) (interface{}, error)) *Handler_TransformOutput_Call { + _c.Call.Return(run) + return _c +} + // TransformUpdate provides a mock function with given fields: ctx, input, model func (_m *Handler) TransformUpdate(ctx context.Context, input interface{}, model db_repo.ModelBased) error { ret := _m.Called(ctx, input, model) @@ -160,6 +366,36 @@ func (_m *Handler) TransformUpdate(ctx context.Context, input interface{}, model return r0 } +// Handler_TransformUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformUpdate' +type Handler_TransformUpdate_Call struct { + *mock.Call +} + +// TransformUpdate is a helper method to define mock.On call +// - ctx context.Context +// - input interface{} +// - model db_repo.ModelBased +func (_e *Handler_Expecter) TransformUpdate(ctx interface{}, input interface{}, model interface{}) *Handler_TransformUpdate_Call { + return &Handler_TransformUpdate_Call{Call: _e.mock.On("TransformUpdate", ctx, input, model)} +} + +func (_c *Handler_TransformUpdate_Call) Run(run func(ctx context.Context, input interface{}, model db_repo.ModelBased)) *Handler_TransformUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Handler_TransformUpdate_Call) Return(err error) *Handler_TransformUpdate_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Handler_TransformUpdate_Call) RunAndReturn(run func(context.Context, interface{}, db_repo.ModelBased) error) *Handler_TransformUpdate_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/ListHandler.go b/pkg/apiserver/crud/mocks/ListHandler.go index 07fa740e4..f4d78e689 100644 --- a/pkg/apiserver/crud/mocks/ListHandler.go +++ b/pkg/apiserver/crud/mocks/ListHandler.go @@ -16,6 +16,14 @@ type ListHandler struct { mock.Mock } +type ListHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *ListHandler) EXPECT() *ListHandler_Expecter { + return &ListHandler_Expecter{mock: &_m.Mock} +} + // GetModel provides a mock function with given fields: func (_m *ListHandler) GetModel() db_repo.ModelBased { ret := _m.Called() @@ -32,6 +40,33 @@ func (_m *ListHandler) GetModel() db_repo.ModelBased { return r0 } +// ListHandler_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type ListHandler_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +func (_e *ListHandler_Expecter) GetModel() *ListHandler_GetModel_Call { + return &ListHandler_GetModel_Call{Call: _e.mock.On("GetModel")} +} + +func (_c *ListHandler_GetModel_Call) Run(run func()) *ListHandler_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ListHandler_GetModel_Call) Return(_a0 db_repo.ModelBased) *ListHandler_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ListHandler_GetModel_Call) RunAndReturn(run func() db_repo.ModelBased) *ListHandler_GetModel_Call { + _c.Call.Return(run) + return _c +} + // GetRepository provides a mock function with given fields: func (_m *ListHandler) GetRepository() crud.Repository { ret := _m.Called() @@ -48,6 +83,33 @@ func (_m *ListHandler) GetRepository() crud.Repository { return r0 } +// ListHandler_GetRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepository' +type ListHandler_GetRepository_Call struct { + *mock.Call +} + +// GetRepository is a helper method to define mock.On call +func (_e *ListHandler_Expecter) GetRepository() *ListHandler_GetRepository_Call { + return &ListHandler_GetRepository_Call{Call: _e.mock.On("GetRepository")} +} + +func (_c *ListHandler_GetRepository_Call) Run(run func()) *ListHandler_GetRepository_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ListHandler_GetRepository_Call) Return(_a0 crud.Repository) *ListHandler_GetRepository_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ListHandler_GetRepository_Call) RunAndReturn(run func() crud.Repository) *ListHandler_GetRepository_Call { + _c.Call.Return(run) + return _c +} + // List provides a mock function with given fields: ctx, qb, apiView func (_m *ListHandler) List(ctx context.Context, qb *db_repo.QueryBuilder, apiView string) (interface{}, error) { ret := _m.Called(ctx, qb, apiView) @@ -74,6 +136,36 @@ func (_m *ListHandler) List(ctx context.Context, qb *db_repo.QueryBuilder, apiVi return r0, r1 } +// ListHandler_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type ListHandler_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - apiView string +func (_e *ListHandler_Expecter) List(ctx interface{}, qb interface{}, apiView interface{}) *ListHandler_List_Call { + return &ListHandler_List_Call{Call: _e.mock.On("List", ctx, qb, apiView)} +} + +func (_c *ListHandler_List_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, apiView string)) *ListHandler_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(string)) + }) + return _c +} + +func (_c *ListHandler_List_Call) Return(out interface{}, err error) *ListHandler_List_Call { + _c.Call.Return(out, err) + return _c +} + +func (_c *ListHandler_List_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, string) (interface{}, error)) *ListHandler_List_Call { + _c.Call.Return(run) + return _c +} + // TransformOutput provides a mock function with given fields: ctx, model, apiView func (_m *ListHandler) TransformOutput(ctx context.Context, model db_repo.ModelBased, apiView string) (interface{}, error) { ret := _m.Called(ctx, model, apiView) @@ -100,6 +192,36 @@ func (_m *ListHandler) TransformOutput(ctx context.Context, model db_repo.ModelB return r0, r1 } +// ListHandler_TransformOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformOutput' +type ListHandler_TransformOutput_Call struct { + *mock.Call +} + +// TransformOutput is a helper method to define mock.On call +// - ctx context.Context +// - model db_repo.ModelBased +// - apiView string +func (_e *ListHandler_Expecter) TransformOutput(ctx interface{}, model interface{}, apiView interface{}) *ListHandler_TransformOutput_Call { + return &ListHandler_TransformOutput_Call{Call: _e.mock.On("TransformOutput", ctx, model, apiView)} +} + +func (_c *ListHandler_TransformOutput_Call) Run(run func(ctx context.Context, model db_repo.ModelBased, apiView string)) *ListHandler_TransformOutput_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased), args[2].(string)) + }) + return _c +} + +func (_c *ListHandler_TransformOutput_Call) Return(output interface{}, err error) *ListHandler_TransformOutput_Call { + _c.Call.Return(output, err) + return _c +} + +func (_c *ListHandler_TransformOutput_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased, string) (interface{}, error)) *ListHandler_TransformOutput_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewListHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/Repository.go b/pkg/apiserver/crud/mocks/Repository.go index dd8ed5f57..3e82f5aff 100644 --- a/pkg/apiserver/crud/mocks/Repository.go +++ b/pkg/apiserver/crud/mocks/Repository.go @@ -15,6 +15,14 @@ type Repository struct { mock.Mock } +type Repository_Expecter struct { + mock *mock.Mock +} + +func (_m *Repository) EXPECT() *Repository_Expecter { + return &Repository_Expecter{mock: &_m.Mock} +} + // Count provides a mock function with given fields: ctx, qb, model func (_m *Repository) Count(ctx context.Context, qb *db_repo.QueryBuilder, model db_repo.ModelBased) (int, error) { ret := _m.Called(ctx, qb, model) @@ -39,6 +47,36 @@ func (_m *Repository) Count(ctx context.Context, qb *db_repo.QueryBuilder, model return r0, r1 } +// Repository_Count_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Count' +type Repository_Count_Call struct { + *mock.Call +} + +// Count is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - model db_repo.ModelBased +func (_e *Repository_Expecter) Count(ctx interface{}, qb interface{}, model interface{}) *Repository_Count_Call { + return &Repository_Count_Call{Call: _e.mock.On("Count", ctx, qb, model)} +} + +func (_c *Repository_Count_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, model db_repo.ModelBased)) *Repository_Count_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Count_Call) Return(_a0 int, _a1 error) *Repository_Count_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_Count_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, db_repo.ModelBased) (int, error)) *Repository_Count_Call { + _c.Call.Return(run) + return _c +} + // Create provides a mock function with given fields: ctx, value func (_m *Repository) Create(ctx context.Context, value db_repo.ModelBased) error { ret := _m.Called(ctx, value) @@ -53,6 +91,35 @@ func (_m *Repository) Create(ctx context.Context, value db_repo.ModelBased) erro return r0 } +// Repository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type Repository_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - value db_repo.ModelBased +func (_e *Repository_Expecter) Create(ctx interface{}, value interface{}) *Repository_Create_Call { + return &Repository_Create_Call{Call: _e.mock.On("Create", ctx, value)} +} + +func (_c *Repository_Create_Call) Run(run func(ctx context.Context, value db_repo.ModelBased)) *Repository_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Create_Call) Return(_a0 error) *Repository_Create_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Create_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased) error) *Repository_Create_Call { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: ctx, value func (_m *Repository) Delete(ctx context.Context, value db_repo.ModelBased) error { ret := _m.Called(ctx, value) @@ -67,6 +134,35 @@ func (_m *Repository) Delete(ctx context.Context, value db_repo.ModelBased) erro return r0 } +// Repository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type Repository_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - value db_repo.ModelBased +func (_e *Repository_Expecter) Delete(ctx interface{}, value interface{}) *Repository_Delete_Call { + return &Repository_Delete_Call{Call: _e.mock.On("Delete", ctx, value)} +} + +func (_c *Repository_Delete_Call) Run(run func(ctx context.Context, value db_repo.ModelBased)) *Repository_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Delete_Call) Return(_a0 error) *Repository_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Delete_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased) error) *Repository_Delete_Call { + _c.Call.Return(run) + return _c +} + // GetMetadata provides a mock function with given fields: func (_m *Repository) GetMetadata() db_repo.Metadata { ret := _m.Called() @@ -81,6 +177,33 @@ func (_m *Repository) GetMetadata() db_repo.Metadata { return r0 } +// Repository_GetMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetadata' +type Repository_GetMetadata_Call struct { + *mock.Call +} + +// GetMetadata is a helper method to define mock.On call +func (_e *Repository_Expecter) GetMetadata() *Repository_GetMetadata_Call { + return &Repository_GetMetadata_Call{Call: _e.mock.On("GetMetadata")} +} + +func (_c *Repository_GetMetadata_Call) Run(run func()) *Repository_GetMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_GetMetadata_Call) Return(_a0 db_repo.Metadata) *Repository_GetMetadata_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_GetMetadata_Call) RunAndReturn(run func() db_repo.Metadata) *Repository_GetMetadata_Call { + _c.Call.Return(run) + return _c +} + // Query provides a mock function with given fields: ctx, qb, result func (_m *Repository) Query(ctx context.Context, qb *db_repo.QueryBuilder, result interface{}) error { ret := _m.Called(ctx, qb, result) @@ -95,6 +218,36 @@ func (_m *Repository) Query(ctx context.Context, qb *db_repo.QueryBuilder, resul return r0 } +// Repository_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' +type Repository_Query_Call struct { + *mock.Call +} + +// Query is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - result interface{} +func (_e *Repository_Expecter) Query(ctx interface{}, qb interface{}, result interface{}) *Repository_Query_Call { + return &Repository_Query_Call{Call: _e.mock.On("Query", ctx, qb, result)} +} + +func (_c *Repository_Query_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, result interface{})) *Repository_Query_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_Query_Call) Return(_a0 error) *Repository_Query_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Query_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, interface{}) error) *Repository_Query_Call { + _c.Call.Return(run) + return _c +} + // Read provides a mock function with given fields: ctx, id, out func (_m *Repository) Read(ctx context.Context, id *uint, out db_repo.ModelBased) error { ret := _m.Called(ctx, id, out) @@ -109,6 +262,36 @@ func (_m *Repository) Read(ctx context.Context, id *uint, out db_repo.ModelBased return r0 } +// Repository_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type Repository_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - ctx context.Context +// - id *uint +// - out db_repo.ModelBased +func (_e *Repository_Expecter) Read(ctx interface{}, id interface{}, out interface{}) *Repository_Read_Call { + return &Repository_Read_Call{Call: _e.mock.On("Read", ctx, id, out)} +} + +func (_c *Repository_Read_Call) Run(run func(ctx context.Context, id *uint, out db_repo.ModelBased)) *Repository_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*uint), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Read_Call) Return(_a0 error) *Repository_Read_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Read_Call) RunAndReturn(run func(context.Context, *uint, db_repo.ModelBased) error) *Repository_Read_Call { + _c.Call.Return(run) + return _c +} + // Update provides a mock function with given fields: ctx, value func (_m *Repository) Update(ctx context.Context, value db_repo.ModelBased) error { ret := _m.Called(ctx, value) @@ -123,6 +306,35 @@ func (_m *Repository) Update(ctx context.Context, value db_repo.ModelBased) erro return r0 } +// Repository_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type Repository_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - ctx context.Context +// - value db_repo.ModelBased +func (_e *Repository_Expecter) Update(ctx interface{}, value interface{}) *Repository_Update_Call { + return &Repository_Update_Call{Call: _e.mock.On("Update", ctx, value)} +} + +func (_c *Repository_Update_Call) Run(run func(ctx context.Context, value db_repo.ModelBased)) *Repository_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Update_Call) Return(_a0 error) *Repository_Update_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Update_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased) error) *Repository_Update_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRepository interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/crud/mocks/UpdateHandler.go b/pkg/apiserver/crud/mocks/UpdateHandler.go index c08e4dded..05b64827d 100644 --- a/pkg/apiserver/crud/mocks/UpdateHandler.go +++ b/pkg/apiserver/crud/mocks/UpdateHandler.go @@ -16,6 +16,14 @@ type UpdateHandler struct { mock.Mock } +type UpdateHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *UpdateHandler) EXPECT() *UpdateHandler_Expecter { + return &UpdateHandler_Expecter{mock: &_m.Mock} +} + // GetModel provides a mock function with given fields: func (_m *UpdateHandler) GetModel() db_repo.ModelBased { ret := _m.Called() @@ -32,6 +40,33 @@ func (_m *UpdateHandler) GetModel() db_repo.ModelBased { return r0 } +// UpdateHandler_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type UpdateHandler_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +func (_e *UpdateHandler_Expecter) GetModel() *UpdateHandler_GetModel_Call { + return &UpdateHandler_GetModel_Call{Call: _e.mock.On("GetModel")} +} + +func (_c *UpdateHandler_GetModel_Call) Run(run func()) *UpdateHandler_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateHandler_GetModel_Call) Return(_a0 db_repo.ModelBased) *UpdateHandler_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateHandler_GetModel_Call) RunAndReturn(run func() db_repo.ModelBased) *UpdateHandler_GetModel_Call { + _c.Call.Return(run) + return _c +} + // GetRepository provides a mock function with given fields: func (_m *UpdateHandler) GetRepository() crud.Repository { ret := _m.Called() @@ -48,6 +83,33 @@ func (_m *UpdateHandler) GetRepository() crud.Repository { return r0 } +// UpdateHandler_GetRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepository' +type UpdateHandler_GetRepository_Call struct { + *mock.Call +} + +// GetRepository is a helper method to define mock.On call +func (_e *UpdateHandler_Expecter) GetRepository() *UpdateHandler_GetRepository_Call { + return &UpdateHandler_GetRepository_Call{Call: _e.mock.On("GetRepository")} +} + +func (_c *UpdateHandler_GetRepository_Call) Run(run func()) *UpdateHandler_GetRepository_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateHandler_GetRepository_Call) Return(_a0 crud.Repository) *UpdateHandler_GetRepository_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateHandler_GetRepository_Call) RunAndReturn(run func() crud.Repository) *UpdateHandler_GetRepository_Call { + _c.Call.Return(run) + return _c +} + // GetUpdateInput provides a mock function with given fields: func (_m *UpdateHandler) GetUpdateInput() interface{} { ret := _m.Called() @@ -64,6 +126,33 @@ func (_m *UpdateHandler) GetUpdateInput() interface{} { return r0 } +// UpdateHandler_GetUpdateInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUpdateInput' +type UpdateHandler_GetUpdateInput_Call struct { + *mock.Call +} + +// GetUpdateInput is a helper method to define mock.On call +func (_e *UpdateHandler_Expecter) GetUpdateInput() *UpdateHandler_GetUpdateInput_Call { + return &UpdateHandler_GetUpdateInput_Call{Call: _e.mock.On("GetUpdateInput")} +} + +func (_c *UpdateHandler_GetUpdateInput_Call) Run(run func()) *UpdateHandler_GetUpdateInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateHandler_GetUpdateInput_Call) Return(_a0 interface{}) *UpdateHandler_GetUpdateInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateHandler_GetUpdateInput_Call) RunAndReturn(run func() interface{}) *UpdateHandler_GetUpdateInput_Call { + _c.Call.Return(run) + return _c +} + // TransformOutput provides a mock function with given fields: ctx, model, apiView func (_m *UpdateHandler) TransformOutput(ctx context.Context, model db_repo.ModelBased, apiView string) (interface{}, error) { ret := _m.Called(ctx, model, apiView) @@ -90,6 +179,36 @@ func (_m *UpdateHandler) TransformOutput(ctx context.Context, model db_repo.Mode return r0, r1 } +// UpdateHandler_TransformOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformOutput' +type UpdateHandler_TransformOutput_Call struct { + *mock.Call +} + +// TransformOutput is a helper method to define mock.On call +// - ctx context.Context +// - model db_repo.ModelBased +// - apiView string +func (_e *UpdateHandler_Expecter) TransformOutput(ctx interface{}, model interface{}, apiView interface{}) *UpdateHandler_TransformOutput_Call { + return &UpdateHandler_TransformOutput_Call{Call: _e.mock.On("TransformOutput", ctx, model, apiView)} +} + +func (_c *UpdateHandler_TransformOutput_Call) Run(run func(ctx context.Context, model db_repo.ModelBased, apiView string)) *UpdateHandler_TransformOutput_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased), args[2].(string)) + }) + return _c +} + +func (_c *UpdateHandler_TransformOutput_Call) Return(output interface{}, err error) *UpdateHandler_TransformOutput_Call { + _c.Call.Return(output, err) + return _c +} + +func (_c *UpdateHandler_TransformOutput_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased, string) (interface{}, error)) *UpdateHandler_TransformOutput_Call { + _c.Call.Return(run) + return _c +} + // TransformUpdate provides a mock function with given fields: ctx, input, model func (_m *UpdateHandler) TransformUpdate(ctx context.Context, input interface{}, model db_repo.ModelBased) error { ret := _m.Called(ctx, input, model) @@ -104,6 +223,36 @@ func (_m *UpdateHandler) TransformUpdate(ctx context.Context, input interface{}, return r0 } +// UpdateHandler_TransformUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformUpdate' +type UpdateHandler_TransformUpdate_Call struct { + *mock.Call +} + +// TransformUpdate is a helper method to define mock.On call +// - ctx context.Context +// - input interface{} +// - model db_repo.ModelBased +func (_e *UpdateHandler_Expecter) TransformUpdate(ctx interface{}, input interface{}, model interface{}) *UpdateHandler_TransformUpdate_Call { + return &UpdateHandler_TransformUpdate_Call{Call: _e.mock.On("TransformUpdate", ctx, input, model)} +} + +func (_c *UpdateHandler_TransformUpdate_Call) Run(run func(ctx context.Context, input interface{}, model db_repo.ModelBased)) *UpdateHandler_TransformUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *UpdateHandler_TransformUpdate_Call) Return(err error) *UpdateHandler_TransformUpdate_Call { + _c.Call.Return(err) + return _c +} + +func (_c *UpdateHandler_TransformUpdate_Call) RunAndReturn(run func(context.Context, interface{}, db_repo.ModelBased) error) *UpdateHandler_TransformUpdate_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewUpdateHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/mocks/HandlerWithInput.go b/pkg/apiserver/mocks/HandlerWithInput.go index 78af601e6..d843e3011 100644 --- a/pkg/apiserver/mocks/HandlerWithInput.go +++ b/pkg/apiserver/mocks/HandlerWithInput.go @@ -15,6 +15,14 @@ type HandlerWithInput struct { mock.Mock } +type HandlerWithInput_Expecter struct { + mock *mock.Mock +} + +func (_m *HandlerWithInput) EXPECT() *HandlerWithInput_Expecter { + return &HandlerWithInput_Expecter{mock: &_m.Mock} +} + // GetInput provides a mock function with given fields: func (_m *HandlerWithInput) GetInput() interface{} { ret := _m.Called() @@ -31,6 +39,33 @@ func (_m *HandlerWithInput) GetInput() interface{} { return r0 } +// HandlerWithInput_GetInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInput' +type HandlerWithInput_GetInput_Call struct { + *mock.Call +} + +// GetInput is a helper method to define mock.On call +func (_e *HandlerWithInput_Expecter) GetInput() *HandlerWithInput_GetInput_Call { + return &HandlerWithInput_GetInput_Call{Call: _e.mock.On("GetInput")} +} + +func (_c *HandlerWithInput_GetInput_Call) Run(run func()) *HandlerWithInput_GetInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *HandlerWithInput_GetInput_Call) Return(_a0 interface{}) *HandlerWithInput_GetInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *HandlerWithInput_GetInput_Call) RunAndReturn(run func() interface{}) *HandlerWithInput_GetInput_Call { + _c.Call.Return(run) + return _c +} + // Handle provides a mock function with given fields: requestContext, request func (_m *HandlerWithInput) Handle(requestContext context.Context, request *apiserver.Request) (*apiserver.Response, error) { ret := _m.Called(requestContext, request) @@ -57,6 +92,35 @@ func (_m *HandlerWithInput) Handle(requestContext context.Context, request *apis return r0, r1 } +// HandlerWithInput_Handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Handle' +type HandlerWithInput_Handle_Call struct { + *mock.Call +} + +// Handle is a helper method to define mock.On call +// - requestContext context.Context +// - request *apiserver.Request +func (_e *HandlerWithInput_Expecter) Handle(requestContext interface{}, request interface{}) *HandlerWithInput_Handle_Call { + return &HandlerWithInput_Handle_Call{Call: _e.mock.On("Handle", requestContext, request)} +} + +func (_c *HandlerWithInput_Handle_Call) Run(run func(requestContext context.Context, request *apiserver.Request)) *HandlerWithInput_Handle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*apiserver.Request)) + }) + return _c +} + +func (_c *HandlerWithInput_Handle_Call) Return(response *apiserver.Response, error error) *HandlerWithInput_Handle_Call { + _c.Call.Return(response, error) + return _c +} + +func (_c *HandlerWithInput_Handle_Call) RunAndReturn(run func(context.Context, *apiserver.Request) (*apiserver.Response, error)) *HandlerWithInput_Handle_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewHandlerWithInput interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/mocks/HandlerWithMultipleBindings.go b/pkg/apiserver/mocks/HandlerWithMultipleBindings.go index 32f78a7a7..60db2ccd6 100644 --- a/pkg/apiserver/mocks/HandlerWithMultipleBindings.go +++ b/pkg/apiserver/mocks/HandlerWithMultipleBindings.go @@ -16,6 +16,14 @@ type HandlerWithMultipleBindings struct { mock.Mock } +type HandlerWithMultipleBindings_Expecter struct { + mock *mock.Mock +} + +func (_m *HandlerWithMultipleBindings) EXPECT() *HandlerWithMultipleBindings_Expecter { + return &HandlerWithMultipleBindings_Expecter{mock: &_m.Mock} +} + // GetBindings provides a mock function with given fields: func (_m *HandlerWithMultipleBindings) GetBindings() []binding.Binding { ret := _m.Called() @@ -32,6 +40,33 @@ func (_m *HandlerWithMultipleBindings) GetBindings() []binding.Binding { return r0 } +// HandlerWithMultipleBindings_GetBindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBindings' +type HandlerWithMultipleBindings_GetBindings_Call struct { + *mock.Call +} + +// GetBindings is a helper method to define mock.On call +func (_e *HandlerWithMultipleBindings_Expecter) GetBindings() *HandlerWithMultipleBindings_GetBindings_Call { + return &HandlerWithMultipleBindings_GetBindings_Call{Call: _e.mock.On("GetBindings")} +} + +func (_c *HandlerWithMultipleBindings_GetBindings_Call) Run(run func()) *HandlerWithMultipleBindings_GetBindings_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *HandlerWithMultipleBindings_GetBindings_Call) Return(_a0 []binding.Binding) *HandlerWithMultipleBindings_GetBindings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *HandlerWithMultipleBindings_GetBindings_Call) RunAndReturn(run func() []binding.Binding) *HandlerWithMultipleBindings_GetBindings_Call { + _c.Call.Return(run) + return _c +} + // GetInput provides a mock function with given fields: func (_m *HandlerWithMultipleBindings) GetInput() interface{} { ret := _m.Called() @@ -48,6 +83,33 @@ func (_m *HandlerWithMultipleBindings) GetInput() interface{} { return r0 } +// HandlerWithMultipleBindings_GetInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInput' +type HandlerWithMultipleBindings_GetInput_Call struct { + *mock.Call +} + +// GetInput is a helper method to define mock.On call +func (_e *HandlerWithMultipleBindings_Expecter) GetInput() *HandlerWithMultipleBindings_GetInput_Call { + return &HandlerWithMultipleBindings_GetInput_Call{Call: _e.mock.On("GetInput")} +} + +func (_c *HandlerWithMultipleBindings_GetInput_Call) Run(run func()) *HandlerWithMultipleBindings_GetInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *HandlerWithMultipleBindings_GetInput_Call) Return(_a0 interface{}) *HandlerWithMultipleBindings_GetInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *HandlerWithMultipleBindings_GetInput_Call) RunAndReturn(run func() interface{}) *HandlerWithMultipleBindings_GetInput_Call { + _c.Call.Return(run) + return _c +} + // Handle provides a mock function with given fields: requestContext, request func (_m *HandlerWithMultipleBindings) Handle(requestContext context.Context, request *apiserver.Request) (*apiserver.Response, error) { ret := _m.Called(requestContext, request) @@ -74,6 +136,35 @@ func (_m *HandlerWithMultipleBindings) Handle(requestContext context.Context, re return r0, r1 } +// HandlerWithMultipleBindings_Handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Handle' +type HandlerWithMultipleBindings_Handle_Call struct { + *mock.Call +} + +// Handle is a helper method to define mock.On call +// - requestContext context.Context +// - request *apiserver.Request +func (_e *HandlerWithMultipleBindings_Expecter) Handle(requestContext interface{}, request interface{}) *HandlerWithMultipleBindings_Handle_Call { + return &HandlerWithMultipleBindings_Handle_Call{Call: _e.mock.On("Handle", requestContext, request)} +} + +func (_c *HandlerWithMultipleBindings_Handle_Call) Run(run func(requestContext context.Context, request *apiserver.Request)) *HandlerWithMultipleBindings_Handle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*apiserver.Request)) + }) + return _c +} + +func (_c *HandlerWithMultipleBindings_Handle_Call) Return(response *apiserver.Response, error error) *HandlerWithMultipleBindings_Handle_Call { + _c.Call.Return(response, error) + return _c +} + +func (_c *HandlerWithMultipleBindings_Handle_Call) RunAndReturn(run func(context.Context, *apiserver.Request) (*apiserver.Response, error)) *HandlerWithMultipleBindings_Handle_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewHandlerWithMultipleBindings interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/mocks/HandlerWithStream.go b/pkg/apiserver/mocks/HandlerWithStream.go index 740b41645..394a92de5 100644 --- a/pkg/apiserver/mocks/HandlerWithStream.go +++ b/pkg/apiserver/mocks/HandlerWithStream.go @@ -17,6 +17,14 @@ type HandlerWithStream struct { mock.Mock } +type HandlerWithStream_Expecter struct { + mock *mock.Mock +} + +func (_m *HandlerWithStream) EXPECT() *HandlerWithStream_Expecter { + return &HandlerWithStream_Expecter{mock: &_m.Mock} +} + // GetInput provides a mock function with given fields: func (_m *HandlerWithStream) GetInput() interface{} { ret := _m.Called() @@ -33,6 +41,33 @@ func (_m *HandlerWithStream) GetInput() interface{} { return r0 } +// HandlerWithStream_GetInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInput' +type HandlerWithStream_GetInput_Call struct { + *mock.Call +} + +// GetInput is a helper method to define mock.On call +func (_e *HandlerWithStream_Expecter) GetInput() *HandlerWithStream_GetInput_Call { + return &HandlerWithStream_GetInput_Call{Call: _e.mock.On("GetInput")} +} + +func (_c *HandlerWithStream_GetInput_Call) Run(run func()) *HandlerWithStream_GetInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *HandlerWithStream_GetInput_Call) Return(_a0 interface{}) *HandlerWithStream_GetInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *HandlerWithStream_GetInput_Call) RunAndReturn(run func() interface{}) *HandlerWithStream_GetInput_Call { + _c.Call.Return(run) + return _c +} + // Handle provides a mock function with given fields: ginContext, requestContext, request func (_m *HandlerWithStream) Handle(ginContext *gin.Context, requestContext context.Context, request *apiserver.Request) error { ret := _m.Called(ginContext, requestContext, request) @@ -47,6 +82,36 @@ func (_m *HandlerWithStream) Handle(ginContext *gin.Context, requestContext cont return r0 } +// HandlerWithStream_Handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Handle' +type HandlerWithStream_Handle_Call struct { + *mock.Call +} + +// Handle is a helper method to define mock.On call +// - ginContext *gin.Context +// - requestContext context.Context +// - request *apiserver.Request +func (_e *HandlerWithStream_Expecter) Handle(ginContext interface{}, requestContext interface{}, request interface{}) *HandlerWithStream_Handle_Call { + return &HandlerWithStream_Handle_Call{Call: _e.mock.On("Handle", ginContext, requestContext, request)} +} + +func (_c *HandlerWithStream_Handle_Call) Run(run func(ginContext *gin.Context, requestContext context.Context, request *apiserver.Request)) *HandlerWithStream_Handle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*gin.Context), args[1].(context.Context), args[2].(*apiserver.Request)) + }) + return _c +} + +func (_c *HandlerWithStream_Handle_Call) Return(error error) *HandlerWithStream_Handle_Call { + _c.Call.Return(error) + return _c +} + +func (_c *HandlerWithStream_Handle_Call) RunAndReturn(run func(*gin.Context, context.Context, *apiserver.Request) error) *HandlerWithStream_Handle_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewHandlerWithStream interface { mock.TestingT Cleanup(func()) diff --git a/pkg/apiserver/mocks/HandlerWithoutInput.go b/pkg/apiserver/mocks/HandlerWithoutInput.go index 65bc52ce9..05903eef4 100644 --- a/pkg/apiserver/mocks/HandlerWithoutInput.go +++ b/pkg/apiserver/mocks/HandlerWithoutInput.go @@ -15,6 +15,14 @@ type HandlerWithoutInput struct { mock.Mock } +type HandlerWithoutInput_Expecter struct { + mock *mock.Mock +} + +func (_m *HandlerWithoutInput) EXPECT() *HandlerWithoutInput_Expecter { + return &HandlerWithoutInput_Expecter{mock: &_m.Mock} +} + // Handle provides a mock function with given fields: requestContext, request func (_m *HandlerWithoutInput) Handle(requestContext context.Context, request *apiserver.Request) (*apiserver.Response, error) { ret := _m.Called(requestContext, request) @@ -41,6 +49,35 @@ func (_m *HandlerWithoutInput) Handle(requestContext context.Context, request *a return r0, r1 } +// HandlerWithoutInput_Handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Handle' +type HandlerWithoutInput_Handle_Call struct { + *mock.Call +} + +// Handle is a helper method to define mock.On call +// - requestContext context.Context +// - request *apiserver.Request +func (_e *HandlerWithoutInput_Expecter) Handle(requestContext interface{}, request interface{}) *HandlerWithoutInput_Handle_Call { + return &HandlerWithoutInput_Handle_Call{Call: _e.mock.On("Handle", requestContext, request)} +} + +func (_c *HandlerWithoutInput_Handle_Call) Run(run func(requestContext context.Context, request *apiserver.Request)) *HandlerWithoutInput_Handle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*apiserver.Request)) + }) + return _c +} + +func (_c *HandlerWithoutInput_Handle_Call) Return(response *apiserver.Response, error error) *HandlerWithoutInput_Handle_Call { + _c.Call.Return(response, error) + return _c +} + +func (_c *HandlerWithoutInput_Handle_Call) RunAndReturn(run func(context.Context, *apiserver.Request) (*apiserver.Response, error)) *HandlerWithoutInput_Handle_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewHandlerWithoutInput interface { mock.TestingT Cleanup(func()) diff --git a/pkg/blob/mocks/BatchRunner.go b/pkg/blob/mocks/BatchRunner.go index 773da857d..f0b120f54 100644 --- a/pkg/blob/mocks/BatchRunner.go +++ b/pkg/blob/mocks/BatchRunner.go @@ -13,6 +13,14 @@ type BatchRunner struct { mock.Mock } +type BatchRunner_Expecter struct { + mock *mock.Mock +} + +func (_m *BatchRunner) EXPECT() *BatchRunner_Expecter { + return &BatchRunner_Expecter{mock: &_m.Mock} +} + // Run provides a mock function with given fields: ctx func (_m *BatchRunner) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -27,6 +35,34 @@ func (_m *BatchRunner) Run(ctx context.Context) error { return r0 } +// BatchRunner_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type BatchRunner_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *BatchRunner_Expecter) Run(ctx interface{}) *BatchRunner_Run_Call { + return &BatchRunner_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *BatchRunner_Run_Call) Run(run func(ctx context.Context)) *BatchRunner_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *BatchRunner_Run_Call) Return(_a0 error) *BatchRunner_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BatchRunner_Run_Call) RunAndReturn(run func(context.Context) error) *BatchRunner_Run_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewBatchRunner interface { mock.TestingT Cleanup(func()) diff --git a/pkg/blob/mocks/ReadCloser.go b/pkg/blob/mocks/ReadCloser.go index 63e1500c8..b8045b7d8 100644 --- a/pkg/blob/mocks/ReadCloser.go +++ b/pkg/blob/mocks/ReadCloser.go @@ -9,6 +9,14 @@ type ReadCloser struct { mock.Mock } +type ReadCloser_Expecter struct { + mock *mock.Mock +} + +func (_m *ReadCloser) EXPECT() *ReadCloser_Expecter { + return &ReadCloser_Expecter{mock: &_m.Mock} +} + // Close provides a mock function with given fields: func (_m *ReadCloser) Close() error { ret := _m.Called() @@ -23,6 +31,33 @@ func (_m *ReadCloser) Close() error { return r0 } +// ReadCloser_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type ReadCloser_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *ReadCloser_Expecter) Close() *ReadCloser_Close_Call { + return &ReadCloser_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *ReadCloser_Close_Call) Run(run func()) *ReadCloser_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ReadCloser_Close_Call) Return(_a0 error) *ReadCloser_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ReadCloser_Close_Call) RunAndReturn(run func() error) *ReadCloser_Close_Call { + _c.Call.Return(run) + return _c +} + // Read provides a mock function with given fields: p func (_m *ReadCloser) Read(p []byte) (int, error) { ret := _m.Called(p) @@ -47,6 +82,34 @@ func (_m *ReadCloser) Read(p []byte) (int, error) { return r0, r1 } +// ReadCloser_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type ReadCloser_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - p []byte +func (_e *ReadCloser_Expecter) Read(p interface{}) *ReadCloser_Read_Call { + return &ReadCloser_Read_Call{Call: _e.mock.On("Read", p)} +} + +func (_c *ReadCloser_Read_Call) Run(run func(p []byte)) *ReadCloser_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]byte)) + }) + return _c +} + +func (_c *ReadCloser_Read_Call) Return(n int, err error) *ReadCloser_Read_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *ReadCloser_Read_Call) RunAndReturn(run func([]byte) (int, error)) *ReadCloser_Read_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewReadCloser interface { mock.TestingT Cleanup(func()) diff --git a/pkg/blob/mocks/ReadSeekerCloser.go b/pkg/blob/mocks/ReadSeekerCloser.go index bb5cbd9ec..b3a6fbd3c 100644 --- a/pkg/blob/mocks/ReadSeekerCloser.go +++ b/pkg/blob/mocks/ReadSeekerCloser.go @@ -9,6 +9,14 @@ type ReadSeekerCloser struct { mock.Mock } +type ReadSeekerCloser_Expecter struct { + mock *mock.Mock +} + +func (_m *ReadSeekerCloser) EXPECT() *ReadSeekerCloser_Expecter { + return &ReadSeekerCloser_Expecter{mock: &_m.Mock} +} + // Close provides a mock function with given fields: func (_m *ReadSeekerCloser) Close() error { ret := _m.Called() @@ -23,6 +31,33 @@ func (_m *ReadSeekerCloser) Close() error { return r0 } +// ReadSeekerCloser_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type ReadSeekerCloser_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *ReadSeekerCloser_Expecter) Close() *ReadSeekerCloser_Close_Call { + return &ReadSeekerCloser_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *ReadSeekerCloser_Close_Call) Run(run func()) *ReadSeekerCloser_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ReadSeekerCloser_Close_Call) Return(_a0 error) *ReadSeekerCloser_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ReadSeekerCloser_Close_Call) RunAndReturn(run func() error) *ReadSeekerCloser_Close_Call { + _c.Call.Return(run) + return _c +} + // Read provides a mock function with given fields: p func (_m *ReadSeekerCloser) Read(p []byte) (int, error) { ret := _m.Called(p) @@ -47,6 +82,34 @@ func (_m *ReadSeekerCloser) Read(p []byte) (int, error) { return r0, r1 } +// ReadSeekerCloser_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type ReadSeekerCloser_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - p []byte +func (_e *ReadSeekerCloser_Expecter) Read(p interface{}) *ReadSeekerCloser_Read_Call { + return &ReadSeekerCloser_Read_Call{Call: _e.mock.On("Read", p)} +} + +func (_c *ReadSeekerCloser_Read_Call) Run(run func(p []byte)) *ReadSeekerCloser_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]byte)) + }) + return _c +} + +func (_c *ReadSeekerCloser_Read_Call) Return(n int, err error) *ReadSeekerCloser_Read_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *ReadSeekerCloser_Read_Call) RunAndReturn(run func([]byte) (int, error)) *ReadSeekerCloser_Read_Call { + _c.Call.Return(run) + return _c +} + // Seek provides a mock function with given fields: offset, whence func (_m *ReadSeekerCloser) Seek(offset int64, whence int) (int64, error) { ret := _m.Called(offset, whence) @@ -71,6 +134,35 @@ func (_m *ReadSeekerCloser) Seek(offset int64, whence int) (int64, error) { return r0, r1 } +// ReadSeekerCloser_Seek_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Seek' +type ReadSeekerCloser_Seek_Call struct { + *mock.Call +} + +// Seek is a helper method to define mock.On call +// - offset int64 +// - whence int +func (_e *ReadSeekerCloser_Expecter) Seek(offset interface{}, whence interface{}) *ReadSeekerCloser_Seek_Call { + return &ReadSeekerCloser_Seek_Call{Call: _e.mock.On("Seek", offset, whence)} +} + +func (_c *ReadSeekerCloser_Seek_Call) Run(run func(offset int64, whence int)) *ReadSeekerCloser_Seek_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int64), args[1].(int)) + }) + return _c +} + +func (_c *ReadSeekerCloser_Seek_Call) Return(_a0 int64, _a1 error) *ReadSeekerCloser_Seek_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ReadSeekerCloser_Seek_Call) RunAndReturn(run func(int64, int) (int64, error)) *ReadSeekerCloser_Seek_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewReadSeekerCloser interface { mock.TestingT Cleanup(func()) diff --git a/pkg/blob/mocks/Store.go b/pkg/blob/mocks/Store.go index 7d4455a8a..04f1c3648 100644 --- a/pkg/blob/mocks/Store.go +++ b/pkg/blob/mocks/Store.go @@ -15,6 +15,14 @@ type Store struct { mock.Mock } +type Store_Expecter struct { + mock *mock.Mock +} + +func (_m *Store) EXPECT() *Store_Expecter { + return &Store_Expecter{mock: &_m.Mock} +} + // BucketName provides a mock function with given fields: func (_m *Store) BucketName() string { ret := _m.Called() @@ -29,11 +37,66 @@ func (_m *Store) BucketName() string { return r0 } +// Store_BucketName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BucketName' +type Store_BucketName_Call struct { + *mock.Call +} + +// BucketName is a helper method to define mock.On call +func (_e *Store_Expecter) BucketName() *Store_BucketName_Call { + return &Store_BucketName_Call{Call: _e.mock.On("BucketName")} +} + +func (_c *Store_BucketName_Call) Run(run func()) *Store_BucketName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Store_BucketName_Call) Return(_a0 string) *Store_BucketName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Store_BucketName_Call) RunAndReturn(run func() string) *Store_BucketName_Call { + _c.Call.Return(run) + return _c +} + // Copy provides a mock function with given fields: batch func (_m *Store) Copy(batch blob.CopyBatch) { _m.Called(batch) } +// Store_Copy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Copy' +type Store_Copy_Call struct { + *mock.Call +} + +// Copy is a helper method to define mock.On call +// - batch blob.CopyBatch +func (_e *Store_Expecter) Copy(batch interface{}) *Store_Copy_Call { + return &Store_Copy_Call{Call: _e.mock.On("Copy", batch)} +} + +func (_c *Store_Copy_Call) Run(run func(batch blob.CopyBatch)) *Store_Copy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(blob.CopyBatch)) + }) + return _c +} + +func (_c *Store_Copy_Call) Return() *Store_Copy_Call { + _c.Call.Return() + return _c +} + +func (_c *Store_Copy_Call) RunAndReturn(run func(blob.CopyBatch)) *Store_Copy_Call { + _c.Call.Return(run) + return _c +} + // CopyOne provides a mock function with given fields: obj func (_m *Store) CopyOne(obj *blob.CopyObject) error { ret := _m.Called(obj) @@ -48,6 +111,34 @@ func (_m *Store) CopyOne(obj *blob.CopyObject) error { return r0 } +// Store_CopyOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyOne' +type Store_CopyOne_Call struct { + *mock.Call +} + +// CopyOne is a helper method to define mock.On call +// - obj *blob.CopyObject +func (_e *Store_Expecter) CopyOne(obj interface{}) *Store_CopyOne_Call { + return &Store_CopyOne_Call{Call: _e.mock.On("CopyOne", obj)} +} + +func (_c *Store_CopyOne_Call) Run(run func(obj *blob.CopyObject)) *Store_CopyOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*blob.CopyObject)) + }) + return _c +} + +func (_c *Store_CopyOne_Call) Return(_a0 error) *Store_CopyOne_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Store_CopyOne_Call) RunAndReturn(run func(*blob.CopyObject) error) *Store_CopyOne_Call { + _c.Call.Return(run) + return _c +} + // CreateBucket provides a mock function with given fields: ctx func (_m *Store) CreateBucket(ctx context.Context) error { ret := _m.Called(ctx) @@ -62,11 +153,67 @@ func (_m *Store) CreateBucket(ctx context.Context) error { return r0 } +// Store_CreateBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucket' +type Store_CreateBucket_Call struct { + *mock.Call +} + +// CreateBucket is a helper method to define mock.On call +// - ctx context.Context +func (_e *Store_Expecter) CreateBucket(ctx interface{}) *Store_CreateBucket_Call { + return &Store_CreateBucket_Call{Call: _e.mock.On("CreateBucket", ctx)} +} + +func (_c *Store_CreateBucket_Call) Run(run func(ctx context.Context)) *Store_CreateBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Store_CreateBucket_Call) Return(_a0 error) *Store_CreateBucket_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Store_CreateBucket_Call) RunAndReturn(run func(context.Context) error) *Store_CreateBucket_Call { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: batch func (_m *Store) Delete(batch blob.Batch) { _m.Called(batch) } +// Store_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type Store_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - batch blob.Batch +func (_e *Store_Expecter) Delete(batch interface{}) *Store_Delete_Call { + return &Store_Delete_Call{Call: _e.mock.On("Delete", batch)} +} + +func (_c *Store_Delete_Call) Run(run func(batch blob.Batch)) *Store_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(blob.Batch)) + }) + return _c +} + +func (_c *Store_Delete_Call) Return() *Store_Delete_Call { + _c.Call.Return() + return _c +} + +func (_c *Store_Delete_Call) RunAndReturn(run func(blob.Batch)) *Store_Delete_Call { + _c.Call.Return(run) + return _c +} + // DeleteBucket provides a mock function with given fields: ctx func (_m *Store) DeleteBucket(ctx context.Context) error { ret := _m.Called(ctx) @@ -81,6 +228,34 @@ func (_m *Store) DeleteBucket(ctx context.Context) error { return r0 } +// Store_DeleteBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucket' +type Store_DeleteBucket_Call struct { + *mock.Call +} + +// DeleteBucket is a helper method to define mock.On call +// - ctx context.Context +func (_e *Store_Expecter) DeleteBucket(ctx interface{}) *Store_DeleteBucket_Call { + return &Store_DeleteBucket_Call{Call: _e.mock.On("DeleteBucket", ctx)} +} + +func (_c *Store_DeleteBucket_Call) Run(run func(ctx context.Context)) *Store_DeleteBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Store_DeleteBucket_Call) Return(_a0 error) *Store_DeleteBucket_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Store_DeleteBucket_Call) RunAndReturn(run func(context.Context) error) *Store_DeleteBucket_Call { + _c.Call.Return(run) + return _c +} + // DeleteOne provides a mock function with given fields: obj func (_m *Store) DeleteOne(obj *blob.Object) error { ret := _m.Called(obj) @@ -95,11 +270,67 @@ func (_m *Store) DeleteOne(obj *blob.Object) error { return r0 } +// Store_DeleteOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOne' +type Store_DeleteOne_Call struct { + *mock.Call +} + +// DeleteOne is a helper method to define mock.On call +// - obj *blob.Object +func (_e *Store_Expecter) DeleteOne(obj interface{}) *Store_DeleteOne_Call { + return &Store_DeleteOne_Call{Call: _e.mock.On("DeleteOne", obj)} +} + +func (_c *Store_DeleteOne_Call) Run(run func(obj *blob.Object)) *Store_DeleteOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*blob.Object)) + }) + return _c +} + +func (_c *Store_DeleteOne_Call) Return(_a0 error) *Store_DeleteOne_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Store_DeleteOne_Call) RunAndReturn(run func(*blob.Object) error) *Store_DeleteOne_Call { + _c.Call.Return(run) + return _c +} + // Read provides a mock function with given fields: batch func (_m *Store) Read(batch blob.Batch) { _m.Called(batch) } +// Store_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type Store_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - batch blob.Batch +func (_e *Store_Expecter) Read(batch interface{}) *Store_Read_Call { + return &Store_Read_Call{Call: _e.mock.On("Read", batch)} +} + +func (_c *Store_Read_Call) Run(run func(batch blob.Batch)) *Store_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(blob.Batch)) + }) + return _c +} + +func (_c *Store_Read_Call) Return() *Store_Read_Call { + _c.Call.Return() + return _c +} + +func (_c *Store_Read_Call) RunAndReturn(run func(blob.Batch)) *Store_Read_Call { + _c.Call.Return(run) + return _c +} + // ReadOne provides a mock function with given fields: obj func (_m *Store) ReadOne(obj *blob.Object) error { ret := _m.Called(obj) @@ -114,6 +345,34 @@ func (_m *Store) ReadOne(obj *blob.Object) error { return r0 } +// Store_ReadOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOne' +type Store_ReadOne_Call struct { + *mock.Call +} + +// ReadOne is a helper method to define mock.On call +// - obj *blob.Object +func (_e *Store_Expecter) ReadOne(obj interface{}) *Store_ReadOne_Call { + return &Store_ReadOne_Call{Call: _e.mock.On("ReadOne", obj)} +} + +func (_c *Store_ReadOne_Call) Run(run func(obj *blob.Object)) *Store_ReadOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*blob.Object)) + }) + return _c +} + +func (_c *Store_ReadOne_Call) Return(_a0 error) *Store_ReadOne_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Store_ReadOne_Call) RunAndReturn(run func(*blob.Object) error) *Store_ReadOne_Call { + _c.Call.Return(run) + return _c +} + // Write provides a mock function with given fields: batch func (_m *Store) Write(batch blob.Batch) error { ret := _m.Called(batch) @@ -128,6 +387,34 @@ func (_m *Store) Write(batch blob.Batch) error { return r0 } +// Store_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type Store_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - batch blob.Batch +func (_e *Store_Expecter) Write(batch interface{}) *Store_Write_Call { + return &Store_Write_Call{Call: _e.mock.On("Write", batch)} +} + +func (_c *Store_Write_Call) Run(run func(batch blob.Batch)) *Store_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(blob.Batch)) + }) + return _c +} + +func (_c *Store_Write_Call) Return(_a0 error) *Store_Write_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Store_Write_Call) RunAndReturn(run func(blob.Batch) error) *Store_Write_Call { + _c.Call.Return(run) + return _c +} + // WriteOne provides a mock function with given fields: obj func (_m *Store) WriteOne(obj *blob.Object) error { ret := _m.Called(obj) @@ -142,6 +429,34 @@ func (_m *Store) WriteOne(obj *blob.Object) error { return r0 } +// Store_WriteOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOne' +type Store_WriteOne_Call struct { + *mock.Call +} + +// WriteOne is a helper method to define mock.On call +// - obj *blob.Object +func (_e *Store_Expecter) WriteOne(obj interface{}) *Store_WriteOne_Call { + return &Store_WriteOne_Call{Call: _e.mock.On("WriteOne", obj)} +} + +func (_c *Store_WriteOne_Call) Run(run func(obj *blob.Object)) *Store_WriteOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*blob.Object)) + }) + return _c +} + +func (_c *Store_WriteOne_Call) Return(_a0 error) *Store_WriteOne_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Store_WriteOne_Call) RunAndReturn(run func(*blob.Object) error) *Store_WriteOne_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewStore interface { mock.TestingT Cleanup(func()) diff --git a/pkg/blob/mocks/Stream.go b/pkg/blob/mocks/Stream.go index 42e98e9a0..8ef6f59a0 100644 --- a/pkg/blob/mocks/Stream.go +++ b/pkg/blob/mocks/Stream.go @@ -12,6 +12,14 @@ type Stream struct { mock.Mock } +type Stream_Expecter struct { + mock *mock.Mock +} + +func (_m *Stream) EXPECT() *Stream_Expecter { + return &Stream_Expecter{mock: &_m.Mock} +} + // AsReader provides a mock function with given fields: func (_m *Stream) AsReader() blob.ReadSeekerCloser { ret := _m.Called() @@ -28,6 +36,33 @@ func (_m *Stream) AsReader() blob.ReadSeekerCloser { return r0 } +// Stream_AsReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AsReader' +type Stream_AsReader_Call struct { + *mock.Call +} + +// AsReader is a helper method to define mock.On call +func (_e *Stream_Expecter) AsReader() *Stream_AsReader_Call { + return &Stream_AsReader_Call{Call: _e.mock.On("AsReader")} +} + +func (_c *Stream_AsReader_Call) Run(run func()) *Stream_AsReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Stream_AsReader_Call) Return(_a0 blob.ReadSeekerCloser) *Stream_AsReader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Stream_AsReader_Call) RunAndReturn(run func() blob.ReadSeekerCloser) *Stream_AsReader_Call { + _c.Call.Return(run) + return _c +} + // ReadAll provides a mock function with given fields: func (_m *Stream) ReadAll() ([]byte, error) { ret := _m.Called() @@ -54,6 +89,33 @@ func (_m *Stream) ReadAll() ([]byte, error) { return r0, r1 } +// Stream_ReadAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadAll' +type Stream_ReadAll_Call struct { + *mock.Call +} + +// ReadAll is a helper method to define mock.On call +func (_e *Stream_Expecter) ReadAll() *Stream_ReadAll_Call { + return &Stream_ReadAll_Call{Call: _e.mock.On("ReadAll")} +} + +func (_c *Stream_ReadAll_Call) Run(run func()) *Stream_ReadAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Stream_ReadAll_Call) Return(_a0 []byte, _a1 error) *Stream_ReadAll_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Stream_ReadAll_Call) RunAndReturn(run func() ([]byte, error)) *Stream_ReadAll_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewStream interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cache/mocks/Cache.go b/pkg/cache/mocks/Cache.go index ecea54818..1215f29da 100644 --- a/pkg/cache/mocks/Cache.go +++ b/pkg/cache/mocks/Cache.go @@ -13,6 +13,14 @@ type Cache[T interface{}] struct { mock.Mock } +type Cache_Expecter[T interface{}] struct { + mock *mock.Mock +} + +func (_m *Cache[T]) EXPECT() *Cache_Expecter[T] { + return &Cache_Expecter[T]{mock: &_m.Mock} +} + // Contains provides a mock function with given fields: key func (_m *Cache[T]) Contains(key string) bool { ret := _m.Called(key) @@ -27,6 +35,34 @@ func (_m *Cache[T]) Contains(key string) bool { return r0 } +// Cache_Contains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Contains' +type Cache_Contains_Call[T interface{}] struct { + *mock.Call +} + +// Contains is a helper method to define mock.On call +// - key string +func (_e *Cache_Expecter[T]) Contains(key interface{}) *Cache_Contains_Call[T] { + return &Cache_Contains_Call[T]{Call: _e.mock.On("Contains", key)} +} + +func (_c *Cache_Contains_Call[T]) Run(run func(key string)) *Cache_Contains_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Cache_Contains_Call[T]) Return(_a0 bool) *Cache_Contains_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Cache_Contains_Call[T]) RunAndReturn(run func(string) bool) *Cache_Contains_Call[T] { + _c.Call.Return(run) + return _c +} + // Expire provides a mock function with given fields: key func (_m *Cache[T]) Expire(key string) bool { ret := _m.Called(key) @@ -41,6 +77,34 @@ func (_m *Cache[T]) Expire(key string) bool { return r0 } +// Cache_Expire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expire' +type Cache_Expire_Call[T interface{}] struct { + *mock.Call +} + +// Expire is a helper method to define mock.On call +// - key string +func (_e *Cache_Expecter[T]) Expire(key interface{}) *Cache_Expire_Call[T] { + return &Cache_Expire_Call[T]{Call: _e.mock.On("Expire", key)} +} + +func (_c *Cache_Expire_Call[T]) Run(run func(key string)) *Cache_Expire_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Cache_Expire_Call[T]) Return(_a0 bool) *Cache_Expire_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Cache_Expire_Call[T]) RunAndReturn(run func(string) bool) *Cache_Expire_Call[T] { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: key func (_m *Cache[T]) Get(key string) (T, bool) { ret := _m.Called(key) @@ -65,6 +129,34 @@ func (_m *Cache[T]) Get(key string) (T, bool) { return r0, r1 } +// Cache_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Cache_Get_Call[T interface{}] struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - key string +func (_e *Cache_Expecter[T]) Get(key interface{}) *Cache_Get_Call[T] { + return &Cache_Get_Call[T]{Call: _e.mock.On("Get", key)} +} + +func (_c *Cache_Get_Call[T]) Run(run func(key string)) *Cache_Get_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Cache_Get_Call[T]) Return(_a0 T, _a1 bool) *Cache_Get_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Cache_Get_Call[T]) RunAndReturn(run func(string) (T, bool)) *Cache_Get_Call[T] { + _c.Call.Return(run) + return _c +} + // Provide provides a mock function with given fields: key, provider func (_m *Cache[T]) Provide(key string, provider func() T) T { ret := _m.Called(key, provider) @@ -79,6 +171,35 @@ func (_m *Cache[T]) Provide(key string, provider func() T) T { return r0 } +// Cache_Provide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Provide' +type Cache_Provide_Call[T interface{}] struct { + *mock.Call +} + +// Provide is a helper method to define mock.On call +// - key string +// - provider func() T +func (_e *Cache_Expecter[T]) Provide(key interface{}, provider interface{}) *Cache_Provide_Call[T] { + return &Cache_Provide_Call[T]{Call: _e.mock.On("Provide", key, provider)} +} + +func (_c *Cache_Provide_Call[T]) Run(run func(key string, provider func() T)) *Cache_Provide_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func() T)) + }) + return _c +} + +func (_c *Cache_Provide_Call[T]) Return(_a0 T) *Cache_Provide_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *Cache_Provide_Call[T]) RunAndReturn(run func(string, func() T) T) *Cache_Provide_Call[T] { + _c.Call.Return(run) + return _c +} + // ProvideWithError provides a mock function with given fields: key, provider func (_m *Cache[T]) ProvideWithError(key string, provider func() (T, error)) (T, error) { ret := _m.Called(key, provider) @@ -103,16 +224,104 @@ func (_m *Cache[T]) ProvideWithError(key string, provider func() (T, error)) (T, return r0, r1 } +// Cache_ProvideWithError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProvideWithError' +type Cache_ProvideWithError_Call[T interface{}] struct { + *mock.Call +} + +// ProvideWithError is a helper method to define mock.On call +// - key string +// - provider func()(T , error) +func (_e *Cache_Expecter[T]) ProvideWithError(key interface{}, provider interface{}) *Cache_ProvideWithError_Call[T] { + return &Cache_ProvideWithError_Call[T]{Call: _e.mock.On("ProvideWithError", key, provider)} +} + +func (_c *Cache_ProvideWithError_Call[T]) Run(run func(key string, provider func() (T, error))) *Cache_ProvideWithError_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func() (T, error))) + }) + return _c +} + +func (_c *Cache_ProvideWithError_Call[T]) Return(_a0 T, _a1 error) *Cache_ProvideWithError_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Cache_ProvideWithError_Call[T]) RunAndReturn(run func(string, func() (T, error)) (T, error)) *Cache_ProvideWithError_Call[T] { + _c.Call.Return(run) + return _c +} + // Set provides a mock function with given fields: key, value func (_m *Cache[T]) Set(key string, value T) { _m.Called(key, value) } +// Cache_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set' +type Cache_Set_Call[T interface{}] struct { + *mock.Call +} + +// Set is a helper method to define mock.On call +// - key string +// - value T +func (_e *Cache_Expecter[T]) Set(key interface{}, value interface{}) *Cache_Set_Call[T] { + return &Cache_Set_Call[T]{Call: _e.mock.On("Set", key, value)} +} + +func (_c *Cache_Set_Call[T]) Run(run func(key string, value T)) *Cache_Set_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(T)) + }) + return _c +} + +func (_c *Cache_Set_Call[T]) Return() *Cache_Set_Call[T] { + _c.Call.Return() + return _c +} + +func (_c *Cache_Set_Call[T]) RunAndReturn(run func(string, T)) *Cache_Set_Call[T] { + _c.Call.Return(run) + return _c +} + // SetX provides a mock function with given fields: key, value, ttl func (_m *Cache[T]) SetX(key string, value T, ttl time.Duration) { _m.Called(key, value, ttl) } +// Cache_SetX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetX' +type Cache_SetX_Call[T interface{}] struct { + *mock.Call +} + +// SetX is a helper method to define mock.On call +// - key string +// - value T +// - ttl time.Duration +func (_e *Cache_Expecter[T]) SetX(key interface{}, value interface{}, ttl interface{}) *Cache_SetX_Call[T] { + return &Cache_SetX_Call[T]{Call: _e.mock.On("SetX", key, value, ttl)} +} + +func (_c *Cache_SetX_Call[T]) Run(run func(key string, value T, ttl time.Duration)) *Cache_SetX_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(T), args[2].(time.Duration)) + }) + return _c +} + +func (_c *Cache_SetX_Call[T]) Return() *Cache_SetX_Call[T] { + _c.Call.Return() + return _c +} + +func (_c *Cache_SetX_Call[T]) RunAndReturn(run func(string, T, time.Duration)) *Cache_SetX_Call[T] { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewCache interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cfg/mocks/Config.go b/pkg/cfg/mocks/Config.go index ca1d9a1f5..1102095f1 100644 --- a/pkg/cfg/mocks/Config.go +++ b/pkg/cfg/mocks/Config.go @@ -14,6 +14,14 @@ type Config struct { mock.Mock } +type Config_Expecter struct { + mock *mock.Mock +} + +func (_m *Config) EXPECT() *Config_Expecter { + return &Config_Expecter{mock: &_m.Mock} +} + // AllKeys provides a mock function with given fields: func (_m *Config) AllKeys() []string { ret := _m.Called() @@ -30,6 +38,33 @@ func (_m *Config) AllKeys() []string { return r0 } +// Config_AllKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllKeys' +type Config_AllKeys_Call struct { + *mock.Call +} + +// AllKeys is a helper method to define mock.On call +func (_e *Config_Expecter) AllKeys() *Config_AllKeys_Call { + return &Config_AllKeys_Call{Call: _e.mock.On("AllKeys")} +} + +func (_c *Config_AllKeys_Call) Run(run func()) *Config_AllKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Config_AllKeys_Call) Return(_a0 []string) *Config_AllKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_AllKeys_Call) RunAndReturn(run func() []string) *Config_AllKeys_Call { + _c.Call.Return(run) + return _c +} + // AllSettings provides a mock function with given fields: func (_m *Config) AllSettings() map[string]interface{} { ret := _m.Called() @@ -46,6 +81,33 @@ func (_m *Config) AllSettings() map[string]interface{} { return r0 } +// Config_AllSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllSettings' +type Config_AllSettings_Call struct { + *mock.Call +} + +// AllSettings is a helper method to define mock.On call +func (_e *Config_Expecter) AllSettings() *Config_AllSettings_Call { + return &Config_AllSettings_Call{Call: _e.mock.On("AllSettings")} +} + +func (_c *Config_AllSettings_Call) Run(run func()) *Config_AllSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Config_AllSettings_Call) Return(_a0 map[string]interface{}) *Config_AllSettings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_AllSettings_Call) RunAndReturn(run func() map[string]interface{}) *Config_AllSettings_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: key, optionalDefault func (_m *Config) Get(key string, optionalDefault ...interface{}) interface{} { var _ca []interface{} @@ -65,6 +127,42 @@ func (_m *Config) Get(key string, optionalDefault ...interface{}) interface{} { return r0 } +// Config_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Config_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - key string +// - optionalDefault ...interface{} +func (_e *Config_Expecter) Get(key interface{}, optionalDefault ...interface{}) *Config_Get_Call { + return &Config_Get_Call{Call: _e.mock.On("Get", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_Get_Call) Run(run func(key string, optionalDefault ...interface{})) *Config_Get_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_Get_Call) Return(_a0 interface{}) *Config_Get_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_Get_Call) RunAndReturn(run func(string, ...interface{}) interface{}) *Config_Get_Call { + _c.Call.Return(run) + return _c +} + // GetBool provides a mock function with given fields: key, optionalDefault func (_m *Config) GetBool(key string, optionalDefault ...bool) bool { _va := make([]interface{}, len(optionalDefault)) @@ -86,6 +184,42 @@ func (_m *Config) GetBool(key string, optionalDefault ...bool) bool { return r0 } +// Config_GetBool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBool' +type Config_GetBool_Call struct { + *mock.Call +} + +// GetBool is a helper method to define mock.On call +// - key string +// - optionalDefault ...bool +func (_e *Config_Expecter) GetBool(key interface{}, optionalDefault ...interface{}) *Config_GetBool_Call { + return &Config_GetBool_Call{Call: _e.mock.On("GetBool", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetBool_Call) Run(run func(key string, optionalDefault ...bool)) *Config_GetBool_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]bool, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(bool) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetBool_Call) Return(_a0 bool) *Config_GetBool_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetBool_Call) RunAndReturn(run func(string, ...bool) bool) *Config_GetBool_Call { + _c.Call.Return(run) + return _c +} + // GetDuration provides a mock function with given fields: key, optionalDefault func (_m *Config) GetDuration(key string, optionalDefault ...time.Duration) time.Duration { _va := make([]interface{}, len(optionalDefault)) @@ -107,6 +241,42 @@ func (_m *Config) GetDuration(key string, optionalDefault ...time.Duration) time return r0 } +// Config_GetDuration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDuration' +type Config_GetDuration_Call struct { + *mock.Call +} + +// GetDuration is a helper method to define mock.On call +// - key string +// - optionalDefault ...time.Duration +func (_e *Config_Expecter) GetDuration(key interface{}, optionalDefault ...interface{}) *Config_GetDuration_Call { + return &Config_GetDuration_Call{Call: _e.mock.On("GetDuration", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetDuration_Call) Run(run func(key string, optionalDefault ...time.Duration)) *Config_GetDuration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]time.Duration, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(time.Duration) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetDuration_Call) Return(_a0 time.Duration) *Config_GetDuration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetDuration_Call) RunAndReturn(run func(string, ...time.Duration) time.Duration) *Config_GetDuration_Call { + _c.Call.Return(run) + return _c +} + // GetFloat64 provides a mock function with given fields: key, optionalDefault func (_m *Config) GetFloat64(key string, optionalDefault ...float64) float64 { _va := make([]interface{}, len(optionalDefault)) @@ -128,6 +298,42 @@ func (_m *Config) GetFloat64(key string, optionalDefault ...float64) float64 { return r0 } +// Config_GetFloat64_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFloat64' +type Config_GetFloat64_Call struct { + *mock.Call +} + +// GetFloat64 is a helper method to define mock.On call +// - key string +// - optionalDefault ...float64 +func (_e *Config_Expecter) GetFloat64(key interface{}, optionalDefault ...interface{}) *Config_GetFloat64_Call { + return &Config_GetFloat64_Call{Call: _e.mock.On("GetFloat64", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetFloat64_Call) Run(run func(key string, optionalDefault ...float64)) *Config_GetFloat64_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]float64, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(float64) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetFloat64_Call) Return(_a0 float64) *Config_GetFloat64_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetFloat64_Call) RunAndReturn(run func(string, ...float64) float64) *Config_GetFloat64_Call { + _c.Call.Return(run) + return _c +} + // GetInt provides a mock function with given fields: key, optionalDefault func (_m *Config) GetInt(key string, optionalDefault ...int) int { _va := make([]interface{}, len(optionalDefault)) @@ -149,6 +355,42 @@ func (_m *Config) GetInt(key string, optionalDefault ...int) int { return r0 } +// Config_GetInt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInt' +type Config_GetInt_Call struct { + *mock.Call +} + +// GetInt is a helper method to define mock.On call +// - key string +// - optionalDefault ...int +func (_e *Config_Expecter) GetInt(key interface{}, optionalDefault ...interface{}) *Config_GetInt_Call { + return &Config_GetInt_Call{Call: _e.mock.On("GetInt", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetInt_Call) Run(run func(key string, optionalDefault ...int)) *Config_GetInt_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetInt_Call) Return(_a0 int) *Config_GetInt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetInt_Call) RunAndReturn(run func(string, ...int) int) *Config_GetInt_Call { + _c.Call.Return(run) + return _c +} + // GetIntSlice provides a mock function with given fields: key, optionalDefault func (_m *Config) GetIntSlice(key string, optionalDefault ...[]int) []int { _va := make([]interface{}, len(optionalDefault)) @@ -172,6 +414,42 @@ func (_m *Config) GetIntSlice(key string, optionalDefault ...[]int) []int { return r0 } +// Config_GetIntSlice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIntSlice' +type Config_GetIntSlice_Call struct { + *mock.Call +} + +// GetIntSlice is a helper method to define mock.On call +// - key string +// - optionalDefault ...[]int +func (_e *Config_Expecter) GetIntSlice(key interface{}, optionalDefault ...interface{}) *Config_GetIntSlice_Call { + return &Config_GetIntSlice_Call{Call: _e.mock.On("GetIntSlice", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetIntSlice_Call) Run(run func(key string, optionalDefault ...[]int)) *Config_GetIntSlice_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetIntSlice_Call) Return(_a0 []int) *Config_GetIntSlice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetIntSlice_Call) RunAndReturn(run func(string, ...[]int) []int) *Config_GetIntSlice_Call { + _c.Call.Return(run) + return _c +} + // GetMsiSlice provides a mock function with given fields: key, optionalDefault func (_m *Config) GetMsiSlice(key string, optionalDefault ...[]map[string]interface{}) []map[string]interface{} { _va := make([]interface{}, len(optionalDefault)) @@ -195,6 +473,42 @@ func (_m *Config) GetMsiSlice(key string, optionalDefault ...[]map[string]interf return r0 } +// Config_GetMsiSlice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMsiSlice' +type Config_GetMsiSlice_Call struct { + *mock.Call +} + +// GetMsiSlice is a helper method to define mock.On call +// - key string +// - optionalDefault ...[]map[string]interface{} +func (_e *Config_Expecter) GetMsiSlice(key interface{}, optionalDefault ...interface{}) *Config_GetMsiSlice_Call { + return &Config_GetMsiSlice_Call{Call: _e.mock.On("GetMsiSlice", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetMsiSlice_Call) Run(run func(key string, optionalDefault ...[]map[string]interface{})) *Config_GetMsiSlice_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([][]map[string]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.([]map[string]interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetMsiSlice_Call) Return(_a0 []map[string]interface{}) *Config_GetMsiSlice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetMsiSlice_Call) RunAndReturn(run func(string, ...[]map[string]interface{}) []map[string]interface{}) *Config_GetMsiSlice_Call { + _c.Call.Return(run) + return _c +} + // GetString provides a mock function with given fields: key, optionalDefault func (_m *Config) GetString(key string, optionalDefault ...string) string { _va := make([]interface{}, len(optionalDefault)) @@ -216,6 +530,42 @@ func (_m *Config) GetString(key string, optionalDefault ...string) string { return r0 } +// Config_GetString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetString' +type Config_GetString_Call struct { + *mock.Call +} + +// GetString is a helper method to define mock.On call +// - key string +// - optionalDefault ...string +func (_e *Config_Expecter) GetString(key interface{}, optionalDefault ...interface{}) *Config_GetString_Call { + return &Config_GetString_Call{Call: _e.mock.On("GetString", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetString_Call) Run(run func(key string, optionalDefault ...string)) *Config_GetString_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetString_Call) Return(_a0 string) *Config_GetString_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetString_Call) RunAndReturn(run func(string, ...string) string) *Config_GetString_Call { + _c.Call.Return(run) + return _c +} + // GetStringMap provides a mock function with given fields: key, optionalDefault func (_m *Config) GetStringMap(key string, optionalDefault ...map[string]interface{}) map[string]interface{} { _va := make([]interface{}, len(optionalDefault)) @@ -239,6 +589,42 @@ func (_m *Config) GetStringMap(key string, optionalDefault ...map[string]interfa return r0 } +// Config_GetStringMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStringMap' +type Config_GetStringMap_Call struct { + *mock.Call +} + +// GetStringMap is a helper method to define mock.On call +// - key string +// - optionalDefault ...map[string]interface{} +func (_e *Config_Expecter) GetStringMap(key interface{}, optionalDefault ...interface{}) *Config_GetStringMap_Call { + return &Config_GetStringMap_Call{Call: _e.mock.On("GetStringMap", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetStringMap_Call) Run(run func(key string, optionalDefault ...map[string]interface{})) *Config_GetStringMap_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetStringMap_Call) Return(_a0 map[string]interface{}) *Config_GetStringMap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetStringMap_Call) RunAndReturn(run func(string, ...map[string]interface{}) map[string]interface{}) *Config_GetStringMap_Call { + _c.Call.Return(run) + return _c +} + // GetStringMapString provides a mock function with given fields: key, optionalDefault func (_m *Config) GetStringMapString(key string, optionalDefault ...map[string]string) map[string]string { _va := make([]interface{}, len(optionalDefault)) @@ -262,6 +648,42 @@ func (_m *Config) GetStringMapString(key string, optionalDefault ...map[string]s return r0 } +// Config_GetStringMapString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStringMapString' +type Config_GetStringMapString_Call struct { + *mock.Call +} + +// GetStringMapString is a helper method to define mock.On call +// - key string +// - optionalDefault ...map[string]string +func (_e *Config_Expecter) GetStringMapString(key interface{}, optionalDefault ...interface{}) *Config_GetStringMapString_Call { + return &Config_GetStringMapString_Call{Call: _e.mock.On("GetStringMapString", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetStringMapString_Call) Run(run func(key string, optionalDefault ...map[string]string)) *Config_GetStringMapString_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(map[string]string) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetStringMapString_Call) Return(_a0 map[string]string) *Config_GetStringMapString_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetStringMapString_Call) RunAndReturn(run func(string, ...map[string]string) map[string]string) *Config_GetStringMapString_Call { + _c.Call.Return(run) + return _c +} + // GetStringSlice provides a mock function with given fields: key, optionalDefault func (_m *Config) GetStringSlice(key string, optionalDefault ...[]string) []string { _va := make([]interface{}, len(optionalDefault)) @@ -285,6 +707,42 @@ func (_m *Config) GetStringSlice(key string, optionalDefault ...[]string) []stri return r0 } +// Config_GetStringSlice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStringSlice' +type Config_GetStringSlice_Call struct { + *mock.Call +} + +// GetStringSlice is a helper method to define mock.On call +// - key string +// - optionalDefault ...[]string +func (_e *Config_Expecter) GetStringSlice(key interface{}, optionalDefault ...interface{}) *Config_GetStringSlice_Call { + return &Config_GetStringSlice_Call{Call: _e.mock.On("GetStringSlice", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetStringSlice_Call) Run(run func(key string, optionalDefault ...[]string)) *Config_GetStringSlice_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetStringSlice_Call) Return(_a0 []string) *Config_GetStringSlice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetStringSlice_Call) RunAndReturn(run func(string, ...[]string) []string) *Config_GetStringSlice_Call { + _c.Call.Return(run) + return _c +} + // GetTime provides a mock function with given fields: key, optionalDefault func (_m *Config) GetTime(key string, optionalDefault ...time.Time) time.Time { _va := make([]interface{}, len(optionalDefault)) @@ -306,6 +764,42 @@ func (_m *Config) GetTime(key string, optionalDefault ...time.Time) time.Time { return r0 } +// Config_GetTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTime' +type Config_GetTime_Call struct { + *mock.Call +} + +// GetTime is a helper method to define mock.On call +// - key string +// - optionalDefault ...time.Time +func (_e *Config_Expecter) GetTime(key interface{}, optionalDefault ...interface{}) *Config_GetTime_Call { + return &Config_GetTime_Call{Call: _e.mock.On("GetTime", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *Config_GetTime_Call) Run(run func(key string, optionalDefault ...time.Time)) *Config_GetTime_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]time.Time, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(time.Time) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *Config_GetTime_Call) Return(_a0 time.Time) *Config_GetTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_GetTime_Call) RunAndReturn(run func(string, ...time.Time) time.Time) *Config_GetTime_Call { + _c.Call.Return(run) + return _c +} + // IsSet provides a mock function with given fields: _a0 func (_m *Config) IsSet(_a0 string) bool { ret := _m.Called(_a0) @@ -320,6 +814,34 @@ func (_m *Config) IsSet(_a0 string) bool { return r0 } +// Config_IsSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsSet' +type Config_IsSet_Call struct { + *mock.Call +} + +// IsSet is a helper method to define mock.On call +// - _a0 string +func (_e *Config_Expecter) IsSet(_a0 interface{}) *Config_IsSet_Call { + return &Config_IsSet_Call{Call: _e.mock.On("IsSet", _a0)} +} + +func (_c *Config_IsSet_Call) Run(run func(_a0 string)) *Config_IsSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Config_IsSet_Call) Return(_a0 bool) *Config_IsSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Config_IsSet_Call) RunAndReturn(run func(string) bool) *Config_IsSet_Call { + _c.Call.Return(run) + return _c +} + // UnmarshalDefaults provides a mock function with given fields: val, additionalDefaults func (_m *Config) UnmarshalDefaults(val interface{}, additionalDefaults ...cfg.UnmarshalDefaults) { _va := make([]interface{}, len(additionalDefaults)) @@ -332,6 +854,42 @@ func (_m *Config) UnmarshalDefaults(val interface{}, additionalDefaults ...cfg.U _m.Called(_ca...) } +// Config_UnmarshalDefaults_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnmarshalDefaults' +type Config_UnmarshalDefaults_Call struct { + *mock.Call +} + +// UnmarshalDefaults is a helper method to define mock.On call +// - val interface{} +// - additionalDefaults ...cfg.UnmarshalDefaults +func (_e *Config_Expecter) UnmarshalDefaults(val interface{}, additionalDefaults ...interface{}) *Config_UnmarshalDefaults_Call { + return &Config_UnmarshalDefaults_Call{Call: _e.mock.On("UnmarshalDefaults", + append([]interface{}{val}, additionalDefaults...)...)} +} + +func (_c *Config_UnmarshalDefaults_Call) Run(run func(val interface{}, additionalDefaults ...cfg.UnmarshalDefaults)) *Config_UnmarshalDefaults_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]cfg.UnmarshalDefaults, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(cfg.UnmarshalDefaults) + } + } + run(args[0].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *Config_UnmarshalDefaults_Call) Return() *Config_UnmarshalDefaults_Call { + _c.Call.Return() + return _c +} + +func (_c *Config_UnmarshalDefaults_Call) RunAndReturn(run func(interface{}, ...cfg.UnmarshalDefaults)) *Config_UnmarshalDefaults_Call { + _c.Call.Return(run) + return _c +} + // UnmarshalKey provides a mock function with given fields: key, val, additionalDefaults func (_m *Config) UnmarshalKey(key string, val interface{}, additionalDefaults ...cfg.UnmarshalDefaults) { _va := make([]interface{}, len(additionalDefaults)) @@ -344,6 +902,43 @@ func (_m *Config) UnmarshalKey(key string, val interface{}, additionalDefaults . _m.Called(_ca...) } +// Config_UnmarshalKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnmarshalKey' +type Config_UnmarshalKey_Call struct { + *mock.Call +} + +// UnmarshalKey is a helper method to define mock.On call +// - key string +// - val interface{} +// - additionalDefaults ...cfg.UnmarshalDefaults +func (_e *Config_Expecter) UnmarshalKey(key interface{}, val interface{}, additionalDefaults ...interface{}) *Config_UnmarshalKey_Call { + return &Config_UnmarshalKey_Call{Call: _e.mock.On("UnmarshalKey", + append([]interface{}{key, val}, additionalDefaults...)...)} +} + +func (_c *Config_UnmarshalKey_Call) Run(run func(key string, val interface{}, additionalDefaults ...cfg.UnmarshalDefaults)) *Config_UnmarshalKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]cfg.UnmarshalDefaults, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(cfg.UnmarshalDefaults) + } + } + run(args[0].(string), args[1].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *Config_UnmarshalKey_Call) Return() *Config_UnmarshalKey_Call { + _c.Call.Return() + return _c +} + +func (_c *Config_UnmarshalKey_Call) RunAndReturn(run func(string, interface{}, ...cfg.UnmarshalDefaults)) *Config_UnmarshalKey_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewConfig interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cfg/mocks/GosoConf.go b/pkg/cfg/mocks/GosoConf.go index 163e25676..da452f475 100644 --- a/pkg/cfg/mocks/GosoConf.go +++ b/pkg/cfg/mocks/GosoConf.go @@ -14,6 +14,14 @@ type GosoConf struct { mock.Mock } +type GosoConf_Expecter struct { + mock *mock.Mock +} + +func (_m *GosoConf) EXPECT() *GosoConf_Expecter { + return &GosoConf_Expecter{mock: &_m.Mock} +} + // AllKeys provides a mock function with given fields: func (_m *GosoConf) AllKeys() []string { ret := _m.Called() @@ -30,6 +38,33 @@ func (_m *GosoConf) AllKeys() []string { return r0 } +// GosoConf_AllKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllKeys' +type GosoConf_AllKeys_Call struct { + *mock.Call +} + +// AllKeys is a helper method to define mock.On call +func (_e *GosoConf_Expecter) AllKeys() *GosoConf_AllKeys_Call { + return &GosoConf_AllKeys_Call{Call: _e.mock.On("AllKeys")} +} + +func (_c *GosoConf_AllKeys_Call) Run(run func()) *GosoConf_AllKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *GosoConf_AllKeys_Call) Return(_a0 []string) *GosoConf_AllKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_AllKeys_Call) RunAndReturn(run func() []string) *GosoConf_AllKeys_Call { + _c.Call.Return(run) + return _c +} + // AllSettings provides a mock function with given fields: func (_m *GosoConf) AllSettings() map[string]interface{} { ret := _m.Called() @@ -46,6 +81,33 @@ func (_m *GosoConf) AllSettings() map[string]interface{} { return r0 } +// GosoConf_AllSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllSettings' +type GosoConf_AllSettings_Call struct { + *mock.Call +} + +// AllSettings is a helper method to define mock.On call +func (_e *GosoConf_Expecter) AllSettings() *GosoConf_AllSettings_Call { + return &GosoConf_AllSettings_Call{Call: _e.mock.On("AllSettings")} +} + +func (_c *GosoConf_AllSettings_Call) Run(run func()) *GosoConf_AllSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *GosoConf_AllSettings_Call) Return(_a0 map[string]interface{}) *GosoConf_AllSettings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_AllSettings_Call) RunAndReturn(run func() map[string]interface{}) *GosoConf_AllSettings_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) Get(key string, optionalDefault ...interface{}) interface{} { var _ca []interface{} @@ -65,6 +127,42 @@ func (_m *GosoConf) Get(key string, optionalDefault ...interface{}) interface{} return r0 } +// GosoConf_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type GosoConf_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - key string +// - optionalDefault ...interface{} +func (_e *GosoConf_Expecter) Get(key interface{}, optionalDefault ...interface{}) *GosoConf_Get_Call { + return &GosoConf_Get_Call{Call: _e.mock.On("Get", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_Get_Call) Run(run func(key string, optionalDefault ...interface{})) *GosoConf_Get_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_Get_Call) Return(_a0 interface{}) *GosoConf_Get_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_Get_Call) RunAndReturn(run func(string, ...interface{}) interface{}) *GosoConf_Get_Call { + _c.Call.Return(run) + return _c +} + // GetBool provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetBool(key string, optionalDefault ...bool) bool { _va := make([]interface{}, len(optionalDefault)) @@ -86,6 +184,42 @@ func (_m *GosoConf) GetBool(key string, optionalDefault ...bool) bool { return r0 } +// GosoConf_GetBool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBool' +type GosoConf_GetBool_Call struct { + *mock.Call +} + +// GetBool is a helper method to define mock.On call +// - key string +// - optionalDefault ...bool +func (_e *GosoConf_Expecter) GetBool(key interface{}, optionalDefault ...interface{}) *GosoConf_GetBool_Call { + return &GosoConf_GetBool_Call{Call: _e.mock.On("GetBool", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetBool_Call) Run(run func(key string, optionalDefault ...bool)) *GosoConf_GetBool_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]bool, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(bool) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetBool_Call) Return(_a0 bool) *GosoConf_GetBool_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetBool_Call) RunAndReturn(run func(string, ...bool) bool) *GosoConf_GetBool_Call { + _c.Call.Return(run) + return _c +} + // GetDuration provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetDuration(key string, optionalDefault ...time.Duration) time.Duration { _va := make([]interface{}, len(optionalDefault)) @@ -107,6 +241,42 @@ func (_m *GosoConf) GetDuration(key string, optionalDefault ...time.Duration) ti return r0 } +// GosoConf_GetDuration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDuration' +type GosoConf_GetDuration_Call struct { + *mock.Call +} + +// GetDuration is a helper method to define mock.On call +// - key string +// - optionalDefault ...time.Duration +func (_e *GosoConf_Expecter) GetDuration(key interface{}, optionalDefault ...interface{}) *GosoConf_GetDuration_Call { + return &GosoConf_GetDuration_Call{Call: _e.mock.On("GetDuration", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetDuration_Call) Run(run func(key string, optionalDefault ...time.Duration)) *GosoConf_GetDuration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]time.Duration, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(time.Duration) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetDuration_Call) Return(_a0 time.Duration) *GosoConf_GetDuration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetDuration_Call) RunAndReturn(run func(string, ...time.Duration) time.Duration) *GosoConf_GetDuration_Call { + _c.Call.Return(run) + return _c +} + // GetFloat64 provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetFloat64(key string, optionalDefault ...float64) float64 { _va := make([]interface{}, len(optionalDefault)) @@ -128,6 +298,42 @@ func (_m *GosoConf) GetFloat64(key string, optionalDefault ...float64) float64 { return r0 } +// GosoConf_GetFloat64_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFloat64' +type GosoConf_GetFloat64_Call struct { + *mock.Call +} + +// GetFloat64 is a helper method to define mock.On call +// - key string +// - optionalDefault ...float64 +func (_e *GosoConf_Expecter) GetFloat64(key interface{}, optionalDefault ...interface{}) *GosoConf_GetFloat64_Call { + return &GosoConf_GetFloat64_Call{Call: _e.mock.On("GetFloat64", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetFloat64_Call) Run(run func(key string, optionalDefault ...float64)) *GosoConf_GetFloat64_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]float64, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(float64) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetFloat64_Call) Return(_a0 float64) *GosoConf_GetFloat64_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetFloat64_Call) RunAndReturn(run func(string, ...float64) float64) *GosoConf_GetFloat64_Call { + _c.Call.Return(run) + return _c +} + // GetInt provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetInt(key string, optionalDefault ...int) int { _va := make([]interface{}, len(optionalDefault)) @@ -149,6 +355,42 @@ func (_m *GosoConf) GetInt(key string, optionalDefault ...int) int { return r0 } +// GosoConf_GetInt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInt' +type GosoConf_GetInt_Call struct { + *mock.Call +} + +// GetInt is a helper method to define mock.On call +// - key string +// - optionalDefault ...int +func (_e *GosoConf_Expecter) GetInt(key interface{}, optionalDefault ...interface{}) *GosoConf_GetInt_Call { + return &GosoConf_GetInt_Call{Call: _e.mock.On("GetInt", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetInt_Call) Run(run func(key string, optionalDefault ...int)) *GosoConf_GetInt_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetInt_Call) Return(_a0 int) *GosoConf_GetInt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetInt_Call) RunAndReturn(run func(string, ...int) int) *GosoConf_GetInt_Call { + _c.Call.Return(run) + return _c +} + // GetIntSlice provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetIntSlice(key string, optionalDefault ...[]int) []int { _va := make([]interface{}, len(optionalDefault)) @@ -172,6 +414,42 @@ func (_m *GosoConf) GetIntSlice(key string, optionalDefault ...[]int) []int { return r0 } +// GosoConf_GetIntSlice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIntSlice' +type GosoConf_GetIntSlice_Call struct { + *mock.Call +} + +// GetIntSlice is a helper method to define mock.On call +// - key string +// - optionalDefault ...[]int +func (_e *GosoConf_Expecter) GetIntSlice(key interface{}, optionalDefault ...interface{}) *GosoConf_GetIntSlice_Call { + return &GosoConf_GetIntSlice_Call{Call: _e.mock.On("GetIntSlice", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetIntSlice_Call) Run(run func(key string, optionalDefault ...[]int)) *GosoConf_GetIntSlice_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetIntSlice_Call) Return(_a0 []int) *GosoConf_GetIntSlice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetIntSlice_Call) RunAndReturn(run func(string, ...[]int) []int) *GosoConf_GetIntSlice_Call { + _c.Call.Return(run) + return _c +} + // GetMsiSlice provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetMsiSlice(key string, optionalDefault ...[]map[string]interface{}) []map[string]interface{} { _va := make([]interface{}, len(optionalDefault)) @@ -195,6 +473,42 @@ func (_m *GosoConf) GetMsiSlice(key string, optionalDefault ...[]map[string]inte return r0 } +// GosoConf_GetMsiSlice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMsiSlice' +type GosoConf_GetMsiSlice_Call struct { + *mock.Call +} + +// GetMsiSlice is a helper method to define mock.On call +// - key string +// - optionalDefault ...[]map[string]interface{} +func (_e *GosoConf_Expecter) GetMsiSlice(key interface{}, optionalDefault ...interface{}) *GosoConf_GetMsiSlice_Call { + return &GosoConf_GetMsiSlice_Call{Call: _e.mock.On("GetMsiSlice", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetMsiSlice_Call) Run(run func(key string, optionalDefault ...[]map[string]interface{})) *GosoConf_GetMsiSlice_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([][]map[string]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.([]map[string]interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetMsiSlice_Call) Return(_a0 []map[string]interface{}) *GosoConf_GetMsiSlice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetMsiSlice_Call) RunAndReturn(run func(string, ...[]map[string]interface{}) []map[string]interface{}) *GosoConf_GetMsiSlice_Call { + _c.Call.Return(run) + return _c +} + // GetString provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetString(key string, optionalDefault ...string) string { _va := make([]interface{}, len(optionalDefault)) @@ -216,6 +530,42 @@ func (_m *GosoConf) GetString(key string, optionalDefault ...string) string { return r0 } +// GosoConf_GetString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetString' +type GosoConf_GetString_Call struct { + *mock.Call +} + +// GetString is a helper method to define mock.On call +// - key string +// - optionalDefault ...string +func (_e *GosoConf_Expecter) GetString(key interface{}, optionalDefault ...interface{}) *GosoConf_GetString_Call { + return &GosoConf_GetString_Call{Call: _e.mock.On("GetString", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetString_Call) Run(run func(key string, optionalDefault ...string)) *GosoConf_GetString_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetString_Call) Return(_a0 string) *GosoConf_GetString_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetString_Call) RunAndReturn(run func(string, ...string) string) *GosoConf_GetString_Call { + _c.Call.Return(run) + return _c +} + // GetStringMap provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetStringMap(key string, optionalDefault ...map[string]interface{}) map[string]interface{} { _va := make([]interface{}, len(optionalDefault)) @@ -239,6 +589,42 @@ func (_m *GosoConf) GetStringMap(key string, optionalDefault ...map[string]inter return r0 } +// GosoConf_GetStringMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStringMap' +type GosoConf_GetStringMap_Call struct { + *mock.Call +} + +// GetStringMap is a helper method to define mock.On call +// - key string +// - optionalDefault ...map[string]interface{} +func (_e *GosoConf_Expecter) GetStringMap(key interface{}, optionalDefault ...interface{}) *GosoConf_GetStringMap_Call { + return &GosoConf_GetStringMap_Call{Call: _e.mock.On("GetStringMap", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetStringMap_Call) Run(run func(key string, optionalDefault ...map[string]interface{})) *GosoConf_GetStringMap_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetStringMap_Call) Return(_a0 map[string]interface{}) *GosoConf_GetStringMap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetStringMap_Call) RunAndReturn(run func(string, ...map[string]interface{}) map[string]interface{}) *GosoConf_GetStringMap_Call { + _c.Call.Return(run) + return _c +} + // GetStringMapString provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetStringMapString(key string, optionalDefault ...map[string]string) map[string]string { _va := make([]interface{}, len(optionalDefault)) @@ -262,6 +648,42 @@ func (_m *GosoConf) GetStringMapString(key string, optionalDefault ...map[string return r0 } +// GosoConf_GetStringMapString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStringMapString' +type GosoConf_GetStringMapString_Call struct { + *mock.Call +} + +// GetStringMapString is a helper method to define mock.On call +// - key string +// - optionalDefault ...map[string]string +func (_e *GosoConf_Expecter) GetStringMapString(key interface{}, optionalDefault ...interface{}) *GosoConf_GetStringMapString_Call { + return &GosoConf_GetStringMapString_Call{Call: _e.mock.On("GetStringMapString", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetStringMapString_Call) Run(run func(key string, optionalDefault ...map[string]string)) *GosoConf_GetStringMapString_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]string, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(map[string]string) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetStringMapString_Call) Return(_a0 map[string]string) *GosoConf_GetStringMapString_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetStringMapString_Call) RunAndReturn(run func(string, ...map[string]string) map[string]string) *GosoConf_GetStringMapString_Call { + _c.Call.Return(run) + return _c +} + // GetStringSlice provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetStringSlice(key string, optionalDefault ...[]string) []string { _va := make([]interface{}, len(optionalDefault)) @@ -285,6 +707,42 @@ func (_m *GosoConf) GetStringSlice(key string, optionalDefault ...[]string) []st return r0 } +// GosoConf_GetStringSlice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStringSlice' +type GosoConf_GetStringSlice_Call struct { + *mock.Call +} + +// GetStringSlice is a helper method to define mock.On call +// - key string +// - optionalDefault ...[]string +func (_e *GosoConf_Expecter) GetStringSlice(key interface{}, optionalDefault ...interface{}) *GosoConf_GetStringSlice_Call { + return &GosoConf_GetStringSlice_Call{Call: _e.mock.On("GetStringSlice", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetStringSlice_Call) Run(run func(key string, optionalDefault ...[]string)) *GosoConf_GetStringSlice_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetStringSlice_Call) Return(_a0 []string) *GosoConf_GetStringSlice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetStringSlice_Call) RunAndReturn(run func(string, ...[]string) []string) *GosoConf_GetStringSlice_Call { + _c.Call.Return(run) + return _c +} + // GetTime provides a mock function with given fields: key, optionalDefault func (_m *GosoConf) GetTime(key string, optionalDefault ...time.Time) time.Time { _va := make([]interface{}, len(optionalDefault)) @@ -306,6 +764,42 @@ func (_m *GosoConf) GetTime(key string, optionalDefault ...time.Time) time.Time return r0 } +// GosoConf_GetTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTime' +type GosoConf_GetTime_Call struct { + *mock.Call +} + +// GetTime is a helper method to define mock.On call +// - key string +// - optionalDefault ...time.Time +func (_e *GosoConf_Expecter) GetTime(key interface{}, optionalDefault ...interface{}) *GosoConf_GetTime_Call { + return &GosoConf_GetTime_Call{Call: _e.mock.On("GetTime", + append([]interface{}{key}, optionalDefault...)...)} +} + +func (_c *GosoConf_GetTime_Call) Run(run func(key string, optionalDefault ...time.Time)) *GosoConf_GetTime_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]time.Time, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(time.Time) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_GetTime_Call) Return(_a0 time.Time) *GosoConf_GetTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_GetTime_Call) RunAndReturn(run func(string, ...time.Time) time.Time) *GosoConf_GetTime_Call { + _c.Call.Return(run) + return _c +} + // IsSet provides a mock function with given fields: _a0 func (_m *GosoConf) IsSet(_a0 string) bool { ret := _m.Called(_a0) @@ -320,6 +814,34 @@ func (_m *GosoConf) IsSet(_a0 string) bool { return r0 } +// GosoConf_IsSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsSet' +type GosoConf_IsSet_Call struct { + *mock.Call +} + +// IsSet is a helper method to define mock.On call +// - _a0 string +func (_e *GosoConf_Expecter) IsSet(_a0 interface{}) *GosoConf_IsSet_Call { + return &GosoConf_IsSet_Call{Call: _e.mock.On("IsSet", _a0)} +} + +func (_c *GosoConf_IsSet_Call) Run(run func(_a0 string)) *GosoConf_IsSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *GosoConf_IsSet_Call) Return(_a0 bool) *GosoConf_IsSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_IsSet_Call) RunAndReturn(run func(string) bool) *GosoConf_IsSet_Call { + _c.Call.Return(run) + return _c +} + // Option provides a mock function with given fields: options func (_m *GosoConf) Option(options ...cfg.Option) error { _va := make([]interface{}, len(options)) @@ -340,6 +862,41 @@ func (_m *GosoConf) Option(options ...cfg.Option) error { return r0 } +// GosoConf_Option_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Option' +type GosoConf_Option_Call struct { + *mock.Call +} + +// Option is a helper method to define mock.On call +// - options ...cfg.Option +func (_e *GosoConf_Expecter) Option(options ...interface{}) *GosoConf_Option_Call { + return &GosoConf_Option_Call{Call: _e.mock.On("Option", + append([]interface{}{}, options...)...)} +} + +func (_c *GosoConf_Option_Call) Run(run func(options ...cfg.Option)) *GosoConf_Option_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]cfg.Option, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(cfg.Option) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_Option_Call) Return(_a0 error) *GosoConf_Option_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GosoConf_Option_Call) RunAndReturn(run func(...cfg.Option) error) *GosoConf_Option_Call { + _c.Call.Return(run) + return _c +} + // UnmarshalDefaults provides a mock function with given fields: val, additionalDefaults func (_m *GosoConf) UnmarshalDefaults(val interface{}, additionalDefaults ...cfg.UnmarshalDefaults) { _va := make([]interface{}, len(additionalDefaults)) @@ -352,6 +909,42 @@ func (_m *GosoConf) UnmarshalDefaults(val interface{}, additionalDefaults ...cfg _m.Called(_ca...) } +// GosoConf_UnmarshalDefaults_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnmarshalDefaults' +type GosoConf_UnmarshalDefaults_Call struct { + *mock.Call +} + +// UnmarshalDefaults is a helper method to define mock.On call +// - val interface{} +// - additionalDefaults ...cfg.UnmarshalDefaults +func (_e *GosoConf_Expecter) UnmarshalDefaults(val interface{}, additionalDefaults ...interface{}) *GosoConf_UnmarshalDefaults_Call { + return &GosoConf_UnmarshalDefaults_Call{Call: _e.mock.On("UnmarshalDefaults", + append([]interface{}{val}, additionalDefaults...)...)} +} + +func (_c *GosoConf_UnmarshalDefaults_Call) Run(run func(val interface{}, additionalDefaults ...cfg.UnmarshalDefaults)) *GosoConf_UnmarshalDefaults_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]cfg.UnmarshalDefaults, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(cfg.UnmarshalDefaults) + } + } + run(args[0].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_UnmarshalDefaults_Call) Return() *GosoConf_UnmarshalDefaults_Call { + _c.Call.Return() + return _c +} + +func (_c *GosoConf_UnmarshalDefaults_Call) RunAndReturn(run func(interface{}, ...cfg.UnmarshalDefaults)) *GosoConf_UnmarshalDefaults_Call { + _c.Call.Return(run) + return _c +} + // UnmarshalKey provides a mock function with given fields: key, val, additionalDefaults func (_m *GosoConf) UnmarshalKey(key string, val interface{}, additionalDefaults ...cfg.UnmarshalDefaults) { _va := make([]interface{}, len(additionalDefaults)) @@ -364,6 +957,43 @@ func (_m *GosoConf) UnmarshalKey(key string, val interface{}, additionalDefaults _m.Called(_ca...) } +// GosoConf_UnmarshalKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnmarshalKey' +type GosoConf_UnmarshalKey_Call struct { + *mock.Call +} + +// UnmarshalKey is a helper method to define mock.On call +// - key string +// - val interface{} +// - additionalDefaults ...cfg.UnmarshalDefaults +func (_e *GosoConf_Expecter) UnmarshalKey(key interface{}, val interface{}, additionalDefaults ...interface{}) *GosoConf_UnmarshalKey_Call { + return &GosoConf_UnmarshalKey_Call{Call: _e.mock.On("UnmarshalKey", + append([]interface{}{key, val}, additionalDefaults...)...)} +} + +func (_c *GosoConf_UnmarshalKey_Call) Run(run func(key string, val interface{}, additionalDefaults ...cfg.UnmarshalDefaults)) *GosoConf_UnmarshalKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]cfg.UnmarshalDefaults, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(cfg.UnmarshalDefaults) + } + } + run(args[0].(string), args[1].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *GosoConf_UnmarshalKey_Call) Return() *GosoConf_UnmarshalKey_Call { + _c.Call.Return() + return _c +} + +func (_c *GosoConf_UnmarshalKey_Call) RunAndReturn(run func(string, interface{}, ...cfg.UnmarshalDefaults)) *GosoConf_UnmarshalKey_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewGosoConf interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cfg/mocks/Sentry.go b/pkg/cfg/mocks/Sentry.go index f3a44d3f2..a2a56b1b5 100644 --- a/pkg/cfg/mocks/Sentry.go +++ b/pkg/cfg/mocks/Sentry.go @@ -12,6 +12,14 @@ type Sentry struct { mock.Mock } +type Sentry_Expecter struct { + mock *mock.Mock +} + +func (_m *Sentry) EXPECT() *Sentry_Expecter { + return &Sentry_Expecter{mock: &_m.Mock} +} + // CaptureException provides a mock function with given fields: exception, hint, scope func (_m *Sentry) CaptureException(exception error, hint *sentry.EventHint, scope sentry.EventModifier) *sentry.EventID { ret := _m.Called(exception, hint, scope) @@ -28,6 +36,36 @@ func (_m *Sentry) CaptureException(exception error, hint *sentry.EventHint, scop return r0 } +// Sentry_CaptureException_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CaptureException' +type Sentry_CaptureException_Call struct { + *mock.Call +} + +// CaptureException is a helper method to define mock.On call +// - exception error +// - hint *sentry.EventHint +// - scope sentry.EventModifier +func (_e *Sentry_Expecter) CaptureException(exception interface{}, hint interface{}, scope interface{}) *Sentry_CaptureException_Call { + return &Sentry_CaptureException_Call{Call: _e.mock.On("CaptureException", exception, hint, scope)} +} + +func (_c *Sentry_CaptureException_Call) Run(run func(exception error, hint *sentry.EventHint, scope sentry.EventModifier)) *Sentry_CaptureException_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(error), args[1].(*sentry.EventHint), args[2].(sentry.EventModifier)) + }) + return _c +} + +func (_c *Sentry_CaptureException_Call) Return(_a0 *sentry.EventID) *Sentry_CaptureException_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Sentry_CaptureException_Call) RunAndReturn(run func(error, *sentry.EventHint, sentry.EventModifier) *sentry.EventID) *Sentry_CaptureException_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewSentry interface { mock.TestingT Cleanup(func()) diff --git a/pkg/clock/mocks/Clock.go b/pkg/clock/mocks/Clock.go index e6a01cbe0..d8bd397e2 100644 --- a/pkg/clock/mocks/Clock.go +++ b/pkg/clock/mocks/Clock.go @@ -14,6 +14,14 @@ type Clock struct { mock.Mock } +type Clock_Expecter struct { + mock *mock.Mock +} + +func (_m *Clock) EXPECT() *Clock_Expecter { + return &Clock_Expecter{mock: &_m.Mock} +} + // After provides a mock function with given fields: d func (_m *Clock) After(d time.Duration) <-chan time.Time { ret := _m.Called(d) @@ -30,6 +38,34 @@ func (_m *Clock) After(d time.Duration) <-chan time.Time { return r0 } +// Clock_After_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'After' +type Clock_After_Call struct { + *mock.Call +} + +// After is a helper method to define mock.On call +// - d time.Duration +func (_e *Clock_Expecter) After(d interface{}) *Clock_After_Call { + return &Clock_After_Call{Call: _e.mock.On("After", d)} +} + +func (_c *Clock_After_Call) Run(run func(d time.Duration)) *Clock_After_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *Clock_After_Call) Return(_a0 <-chan time.Time) *Clock_After_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Clock_After_Call) RunAndReturn(run func(time.Duration) <-chan time.Time) *Clock_After_Call { + _c.Call.Return(run) + return _c +} + // NewTicker provides a mock function with given fields: d func (_m *Clock) NewTicker(d time.Duration) clock.Ticker { ret := _m.Called(d) @@ -46,6 +82,34 @@ func (_m *Clock) NewTicker(d time.Duration) clock.Ticker { return r0 } +// Clock_NewTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTicker' +type Clock_NewTicker_Call struct { + *mock.Call +} + +// NewTicker is a helper method to define mock.On call +// - d time.Duration +func (_e *Clock_Expecter) NewTicker(d interface{}) *Clock_NewTicker_Call { + return &Clock_NewTicker_Call{Call: _e.mock.On("NewTicker", d)} +} + +func (_c *Clock_NewTicker_Call) Run(run func(d time.Duration)) *Clock_NewTicker_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *Clock_NewTicker_Call) Return(_a0 clock.Ticker) *Clock_NewTicker_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Clock_NewTicker_Call) RunAndReturn(run func(time.Duration) clock.Ticker) *Clock_NewTicker_Call { + _c.Call.Return(run) + return _c +} + // NewTimer provides a mock function with given fields: d func (_m *Clock) NewTimer(d time.Duration) clock.Timer { ret := _m.Called(d) @@ -62,6 +126,34 @@ func (_m *Clock) NewTimer(d time.Duration) clock.Timer { return r0 } +// Clock_NewTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTimer' +type Clock_NewTimer_Call struct { + *mock.Call +} + +// NewTimer is a helper method to define mock.On call +// - d time.Duration +func (_e *Clock_Expecter) NewTimer(d interface{}) *Clock_NewTimer_Call { + return &Clock_NewTimer_Call{Call: _e.mock.On("NewTimer", d)} +} + +func (_c *Clock_NewTimer_Call) Run(run func(d time.Duration)) *Clock_NewTimer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *Clock_NewTimer_Call) Return(_a0 clock.Timer) *Clock_NewTimer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Clock_NewTimer_Call) RunAndReturn(run func(time.Duration) clock.Timer) *Clock_NewTimer_Call { + _c.Call.Return(run) + return _c +} + // Now provides a mock function with given fields: func (_m *Clock) Now() time.Time { ret := _m.Called() @@ -76,6 +168,33 @@ func (_m *Clock) Now() time.Time { return r0 } +// Clock_Now_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Now' +type Clock_Now_Call struct { + *mock.Call +} + +// Now is a helper method to define mock.On call +func (_e *Clock_Expecter) Now() *Clock_Now_Call { + return &Clock_Now_Call{Call: _e.mock.On("Now")} +} + +func (_c *Clock_Now_Call) Run(run func()) *Clock_Now_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Clock_Now_Call) Return(_a0 time.Time) *Clock_Now_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Clock_Now_Call) RunAndReturn(run func() time.Time) *Clock_Now_Call { + _c.Call.Return(run) + return _c +} + // Since provides a mock function with given fields: t func (_m *Clock) Since(t time.Time) time.Duration { ret := _m.Called(t) @@ -90,11 +209,67 @@ func (_m *Clock) Since(t time.Time) time.Duration { return r0 } +// Clock_Since_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Since' +type Clock_Since_Call struct { + *mock.Call +} + +// Since is a helper method to define mock.On call +// - t time.Time +func (_e *Clock_Expecter) Since(t interface{}) *Clock_Since_Call { + return &Clock_Since_Call{Call: _e.mock.On("Since", t)} +} + +func (_c *Clock_Since_Call) Run(run func(t time.Time)) *Clock_Since_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Time)) + }) + return _c +} + +func (_c *Clock_Since_Call) Return(_a0 time.Duration) *Clock_Since_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Clock_Since_Call) RunAndReturn(run func(time.Time) time.Duration) *Clock_Since_Call { + _c.Call.Return(run) + return _c +} + // Sleep provides a mock function with given fields: d func (_m *Clock) Sleep(d time.Duration) { _m.Called(d) } +// Clock_Sleep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sleep' +type Clock_Sleep_Call struct { + *mock.Call +} + +// Sleep is a helper method to define mock.On call +// - d time.Duration +func (_e *Clock_Expecter) Sleep(d interface{}) *Clock_Sleep_Call { + return &Clock_Sleep_Call{Call: _e.mock.On("Sleep", d)} +} + +func (_c *Clock_Sleep_Call) Run(run func(d time.Duration)) *Clock_Sleep_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *Clock_Sleep_Call) Return() *Clock_Sleep_Call { + _c.Call.Return() + return _c +} + +func (_c *Clock_Sleep_Call) RunAndReturn(run func(time.Duration)) *Clock_Sleep_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClock interface { mock.TestingT Cleanup(func()) diff --git a/pkg/clock/mocks/FakeClock.go b/pkg/clock/mocks/FakeClock.go index eb91efd56..7ed1e8286 100644 --- a/pkg/clock/mocks/FakeClock.go +++ b/pkg/clock/mocks/FakeClock.go @@ -14,11 +14,47 @@ type FakeClock struct { mock.Mock } +type FakeClock_Expecter struct { + mock *mock.Mock +} + +func (_m *FakeClock) EXPECT() *FakeClock_Expecter { + return &FakeClock_Expecter{mock: &_m.Mock} +} + // Advance provides a mock function with given fields: d func (_m *FakeClock) Advance(d time.Duration) { _m.Called(d) } +// FakeClock_Advance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Advance' +type FakeClock_Advance_Call struct { + *mock.Call +} + +// Advance is a helper method to define mock.On call +// - d time.Duration +func (_e *FakeClock_Expecter) Advance(d interface{}) *FakeClock_Advance_Call { + return &FakeClock_Advance_Call{Call: _e.mock.On("Advance", d)} +} + +func (_c *FakeClock_Advance_Call) Run(run func(d time.Duration)) *FakeClock_Advance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *FakeClock_Advance_Call) Return() *FakeClock_Advance_Call { + _c.Call.Return() + return _c +} + +func (_c *FakeClock_Advance_Call) RunAndReturn(run func(time.Duration)) *FakeClock_Advance_Call { + _c.Call.Return(run) + return _c +} + // After provides a mock function with given fields: d func (_m *FakeClock) After(d time.Duration) <-chan time.Time { ret := _m.Called(d) @@ -35,21 +71,133 @@ func (_m *FakeClock) After(d time.Duration) <-chan time.Time { return r0 } +// FakeClock_After_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'After' +type FakeClock_After_Call struct { + *mock.Call +} + +// After is a helper method to define mock.On call +// - d time.Duration +func (_e *FakeClock_Expecter) After(d interface{}) *FakeClock_After_Call { + return &FakeClock_After_Call{Call: _e.mock.On("After", d)} +} + +func (_c *FakeClock_After_Call) Run(run func(d time.Duration)) *FakeClock_After_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *FakeClock_After_Call) Return(_a0 <-chan time.Time) *FakeClock_After_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FakeClock_After_Call) RunAndReturn(run func(time.Duration) <-chan time.Time) *FakeClock_After_Call { + _c.Call.Return(run) + return _c +} + // BlockUntil provides a mock function with given fields: n func (_m *FakeClock) BlockUntil(n int) { _m.Called(n) } +// FakeClock_BlockUntil_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockUntil' +type FakeClock_BlockUntil_Call struct { + *mock.Call +} + +// BlockUntil is a helper method to define mock.On call +// - n int +func (_e *FakeClock_Expecter) BlockUntil(n interface{}) *FakeClock_BlockUntil_Call { + return &FakeClock_BlockUntil_Call{Call: _e.mock.On("BlockUntil", n)} +} + +func (_c *FakeClock_BlockUntil_Call) Run(run func(n int)) *FakeClock_BlockUntil_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *FakeClock_BlockUntil_Call) Return() *FakeClock_BlockUntil_Call { + _c.Call.Return() + return _c +} + +func (_c *FakeClock_BlockUntil_Call) RunAndReturn(run func(int)) *FakeClock_BlockUntil_Call { + _c.Call.Return(run) + return _c +} + // BlockUntilTickers provides a mock function with given fields: n func (_m *FakeClock) BlockUntilTickers(n int) { _m.Called(n) } +// FakeClock_BlockUntilTickers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockUntilTickers' +type FakeClock_BlockUntilTickers_Call struct { + *mock.Call +} + +// BlockUntilTickers is a helper method to define mock.On call +// - n int +func (_e *FakeClock_Expecter) BlockUntilTickers(n interface{}) *FakeClock_BlockUntilTickers_Call { + return &FakeClock_BlockUntilTickers_Call{Call: _e.mock.On("BlockUntilTickers", n)} +} + +func (_c *FakeClock_BlockUntilTickers_Call) Run(run func(n int)) *FakeClock_BlockUntilTickers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *FakeClock_BlockUntilTickers_Call) Return() *FakeClock_BlockUntilTickers_Call { + _c.Call.Return() + return _c +} + +func (_c *FakeClock_BlockUntilTickers_Call) RunAndReturn(run func(int)) *FakeClock_BlockUntilTickers_Call { + _c.Call.Return(run) + return _c +} + // BlockUntilTimers provides a mock function with given fields: n func (_m *FakeClock) BlockUntilTimers(n int) { _m.Called(n) } +// FakeClock_BlockUntilTimers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockUntilTimers' +type FakeClock_BlockUntilTimers_Call struct { + *mock.Call +} + +// BlockUntilTimers is a helper method to define mock.On call +// - n int +func (_e *FakeClock_Expecter) BlockUntilTimers(n interface{}) *FakeClock_BlockUntilTimers_Call { + return &FakeClock_BlockUntilTimers_Call{Call: _e.mock.On("BlockUntilTimers", n)} +} + +func (_c *FakeClock_BlockUntilTimers_Call) Run(run func(n int)) *FakeClock_BlockUntilTimers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *FakeClock_BlockUntilTimers_Call) Return() *FakeClock_BlockUntilTimers_Call { + _c.Call.Return() + return _c +} + +func (_c *FakeClock_BlockUntilTimers_Call) RunAndReturn(run func(int)) *FakeClock_BlockUntilTimers_Call { + _c.Call.Return(run) + return _c +} + // NewTicker provides a mock function with given fields: d func (_m *FakeClock) NewTicker(d time.Duration) clock.Ticker { ret := _m.Called(d) @@ -66,6 +214,34 @@ func (_m *FakeClock) NewTicker(d time.Duration) clock.Ticker { return r0 } +// FakeClock_NewTicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTicker' +type FakeClock_NewTicker_Call struct { + *mock.Call +} + +// NewTicker is a helper method to define mock.On call +// - d time.Duration +func (_e *FakeClock_Expecter) NewTicker(d interface{}) *FakeClock_NewTicker_Call { + return &FakeClock_NewTicker_Call{Call: _e.mock.On("NewTicker", d)} +} + +func (_c *FakeClock_NewTicker_Call) Run(run func(d time.Duration)) *FakeClock_NewTicker_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *FakeClock_NewTicker_Call) Return(_a0 clock.Ticker) *FakeClock_NewTicker_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FakeClock_NewTicker_Call) RunAndReturn(run func(time.Duration) clock.Ticker) *FakeClock_NewTicker_Call { + _c.Call.Return(run) + return _c +} + // NewTimer provides a mock function with given fields: d func (_m *FakeClock) NewTimer(d time.Duration) clock.Timer { ret := _m.Called(d) @@ -82,6 +258,34 @@ func (_m *FakeClock) NewTimer(d time.Duration) clock.Timer { return r0 } +// FakeClock_NewTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTimer' +type FakeClock_NewTimer_Call struct { + *mock.Call +} + +// NewTimer is a helper method to define mock.On call +// - d time.Duration +func (_e *FakeClock_Expecter) NewTimer(d interface{}) *FakeClock_NewTimer_Call { + return &FakeClock_NewTimer_Call{Call: _e.mock.On("NewTimer", d)} +} + +func (_c *FakeClock_NewTimer_Call) Run(run func(d time.Duration)) *FakeClock_NewTimer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *FakeClock_NewTimer_Call) Return(_a0 clock.Timer) *FakeClock_NewTimer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FakeClock_NewTimer_Call) RunAndReturn(run func(time.Duration) clock.Timer) *FakeClock_NewTimer_Call { + _c.Call.Return(run) + return _c +} + // Now provides a mock function with given fields: func (_m *FakeClock) Now() time.Time { ret := _m.Called() @@ -96,6 +300,33 @@ func (_m *FakeClock) Now() time.Time { return r0 } +// FakeClock_Now_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Now' +type FakeClock_Now_Call struct { + *mock.Call +} + +// Now is a helper method to define mock.On call +func (_e *FakeClock_Expecter) Now() *FakeClock_Now_Call { + return &FakeClock_Now_Call{Call: _e.mock.On("Now")} +} + +func (_c *FakeClock_Now_Call) Run(run func()) *FakeClock_Now_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *FakeClock_Now_Call) Return(_a0 time.Time) *FakeClock_Now_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FakeClock_Now_Call) RunAndReturn(run func() time.Time) *FakeClock_Now_Call { + _c.Call.Return(run) + return _c +} + // Since provides a mock function with given fields: t func (_m *FakeClock) Since(t time.Time) time.Duration { ret := _m.Called(t) @@ -110,11 +341,67 @@ func (_m *FakeClock) Since(t time.Time) time.Duration { return r0 } +// FakeClock_Since_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Since' +type FakeClock_Since_Call struct { + *mock.Call +} + +// Since is a helper method to define mock.On call +// - t time.Time +func (_e *FakeClock_Expecter) Since(t interface{}) *FakeClock_Since_Call { + return &FakeClock_Since_Call{Call: _e.mock.On("Since", t)} +} + +func (_c *FakeClock_Since_Call) Run(run func(t time.Time)) *FakeClock_Since_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Time)) + }) + return _c +} + +func (_c *FakeClock_Since_Call) Return(_a0 time.Duration) *FakeClock_Since_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FakeClock_Since_Call) RunAndReturn(run func(time.Time) time.Duration) *FakeClock_Since_Call { + _c.Call.Return(run) + return _c +} + // Sleep provides a mock function with given fields: d func (_m *FakeClock) Sleep(d time.Duration) { _m.Called(d) } +// FakeClock_Sleep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sleep' +type FakeClock_Sleep_Call struct { + *mock.Call +} + +// Sleep is a helper method to define mock.On call +// - d time.Duration +func (_e *FakeClock_Expecter) Sleep(d interface{}) *FakeClock_Sleep_Call { + return &FakeClock_Sleep_Call{Call: _e.mock.On("Sleep", d)} +} + +func (_c *FakeClock_Sleep_Call) Run(run func(d time.Duration)) *FakeClock_Sleep_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *FakeClock_Sleep_Call) Return() *FakeClock_Sleep_Call { + _c.Call.Return() + return _c +} + +func (_c *FakeClock_Sleep_Call) RunAndReturn(run func(time.Duration)) *FakeClock_Sleep_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewFakeClock interface { mock.TestingT Cleanup(func()) diff --git a/pkg/clock/mocks/Ticker.go b/pkg/clock/mocks/Ticker.go index ffeda2659..ea2231158 100644 --- a/pkg/clock/mocks/Ticker.go +++ b/pkg/clock/mocks/Ticker.go @@ -13,6 +13,14 @@ type Ticker struct { mock.Mock } +type Ticker_Expecter struct { + mock *mock.Mock +} + +func (_m *Ticker) EXPECT() *Ticker_Expecter { + return &Ticker_Expecter{mock: &_m.Mock} +} + // Chan provides a mock function with given fields: func (_m *Ticker) Chan() <-chan time.Time { ret := _m.Called() @@ -29,16 +37,98 @@ func (_m *Ticker) Chan() <-chan time.Time { return r0 } +// Ticker_Chan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Chan' +type Ticker_Chan_Call struct { + *mock.Call +} + +// Chan is a helper method to define mock.On call +func (_e *Ticker_Expecter) Chan() *Ticker_Chan_Call { + return &Ticker_Chan_Call{Call: _e.mock.On("Chan")} +} + +func (_c *Ticker_Chan_Call) Run(run func()) *Ticker_Chan_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Ticker_Chan_Call) Return(_a0 <-chan time.Time) *Ticker_Chan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Ticker_Chan_Call) RunAndReturn(run func() <-chan time.Time) *Ticker_Chan_Call { + _c.Call.Return(run) + return _c +} + // Reset provides a mock function with given fields: d func (_m *Ticker) Reset(d time.Duration) { _m.Called(d) } +// Ticker_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset' +type Ticker_Reset_Call struct { + *mock.Call +} + +// Reset is a helper method to define mock.On call +// - d time.Duration +func (_e *Ticker_Expecter) Reset(d interface{}) *Ticker_Reset_Call { + return &Ticker_Reset_Call{Call: _e.mock.On("Reset", d)} +} + +func (_c *Ticker_Reset_Call) Run(run func(d time.Duration)) *Ticker_Reset_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *Ticker_Reset_Call) Return() *Ticker_Reset_Call { + _c.Call.Return() + return _c +} + +func (_c *Ticker_Reset_Call) RunAndReturn(run func(time.Duration)) *Ticker_Reset_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *Ticker) Stop() { _m.Called() } +// Ticker_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type Ticker_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *Ticker_Expecter) Stop() *Ticker_Stop_Call { + return &Ticker_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *Ticker_Stop_Call) Run(run func()) *Ticker_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Ticker_Stop_Call) Return() *Ticker_Stop_Call { + _c.Call.Return() + return _c +} + +func (_c *Ticker_Stop_Call) RunAndReturn(run func()) *Ticker_Stop_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTicker interface { mock.TestingT Cleanup(func()) diff --git a/pkg/clock/mocks/Timer.go b/pkg/clock/mocks/Timer.go index e978add8e..7eb6cf707 100644 --- a/pkg/clock/mocks/Timer.go +++ b/pkg/clock/mocks/Timer.go @@ -13,6 +13,14 @@ type Timer struct { mock.Mock } +type Timer_Expecter struct { + mock *mock.Mock +} + +func (_m *Timer) EXPECT() *Timer_Expecter { + return &Timer_Expecter{mock: &_m.Mock} +} + // Chan provides a mock function with given fields: func (_m *Timer) Chan() <-chan time.Time { ret := _m.Called() @@ -29,11 +37,66 @@ func (_m *Timer) Chan() <-chan time.Time { return r0 } +// Timer_Chan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Chan' +type Timer_Chan_Call struct { + *mock.Call +} + +// Chan is a helper method to define mock.On call +func (_e *Timer_Expecter) Chan() *Timer_Chan_Call { + return &Timer_Chan_Call{Call: _e.mock.On("Chan")} +} + +func (_c *Timer_Chan_Call) Run(run func()) *Timer_Chan_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Timer_Chan_Call) Return(_a0 <-chan time.Time) *Timer_Chan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Timer_Chan_Call) RunAndReturn(run func() <-chan time.Time) *Timer_Chan_Call { + _c.Call.Return(run) + return _c +} + // Reset provides a mock function with given fields: d func (_m *Timer) Reset(d time.Duration) { _m.Called(d) } +// Timer_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset' +type Timer_Reset_Call struct { + *mock.Call +} + +// Reset is a helper method to define mock.On call +// - d time.Duration +func (_e *Timer_Expecter) Reset(d interface{}) *Timer_Reset_Call { + return &Timer_Reset_Call{Call: _e.mock.On("Reset", d)} +} + +func (_c *Timer_Reset_Call) Run(run func(d time.Duration)) *Timer_Reset_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *Timer_Reset_Call) Return() *Timer_Reset_Call { + _c.Call.Return() + return _c +} + +func (_c *Timer_Reset_Call) RunAndReturn(run func(time.Duration)) *Timer_Reset_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *Timer) Stop() bool { ret := _m.Called() @@ -48,6 +111,33 @@ func (_m *Timer) Stop() bool { return r0 } +// Timer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type Timer_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *Timer_Expecter) Stop() *Timer_Stop_Call { + return &Timer_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *Timer_Stop_Call) Run(run func()) *Timer_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Timer_Stop_Call) Return(_a0 bool) *Timer_Stop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Timer_Stop_Call) RunAndReturn(run func() bool) *Timer_Stop_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTimer interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/cloudwatch/mocks/Client.go b/pkg/cloud/aws/cloudwatch/mocks/Client.go index c2bc3787d..7442f2ee2 100644 --- a/pkg/cloud/aws/cloudwatch/mocks/Client.go +++ b/pkg/cloud/aws/cloudwatch/mocks/Client.go @@ -15,6 +15,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // GetMetricData provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetMetricData(ctx context.Context, params *cloudwatch.GetMetricDataInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.GetMetricDataOutput, error) { _va := make([]interface{}, len(optFns)) @@ -48,6 +56,43 @@ func (_m *Client) GetMetricData(ctx context.Context, params *cloudwatch.GetMetri return r0, r1 } +// Client_GetMetricData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetricData' +type Client_GetMetricData_Call struct { + *mock.Call +} + +// GetMetricData is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudwatch.GetMetricDataInput +// - optFns ...func(*cloudwatch.Options) +func (_e *Client_Expecter) GetMetricData(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetMetricData_Call { + return &Client_GetMetricData_Call{Call: _e.mock.On("GetMetricData", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetMetricData_Call) Run(run func(ctx context.Context, params *cloudwatch.GetMetricDataInput, optFns ...func(*cloudwatch.Options))) *Client_GetMetricData_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudwatch.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudwatch.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudwatch.GetMetricDataInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetMetricData_Call) Return(_a0 *cloudwatch.GetMetricDataOutput, _a1 error) *Client_GetMetricData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetMetricData_Call) RunAndReturn(run func(context.Context, *cloudwatch.GetMetricDataInput, ...func(*cloudwatch.Options)) (*cloudwatch.GetMetricDataOutput, error)) *Client_GetMetricData_Call { + _c.Call.Return(run) + return _c +} + // PutMetricData provides a mock function with given fields: ctx, params, optFns func (_m *Client) PutMetricData(ctx context.Context, params *cloudwatch.PutMetricDataInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.PutMetricDataOutput, error) { _va := make([]interface{}, len(optFns)) @@ -81,6 +126,43 @@ func (_m *Client) PutMetricData(ctx context.Context, params *cloudwatch.PutMetri return r0, r1 } +// Client_PutMetricData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutMetricData' +type Client_PutMetricData_Call struct { + *mock.Call +} + +// PutMetricData is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudwatch.PutMetricDataInput +// - optFns ...func(*cloudwatch.Options) +func (_e *Client_Expecter) PutMetricData(ctx interface{}, params interface{}, optFns ...interface{}) *Client_PutMetricData_Call { + return &Client_PutMetricData_Call{Call: _e.mock.On("PutMetricData", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_PutMetricData_Call) Run(run func(ctx context.Context, params *cloudwatch.PutMetricDataInput, optFns ...func(*cloudwatch.Options))) *Client_PutMetricData_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudwatch.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudwatch.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudwatch.PutMetricDataInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_PutMetricData_Call) Return(_a0 *cloudwatch.PutMetricDataOutput, _a1 error) *Client_PutMetricData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PutMetricData_Call) RunAndReturn(run func(context.Context, *cloudwatch.PutMetricDataInput, ...func(*cloudwatch.Options)) (*cloudwatch.PutMetricDataOutput, error)) *Client_PutMetricData_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/dynamodb/mocks/Client.go b/pkg/cloud/aws/dynamodb/mocks/Client.go index cd7b48e5d..87f23d4f0 100644 --- a/pkg/cloud/aws/dynamodb/mocks/Client.go +++ b/pkg/cloud/aws/dynamodb/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // BatchGetItem provides a mock function with given fields: ctx, params, optFns func (_m *Client) BatchGetItem(ctx context.Context, params *dynamodb.BatchGetItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.BatchGetItemOutput, error) { _va := make([]interface{}, len(optFns)) @@ -47,6 +55,43 @@ func (_m *Client) BatchGetItem(ctx context.Context, params *dynamodb.BatchGetIte return r0, r1 } +// Client_BatchGetItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchGetItem' +type Client_BatchGetItem_Call struct { + *mock.Call +} + +// BatchGetItem is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.BatchGetItemInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) BatchGetItem(ctx interface{}, params interface{}, optFns ...interface{}) *Client_BatchGetItem_Call { + return &Client_BatchGetItem_Call{Call: _e.mock.On("BatchGetItem", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_BatchGetItem_Call) Run(run func(ctx context.Context, params *dynamodb.BatchGetItemInput, optFns ...func(*dynamodb.Options))) *Client_BatchGetItem_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.BatchGetItemInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_BatchGetItem_Call) Return(_a0 *dynamodb.BatchGetItemOutput, _a1 error) *Client_BatchGetItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_BatchGetItem_Call) RunAndReturn(run func(context.Context, *dynamodb.BatchGetItemInput, ...func(*dynamodb.Options)) (*dynamodb.BatchGetItemOutput, error)) *Client_BatchGetItem_Call { + _c.Call.Return(run) + return _c +} + // BatchWriteItem provides a mock function with given fields: ctx, params, optFns func (_m *Client) BatchWriteItem(ctx context.Context, params *dynamodb.BatchWriteItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.BatchWriteItemOutput, error) { _va := make([]interface{}, len(optFns)) @@ -80,6 +125,43 @@ func (_m *Client) BatchWriteItem(ctx context.Context, params *dynamodb.BatchWrit return r0, r1 } +// Client_BatchWriteItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchWriteItem' +type Client_BatchWriteItem_Call struct { + *mock.Call +} + +// BatchWriteItem is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.BatchWriteItemInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) BatchWriteItem(ctx interface{}, params interface{}, optFns ...interface{}) *Client_BatchWriteItem_Call { + return &Client_BatchWriteItem_Call{Call: _e.mock.On("BatchWriteItem", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_BatchWriteItem_Call) Run(run func(ctx context.Context, params *dynamodb.BatchWriteItemInput, optFns ...func(*dynamodb.Options))) *Client_BatchWriteItem_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.BatchWriteItemInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_BatchWriteItem_Call) Return(_a0 *dynamodb.BatchWriteItemOutput, _a1 error) *Client_BatchWriteItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_BatchWriteItem_Call) RunAndReturn(run func(context.Context, *dynamodb.BatchWriteItemInput, ...func(*dynamodb.Options)) (*dynamodb.BatchWriteItemOutput, error)) *Client_BatchWriteItem_Call { + _c.Call.Return(run) + return _c +} + // CreateTable provides a mock function with given fields: ctx, params, optFns func (_m *Client) CreateTable(ctx context.Context, params *dynamodb.CreateTableInput, optFns ...func(*dynamodb.Options)) (*dynamodb.CreateTableOutput, error) { _va := make([]interface{}, len(optFns)) @@ -113,6 +195,43 @@ func (_m *Client) CreateTable(ctx context.Context, params *dynamodb.CreateTableI return r0, r1 } +// Client_CreateTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTable' +type Client_CreateTable_Call struct { + *mock.Call +} + +// CreateTable is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.CreateTableInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) CreateTable(ctx interface{}, params interface{}, optFns ...interface{}) *Client_CreateTable_Call { + return &Client_CreateTable_Call{Call: _e.mock.On("CreateTable", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_CreateTable_Call) Run(run func(ctx context.Context, params *dynamodb.CreateTableInput, optFns ...func(*dynamodb.Options))) *Client_CreateTable_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.CreateTableInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_CreateTable_Call) Return(_a0 *dynamodb.CreateTableOutput, _a1 error) *Client_CreateTable_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_CreateTable_Call) RunAndReturn(run func(context.Context, *dynamodb.CreateTableInput, ...func(*dynamodb.Options)) (*dynamodb.CreateTableOutput, error)) *Client_CreateTable_Call { + _c.Call.Return(run) + return _c +} + // DeleteItem provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeleteItem(ctx context.Context, params *dynamodb.DeleteItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DeleteItemOutput, error) { _va := make([]interface{}, len(optFns)) @@ -146,6 +265,43 @@ func (_m *Client) DeleteItem(ctx context.Context, params *dynamodb.DeleteItemInp return r0, r1 } +// Client_DeleteItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteItem' +type Client_DeleteItem_Call struct { + *mock.Call +} + +// DeleteItem is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.DeleteItemInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) DeleteItem(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteItem_Call { + return &Client_DeleteItem_Call{Call: _e.mock.On("DeleteItem", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeleteItem_Call) Run(run func(ctx context.Context, params *dynamodb.DeleteItemInput, optFns ...func(*dynamodb.Options))) *Client_DeleteItem_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.DeleteItemInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeleteItem_Call) Return(_a0 *dynamodb.DeleteItemOutput, _a1 error) *Client_DeleteItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeleteItem_Call) RunAndReturn(run func(context.Context, *dynamodb.DeleteItemInput, ...func(*dynamodb.Options)) (*dynamodb.DeleteItemOutput, error)) *Client_DeleteItem_Call { + _c.Call.Return(run) + return _c +} + // DeleteTable provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeleteTable(ctx context.Context, params *dynamodb.DeleteTableInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DeleteTableOutput, error) { _va := make([]interface{}, len(optFns)) @@ -179,6 +335,43 @@ func (_m *Client) DeleteTable(ctx context.Context, params *dynamodb.DeleteTableI return r0, r1 } +// Client_DeleteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTable' +type Client_DeleteTable_Call struct { + *mock.Call +} + +// DeleteTable is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.DeleteTableInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) DeleteTable(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteTable_Call { + return &Client_DeleteTable_Call{Call: _e.mock.On("DeleteTable", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeleteTable_Call) Run(run func(ctx context.Context, params *dynamodb.DeleteTableInput, optFns ...func(*dynamodb.Options))) *Client_DeleteTable_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.DeleteTableInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeleteTable_Call) Return(_a0 *dynamodb.DeleteTableOutput, _a1 error) *Client_DeleteTable_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeleteTable_Call) RunAndReturn(run func(context.Context, *dynamodb.DeleteTableInput, ...func(*dynamodb.Options)) (*dynamodb.DeleteTableOutput, error)) *Client_DeleteTable_Call { + _c.Call.Return(run) + return _c +} + // DescribeTable provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeTable(ctx context.Context, params *dynamodb.DescribeTableInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DescribeTableOutput, error) { _va := make([]interface{}, len(optFns)) @@ -212,6 +405,43 @@ func (_m *Client) DescribeTable(ctx context.Context, params *dynamodb.DescribeTa return r0, r1 } +// Client_DescribeTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTable' +type Client_DescribeTable_Call struct { + *mock.Call +} + +// DescribeTable is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.DescribeTableInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) DescribeTable(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeTable_Call { + return &Client_DescribeTable_Call{Call: _e.mock.On("DescribeTable", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeTable_Call) Run(run func(ctx context.Context, params *dynamodb.DescribeTableInput, optFns ...func(*dynamodb.Options))) *Client_DescribeTable_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.DescribeTableInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeTable_Call) Return(_a0 *dynamodb.DescribeTableOutput, _a1 error) *Client_DescribeTable_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeTable_Call) RunAndReturn(run func(context.Context, *dynamodb.DescribeTableInput, ...func(*dynamodb.Options)) (*dynamodb.DescribeTableOutput, error)) *Client_DescribeTable_Call { + _c.Call.Return(run) + return _c +} + // GetItem provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetItem(ctx context.Context, params *dynamodb.GetItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.GetItemOutput, error) { _va := make([]interface{}, len(optFns)) @@ -245,6 +475,43 @@ func (_m *Client) GetItem(ctx context.Context, params *dynamodb.GetItemInput, op return r0, r1 } +// Client_GetItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItem' +type Client_GetItem_Call struct { + *mock.Call +} + +// GetItem is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.GetItemInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) GetItem(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetItem_Call { + return &Client_GetItem_Call{Call: _e.mock.On("GetItem", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetItem_Call) Run(run func(ctx context.Context, params *dynamodb.GetItemInput, optFns ...func(*dynamodb.Options))) *Client_GetItem_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.GetItemInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetItem_Call) Return(_a0 *dynamodb.GetItemOutput, _a1 error) *Client_GetItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetItem_Call) RunAndReturn(run func(context.Context, *dynamodb.GetItemInput, ...func(*dynamodb.Options)) (*dynamodb.GetItemOutput, error)) *Client_GetItem_Call { + _c.Call.Return(run) + return _c +} + // ListTagsOfResource provides a mock function with given fields: ctx, params, optFns func (_m *Client) ListTagsOfResource(ctx context.Context, params *dynamodb.ListTagsOfResourceInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ListTagsOfResourceOutput, error) { _va := make([]interface{}, len(optFns)) @@ -278,6 +545,43 @@ func (_m *Client) ListTagsOfResource(ctx context.Context, params *dynamodb.ListT return r0, r1 } +// Client_ListTagsOfResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTagsOfResource' +type Client_ListTagsOfResource_Call struct { + *mock.Call +} + +// ListTagsOfResource is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.ListTagsOfResourceInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) ListTagsOfResource(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListTagsOfResource_Call { + return &Client_ListTagsOfResource_Call{Call: _e.mock.On("ListTagsOfResource", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ListTagsOfResource_Call) Run(run func(ctx context.Context, params *dynamodb.ListTagsOfResourceInput, optFns ...func(*dynamodb.Options))) *Client_ListTagsOfResource_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.ListTagsOfResourceInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_ListTagsOfResource_Call) Return(_a0 *dynamodb.ListTagsOfResourceOutput, _a1 error) *Client_ListTagsOfResource_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ListTagsOfResource_Call) RunAndReturn(run func(context.Context, *dynamodb.ListTagsOfResourceInput, ...func(*dynamodb.Options)) (*dynamodb.ListTagsOfResourceOutput, error)) *Client_ListTagsOfResource_Call { + _c.Call.Return(run) + return _c +} + // PutItem provides a mock function with given fields: ctx, params, optFns func (_m *Client) PutItem(ctx context.Context, params *dynamodb.PutItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.PutItemOutput, error) { _va := make([]interface{}, len(optFns)) @@ -311,6 +615,43 @@ func (_m *Client) PutItem(ctx context.Context, params *dynamodb.PutItemInput, op return r0, r1 } +// Client_PutItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutItem' +type Client_PutItem_Call struct { + *mock.Call +} + +// PutItem is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.PutItemInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) PutItem(ctx interface{}, params interface{}, optFns ...interface{}) *Client_PutItem_Call { + return &Client_PutItem_Call{Call: _e.mock.On("PutItem", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_PutItem_Call) Run(run func(ctx context.Context, params *dynamodb.PutItemInput, optFns ...func(*dynamodb.Options))) *Client_PutItem_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.PutItemInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_PutItem_Call) Return(_a0 *dynamodb.PutItemOutput, _a1 error) *Client_PutItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PutItem_Call) RunAndReturn(run func(context.Context, *dynamodb.PutItemInput, ...func(*dynamodb.Options)) (*dynamodb.PutItemOutput, error)) *Client_PutItem_Call { + _c.Call.Return(run) + return _c +} + // Query provides a mock function with given fields: ctx, params, optFns func (_m *Client) Query(ctx context.Context, params *dynamodb.QueryInput, optFns ...func(*dynamodb.Options)) (*dynamodb.QueryOutput, error) { _va := make([]interface{}, len(optFns)) @@ -344,6 +685,43 @@ func (_m *Client) Query(ctx context.Context, params *dynamodb.QueryInput, optFns return r0, r1 } +// Client_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' +type Client_Query_Call struct { + *mock.Call +} + +// Query is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.QueryInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) Query(ctx interface{}, params interface{}, optFns ...interface{}) *Client_Query_Call { + return &Client_Query_Call{Call: _e.mock.On("Query", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_Query_Call) Run(run func(ctx context.Context, params *dynamodb.QueryInput, optFns ...func(*dynamodb.Options))) *Client_Query_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.QueryInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_Query_Call) Return(_a0 *dynamodb.QueryOutput, _a1 error) *Client_Query_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Query_Call) RunAndReturn(run func(context.Context, *dynamodb.QueryInput, ...func(*dynamodb.Options)) (*dynamodb.QueryOutput, error)) *Client_Query_Call { + _c.Call.Return(run) + return _c +} + // Scan provides a mock function with given fields: ctx, params, optFns func (_m *Client) Scan(ctx context.Context, params *dynamodb.ScanInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error) { _va := make([]interface{}, len(optFns)) @@ -377,6 +755,43 @@ func (_m *Client) Scan(ctx context.Context, params *dynamodb.ScanInput, optFns . return r0, r1 } +// Client_Scan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Scan' +type Client_Scan_Call struct { + *mock.Call +} + +// Scan is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.ScanInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) Scan(ctx interface{}, params interface{}, optFns ...interface{}) *Client_Scan_Call { + return &Client_Scan_Call{Call: _e.mock.On("Scan", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_Scan_Call) Run(run func(ctx context.Context, params *dynamodb.ScanInput, optFns ...func(*dynamodb.Options))) *Client_Scan_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.ScanInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_Scan_Call) Return(_a0 *dynamodb.ScanOutput, _a1 error) *Client_Scan_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Scan_Call) RunAndReturn(run func(context.Context, *dynamodb.ScanInput, ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error)) *Client_Scan_Call { + _c.Call.Return(run) + return _c +} + // TransactGetItems provides a mock function with given fields: ctx, params, optFns func (_m *Client) TransactGetItems(ctx context.Context, params *dynamodb.TransactGetItemsInput, optFns ...func(*dynamodb.Options)) (*dynamodb.TransactGetItemsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -410,6 +825,43 @@ func (_m *Client) TransactGetItems(ctx context.Context, params *dynamodb.Transac return r0, r1 } +// Client_TransactGetItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactGetItems' +type Client_TransactGetItems_Call struct { + *mock.Call +} + +// TransactGetItems is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.TransactGetItemsInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) TransactGetItems(ctx interface{}, params interface{}, optFns ...interface{}) *Client_TransactGetItems_Call { + return &Client_TransactGetItems_Call{Call: _e.mock.On("TransactGetItems", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_TransactGetItems_Call) Run(run func(ctx context.Context, params *dynamodb.TransactGetItemsInput, optFns ...func(*dynamodb.Options))) *Client_TransactGetItems_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.TransactGetItemsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_TransactGetItems_Call) Return(_a0 *dynamodb.TransactGetItemsOutput, _a1 error) *Client_TransactGetItems_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_TransactGetItems_Call) RunAndReturn(run func(context.Context, *dynamodb.TransactGetItemsInput, ...func(*dynamodb.Options)) (*dynamodb.TransactGetItemsOutput, error)) *Client_TransactGetItems_Call { + _c.Call.Return(run) + return _c +} + // TransactWriteItems provides a mock function with given fields: ctx, params, optFns func (_m *Client) TransactWriteItems(ctx context.Context, params *dynamodb.TransactWriteItemsInput, optFns ...func(*dynamodb.Options)) (*dynamodb.TransactWriteItemsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -443,6 +895,43 @@ func (_m *Client) TransactWriteItems(ctx context.Context, params *dynamodb.Trans return r0, r1 } +// Client_TransactWriteItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactWriteItems' +type Client_TransactWriteItems_Call struct { + *mock.Call +} + +// TransactWriteItems is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.TransactWriteItemsInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) TransactWriteItems(ctx interface{}, params interface{}, optFns ...interface{}) *Client_TransactWriteItems_Call { + return &Client_TransactWriteItems_Call{Call: _e.mock.On("TransactWriteItems", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_TransactWriteItems_Call) Run(run func(ctx context.Context, params *dynamodb.TransactWriteItemsInput, optFns ...func(*dynamodb.Options))) *Client_TransactWriteItems_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.TransactWriteItemsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_TransactWriteItems_Call) Return(_a0 *dynamodb.TransactWriteItemsOutput, _a1 error) *Client_TransactWriteItems_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_TransactWriteItems_Call) RunAndReturn(run func(context.Context, *dynamodb.TransactWriteItemsInput, ...func(*dynamodb.Options)) (*dynamodb.TransactWriteItemsOutput, error)) *Client_TransactWriteItems_Call { + _c.Call.Return(run) + return _c +} + // UpdateItem provides a mock function with given fields: ctx, params, optFns func (_m *Client) UpdateItem(ctx context.Context, params *dynamodb.UpdateItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.UpdateItemOutput, error) { _va := make([]interface{}, len(optFns)) @@ -476,6 +965,43 @@ func (_m *Client) UpdateItem(ctx context.Context, params *dynamodb.UpdateItemInp return r0, r1 } +// Client_UpdateItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateItem' +type Client_UpdateItem_Call struct { + *mock.Call +} + +// UpdateItem is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.UpdateItemInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) UpdateItem(ctx interface{}, params interface{}, optFns ...interface{}) *Client_UpdateItem_Call { + return &Client_UpdateItem_Call{Call: _e.mock.On("UpdateItem", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_UpdateItem_Call) Run(run func(ctx context.Context, params *dynamodb.UpdateItemInput, optFns ...func(*dynamodb.Options))) *Client_UpdateItem_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.UpdateItemInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_UpdateItem_Call) Return(_a0 *dynamodb.UpdateItemOutput, _a1 error) *Client_UpdateItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_UpdateItem_Call) RunAndReturn(run func(context.Context, *dynamodb.UpdateItemInput, ...func(*dynamodb.Options)) (*dynamodb.UpdateItemOutput, error)) *Client_UpdateItem_Call { + _c.Call.Return(run) + return _c +} + // UpdateTimeToLive provides a mock function with given fields: ctx, params, optFns func (_m *Client) UpdateTimeToLive(ctx context.Context, params *dynamodb.UpdateTimeToLiveInput, optFns ...func(*dynamodb.Options)) (*dynamodb.UpdateTimeToLiveOutput, error) { _va := make([]interface{}, len(optFns)) @@ -509,6 +1035,43 @@ func (_m *Client) UpdateTimeToLive(ctx context.Context, params *dynamodb.UpdateT return r0, r1 } +// Client_UpdateTimeToLive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTimeToLive' +type Client_UpdateTimeToLive_Call struct { + *mock.Call +} + +// UpdateTimeToLive is a helper method to define mock.On call +// - ctx context.Context +// - params *dynamodb.UpdateTimeToLiveInput +// - optFns ...func(*dynamodb.Options) +func (_e *Client_Expecter) UpdateTimeToLive(ctx interface{}, params interface{}, optFns ...interface{}) *Client_UpdateTimeToLive_Call { + return &Client_UpdateTimeToLive_Call{Call: _e.mock.On("UpdateTimeToLive", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_UpdateTimeToLive_Call) Run(run func(ctx context.Context, params *dynamodb.UpdateTimeToLiveInput, optFns ...func(*dynamodb.Options))) *Client_UpdateTimeToLive_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*dynamodb.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*dynamodb.Options)) + } + } + run(args[0].(context.Context), args[1].(*dynamodb.UpdateTimeToLiveInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_UpdateTimeToLive_Call) Return(_a0 *dynamodb.UpdateTimeToLiveOutput, _a1 error) *Client_UpdateTimeToLive_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_UpdateTimeToLive_Call) RunAndReturn(run func(context.Context, *dynamodb.UpdateTimeToLiveInput, ...func(*dynamodb.Options)) (*dynamodb.UpdateTimeToLiveOutput, error)) *Client_UpdateTimeToLive_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/ec2/mocks/Client.go b/pkg/cloud/aws/ec2/mocks/Client.go index 039920723..1c959e50a 100644 --- a/pkg/cloud/aws/ec2/mocks/Client.go +++ b/pkg/cloud/aws/ec2/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // DescribeInstances provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeInstances(ctx context.Context, params *ec2.DescribeInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstancesOutput, error) { _va := make([]interface{}, len(optFns)) @@ -47,6 +55,43 @@ func (_m *Client) DescribeInstances(ctx context.Context, params *ec2.DescribeIns return r0, r1 } +// Client_DescribeInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstances' +type Client_DescribeInstances_Call struct { + *mock.Call +} + +// DescribeInstances is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DescribeInstancesInput +// - optFns ...func(*ec2.Options) +func (_e *Client_Expecter) DescribeInstances(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeInstances_Call { + return &Client_DescribeInstances_Call{Call: _e.mock.On("DescribeInstances", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeInstances_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstancesInput, optFns ...func(*ec2.Options))) *Client_DescribeInstances_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DescribeInstancesInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeInstances_Call) Return(_a0 *ec2.DescribeInstancesOutput, _a1 error) *Client_DescribeInstances_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeInstances_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeInstancesOutput, error)) *Client_DescribeInstances_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/ecs/mocks/Client.go b/pkg/cloud/aws/ecs/mocks/Client.go index beca60123..640bd01dd 100644 --- a/pkg/cloud/aws/ecs/mocks/Client.go +++ b/pkg/cloud/aws/ecs/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // DescribeContainerInstances provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeContainerInstances(ctx context.Context, params *ecs.DescribeContainerInstancesInput, optFns ...func(*ecs.Options)) (*ecs.DescribeContainerInstancesOutput, error) { _va := make([]interface{}, len(optFns)) @@ -47,6 +55,43 @@ func (_m *Client) DescribeContainerInstances(ctx context.Context, params *ecs.De return r0, r1 } +// Client_DescribeContainerInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeContainerInstances' +type Client_DescribeContainerInstances_Call struct { + *mock.Call +} + +// DescribeContainerInstances is a helper method to define mock.On call +// - ctx context.Context +// - params *ecs.DescribeContainerInstancesInput +// - optFns ...func(*ecs.Options) +func (_e *Client_Expecter) DescribeContainerInstances(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeContainerInstances_Call { + return &Client_DescribeContainerInstances_Call{Call: _e.mock.On("DescribeContainerInstances", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeContainerInstances_Call) Run(run func(ctx context.Context, params *ecs.DescribeContainerInstancesInput, optFns ...func(*ecs.Options))) *Client_DescribeContainerInstances_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ecs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ecs.Options)) + } + } + run(args[0].(context.Context), args[1].(*ecs.DescribeContainerInstancesInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeContainerInstances_Call) Return(_a0 *ecs.DescribeContainerInstancesOutput, _a1 error) *Client_DescribeContainerInstances_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeContainerInstances_Call) RunAndReturn(run func(context.Context, *ecs.DescribeContainerInstancesInput, ...func(*ecs.Options)) (*ecs.DescribeContainerInstancesOutput, error)) *Client_DescribeContainerInstances_Call { + _c.Call.Return(run) + return _c +} + // DescribeTasks provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeTasks(ctx context.Context, params *ecs.DescribeTasksInput, optFns ...func(*ecs.Options)) (*ecs.DescribeTasksOutput, error) { _va := make([]interface{}, len(optFns)) @@ -80,6 +125,43 @@ func (_m *Client) DescribeTasks(ctx context.Context, params *ecs.DescribeTasksIn return r0, r1 } +// Client_DescribeTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTasks' +type Client_DescribeTasks_Call struct { + *mock.Call +} + +// DescribeTasks is a helper method to define mock.On call +// - ctx context.Context +// - params *ecs.DescribeTasksInput +// - optFns ...func(*ecs.Options) +func (_e *Client_Expecter) DescribeTasks(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeTasks_Call { + return &Client_DescribeTasks_Call{Call: _e.mock.On("DescribeTasks", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeTasks_Call) Run(run func(ctx context.Context, params *ecs.DescribeTasksInput, optFns ...func(*ecs.Options))) *Client_DescribeTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ecs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ecs.Options)) + } + } + run(args[0].(context.Context), args[1].(*ecs.DescribeTasksInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeTasks_Call) Return(_a0 *ecs.DescribeTasksOutput, _a1 error) *Client_DescribeTasks_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeTasks_Call) RunAndReturn(run func(context.Context, *ecs.DescribeTasksInput, ...func(*ecs.Options)) (*ecs.DescribeTasksOutput, error)) *Client_DescribeTasks_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/kinesis/mocks/Checkpoint.go b/pkg/cloud/aws/kinesis/mocks/Checkpoint.go index 760ab7f7b..d95b7ed14 100644 --- a/pkg/cloud/aws/kinesis/mocks/Checkpoint.go +++ b/pkg/cloud/aws/kinesis/mocks/Checkpoint.go @@ -14,6 +14,14 @@ type Checkpoint struct { mock.Mock } +type Checkpoint_Expecter struct { + mock *mock.Mock +} + +func (_m *Checkpoint) EXPECT() *Checkpoint_Expecter { + return &Checkpoint_Expecter{mock: &_m.Mock} +} + // Advance provides a mock function with given fields: sequenceNumber func (_m *Checkpoint) Advance(sequenceNumber kinesis.SequenceNumber) error { ret := _m.Called(sequenceNumber) @@ -28,6 +36,34 @@ func (_m *Checkpoint) Advance(sequenceNumber kinesis.SequenceNumber) error { return r0 } +// Checkpoint_Advance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Advance' +type Checkpoint_Advance_Call struct { + *mock.Call +} + +// Advance is a helper method to define mock.On call +// - sequenceNumber kinesis.SequenceNumber +func (_e *Checkpoint_Expecter) Advance(sequenceNumber interface{}) *Checkpoint_Advance_Call { + return &Checkpoint_Advance_Call{Call: _e.mock.On("Advance", sequenceNumber)} +} + +func (_c *Checkpoint_Advance_Call) Run(run func(sequenceNumber kinesis.SequenceNumber)) *Checkpoint_Advance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(kinesis.SequenceNumber)) + }) + return _c +} + +func (_c *Checkpoint_Advance_Call) Return(_a0 error) *Checkpoint_Advance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Checkpoint_Advance_Call) RunAndReturn(run func(kinesis.SequenceNumber) error) *Checkpoint_Advance_Call { + _c.Call.Return(run) + return _c +} + // Done provides a mock function with given fields: sequenceNumber func (_m *Checkpoint) Done(sequenceNumber kinesis.SequenceNumber) error { ret := _m.Called(sequenceNumber) @@ -42,6 +78,34 @@ func (_m *Checkpoint) Done(sequenceNumber kinesis.SequenceNumber) error { return r0 } +// Checkpoint_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done' +type Checkpoint_Done_Call struct { + *mock.Call +} + +// Done is a helper method to define mock.On call +// - sequenceNumber kinesis.SequenceNumber +func (_e *Checkpoint_Expecter) Done(sequenceNumber interface{}) *Checkpoint_Done_Call { + return &Checkpoint_Done_Call{Call: _e.mock.On("Done", sequenceNumber)} +} + +func (_c *Checkpoint_Done_Call) Run(run func(sequenceNumber kinesis.SequenceNumber)) *Checkpoint_Done_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(kinesis.SequenceNumber)) + }) + return _c +} + +func (_c *Checkpoint_Done_Call) Return(_a0 error) *Checkpoint_Done_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Checkpoint_Done_Call) RunAndReturn(run func(kinesis.SequenceNumber) error) *Checkpoint_Done_Call { + _c.Call.Return(run) + return _c +} + // GetSequenceNumber provides a mock function with given fields: func (_m *Checkpoint) GetSequenceNumber() kinesis.SequenceNumber { ret := _m.Called() @@ -56,6 +120,33 @@ func (_m *Checkpoint) GetSequenceNumber() kinesis.SequenceNumber { return r0 } +// Checkpoint_GetSequenceNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSequenceNumber' +type Checkpoint_GetSequenceNumber_Call struct { + *mock.Call +} + +// GetSequenceNumber is a helper method to define mock.On call +func (_e *Checkpoint_Expecter) GetSequenceNumber() *Checkpoint_GetSequenceNumber_Call { + return &Checkpoint_GetSequenceNumber_Call{Call: _e.mock.On("GetSequenceNumber")} +} + +func (_c *Checkpoint_GetSequenceNumber_Call) Run(run func()) *Checkpoint_GetSequenceNumber_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Checkpoint_GetSequenceNumber_Call) Return(_a0 kinesis.SequenceNumber) *Checkpoint_GetSequenceNumber_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Checkpoint_GetSequenceNumber_Call) RunAndReturn(run func() kinesis.SequenceNumber) *Checkpoint_GetSequenceNumber_Call { + _c.Call.Return(run) + return _c +} + // Persist provides a mock function with given fields: ctx func (_m *Checkpoint) Persist(ctx context.Context) (bool, error) { ret := _m.Called(ctx) @@ -80,6 +171,34 @@ func (_m *Checkpoint) Persist(ctx context.Context) (bool, error) { return r0, r1 } +// Checkpoint_Persist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Persist' +type Checkpoint_Persist_Call struct { + *mock.Call +} + +// Persist is a helper method to define mock.On call +// - ctx context.Context +func (_e *Checkpoint_Expecter) Persist(ctx interface{}) *Checkpoint_Persist_Call { + return &Checkpoint_Persist_Call{Call: _e.mock.On("Persist", ctx)} +} + +func (_c *Checkpoint_Persist_Call) Run(run func(ctx context.Context)) *Checkpoint_Persist_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Checkpoint_Persist_Call) Return(shouldRelease bool, err error) *Checkpoint_Persist_Call { + _c.Call.Return(shouldRelease, err) + return _c +} + +func (_c *Checkpoint_Persist_Call) RunAndReturn(run func(context.Context) (bool, error)) *Checkpoint_Persist_Call { + _c.Call.Return(run) + return _c +} + // Release provides a mock function with given fields: ctx func (_m *Checkpoint) Release(ctx context.Context) error { ret := _m.Called(ctx) @@ -94,6 +213,34 @@ func (_m *Checkpoint) Release(ctx context.Context) error { return r0 } +// Checkpoint_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release' +type Checkpoint_Release_Call struct { + *mock.Call +} + +// Release is a helper method to define mock.On call +// - ctx context.Context +func (_e *Checkpoint_Expecter) Release(ctx interface{}) *Checkpoint_Release_Call { + return &Checkpoint_Release_Call{Call: _e.mock.On("Release", ctx)} +} + +func (_c *Checkpoint_Release_Call) Run(run func(ctx context.Context)) *Checkpoint_Release_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Checkpoint_Release_Call) Return(_a0 error) *Checkpoint_Release_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Checkpoint_Release_Call) RunAndReturn(run func(context.Context) error) *Checkpoint_Release_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewCheckpoint interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/kinesis/mocks/CheckpointWithoutRelease.go b/pkg/cloud/aws/kinesis/mocks/CheckpointWithoutRelease.go index 0ede41f67..889fd8e65 100644 --- a/pkg/cloud/aws/kinesis/mocks/CheckpointWithoutRelease.go +++ b/pkg/cloud/aws/kinesis/mocks/CheckpointWithoutRelease.go @@ -14,6 +14,14 @@ type CheckpointWithoutRelease struct { mock.Mock } +type CheckpointWithoutRelease_Expecter struct { + mock *mock.Mock +} + +func (_m *CheckpointWithoutRelease) EXPECT() *CheckpointWithoutRelease_Expecter { + return &CheckpointWithoutRelease_Expecter{mock: &_m.Mock} +} + // Advance provides a mock function with given fields: sequenceNumber func (_m *CheckpointWithoutRelease) Advance(sequenceNumber kinesis.SequenceNumber) error { ret := _m.Called(sequenceNumber) @@ -28,6 +36,34 @@ func (_m *CheckpointWithoutRelease) Advance(sequenceNumber kinesis.SequenceNumbe return r0 } +// CheckpointWithoutRelease_Advance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Advance' +type CheckpointWithoutRelease_Advance_Call struct { + *mock.Call +} + +// Advance is a helper method to define mock.On call +// - sequenceNumber kinesis.SequenceNumber +func (_e *CheckpointWithoutRelease_Expecter) Advance(sequenceNumber interface{}) *CheckpointWithoutRelease_Advance_Call { + return &CheckpointWithoutRelease_Advance_Call{Call: _e.mock.On("Advance", sequenceNumber)} +} + +func (_c *CheckpointWithoutRelease_Advance_Call) Run(run func(sequenceNumber kinesis.SequenceNumber)) *CheckpointWithoutRelease_Advance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(kinesis.SequenceNumber)) + }) + return _c +} + +func (_c *CheckpointWithoutRelease_Advance_Call) Return(_a0 error) *CheckpointWithoutRelease_Advance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CheckpointWithoutRelease_Advance_Call) RunAndReturn(run func(kinesis.SequenceNumber) error) *CheckpointWithoutRelease_Advance_Call { + _c.Call.Return(run) + return _c +} + // Done provides a mock function with given fields: sequenceNumber func (_m *CheckpointWithoutRelease) Done(sequenceNumber kinesis.SequenceNumber) error { ret := _m.Called(sequenceNumber) @@ -42,6 +78,34 @@ func (_m *CheckpointWithoutRelease) Done(sequenceNumber kinesis.SequenceNumber) return r0 } +// CheckpointWithoutRelease_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done' +type CheckpointWithoutRelease_Done_Call struct { + *mock.Call +} + +// Done is a helper method to define mock.On call +// - sequenceNumber kinesis.SequenceNumber +func (_e *CheckpointWithoutRelease_Expecter) Done(sequenceNumber interface{}) *CheckpointWithoutRelease_Done_Call { + return &CheckpointWithoutRelease_Done_Call{Call: _e.mock.On("Done", sequenceNumber)} +} + +func (_c *CheckpointWithoutRelease_Done_Call) Run(run func(sequenceNumber kinesis.SequenceNumber)) *CheckpointWithoutRelease_Done_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(kinesis.SequenceNumber)) + }) + return _c +} + +func (_c *CheckpointWithoutRelease_Done_Call) Return(_a0 error) *CheckpointWithoutRelease_Done_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CheckpointWithoutRelease_Done_Call) RunAndReturn(run func(kinesis.SequenceNumber) error) *CheckpointWithoutRelease_Done_Call { + _c.Call.Return(run) + return _c +} + // GetSequenceNumber provides a mock function with given fields: func (_m *CheckpointWithoutRelease) GetSequenceNumber() kinesis.SequenceNumber { ret := _m.Called() @@ -56,6 +120,33 @@ func (_m *CheckpointWithoutRelease) GetSequenceNumber() kinesis.SequenceNumber { return r0 } +// CheckpointWithoutRelease_GetSequenceNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSequenceNumber' +type CheckpointWithoutRelease_GetSequenceNumber_Call struct { + *mock.Call +} + +// GetSequenceNumber is a helper method to define mock.On call +func (_e *CheckpointWithoutRelease_Expecter) GetSequenceNumber() *CheckpointWithoutRelease_GetSequenceNumber_Call { + return &CheckpointWithoutRelease_GetSequenceNumber_Call{Call: _e.mock.On("GetSequenceNumber")} +} + +func (_c *CheckpointWithoutRelease_GetSequenceNumber_Call) Run(run func()) *CheckpointWithoutRelease_GetSequenceNumber_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *CheckpointWithoutRelease_GetSequenceNumber_Call) Return(_a0 kinesis.SequenceNumber) *CheckpointWithoutRelease_GetSequenceNumber_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CheckpointWithoutRelease_GetSequenceNumber_Call) RunAndReturn(run func() kinesis.SequenceNumber) *CheckpointWithoutRelease_GetSequenceNumber_Call { + _c.Call.Return(run) + return _c +} + // Persist provides a mock function with given fields: ctx func (_m *CheckpointWithoutRelease) Persist(ctx context.Context) (bool, error) { ret := _m.Called(ctx) @@ -80,6 +171,34 @@ func (_m *CheckpointWithoutRelease) Persist(ctx context.Context) (bool, error) { return r0, r1 } +// CheckpointWithoutRelease_Persist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Persist' +type CheckpointWithoutRelease_Persist_Call struct { + *mock.Call +} + +// Persist is a helper method to define mock.On call +// - ctx context.Context +func (_e *CheckpointWithoutRelease_Expecter) Persist(ctx interface{}) *CheckpointWithoutRelease_Persist_Call { + return &CheckpointWithoutRelease_Persist_Call{Call: _e.mock.On("Persist", ctx)} +} + +func (_c *CheckpointWithoutRelease_Persist_Call) Run(run func(ctx context.Context)) *CheckpointWithoutRelease_Persist_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *CheckpointWithoutRelease_Persist_Call) Return(shouldRelease bool, err error) *CheckpointWithoutRelease_Persist_Call { + _c.Call.Return(shouldRelease, err) + return _c +} + +func (_c *CheckpointWithoutRelease_Persist_Call) RunAndReturn(run func(context.Context) (bool, error)) *CheckpointWithoutRelease_Persist_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewCheckpointWithoutRelease interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/kinesis/mocks/Client.go b/pkg/cloud/aws/kinesis/mocks/Client.go index 62aa9c7cf..4a6ed4912 100644 --- a/pkg/cloud/aws/kinesis/mocks/Client.go +++ b/pkg/cloud/aws/kinesis/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // AddTagsToStream provides a mock function with given fields: ctx, params, optFns func (_m *Client) AddTagsToStream(ctx context.Context, params *kinesis.AddTagsToStreamInput, optFns ...func(*kinesis.Options)) (*kinesis.AddTagsToStreamOutput, error) { _va := make([]interface{}, len(optFns)) @@ -47,6 +55,43 @@ func (_m *Client) AddTagsToStream(ctx context.Context, params *kinesis.AddTagsTo return r0, r1 } +// Client_AddTagsToStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTagsToStream' +type Client_AddTagsToStream_Call struct { + *mock.Call +} + +// AddTagsToStream is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.AddTagsToStreamInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) AddTagsToStream(ctx interface{}, params interface{}, optFns ...interface{}) *Client_AddTagsToStream_Call { + return &Client_AddTagsToStream_Call{Call: _e.mock.On("AddTagsToStream", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_AddTagsToStream_Call) Run(run func(ctx context.Context, params *kinesis.AddTagsToStreamInput, optFns ...func(*kinesis.Options))) *Client_AddTagsToStream_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.AddTagsToStreamInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_AddTagsToStream_Call) Return(_a0 *kinesis.AddTagsToStreamOutput, _a1 error) *Client_AddTagsToStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_AddTagsToStream_Call) RunAndReturn(run func(context.Context, *kinesis.AddTagsToStreamInput, ...func(*kinesis.Options)) (*kinesis.AddTagsToStreamOutput, error)) *Client_AddTagsToStream_Call { + _c.Call.Return(run) + return _c +} + // CreateStream provides a mock function with given fields: ctx, params, optFns func (_m *Client) CreateStream(ctx context.Context, params *kinesis.CreateStreamInput, optFns ...func(*kinesis.Options)) (*kinesis.CreateStreamOutput, error) { _va := make([]interface{}, len(optFns)) @@ -80,6 +125,43 @@ func (_m *Client) CreateStream(ctx context.Context, params *kinesis.CreateStream return r0, r1 } +// Client_CreateStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStream' +type Client_CreateStream_Call struct { + *mock.Call +} + +// CreateStream is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.CreateStreamInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) CreateStream(ctx interface{}, params interface{}, optFns ...interface{}) *Client_CreateStream_Call { + return &Client_CreateStream_Call{Call: _e.mock.On("CreateStream", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_CreateStream_Call) Run(run func(ctx context.Context, params *kinesis.CreateStreamInput, optFns ...func(*kinesis.Options))) *Client_CreateStream_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.CreateStreamInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_CreateStream_Call) Return(_a0 *kinesis.CreateStreamOutput, _a1 error) *Client_CreateStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_CreateStream_Call) RunAndReturn(run func(context.Context, *kinesis.CreateStreamInput, ...func(*kinesis.Options)) (*kinesis.CreateStreamOutput, error)) *Client_CreateStream_Call { + _c.Call.Return(run) + return _c +} + // DecreaseStreamRetentionPeriod provides a mock function with given fields: ctx, params, optFns func (_m *Client) DecreaseStreamRetentionPeriod(ctx context.Context, params *kinesis.DecreaseStreamRetentionPeriodInput, optFns ...func(*kinesis.Options)) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) { _va := make([]interface{}, len(optFns)) @@ -113,6 +195,43 @@ func (_m *Client) DecreaseStreamRetentionPeriod(ctx context.Context, params *kin return r0, r1 } +// Client_DecreaseStreamRetentionPeriod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DecreaseStreamRetentionPeriod' +type Client_DecreaseStreamRetentionPeriod_Call struct { + *mock.Call +} + +// DecreaseStreamRetentionPeriod is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.DecreaseStreamRetentionPeriodInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) DecreaseStreamRetentionPeriod(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DecreaseStreamRetentionPeriod_Call { + return &Client_DecreaseStreamRetentionPeriod_Call{Call: _e.mock.On("DecreaseStreamRetentionPeriod", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DecreaseStreamRetentionPeriod_Call) Run(run func(ctx context.Context, params *kinesis.DecreaseStreamRetentionPeriodInput, optFns ...func(*kinesis.Options))) *Client_DecreaseStreamRetentionPeriod_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.DecreaseStreamRetentionPeriodInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DecreaseStreamRetentionPeriod_Call) Return(_a0 *kinesis.DecreaseStreamRetentionPeriodOutput, _a1 error) *Client_DecreaseStreamRetentionPeriod_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DecreaseStreamRetentionPeriod_Call) RunAndReturn(run func(context.Context, *kinesis.DecreaseStreamRetentionPeriodInput, ...func(*kinesis.Options)) (*kinesis.DecreaseStreamRetentionPeriodOutput, error)) *Client_DecreaseStreamRetentionPeriod_Call { + _c.Call.Return(run) + return _c +} + // DeleteStream provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeleteStream(ctx context.Context, params *kinesis.DeleteStreamInput, optFns ...func(*kinesis.Options)) (*kinesis.DeleteStreamOutput, error) { _va := make([]interface{}, len(optFns)) @@ -146,6 +265,43 @@ func (_m *Client) DeleteStream(ctx context.Context, params *kinesis.DeleteStream return r0, r1 } +// Client_DeleteStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStream' +type Client_DeleteStream_Call struct { + *mock.Call +} + +// DeleteStream is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.DeleteStreamInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) DeleteStream(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteStream_Call { + return &Client_DeleteStream_Call{Call: _e.mock.On("DeleteStream", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeleteStream_Call) Run(run func(ctx context.Context, params *kinesis.DeleteStreamInput, optFns ...func(*kinesis.Options))) *Client_DeleteStream_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.DeleteStreamInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeleteStream_Call) Return(_a0 *kinesis.DeleteStreamOutput, _a1 error) *Client_DeleteStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeleteStream_Call) RunAndReturn(run func(context.Context, *kinesis.DeleteStreamInput, ...func(*kinesis.Options)) (*kinesis.DeleteStreamOutput, error)) *Client_DeleteStream_Call { + _c.Call.Return(run) + return _c +} + // DeregisterStreamConsumer provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeregisterStreamConsumer(ctx context.Context, params *kinesis.DeregisterStreamConsumerInput, optFns ...func(*kinesis.Options)) (*kinesis.DeregisterStreamConsumerOutput, error) { _va := make([]interface{}, len(optFns)) @@ -179,6 +335,43 @@ func (_m *Client) DeregisterStreamConsumer(ctx context.Context, params *kinesis. return r0, r1 } +// Client_DeregisterStreamConsumer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeregisterStreamConsumer' +type Client_DeregisterStreamConsumer_Call struct { + *mock.Call +} + +// DeregisterStreamConsumer is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.DeregisterStreamConsumerInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) DeregisterStreamConsumer(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeregisterStreamConsumer_Call { + return &Client_DeregisterStreamConsumer_Call{Call: _e.mock.On("DeregisterStreamConsumer", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeregisterStreamConsumer_Call) Run(run func(ctx context.Context, params *kinesis.DeregisterStreamConsumerInput, optFns ...func(*kinesis.Options))) *Client_DeregisterStreamConsumer_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.DeregisterStreamConsumerInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeregisterStreamConsumer_Call) Return(_a0 *kinesis.DeregisterStreamConsumerOutput, _a1 error) *Client_DeregisterStreamConsumer_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeregisterStreamConsumer_Call) RunAndReturn(run func(context.Context, *kinesis.DeregisterStreamConsumerInput, ...func(*kinesis.Options)) (*kinesis.DeregisterStreamConsumerOutput, error)) *Client_DeregisterStreamConsumer_Call { + _c.Call.Return(run) + return _c +} + // DescribeLimits provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeLimits(ctx context.Context, params *kinesis.DescribeLimitsInput, optFns ...func(*kinesis.Options)) (*kinesis.DescribeLimitsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -212,6 +405,43 @@ func (_m *Client) DescribeLimits(ctx context.Context, params *kinesis.DescribeLi return r0, r1 } +// Client_DescribeLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLimits' +type Client_DescribeLimits_Call struct { + *mock.Call +} + +// DescribeLimits is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.DescribeLimitsInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) DescribeLimits(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeLimits_Call { + return &Client_DescribeLimits_Call{Call: _e.mock.On("DescribeLimits", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeLimits_Call) Run(run func(ctx context.Context, params *kinesis.DescribeLimitsInput, optFns ...func(*kinesis.Options))) *Client_DescribeLimits_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.DescribeLimitsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeLimits_Call) Return(_a0 *kinesis.DescribeLimitsOutput, _a1 error) *Client_DescribeLimits_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeLimits_Call) RunAndReturn(run func(context.Context, *kinesis.DescribeLimitsInput, ...func(*kinesis.Options)) (*kinesis.DescribeLimitsOutput, error)) *Client_DescribeLimits_Call { + _c.Call.Return(run) + return _c +} + // DescribeStream provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeStream(ctx context.Context, params *kinesis.DescribeStreamInput, optFns ...func(*kinesis.Options)) (*kinesis.DescribeStreamOutput, error) { _va := make([]interface{}, len(optFns)) @@ -245,6 +475,43 @@ func (_m *Client) DescribeStream(ctx context.Context, params *kinesis.DescribeSt return r0, r1 } +// Client_DescribeStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStream' +type Client_DescribeStream_Call struct { + *mock.Call +} + +// DescribeStream is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.DescribeStreamInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) DescribeStream(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeStream_Call { + return &Client_DescribeStream_Call{Call: _e.mock.On("DescribeStream", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeStream_Call) Run(run func(ctx context.Context, params *kinesis.DescribeStreamInput, optFns ...func(*kinesis.Options))) *Client_DescribeStream_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.DescribeStreamInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeStream_Call) Return(_a0 *kinesis.DescribeStreamOutput, _a1 error) *Client_DescribeStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeStream_Call) RunAndReturn(run func(context.Context, *kinesis.DescribeStreamInput, ...func(*kinesis.Options)) (*kinesis.DescribeStreamOutput, error)) *Client_DescribeStream_Call { + _c.Call.Return(run) + return _c +} + // DescribeStreamConsumer provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeStreamConsumer(ctx context.Context, params *kinesis.DescribeStreamConsumerInput, optFns ...func(*kinesis.Options)) (*kinesis.DescribeStreamConsumerOutput, error) { _va := make([]interface{}, len(optFns)) @@ -278,6 +545,43 @@ func (_m *Client) DescribeStreamConsumer(ctx context.Context, params *kinesis.De return r0, r1 } +// Client_DescribeStreamConsumer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStreamConsumer' +type Client_DescribeStreamConsumer_Call struct { + *mock.Call +} + +// DescribeStreamConsumer is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.DescribeStreamConsumerInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) DescribeStreamConsumer(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeStreamConsumer_Call { + return &Client_DescribeStreamConsumer_Call{Call: _e.mock.On("DescribeStreamConsumer", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeStreamConsumer_Call) Run(run func(ctx context.Context, params *kinesis.DescribeStreamConsumerInput, optFns ...func(*kinesis.Options))) *Client_DescribeStreamConsumer_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.DescribeStreamConsumerInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeStreamConsumer_Call) Return(_a0 *kinesis.DescribeStreamConsumerOutput, _a1 error) *Client_DescribeStreamConsumer_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeStreamConsumer_Call) RunAndReturn(run func(context.Context, *kinesis.DescribeStreamConsumerInput, ...func(*kinesis.Options)) (*kinesis.DescribeStreamConsumerOutput, error)) *Client_DescribeStreamConsumer_Call { + _c.Call.Return(run) + return _c +} + // DescribeStreamSummary provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeStreamSummary(ctx context.Context, params *kinesis.DescribeStreamSummaryInput, optFns ...func(*kinesis.Options)) (*kinesis.DescribeStreamSummaryOutput, error) { _va := make([]interface{}, len(optFns)) @@ -311,6 +615,43 @@ func (_m *Client) DescribeStreamSummary(ctx context.Context, params *kinesis.Des return r0, r1 } +// Client_DescribeStreamSummary_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStreamSummary' +type Client_DescribeStreamSummary_Call struct { + *mock.Call +} + +// DescribeStreamSummary is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.DescribeStreamSummaryInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) DescribeStreamSummary(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeStreamSummary_Call { + return &Client_DescribeStreamSummary_Call{Call: _e.mock.On("DescribeStreamSummary", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeStreamSummary_Call) Run(run func(ctx context.Context, params *kinesis.DescribeStreamSummaryInput, optFns ...func(*kinesis.Options))) *Client_DescribeStreamSummary_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.DescribeStreamSummaryInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeStreamSummary_Call) Return(_a0 *kinesis.DescribeStreamSummaryOutput, _a1 error) *Client_DescribeStreamSummary_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeStreamSummary_Call) RunAndReturn(run func(context.Context, *kinesis.DescribeStreamSummaryInput, ...func(*kinesis.Options)) (*kinesis.DescribeStreamSummaryOutput, error)) *Client_DescribeStreamSummary_Call { + _c.Call.Return(run) + return _c +} + // DisableEnhancedMonitoring provides a mock function with given fields: ctx, params, optFns func (_m *Client) DisableEnhancedMonitoring(ctx context.Context, params *kinesis.DisableEnhancedMonitoringInput, optFns ...func(*kinesis.Options)) (*kinesis.DisableEnhancedMonitoringOutput, error) { _va := make([]interface{}, len(optFns)) @@ -344,6 +685,43 @@ func (_m *Client) DisableEnhancedMonitoring(ctx context.Context, params *kinesis return r0, r1 } +// Client_DisableEnhancedMonitoring_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableEnhancedMonitoring' +type Client_DisableEnhancedMonitoring_Call struct { + *mock.Call +} + +// DisableEnhancedMonitoring is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.DisableEnhancedMonitoringInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) DisableEnhancedMonitoring(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DisableEnhancedMonitoring_Call { + return &Client_DisableEnhancedMonitoring_Call{Call: _e.mock.On("DisableEnhancedMonitoring", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DisableEnhancedMonitoring_Call) Run(run func(ctx context.Context, params *kinesis.DisableEnhancedMonitoringInput, optFns ...func(*kinesis.Options))) *Client_DisableEnhancedMonitoring_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.DisableEnhancedMonitoringInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DisableEnhancedMonitoring_Call) Return(_a0 *kinesis.DisableEnhancedMonitoringOutput, _a1 error) *Client_DisableEnhancedMonitoring_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DisableEnhancedMonitoring_Call) RunAndReturn(run func(context.Context, *kinesis.DisableEnhancedMonitoringInput, ...func(*kinesis.Options)) (*kinesis.DisableEnhancedMonitoringOutput, error)) *Client_DisableEnhancedMonitoring_Call { + _c.Call.Return(run) + return _c +} + // EnableEnhancedMonitoring provides a mock function with given fields: ctx, params, optFns func (_m *Client) EnableEnhancedMonitoring(ctx context.Context, params *kinesis.EnableEnhancedMonitoringInput, optFns ...func(*kinesis.Options)) (*kinesis.EnableEnhancedMonitoringOutput, error) { _va := make([]interface{}, len(optFns)) @@ -377,6 +755,43 @@ func (_m *Client) EnableEnhancedMonitoring(ctx context.Context, params *kinesis. return r0, r1 } +// Client_EnableEnhancedMonitoring_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableEnhancedMonitoring' +type Client_EnableEnhancedMonitoring_Call struct { + *mock.Call +} + +// EnableEnhancedMonitoring is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.EnableEnhancedMonitoringInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) EnableEnhancedMonitoring(ctx interface{}, params interface{}, optFns ...interface{}) *Client_EnableEnhancedMonitoring_Call { + return &Client_EnableEnhancedMonitoring_Call{Call: _e.mock.On("EnableEnhancedMonitoring", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_EnableEnhancedMonitoring_Call) Run(run func(ctx context.Context, params *kinesis.EnableEnhancedMonitoringInput, optFns ...func(*kinesis.Options))) *Client_EnableEnhancedMonitoring_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.EnableEnhancedMonitoringInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_EnableEnhancedMonitoring_Call) Return(_a0 *kinesis.EnableEnhancedMonitoringOutput, _a1 error) *Client_EnableEnhancedMonitoring_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_EnableEnhancedMonitoring_Call) RunAndReturn(run func(context.Context, *kinesis.EnableEnhancedMonitoringInput, ...func(*kinesis.Options)) (*kinesis.EnableEnhancedMonitoringOutput, error)) *Client_EnableEnhancedMonitoring_Call { + _c.Call.Return(run) + return _c +} + // GetRecords provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetRecords(ctx context.Context, params *kinesis.GetRecordsInput, optFns ...func(*kinesis.Options)) (*kinesis.GetRecordsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -410,6 +825,43 @@ func (_m *Client) GetRecords(ctx context.Context, params *kinesis.GetRecordsInpu return r0, r1 } +// Client_GetRecords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecords' +type Client_GetRecords_Call struct { + *mock.Call +} + +// GetRecords is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.GetRecordsInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) GetRecords(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetRecords_Call { + return &Client_GetRecords_Call{Call: _e.mock.On("GetRecords", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetRecords_Call) Run(run func(ctx context.Context, params *kinesis.GetRecordsInput, optFns ...func(*kinesis.Options))) *Client_GetRecords_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.GetRecordsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetRecords_Call) Return(_a0 *kinesis.GetRecordsOutput, _a1 error) *Client_GetRecords_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetRecords_Call) RunAndReturn(run func(context.Context, *kinesis.GetRecordsInput, ...func(*kinesis.Options)) (*kinesis.GetRecordsOutput, error)) *Client_GetRecords_Call { + _c.Call.Return(run) + return _c +} + // GetShardIterator provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetShardIterator(ctx context.Context, params *kinesis.GetShardIteratorInput, optFns ...func(*kinesis.Options)) (*kinesis.GetShardIteratorOutput, error) { _va := make([]interface{}, len(optFns)) @@ -443,6 +895,43 @@ func (_m *Client) GetShardIterator(ctx context.Context, params *kinesis.GetShard return r0, r1 } +// Client_GetShardIterator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShardIterator' +type Client_GetShardIterator_Call struct { + *mock.Call +} + +// GetShardIterator is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.GetShardIteratorInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) GetShardIterator(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetShardIterator_Call { + return &Client_GetShardIterator_Call{Call: _e.mock.On("GetShardIterator", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetShardIterator_Call) Run(run func(ctx context.Context, params *kinesis.GetShardIteratorInput, optFns ...func(*kinesis.Options))) *Client_GetShardIterator_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.GetShardIteratorInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetShardIterator_Call) Return(_a0 *kinesis.GetShardIteratorOutput, _a1 error) *Client_GetShardIterator_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetShardIterator_Call) RunAndReturn(run func(context.Context, *kinesis.GetShardIteratorInput, ...func(*kinesis.Options)) (*kinesis.GetShardIteratorOutput, error)) *Client_GetShardIterator_Call { + _c.Call.Return(run) + return _c +} + // IncreaseStreamRetentionPeriod provides a mock function with given fields: ctx, params, optFns func (_m *Client) IncreaseStreamRetentionPeriod(ctx context.Context, params *kinesis.IncreaseStreamRetentionPeriodInput, optFns ...func(*kinesis.Options)) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) { _va := make([]interface{}, len(optFns)) @@ -476,6 +965,43 @@ func (_m *Client) IncreaseStreamRetentionPeriod(ctx context.Context, params *kin return r0, r1 } +// Client_IncreaseStreamRetentionPeriod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncreaseStreamRetentionPeriod' +type Client_IncreaseStreamRetentionPeriod_Call struct { + *mock.Call +} + +// IncreaseStreamRetentionPeriod is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.IncreaseStreamRetentionPeriodInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) IncreaseStreamRetentionPeriod(ctx interface{}, params interface{}, optFns ...interface{}) *Client_IncreaseStreamRetentionPeriod_Call { + return &Client_IncreaseStreamRetentionPeriod_Call{Call: _e.mock.On("IncreaseStreamRetentionPeriod", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_IncreaseStreamRetentionPeriod_Call) Run(run func(ctx context.Context, params *kinesis.IncreaseStreamRetentionPeriodInput, optFns ...func(*kinesis.Options))) *Client_IncreaseStreamRetentionPeriod_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.IncreaseStreamRetentionPeriodInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_IncreaseStreamRetentionPeriod_Call) Return(_a0 *kinesis.IncreaseStreamRetentionPeriodOutput, _a1 error) *Client_IncreaseStreamRetentionPeriod_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_IncreaseStreamRetentionPeriod_Call) RunAndReturn(run func(context.Context, *kinesis.IncreaseStreamRetentionPeriodInput, ...func(*kinesis.Options)) (*kinesis.IncreaseStreamRetentionPeriodOutput, error)) *Client_IncreaseStreamRetentionPeriod_Call { + _c.Call.Return(run) + return _c +} + // ListShards provides a mock function with given fields: ctx, params, optFns func (_m *Client) ListShards(ctx context.Context, params *kinesis.ListShardsInput, optFns ...func(*kinesis.Options)) (*kinesis.ListShardsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -509,6 +1035,43 @@ func (_m *Client) ListShards(ctx context.Context, params *kinesis.ListShardsInpu return r0, r1 } +// Client_ListShards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListShards' +type Client_ListShards_Call struct { + *mock.Call +} + +// ListShards is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.ListShardsInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) ListShards(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListShards_Call { + return &Client_ListShards_Call{Call: _e.mock.On("ListShards", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ListShards_Call) Run(run func(ctx context.Context, params *kinesis.ListShardsInput, optFns ...func(*kinesis.Options))) *Client_ListShards_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.ListShardsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_ListShards_Call) Return(_a0 *kinesis.ListShardsOutput, _a1 error) *Client_ListShards_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ListShards_Call) RunAndReturn(run func(context.Context, *kinesis.ListShardsInput, ...func(*kinesis.Options)) (*kinesis.ListShardsOutput, error)) *Client_ListShards_Call { + _c.Call.Return(run) + return _c +} + // ListStreamConsumers provides a mock function with given fields: ctx, params, optFns func (_m *Client) ListStreamConsumers(ctx context.Context, params *kinesis.ListStreamConsumersInput, optFns ...func(*kinesis.Options)) (*kinesis.ListStreamConsumersOutput, error) { _va := make([]interface{}, len(optFns)) @@ -542,6 +1105,43 @@ func (_m *Client) ListStreamConsumers(ctx context.Context, params *kinesis.ListS return r0, r1 } +// Client_ListStreamConsumers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStreamConsumers' +type Client_ListStreamConsumers_Call struct { + *mock.Call +} + +// ListStreamConsumers is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.ListStreamConsumersInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) ListStreamConsumers(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListStreamConsumers_Call { + return &Client_ListStreamConsumers_Call{Call: _e.mock.On("ListStreamConsumers", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ListStreamConsumers_Call) Run(run func(ctx context.Context, params *kinesis.ListStreamConsumersInput, optFns ...func(*kinesis.Options))) *Client_ListStreamConsumers_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.ListStreamConsumersInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_ListStreamConsumers_Call) Return(_a0 *kinesis.ListStreamConsumersOutput, _a1 error) *Client_ListStreamConsumers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ListStreamConsumers_Call) RunAndReturn(run func(context.Context, *kinesis.ListStreamConsumersInput, ...func(*kinesis.Options)) (*kinesis.ListStreamConsumersOutput, error)) *Client_ListStreamConsumers_Call { + _c.Call.Return(run) + return _c +} + // ListStreams provides a mock function with given fields: ctx, params, optFns func (_m *Client) ListStreams(ctx context.Context, params *kinesis.ListStreamsInput, optFns ...func(*kinesis.Options)) (*kinesis.ListStreamsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -575,6 +1175,43 @@ func (_m *Client) ListStreams(ctx context.Context, params *kinesis.ListStreamsIn return r0, r1 } +// Client_ListStreams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStreams' +type Client_ListStreams_Call struct { + *mock.Call +} + +// ListStreams is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.ListStreamsInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) ListStreams(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListStreams_Call { + return &Client_ListStreams_Call{Call: _e.mock.On("ListStreams", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ListStreams_Call) Run(run func(ctx context.Context, params *kinesis.ListStreamsInput, optFns ...func(*kinesis.Options))) *Client_ListStreams_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.ListStreamsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_ListStreams_Call) Return(_a0 *kinesis.ListStreamsOutput, _a1 error) *Client_ListStreams_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ListStreams_Call) RunAndReturn(run func(context.Context, *kinesis.ListStreamsInput, ...func(*kinesis.Options)) (*kinesis.ListStreamsOutput, error)) *Client_ListStreams_Call { + _c.Call.Return(run) + return _c +} + // ListTagsForStream provides a mock function with given fields: ctx, params, optFns func (_m *Client) ListTagsForStream(ctx context.Context, params *kinesis.ListTagsForStreamInput, optFns ...func(*kinesis.Options)) (*kinesis.ListTagsForStreamOutput, error) { _va := make([]interface{}, len(optFns)) @@ -608,6 +1245,43 @@ func (_m *Client) ListTagsForStream(ctx context.Context, params *kinesis.ListTag return r0, r1 } +// Client_ListTagsForStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTagsForStream' +type Client_ListTagsForStream_Call struct { + *mock.Call +} + +// ListTagsForStream is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.ListTagsForStreamInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) ListTagsForStream(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListTagsForStream_Call { + return &Client_ListTagsForStream_Call{Call: _e.mock.On("ListTagsForStream", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ListTagsForStream_Call) Run(run func(ctx context.Context, params *kinesis.ListTagsForStreamInput, optFns ...func(*kinesis.Options))) *Client_ListTagsForStream_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.ListTagsForStreamInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_ListTagsForStream_Call) Return(_a0 *kinesis.ListTagsForStreamOutput, _a1 error) *Client_ListTagsForStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ListTagsForStream_Call) RunAndReturn(run func(context.Context, *kinesis.ListTagsForStreamInput, ...func(*kinesis.Options)) (*kinesis.ListTagsForStreamOutput, error)) *Client_ListTagsForStream_Call { + _c.Call.Return(run) + return _c +} + // MergeShards provides a mock function with given fields: ctx, params, optFns func (_m *Client) MergeShards(ctx context.Context, params *kinesis.MergeShardsInput, optFns ...func(*kinesis.Options)) (*kinesis.MergeShardsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -641,6 +1315,43 @@ func (_m *Client) MergeShards(ctx context.Context, params *kinesis.MergeShardsIn return r0, r1 } +// Client_MergeShards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MergeShards' +type Client_MergeShards_Call struct { + *mock.Call +} + +// MergeShards is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.MergeShardsInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) MergeShards(ctx interface{}, params interface{}, optFns ...interface{}) *Client_MergeShards_Call { + return &Client_MergeShards_Call{Call: _e.mock.On("MergeShards", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_MergeShards_Call) Run(run func(ctx context.Context, params *kinesis.MergeShardsInput, optFns ...func(*kinesis.Options))) *Client_MergeShards_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.MergeShardsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_MergeShards_Call) Return(_a0 *kinesis.MergeShardsOutput, _a1 error) *Client_MergeShards_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_MergeShards_Call) RunAndReturn(run func(context.Context, *kinesis.MergeShardsInput, ...func(*kinesis.Options)) (*kinesis.MergeShardsOutput, error)) *Client_MergeShards_Call { + _c.Call.Return(run) + return _c +} + // PutRecord provides a mock function with given fields: ctx, params, optFns func (_m *Client) PutRecord(ctx context.Context, params *kinesis.PutRecordInput, optFns ...func(*kinesis.Options)) (*kinesis.PutRecordOutput, error) { _va := make([]interface{}, len(optFns)) @@ -674,6 +1385,43 @@ func (_m *Client) PutRecord(ctx context.Context, params *kinesis.PutRecordInput, return r0, r1 } +// Client_PutRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutRecord' +type Client_PutRecord_Call struct { + *mock.Call +} + +// PutRecord is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.PutRecordInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) PutRecord(ctx interface{}, params interface{}, optFns ...interface{}) *Client_PutRecord_Call { + return &Client_PutRecord_Call{Call: _e.mock.On("PutRecord", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_PutRecord_Call) Run(run func(ctx context.Context, params *kinesis.PutRecordInput, optFns ...func(*kinesis.Options))) *Client_PutRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.PutRecordInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_PutRecord_Call) Return(_a0 *kinesis.PutRecordOutput, _a1 error) *Client_PutRecord_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PutRecord_Call) RunAndReturn(run func(context.Context, *kinesis.PutRecordInput, ...func(*kinesis.Options)) (*kinesis.PutRecordOutput, error)) *Client_PutRecord_Call { + _c.Call.Return(run) + return _c +} + // PutRecords provides a mock function with given fields: ctx, params, optFns func (_m *Client) PutRecords(ctx context.Context, params *kinesis.PutRecordsInput, optFns ...func(*kinesis.Options)) (*kinesis.PutRecordsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -707,6 +1455,43 @@ func (_m *Client) PutRecords(ctx context.Context, params *kinesis.PutRecordsInpu return r0, r1 } +// Client_PutRecords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutRecords' +type Client_PutRecords_Call struct { + *mock.Call +} + +// PutRecords is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.PutRecordsInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) PutRecords(ctx interface{}, params interface{}, optFns ...interface{}) *Client_PutRecords_Call { + return &Client_PutRecords_Call{Call: _e.mock.On("PutRecords", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_PutRecords_Call) Run(run func(ctx context.Context, params *kinesis.PutRecordsInput, optFns ...func(*kinesis.Options))) *Client_PutRecords_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.PutRecordsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_PutRecords_Call) Return(_a0 *kinesis.PutRecordsOutput, _a1 error) *Client_PutRecords_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PutRecords_Call) RunAndReturn(run func(context.Context, *kinesis.PutRecordsInput, ...func(*kinesis.Options)) (*kinesis.PutRecordsOutput, error)) *Client_PutRecords_Call { + _c.Call.Return(run) + return _c +} + // RegisterStreamConsumer provides a mock function with given fields: ctx, params, optFns func (_m *Client) RegisterStreamConsumer(ctx context.Context, params *kinesis.RegisterStreamConsumerInput, optFns ...func(*kinesis.Options)) (*kinesis.RegisterStreamConsumerOutput, error) { _va := make([]interface{}, len(optFns)) @@ -740,6 +1525,43 @@ func (_m *Client) RegisterStreamConsumer(ctx context.Context, params *kinesis.Re return r0, r1 } +// Client_RegisterStreamConsumer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterStreamConsumer' +type Client_RegisterStreamConsumer_Call struct { + *mock.Call +} + +// RegisterStreamConsumer is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.RegisterStreamConsumerInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) RegisterStreamConsumer(ctx interface{}, params interface{}, optFns ...interface{}) *Client_RegisterStreamConsumer_Call { + return &Client_RegisterStreamConsumer_Call{Call: _e.mock.On("RegisterStreamConsumer", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_RegisterStreamConsumer_Call) Run(run func(ctx context.Context, params *kinesis.RegisterStreamConsumerInput, optFns ...func(*kinesis.Options))) *Client_RegisterStreamConsumer_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.RegisterStreamConsumerInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_RegisterStreamConsumer_Call) Return(_a0 *kinesis.RegisterStreamConsumerOutput, _a1 error) *Client_RegisterStreamConsumer_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_RegisterStreamConsumer_Call) RunAndReturn(run func(context.Context, *kinesis.RegisterStreamConsumerInput, ...func(*kinesis.Options)) (*kinesis.RegisterStreamConsumerOutput, error)) *Client_RegisterStreamConsumer_Call { + _c.Call.Return(run) + return _c +} + // RemoveTagsFromStream provides a mock function with given fields: ctx, params, optFns func (_m *Client) RemoveTagsFromStream(ctx context.Context, params *kinesis.RemoveTagsFromStreamInput, optFns ...func(*kinesis.Options)) (*kinesis.RemoveTagsFromStreamOutput, error) { _va := make([]interface{}, len(optFns)) @@ -773,6 +1595,43 @@ func (_m *Client) RemoveTagsFromStream(ctx context.Context, params *kinesis.Remo return r0, r1 } +// Client_RemoveTagsFromStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTagsFromStream' +type Client_RemoveTagsFromStream_Call struct { + *mock.Call +} + +// RemoveTagsFromStream is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.RemoveTagsFromStreamInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) RemoveTagsFromStream(ctx interface{}, params interface{}, optFns ...interface{}) *Client_RemoveTagsFromStream_Call { + return &Client_RemoveTagsFromStream_Call{Call: _e.mock.On("RemoveTagsFromStream", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_RemoveTagsFromStream_Call) Run(run func(ctx context.Context, params *kinesis.RemoveTagsFromStreamInput, optFns ...func(*kinesis.Options))) *Client_RemoveTagsFromStream_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.RemoveTagsFromStreamInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_RemoveTagsFromStream_Call) Return(_a0 *kinesis.RemoveTagsFromStreamOutput, _a1 error) *Client_RemoveTagsFromStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_RemoveTagsFromStream_Call) RunAndReturn(run func(context.Context, *kinesis.RemoveTagsFromStreamInput, ...func(*kinesis.Options)) (*kinesis.RemoveTagsFromStreamOutput, error)) *Client_RemoveTagsFromStream_Call { + _c.Call.Return(run) + return _c +} + // SplitShard provides a mock function with given fields: ctx, params, optFns func (_m *Client) SplitShard(ctx context.Context, params *kinesis.SplitShardInput, optFns ...func(*kinesis.Options)) (*kinesis.SplitShardOutput, error) { _va := make([]interface{}, len(optFns)) @@ -806,6 +1665,43 @@ func (_m *Client) SplitShard(ctx context.Context, params *kinesis.SplitShardInpu return r0, r1 } +// Client_SplitShard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SplitShard' +type Client_SplitShard_Call struct { + *mock.Call +} + +// SplitShard is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.SplitShardInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) SplitShard(ctx interface{}, params interface{}, optFns ...interface{}) *Client_SplitShard_Call { + return &Client_SplitShard_Call{Call: _e.mock.On("SplitShard", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_SplitShard_Call) Run(run func(ctx context.Context, params *kinesis.SplitShardInput, optFns ...func(*kinesis.Options))) *Client_SplitShard_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.SplitShardInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_SplitShard_Call) Return(_a0 *kinesis.SplitShardOutput, _a1 error) *Client_SplitShard_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SplitShard_Call) RunAndReturn(run func(context.Context, *kinesis.SplitShardInput, ...func(*kinesis.Options)) (*kinesis.SplitShardOutput, error)) *Client_SplitShard_Call { + _c.Call.Return(run) + return _c +} + // StartStreamEncryption provides a mock function with given fields: ctx, params, optFns func (_m *Client) StartStreamEncryption(ctx context.Context, params *kinesis.StartStreamEncryptionInput, optFns ...func(*kinesis.Options)) (*kinesis.StartStreamEncryptionOutput, error) { _va := make([]interface{}, len(optFns)) @@ -839,6 +1735,43 @@ func (_m *Client) StartStreamEncryption(ctx context.Context, params *kinesis.Sta return r0, r1 } +// Client_StartStreamEncryption_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartStreamEncryption' +type Client_StartStreamEncryption_Call struct { + *mock.Call +} + +// StartStreamEncryption is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.StartStreamEncryptionInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) StartStreamEncryption(ctx interface{}, params interface{}, optFns ...interface{}) *Client_StartStreamEncryption_Call { + return &Client_StartStreamEncryption_Call{Call: _e.mock.On("StartStreamEncryption", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_StartStreamEncryption_Call) Run(run func(ctx context.Context, params *kinesis.StartStreamEncryptionInput, optFns ...func(*kinesis.Options))) *Client_StartStreamEncryption_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.StartStreamEncryptionInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_StartStreamEncryption_Call) Return(_a0 *kinesis.StartStreamEncryptionOutput, _a1 error) *Client_StartStreamEncryption_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_StartStreamEncryption_Call) RunAndReturn(run func(context.Context, *kinesis.StartStreamEncryptionInput, ...func(*kinesis.Options)) (*kinesis.StartStreamEncryptionOutput, error)) *Client_StartStreamEncryption_Call { + _c.Call.Return(run) + return _c +} + // StopStreamEncryption provides a mock function with given fields: ctx, params, optFns func (_m *Client) StopStreamEncryption(ctx context.Context, params *kinesis.StopStreamEncryptionInput, optFns ...func(*kinesis.Options)) (*kinesis.StopStreamEncryptionOutput, error) { _va := make([]interface{}, len(optFns)) @@ -872,6 +1805,43 @@ func (_m *Client) StopStreamEncryption(ctx context.Context, params *kinesis.Stop return r0, r1 } +// Client_StopStreamEncryption_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopStreamEncryption' +type Client_StopStreamEncryption_Call struct { + *mock.Call +} + +// StopStreamEncryption is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.StopStreamEncryptionInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) StopStreamEncryption(ctx interface{}, params interface{}, optFns ...interface{}) *Client_StopStreamEncryption_Call { + return &Client_StopStreamEncryption_Call{Call: _e.mock.On("StopStreamEncryption", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_StopStreamEncryption_Call) Run(run func(ctx context.Context, params *kinesis.StopStreamEncryptionInput, optFns ...func(*kinesis.Options))) *Client_StopStreamEncryption_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.StopStreamEncryptionInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_StopStreamEncryption_Call) Return(_a0 *kinesis.StopStreamEncryptionOutput, _a1 error) *Client_StopStreamEncryption_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_StopStreamEncryption_Call) RunAndReturn(run func(context.Context, *kinesis.StopStreamEncryptionInput, ...func(*kinesis.Options)) (*kinesis.StopStreamEncryptionOutput, error)) *Client_StopStreamEncryption_Call { + _c.Call.Return(run) + return _c +} + // SubscribeToShard provides a mock function with given fields: ctx, params, optFns func (_m *Client) SubscribeToShard(ctx context.Context, params *kinesis.SubscribeToShardInput, optFns ...func(*kinesis.Options)) (*kinesis.SubscribeToShardOutput, error) { _va := make([]interface{}, len(optFns)) @@ -905,6 +1875,43 @@ func (_m *Client) SubscribeToShard(ctx context.Context, params *kinesis.Subscrib return r0, r1 } +// Client_SubscribeToShard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeToShard' +type Client_SubscribeToShard_Call struct { + *mock.Call +} + +// SubscribeToShard is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.SubscribeToShardInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) SubscribeToShard(ctx interface{}, params interface{}, optFns ...interface{}) *Client_SubscribeToShard_Call { + return &Client_SubscribeToShard_Call{Call: _e.mock.On("SubscribeToShard", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_SubscribeToShard_Call) Run(run func(ctx context.Context, params *kinesis.SubscribeToShardInput, optFns ...func(*kinesis.Options))) *Client_SubscribeToShard_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.SubscribeToShardInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_SubscribeToShard_Call) Return(_a0 *kinesis.SubscribeToShardOutput, _a1 error) *Client_SubscribeToShard_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SubscribeToShard_Call) RunAndReturn(run func(context.Context, *kinesis.SubscribeToShardInput, ...func(*kinesis.Options)) (*kinesis.SubscribeToShardOutput, error)) *Client_SubscribeToShard_Call { + _c.Call.Return(run) + return _c +} + // UpdateShardCount provides a mock function with given fields: ctx, params, optFns func (_m *Client) UpdateShardCount(ctx context.Context, params *kinesis.UpdateShardCountInput, optFns ...func(*kinesis.Options)) (*kinesis.UpdateShardCountOutput, error) { _va := make([]interface{}, len(optFns)) @@ -938,6 +1945,43 @@ func (_m *Client) UpdateShardCount(ctx context.Context, params *kinesis.UpdateSh return r0, r1 } +// Client_UpdateShardCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateShardCount' +type Client_UpdateShardCount_Call struct { + *mock.Call +} + +// UpdateShardCount is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.UpdateShardCountInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) UpdateShardCount(ctx interface{}, params interface{}, optFns ...interface{}) *Client_UpdateShardCount_Call { + return &Client_UpdateShardCount_Call{Call: _e.mock.On("UpdateShardCount", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_UpdateShardCount_Call) Run(run func(ctx context.Context, params *kinesis.UpdateShardCountInput, optFns ...func(*kinesis.Options))) *Client_UpdateShardCount_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.UpdateShardCountInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_UpdateShardCount_Call) Return(_a0 *kinesis.UpdateShardCountOutput, _a1 error) *Client_UpdateShardCount_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_UpdateShardCount_Call) RunAndReturn(run func(context.Context, *kinesis.UpdateShardCountInput, ...func(*kinesis.Options)) (*kinesis.UpdateShardCountOutput, error)) *Client_UpdateShardCount_Call { + _c.Call.Return(run) + return _c +} + // UpdateStreamMode provides a mock function with given fields: ctx, params, optFns func (_m *Client) UpdateStreamMode(ctx context.Context, params *kinesis.UpdateStreamModeInput, optFns ...func(*kinesis.Options)) (*kinesis.UpdateStreamModeOutput, error) { _va := make([]interface{}, len(optFns)) @@ -971,6 +2015,43 @@ func (_m *Client) UpdateStreamMode(ctx context.Context, params *kinesis.UpdateSt return r0, r1 } +// Client_UpdateStreamMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStreamMode' +type Client_UpdateStreamMode_Call struct { + *mock.Call +} + +// UpdateStreamMode is a helper method to define mock.On call +// - ctx context.Context +// - params *kinesis.UpdateStreamModeInput +// - optFns ...func(*kinesis.Options) +func (_e *Client_Expecter) UpdateStreamMode(ctx interface{}, params interface{}, optFns ...interface{}) *Client_UpdateStreamMode_Call { + return &Client_UpdateStreamMode_Call{Call: _e.mock.On("UpdateStreamMode", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_UpdateStreamMode_Call) Run(run func(ctx context.Context, params *kinesis.UpdateStreamModeInput, optFns ...func(*kinesis.Options))) *Client_UpdateStreamMode_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*kinesis.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*kinesis.Options)) + } + } + run(args[0].(context.Context), args[1].(*kinesis.UpdateStreamModeInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_UpdateStreamMode_Call) Return(_a0 *kinesis.UpdateStreamModeOutput, _a1 error) *Client_UpdateStreamMode_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_UpdateStreamMode_Call) RunAndReturn(run func(context.Context, *kinesis.UpdateStreamModeInput, ...func(*kinesis.Options)) (*kinesis.UpdateStreamModeOutput, error)) *Client_UpdateStreamMode_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/kinesis/mocks/Kinsumer.go b/pkg/cloud/aws/kinesis/mocks/Kinsumer.go index e73441a76..9f4223ddb 100644 --- a/pkg/cloud/aws/kinesis/mocks/Kinsumer.go +++ b/pkg/cloud/aws/kinesis/mocks/Kinsumer.go @@ -14,6 +14,14 @@ type Kinsumer struct { mock.Mock } +type Kinsumer_Expecter struct { + mock *mock.Mock +} + +func (_m *Kinsumer) EXPECT() *Kinsumer_Expecter { + return &Kinsumer_Expecter{mock: &_m.Mock} +} + // Run provides a mock function with given fields: ctx, handler func (_m *Kinsumer) Run(ctx context.Context, handler kinesis.MessageHandler) error { ret := _m.Called(ctx, handler) @@ -28,11 +36,67 @@ func (_m *Kinsumer) Run(ctx context.Context, handler kinesis.MessageHandler) err return r0 } +// Kinsumer_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type Kinsumer_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +// - handler kinesis.MessageHandler +func (_e *Kinsumer_Expecter) Run(ctx interface{}, handler interface{}) *Kinsumer_Run_Call { + return &Kinsumer_Run_Call{Call: _e.mock.On("Run", ctx, handler)} +} + +func (_c *Kinsumer_Run_Call) Run(run func(ctx context.Context, handler kinesis.MessageHandler)) *Kinsumer_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(kinesis.MessageHandler)) + }) + return _c +} + +func (_c *Kinsumer_Run_Call) Return(_a0 error) *Kinsumer_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Kinsumer_Run_Call) RunAndReturn(run func(context.Context, kinesis.MessageHandler) error) *Kinsumer_Run_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *Kinsumer) Stop() { _m.Called() } +// Kinsumer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type Kinsumer_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *Kinsumer_Expecter) Stop() *Kinsumer_Stop_Call { + return &Kinsumer_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *Kinsumer_Stop_Call) Run(run func()) *Kinsumer_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Kinsumer_Stop_Call) Return() *Kinsumer_Stop_Call { + _c.Call.Return() + return _c +} + +func (_c *Kinsumer_Stop_Call) RunAndReturn(run func()) *Kinsumer_Stop_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewKinsumer interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/kinesis/mocks/MessageHandler.go b/pkg/cloud/aws/kinesis/mocks/MessageHandler.go index 775a37a55..5531aca3f 100644 --- a/pkg/cloud/aws/kinesis/mocks/MessageHandler.go +++ b/pkg/cloud/aws/kinesis/mocks/MessageHandler.go @@ -9,11 +9,46 @@ type MessageHandler struct { mock.Mock } +type MessageHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *MessageHandler) EXPECT() *MessageHandler_Expecter { + return &MessageHandler_Expecter{mock: &_m.Mock} +} + // Done provides a mock function with given fields: func (_m *MessageHandler) Done() { _m.Called() } +// MessageHandler_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done' +type MessageHandler_Done_Call struct { + *mock.Call +} + +// Done is a helper method to define mock.On call +func (_e *MessageHandler_Expecter) Done() *MessageHandler_Done_Call { + return &MessageHandler_Done_Call{Call: _e.mock.On("Done")} +} + +func (_c *MessageHandler_Done_Call) Run(run func()) *MessageHandler_Done_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MessageHandler_Done_Call) Return() *MessageHandler_Done_Call { + _c.Call.Return() + return _c +} + +func (_c *MessageHandler_Done_Call) RunAndReturn(run func()) *MessageHandler_Done_Call { + _c.Call.Return(run) + return _c +} + // Handle provides a mock function with given fields: rawMessage func (_m *MessageHandler) Handle(rawMessage []byte) error { ret := _m.Called(rawMessage) @@ -28,6 +63,34 @@ func (_m *MessageHandler) Handle(rawMessage []byte) error { return r0 } +// MessageHandler_Handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Handle' +type MessageHandler_Handle_Call struct { + *mock.Call +} + +// Handle is a helper method to define mock.On call +// - rawMessage []byte +func (_e *MessageHandler_Expecter) Handle(rawMessage interface{}) *MessageHandler_Handle_Call { + return &MessageHandler_Handle_Call{Call: _e.mock.On("Handle", rawMessage)} +} + +func (_c *MessageHandler_Handle_Call) Run(run func(rawMessage []byte)) *MessageHandler_Handle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]byte)) + }) + return _c +} + +func (_c *MessageHandler_Handle_Call) Return(_a0 error) *MessageHandler_Handle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MessageHandler_Handle_Call) RunAndReturn(run func([]byte) error) *MessageHandler_Handle_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewMessageHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/kinesis/mocks/MetadataRepository.go b/pkg/cloud/aws/kinesis/mocks/MetadataRepository.go index b9b2b85eb..3ff898dde 100644 --- a/pkg/cloud/aws/kinesis/mocks/MetadataRepository.go +++ b/pkg/cloud/aws/kinesis/mocks/MetadataRepository.go @@ -14,6 +14,14 @@ type MetadataRepository struct { mock.Mock } +type MetadataRepository_Expecter struct { + mock *mock.Mock +} + +func (_m *MetadataRepository) EXPECT() *MetadataRepository_Expecter { + return &MetadataRepository_Expecter{mock: &_m.Mock} +} + // AcquireShard provides a mock function with given fields: ctx, shardId func (_m *MetadataRepository) AcquireShard(ctx context.Context, shardId kinesis.ShardId) (kinesis.Checkpoint, error) { ret := _m.Called(ctx, shardId) @@ -40,6 +48,35 @@ func (_m *MetadataRepository) AcquireShard(ctx context.Context, shardId kinesis. return r0, r1 } +// MetadataRepository_AcquireShard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcquireShard' +type MetadataRepository_AcquireShard_Call struct { + *mock.Call +} + +// AcquireShard is a helper method to define mock.On call +// - ctx context.Context +// - shardId kinesis.ShardId +func (_e *MetadataRepository_Expecter) AcquireShard(ctx interface{}, shardId interface{}) *MetadataRepository_AcquireShard_Call { + return &MetadataRepository_AcquireShard_Call{Call: _e.mock.On("AcquireShard", ctx, shardId)} +} + +func (_c *MetadataRepository_AcquireShard_Call) Run(run func(ctx context.Context, shardId kinesis.ShardId)) *MetadataRepository_AcquireShard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(kinesis.ShardId)) + }) + return _c +} + +func (_c *MetadataRepository_AcquireShard_Call) Return(_a0 kinesis.Checkpoint, _a1 error) *MetadataRepository_AcquireShard_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MetadataRepository_AcquireShard_Call) RunAndReturn(run func(context.Context, kinesis.ShardId) (kinesis.Checkpoint, error)) *MetadataRepository_AcquireShard_Call { + _c.Call.Return(run) + return _c +} + // DeregisterClient provides a mock function with given fields: ctx func (_m *MetadataRepository) DeregisterClient(ctx context.Context) error { ret := _m.Called(ctx) @@ -54,6 +91,34 @@ func (_m *MetadataRepository) DeregisterClient(ctx context.Context) error { return r0 } +// MetadataRepository_DeregisterClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeregisterClient' +type MetadataRepository_DeregisterClient_Call struct { + *mock.Call +} + +// DeregisterClient is a helper method to define mock.On call +// - ctx context.Context +func (_e *MetadataRepository_Expecter) DeregisterClient(ctx interface{}) *MetadataRepository_DeregisterClient_Call { + return &MetadataRepository_DeregisterClient_Call{Call: _e.mock.On("DeregisterClient", ctx)} +} + +func (_c *MetadataRepository_DeregisterClient_Call) Run(run func(ctx context.Context)) *MetadataRepository_DeregisterClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MetadataRepository_DeregisterClient_Call) Return(_a0 error) *MetadataRepository_DeregisterClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MetadataRepository_DeregisterClient_Call) RunAndReturn(run func(context.Context) error) *MetadataRepository_DeregisterClient_Call { + _c.Call.Return(run) + return _c +} + // IsShardFinished provides a mock function with given fields: ctx, shardId func (_m *MetadataRepository) IsShardFinished(ctx context.Context, shardId kinesis.ShardId) (bool, error) { ret := _m.Called(ctx, shardId) @@ -78,6 +143,35 @@ func (_m *MetadataRepository) IsShardFinished(ctx context.Context, shardId kines return r0, r1 } +// MetadataRepository_IsShardFinished_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsShardFinished' +type MetadataRepository_IsShardFinished_Call struct { + *mock.Call +} + +// IsShardFinished is a helper method to define mock.On call +// - ctx context.Context +// - shardId kinesis.ShardId +func (_e *MetadataRepository_Expecter) IsShardFinished(ctx interface{}, shardId interface{}) *MetadataRepository_IsShardFinished_Call { + return &MetadataRepository_IsShardFinished_Call{Call: _e.mock.On("IsShardFinished", ctx, shardId)} +} + +func (_c *MetadataRepository_IsShardFinished_Call) Run(run func(ctx context.Context, shardId kinesis.ShardId)) *MetadataRepository_IsShardFinished_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(kinesis.ShardId)) + }) + return _c +} + +func (_c *MetadataRepository_IsShardFinished_Call) Return(_a0 bool, _a1 error) *MetadataRepository_IsShardFinished_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MetadataRepository_IsShardFinished_Call) RunAndReturn(run func(context.Context, kinesis.ShardId) (bool, error)) *MetadataRepository_IsShardFinished_Call { + _c.Call.Return(run) + return _c +} + // RegisterClient provides a mock function with given fields: ctx func (_m *MetadataRepository) RegisterClient(ctx context.Context) (int, int, error) { ret := _m.Called(ctx) @@ -109,6 +203,34 @@ func (_m *MetadataRepository) RegisterClient(ctx context.Context) (int, int, err return r0, r1, r2 } +// MetadataRepository_RegisterClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterClient' +type MetadataRepository_RegisterClient_Call struct { + *mock.Call +} + +// RegisterClient is a helper method to define mock.On call +// - ctx context.Context +func (_e *MetadataRepository_Expecter) RegisterClient(ctx interface{}) *MetadataRepository_RegisterClient_Call { + return &MetadataRepository_RegisterClient_Call{Call: _e.mock.On("RegisterClient", ctx)} +} + +func (_c *MetadataRepository_RegisterClient_Call) Run(run func(ctx context.Context)) *MetadataRepository_RegisterClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MetadataRepository_RegisterClient_Call) Return(clientIndex int, totalClients int, err error) *MetadataRepository_RegisterClient_Call { + _c.Call.Return(clientIndex, totalClients, err) + return _c +} + +func (_c *MetadataRepository_RegisterClient_Call) RunAndReturn(run func(context.Context) (int, int, error)) *MetadataRepository_RegisterClient_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewMetadataRepository interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/kinesis/mocks/RecordWriter.go b/pkg/cloud/aws/kinesis/mocks/RecordWriter.go index e3b7b1921..765678dc5 100644 --- a/pkg/cloud/aws/kinesis/mocks/RecordWriter.go +++ b/pkg/cloud/aws/kinesis/mocks/RecordWriter.go @@ -14,6 +14,14 @@ type RecordWriter struct { mock.Mock } +type RecordWriter_Expecter struct { + mock *mock.Mock +} + +func (_m *RecordWriter) EXPECT() *RecordWriter_Expecter { + return &RecordWriter_Expecter{mock: &_m.Mock} +} + // PutRecord provides a mock function with given fields: ctx, record func (_m *RecordWriter) PutRecord(ctx context.Context, record *kinesis.Record) error { ret := _m.Called(ctx, record) @@ -28,6 +36,35 @@ func (_m *RecordWriter) PutRecord(ctx context.Context, record *kinesis.Record) e return r0 } +// RecordWriter_PutRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutRecord' +type RecordWriter_PutRecord_Call struct { + *mock.Call +} + +// PutRecord is a helper method to define mock.On call +// - ctx context.Context +// - record *kinesis.Record +func (_e *RecordWriter_Expecter) PutRecord(ctx interface{}, record interface{}) *RecordWriter_PutRecord_Call { + return &RecordWriter_PutRecord_Call{Call: _e.mock.On("PutRecord", ctx, record)} +} + +func (_c *RecordWriter_PutRecord_Call) Run(run func(ctx context.Context, record *kinesis.Record)) *RecordWriter_PutRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*kinesis.Record)) + }) + return _c +} + +func (_c *RecordWriter_PutRecord_Call) Return(_a0 error) *RecordWriter_PutRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RecordWriter_PutRecord_Call) RunAndReturn(run func(context.Context, *kinesis.Record) error) *RecordWriter_PutRecord_Call { + _c.Call.Return(run) + return _c +} + // PutRecords provides a mock function with given fields: ctx, batch func (_m *RecordWriter) PutRecords(ctx context.Context, batch []*kinesis.Record) error { ret := _m.Called(ctx, batch) @@ -42,6 +79,35 @@ func (_m *RecordWriter) PutRecords(ctx context.Context, batch []*kinesis.Record) return r0 } +// RecordWriter_PutRecords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutRecords' +type RecordWriter_PutRecords_Call struct { + *mock.Call +} + +// PutRecords is a helper method to define mock.On call +// - ctx context.Context +// - batch []*kinesis.Record +func (_e *RecordWriter_Expecter) PutRecords(ctx interface{}, batch interface{}) *RecordWriter_PutRecords_Call { + return &RecordWriter_PutRecords_Call{Call: _e.mock.On("PutRecords", ctx, batch)} +} + +func (_c *RecordWriter_PutRecords_Call) Run(run func(ctx context.Context, batch []*kinesis.Record)) *RecordWriter_PutRecords_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*kinesis.Record)) + }) + return _c +} + +func (_c *RecordWriter_PutRecords_Call) Return(_a0 error) *RecordWriter_PutRecords_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RecordWriter_PutRecords_Call) RunAndReturn(run func(context.Context, []*kinesis.Record) error) *RecordWriter_PutRecords_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRecordWriter interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/kinesis/mocks/ShardReader.go b/pkg/cloud/aws/kinesis/mocks/ShardReader.go index f4b3f6750..4e4ad0094 100644 --- a/pkg/cloud/aws/kinesis/mocks/ShardReader.go +++ b/pkg/cloud/aws/kinesis/mocks/ShardReader.go @@ -13,6 +13,14 @@ type ShardReader struct { mock.Mock } +type ShardReader_Expecter struct { + mock *mock.Mock +} + +func (_m *ShardReader) EXPECT() *ShardReader_Expecter { + return &ShardReader_Expecter{mock: &_m.Mock} +} + // Run provides a mock function with given fields: ctx, handler func (_m *ShardReader) Run(ctx context.Context, handler func([]byte) error) error { ret := _m.Called(ctx, handler) @@ -27,6 +35,35 @@ func (_m *ShardReader) Run(ctx context.Context, handler func([]byte) error) erro return r0 } +// ShardReader_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type ShardReader_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +// - handler func([]byte) error +func (_e *ShardReader_Expecter) Run(ctx interface{}, handler interface{}) *ShardReader_Run_Call { + return &ShardReader_Run_Call{Call: _e.mock.On("Run", ctx, handler)} +} + +func (_c *ShardReader_Run_Call) Run(run func(ctx context.Context, handler func([]byte) error)) *ShardReader_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(func([]byte) error)) + }) + return _c +} + +func (_c *ShardReader_Run_Call) Return(_a0 error) *ShardReader_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ShardReader_Run_Call) RunAndReturn(run func(context.Context, func([]byte) error) error) *ShardReader_Run_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewShardReader interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/mocks/Executor.go b/pkg/cloud/aws/mocks/Executor.go index 5cf4107ed..3a56b446b 100644 --- a/pkg/cloud/aws/mocks/Executor.go +++ b/pkg/cloud/aws/mocks/Executor.go @@ -15,6 +15,14 @@ type Executor struct { mock.Mock } +type Executor_Expecter struct { + mock *mock.Mock +} + +func (_m *Executor) EXPECT() *Executor_Expecter { + return &Executor_Expecter{mock: &_m.Mock} +} + // Execute provides a mock function with given fields: ctx, f func (_m *Executor) Execute(ctx context.Context, f aws.RequestFunction) (interface{}, error) { ret := _m.Called(ctx, f) @@ -41,6 +49,35 @@ func (_m *Executor) Execute(ctx context.Context, f aws.RequestFunction) (interfa return r0, r1 } +// Executor_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type Executor_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - ctx context.Context +// - f aws.RequestFunction +func (_e *Executor_Expecter) Execute(ctx interface{}, f interface{}) *Executor_Execute_Call { + return &Executor_Execute_Call{Call: _e.mock.On("Execute", ctx, f)} +} + +func (_c *Executor_Execute_Call) Run(run func(ctx context.Context, f aws.RequestFunction)) *Executor_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(aws.RequestFunction)) + }) + return _c +} + +func (_c *Executor_Execute_Call) Return(_a0 interface{}, _a1 error) *Executor_Execute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Executor_Execute_Call) RunAndReturn(run func(context.Context, aws.RequestFunction) (interface{}, error)) *Executor_Execute_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewExecutor interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/rds/mocks/Client.go b/pkg/cloud/aws/rds/mocks/Client.go index 4a053088d..959ba3fe4 100644 --- a/pkg/cloud/aws/rds/mocks/Client.go +++ b/pkg/cloud/aws/rds/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // DescribeDBInstances provides a mock function with given fields: ctx, params, optFns func (_m *Client) DescribeDBInstances(ctx context.Context, params *rds.DescribeDBInstancesInput, optFns ...func(*rds.Options)) (*rds.DescribeDBInstancesOutput, error) { _va := make([]interface{}, len(optFns)) @@ -47,6 +55,43 @@ func (_m *Client) DescribeDBInstances(ctx context.Context, params *rds.DescribeD return r0, r1 } +// Client_DescribeDBInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeDBInstances' +type Client_DescribeDBInstances_Call struct { + *mock.Call +} + +// DescribeDBInstances is a helper method to define mock.On call +// - ctx context.Context +// - params *rds.DescribeDBInstancesInput +// - optFns ...func(*rds.Options) +func (_e *Client_Expecter) DescribeDBInstances(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DescribeDBInstances_Call { + return &Client_DescribeDBInstances_Call{Call: _e.mock.On("DescribeDBInstances", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DescribeDBInstances_Call) Run(run func(ctx context.Context, params *rds.DescribeDBInstancesInput, optFns ...func(*rds.Options))) *Client_DescribeDBInstances_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*rds.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*rds.Options)) + } + } + run(args[0].(context.Context), args[1].(*rds.DescribeDBInstancesInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DescribeDBInstances_Call) Return(_a0 *rds.DescribeDBInstancesOutput, _a1 error) *Client_DescribeDBInstances_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DescribeDBInstances_Call) RunAndReturn(run func(context.Context, *rds.DescribeDBInstancesInput, ...func(*rds.Options)) (*rds.DescribeDBInstancesOutput, error)) *Client_DescribeDBInstances_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/resourcegroupstaggingapi/mocks/Client.go b/pkg/cloud/aws/resourcegroupstaggingapi/mocks/Client.go index ddd36d91f..aadaeff2d 100644 --- a/pkg/cloud/aws/resourcegroupstaggingapi/mocks/Client.go +++ b/pkg/cloud/aws/resourcegroupstaggingapi/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // GetResources provides a mock function with given fields: _a0, _a1, _a2 func (_m *Client) GetResources(_a0 context.Context, _a1 *resourcegroupstaggingapi.GetResourcesInput, _a2 ...func(*resourcegroupstaggingapi.Options)) (*resourcegroupstaggingapi.GetResourcesOutput, error) { _va := make([]interface{}, len(_a2)) @@ -47,6 +55,43 @@ func (_m *Client) GetResources(_a0 context.Context, _a1 *resourcegroupstaggingap return r0, r1 } +// Client_GetResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResources' +type Client_GetResources_Call struct { + *mock.Call +} + +// GetResources is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *resourcegroupstaggingapi.GetResourcesInput +// - _a2 ...func(*resourcegroupstaggingapi.Options) +func (_e *Client_Expecter) GetResources(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_GetResources_Call { + return &Client_GetResources_Call{Call: _e.mock.On("GetResources", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *Client_GetResources_Call) Run(run func(_a0 context.Context, _a1 *resourcegroupstaggingapi.GetResourcesInput, _a2 ...func(*resourcegroupstaggingapi.Options))) *Client_GetResources_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*resourcegroupstaggingapi.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*resourcegroupstaggingapi.Options)) + } + } + run(args[0].(context.Context), args[1].(*resourcegroupstaggingapi.GetResourcesInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetResources_Call) Return(_a0 *resourcegroupstaggingapi.GetResourcesOutput, _a1 error) *Client_GetResources_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetResources_Call) RunAndReturn(run func(context.Context, *resourcegroupstaggingapi.GetResourcesInput, ...func(*resourcegroupstaggingapi.Options)) (*resourcegroupstaggingapi.GetResourcesOutput, error)) *Client_GetResources_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/resourcegroupstaggingapi/mocks/Service.go b/pkg/cloud/aws/resourcegroupstaggingapi/mocks/Service.go index 908a02b93..aa11b6dc4 100644 --- a/pkg/cloud/aws/resourcegroupstaggingapi/mocks/Service.go +++ b/pkg/cloud/aws/resourcegroupstaggingapi/mocks/Service.go @@ -14,6 +14,14 @@ type Service struct { mock.Mock } +type Service_Expecter struct { + mock *mock.Mock +} + +func (_m *Service) EXPECT() *Service_Expecter { + return &Service_Expecter{mock: &_m.Mock} +} + // GetResources provides a mock function with given fields: ctx, filter func (_m *Service) GetResources(ctx context.Context, filter resourcegroupstaggingapi.Filter) ([]string, error) { ret := _m.Called(ctx, filter) @@ -40,6 +48,35 @@ func (_m *Service) GetResources(ctx context.Context, filter resourcegroupstaggin return r0, r1 } +// Service_GetResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResources' +type Service_GetResources_Call struct { + *mock.Call +} + +// GetResources is a helper method to define mock.On call +// - ctx context.Context +// - filter resourcegroupstaggingapi.Filter +func (_e *Service_Expecter) GetResources(ctx interface{}, filter interface{}) *Service_GetResources_Call { + return &Service_GetResources_Call{Call: _e.mock.On("GetResources", ctx, filter)} +} + +func (_c *Service_GetResources_Call) Run(run func(ctx context.Context, filter resourcegroupstaggingapi.Filter)) *Service_GetResources_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(resourcegroupstaggingapi.Filter)) + }) + return _c +} + +func (_c *Service_GetResources_Call) Return(_a0 []string, _a1 error) *Service_GetResources_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_GetResources_Call) RunAndReturn(run func(context.Context, resourcegroupstaggingapi.Filter) ([]string, error)) *Service_GetResources_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewService interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/s3/mocks/Client.go b/pkg/cloud/aws/s3/mocks/Client.go index 87d16b589..3f0c9f156 100644 --- a/pkg/cloud/aws/s3/mocks/Client.go +++ b/pkg/cloud/aws/s3/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // AbortMultipartUpload provides a mock function with given fields: _a0, _a1, _a2 func (_m *Client) AbortMultipartUpload(_a0 context.Context, _a1 *s3.AbortMultipartUploadInput, _a2 ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error) { _va := make([]interface{}, len(_a2)) @@ -47,6 +55,43 @@ func (_m *Client) AbortMultipartUpload(_a0 context.Context, _a1 *s3.AbortMultipa return r0, r1 } +// Client_AbortMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUpload' +type Client_AbortMultipartUpload_Call struct { + *mock.Call +} + +// AbortMultipartUpload is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *s3.AbortMultipartUploadInput +// - _a2 ...func(*s3.Options) +func (_e *Client_Expecter) AbortMultipartUpload(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_AbortMultipartUpload_Call { + return &Client_AbortMultipartUpload_Call{Call: _e.mock.On("AbortMultipartUpload", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *Client_AbortMultipartUpload_Call) Run(run func(_a0 context.Context, _a1 *s3.AbortMultipartUploadInput, _a2 ...func(*s3.Options))) *Client_AbortMultipartUpload_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.AbortMultipartUploadInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_AbortMultipartUpload_Call) Return(_a0 *s3.AbortMultipartUploadOutput, _a1 error) *Client_AbortMultipartUpload_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_AbortMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.AbortMultipartUploadInput, ...func(*s3.Options)) (*s3.AbortMultipartUploadOutput, error)) *Client_AbortMultipartUpload_Call { + _c.Call.Return(run) + return _c +} + // CompleteMultipartUpload provides a mock function with given fields: _a0, _a1, _a2 func (_m *Client) CompleteMultipartUpload(_a0 context.Context, _a1 *s3.CompleteMultipartUploadInput, _a2 ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error) { _va := make([]interface{}, len(_a2)) @@ -80,6 +125,43 @@ func (_m *Client) CompleteMultipartUpload(_a0 context.Context, _a1 *s3.CompleteM return r0, r1 } +// Client_CompleteMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUpload' +type Client_CompleteMultipartUpload_Call struct { + *mock.Call +} + +// CompleteMultipartUpload is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *s3.CompleteMultipartUploadInput +// - _a2 ...func(*s3.Options) +func (_e *Client_Expecter) CompleteMultipartUpload(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_CompleteMultipartUpload_Call { + return &Client_CompleteMultipartUpload_Call{Call: _e.mock.On("CompleteMultipartUpload", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *Client_CompleteMultipartUpload_Call) Run(run func(_a0 context.Context, _a1 *s3.CompleteMultipartUploadInput, _a2 ...func(*s3.Options))) *Client_CompleteMultipartUpload_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.CompleteMultipartUploadInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_CompleteMultipartUpload_Call) Return(_a0 *s3.CompleteMultipartUploadOutput, _a1 error) *Client_CompleteMultipartUpload_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_CompleteMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.CompleteMultipartUploadInput, ...func(*s3.Options)) (*s3.CompleteMultipartUploadOutput, error)) *Client_CompleteMultipartUpload_Call { + _c.Call.Return(run) + return _c +} + // CopyObject provides a mock function with given fields: ctx, params, optFns func (_m *Client) CopyObject(ctx context.Context, params *s3.CopyObjectInput, optFns ...func(*s3.Options)) (*s3.CopyObjectOutput, error) { _va := make([]interface{}, len(optFns)) @@ -113,6 +195,43 @@ func (_m *Client) CopyObject(ctx context.Context, params *s3.CopyObjectInput, op return r0, r1 } +// Client_CopyObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObject' +type Client_CopyObject_Call struct { + *mock.Call +} + +// CopyObject is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.CopyObjectInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) CopyObject(ctx interface{}, params interface{}, optFns ...interface{}) *Client_CopyObject_Call { + return &Client_CopyObject_Call{Call: _e.mock.On("CopyObject", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_CopyObject_Call) Run(run func(ctx context.Context, params *s3.CopyObjectInput, optFns ...func(*s3.Options))) *Client_CopyObject_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.CopyObjectInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_CopyObject_Call) Return(_a0 *s3.CopyObjectOutput, _a1 error) *Client_CopyObject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_CopyObject_Call) RunAndReturn(run func(context.Context, *s3.CopyObjectInput, ...func(*s3.Options)) (*s3.CopyObjectOutput, error)) *Client_CopyObject_Call { + _c.Call.Return(run) + return _c +} + // CreateBucket provides a mock function with given fields: ctx, params, optFns func (_m *Client) CreateBucket(ctx context.Context, params *s3.CreateBucketInput, optFns ...func(*s3.Options)) (*s3.CreateBucketOutput, error) { _va := make([]interface{}, len(optFns)) @@ -146,6 +265,43 @@ func (_m *Client) CreateBucket(ctx context.Context, params *s3.CreateBucketInput return r0, r1 } +// Client_CreateBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucket' +type Client_CreateBucket_Call struct { + *mock.Call +} + +// CreateBucket is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.CreateBucketInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) CreateBucket(ctx interface{}, params interface{}, optFns ...interface{}) *Client_CreateBucket_Call { + return &Client_CreateBucket_Call{Call: _e.mock.On("CreateBucket", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_CreateBucket_Call) Run(run func(ctx context.Context, params *s3.CreateBucketInput, optFns ...func(*s3.Options))) *Client_CreateBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.CreateBucketInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_CreateBucket_Call) Return(_a0 *s3.CreateBucketOutput, _a1 error) *Client_CreateBucket_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_CreateBucket_Call) RunAndReturn(run func(context.Context, *s3.CreateBucketInput, ...func(*s3.Options)) (*s3.CreateBucketOutput, error)) *Client_CreateBucket_Call { + _c.Call.Return(run) + return _c +} + // CreateMultipartUpload provides a mock function with given fields: _a0, _a1, _a2 func (_m *Client) CreateMultipartUpload(_a0 context.Context, _a1 *s3.CreateMultipartUploadInput, _a2 ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error) { _va := make([]interface{}, len(_a2)) @@ -179,6 +335,43 @@ func (_m *Client) CreateMultipartUpload(_a0 context.Context, _a1 *s3.CreateMulti return r0, r1 } +// Client_CreateMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUpload' +type Client_CreateMultipartUpload_Call struct { + *mock.Call +} + +// CreateMultipartUpload is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *s3.CreateMultipartUploadInput +// - _a2 ...func(*s3.Options) +func (_e *Client_Expecter) CreateMultipartUpload(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_CreateMultipartUpload_Call { + return &Client_CreateMultipartUpload_Call{Call: _e.mock.On("CreateMultipartUpload", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *Client_CreateMultipartUpload_Call) Run(run func(_a0 context.Context, _a1 *s3.CreateMultipartUploadInput, _a2 ...func(*s3.Options))) *Client_CreateMultipartUpload_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.CreateMultipartUploadInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_CreateMultipartUpload_Call) Return(_a0 *s3.CreateMultipartUploadOutput, _a1 error) *Client_CreateMultipartUpload_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_CreateMultipartUpload_Call) RunAndReturn(run func(context.Context, *s3.CreateMultipartUploadInput, ...func(*s3.Options)) (*s3.CreateMultipartUploadOutput, error)) *Client_CreateMultipartUpload_Call { + _c.Call.Return(run) + return _c +} + // DeleteBucket provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeleteBucket(ctx context.Context, params *s3.DeleteBucketInput, optFns ...func(*s3.Options)) (*s3.DeleteBucketOutput, error) { _va := make([]interface{}, len(optFns)) @@ -212,6 +405,43 @@ func (_m *Client) DeleteBucket(ctx context.Context, params *s3.DeleteBucketInput return r0, r1 } +// Client_DeleteBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucket' +type Client_DeleteBucket_Call struct { + *mock.Call +} + +// DeleteBucket is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.DeleteBucketInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) DeleteBucket(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteBucket_Call { + return &Client_DeleteBucket_Call{Call: _e.mock.On("DeleteBucket", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeleteBucket_Call) Run(run func(ctx context.Context, params *s3.DeleteBucketInput, optFns ...func(*s3.Options))) *Client_DeleteBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.DeleteBucketInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeleteBucket_Call) Return(_a0 *s3.DeleteBucketOutput, _a1 error) *Client_DeleteBucket_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeleteBucket_Call) RunAndReturn(run func(context.Context, *s3.DeleteBucketInput, ...func(*s3.Options)) (*s3.DeleteBucketOutput, error)) *Client_DeleteBucket_Call { + _c.Call.Return(run) + return _c +} + // DeleteObject provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeleteObject(ctx context.Context, params *s3.DeleteObjectInput, optFns ...func(*s3.Options)) (*s3.DeleteObjectOutput, error) { _va := make([]interface{}, len(optFns)) @@ -245,6 +475,43 @@ func (_m *Client) DeleteObject(ctx context.Context, params *s3.DeleteObjectInput return r0, r1 } +// Client_DeleteObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObject' +type Client_DeleteObject_Call struct { + *mock.Call +} + +// DeleteObject is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.DeleteObjectInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) DeleteObject(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteObject_Call { + return &Client_DeleteObject_Call{Call: _e.mock.On("DeleteObject", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeleteObject_Call) Run(run func(ctx context.Context, params *s3.DeleteObjectInput, optFns ...func(*s3.Options))) *Client_DeleteObject_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.DeleteObjectInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeleteObject_Call) Return(_a0 *s3.DeleteObjectOutput, _a1 error) *Client_DeleteObject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeleteObject_Call) RunAndReturn(run func(context.Context, *s3.DeleteObjectInput, ...func(*s3.Options)) (*s3.DeleteObjectOutput, error)) *Client_DeleteObject_Call { + _c.Call.Return(run) + return _c +} + // DeleteObjects provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeleteObjects(ctx context.Context, params *s3.DeleteObjectsInput, optFns ...func(*s3.Options)) (*s3.DeleteObjectsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -278,6 +545,43 @@ func (_m *Client) DeleteObjects(ctx context.Context, params *s3.DeleteObjectsInp return r0, r1 } +// Client_DeleteObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjects' +type Client_DeleteObjects_Call struct { + *mock.Call +} + +// DeleteObjects is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.DeleteObjectsInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) DeleteObjects(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteObjects_Call { + return &Client_DeleteObjects_Call{Call: _e.mock.On("DeleteObjects", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeleteObjects_Call) Run(run func(ctx context.Context, params *s3.DeleteObjectsInput, optFns ...func(*s3.Options))) *Client_DeleteObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.DeleteObjectsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeleteObjects_Call) Return(_a0 *s3.DeleteObjectsOutput, _a1 error) *Client_DeleteObjects_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeleteObjects_Call) RunAndReturn(run func(context.Context, *s3.DeleteObjectsInput, ...func(*s3.Options)) (*s3.DeleteObjectsOutput, error)) *Client_DeleteObjects_Call { + _c.Call.Return(run) + return _c +} + // GetObject provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetObject(ctx context.Context, params *s3.GetObjectInput, optFns ...func(*s3.Options)) (*s3.GetObjectOutput, error) { _va := make([]interface{}, len(optFns)) @@ -311,6 +615,43 @@ func (_m *Client) GetObject(ctx context.Context, params *s3.GetObjectInput, optF return r0, r1 } +// Client_GetObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObject' +type Client_GetObject_Call struct { + *mock.Call +} + +// GetObject is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.GetObjectInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) GetObject(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetObject_Call { + return &Client_GetObject_Call{Call: _e.mock.On("GetObject", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetObject_Call) Run(run func(ctx context.Context, params *s3.GetObjectInput, optFns ...func(*s3.Options))) *Client_GetObject_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.GetObjectInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetObject_Call) Return(_a0 *s3.GetObjectOutput, _a1 error) *Client_GetObject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetObject_Call) RunAndReturn(run func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)) *Client_GetObject_Call { + _c.Call.Return(run) + return _c +} + // HeadObject provides a mock function with given fields: ctx, params, optFns func (_m *Client) HeadObject(ctx context.Context, params *s3.HeadObjectInput, optFns ...func(*s3.Options)) (*s3.HeadObjectOutput, error) { _va := make([]interface{}, len(optFns)) @@ -344,6 +685,43 @@ func (_m *Client) HeadObject(ctx context.Context, params *s3.HeadObjectInput, op return r0, r1 } +// Client_HeadObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObject' +type Client_HeadObject_Call struct { + *mock.Call +} + +// HeadObject is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.HeadObjectInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) HeadObject(ctx interface{}, params interface{}, optFns ...interface{}) *Client_HeadObject_Call { + return &Client_HeadObject_Call{Call: _e.mock.On("HeadObject", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_HeadObject_Call) Run(run func(ctx context.Context, params *s3.HeadObjectInput, optFns ...func(*s3.Options))) *Client_HeadObject_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.HeadObjectInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_HeadObject_Call) Return(_a0 *s3.HeadObjectOutput, _a1 error) *Client_HeadObject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_HeadObject_Call) RunAndReturn(run func(context.Context, *s3.HeadObjectInput, ...func(*s3.Options)) (*s3.HeadObjectOutput, error)) *Client_HeadObject_Call { + _c.Call.Return(run) + return _c +} + // ListObjects provides a mock function with given fields: ctx, params, optFns func (_m *Client) ListObjects(ctx context.Context, params *s3.ListObjectsInput, optFns ...func(*s3.Options)) (*s3.ListObjectsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -377,6 +755,43 @@ func (_m *Client) ListObjects(ctx context.Context, params *s3.ListObjectsInput, return r0, r1 } +// Client_ListObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjects' +type Client_ListObjects_Call struct { + *mock.Call +} + +// ListObjects is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.ListObjectsInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) ListObjects(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListObjects_Call { + return &Client_ListObjects_Call{Call: _e.mock.On("ListObjects", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ListObjects_Call) Run(run func(ctx context.Context, params *s3.ListObjectsInput, optFns ...func(*s3.Options))) *Client_ListObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.ListObjectsInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_ListObjects_Call) Return(_a0 *s3.ListObjectsOutput, _a1 error) *Client_ListObjects_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ListObjects_Call) RunAndReturn(run func(context.Context, *s3.ListObjectsInput, ...func(*s3.Options)) (*s3.ListObjectsOutput, error)) *Client_ListObjects_Call { + _c.Call.Return(run) + return _c +} + // ListObjectsV2 provides a mock function with given fields: ctx, params, optFns func (_m *Client) ListObjectsV2(ctx context.Context, params *s3.ListObjectsV2Input, optFns ...func(*s3.Options)) (*s3.ListObjectsV2Output, error) { _va := make([]interface{}, len(optFns)) @@ -410,6 +825,43 @@ func (_m *Client) ListObjectsV2(ctx context.Context, params *s3.ListObjectsV2Inp return r0, r1 } +// Client_ListObjectsV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2' +type Client_ListObjectsV2_Call struct { + *mock.Call +} + +// ListObjectsV2 is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.ListObjectsV2Input +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) ListObjectsV2(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListObjectsV2_Call { + return &Client_ListObjectsV2_Call{Call: _e.mock.On("ListObjectsV2", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ListObjectsV2_Call) Run(run func(ctx context.Context, params *s3.ListObjectsV2Input, optFns ...func(*s3.Options))) *Client_ListObjectsV2_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.ListObjectsV2Input), variadicArgs...) + }) + return _c +} + +func (_c *Client_ListObjectsV2_Call) Return(_a0 *s3.ListObjectsV2Output, _a1 error) *Client_ListObjectsV2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ListObjectsV2_Call) RunAndReturn(run func(context.Context, *s3.ListObjectsV2Input, ...func(*s3.Options)) (*s3.ListObjectsV2Output, error)) *Client_ListObjectsV2_Call { + _c.Call.Return(run) + return _c +} + // PutObject provides a mock function with given fields: ctx, params, optFns func (_m *Client) PutObject(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error) { _va := make([]interface{}, len(optFns)) @@ -443,6 +895,43 @@ func (_m *Client) PutObject(ctx context.Context, params *s3.PutObjectInput, optF return r0, r1 } +// Client_PutObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObject' +type Client_PutObject_Call struct { + *mock.Call +} + +// PutObject is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.PutObjectInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) PutObject(ctx interface{}, params interface{}, optFns ...interface{}) *Client_PutObject_Call { + return &Client_PutObject_Call{Call: _e.mock.On("PutObject", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_PutObject_Call) Run(run func(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options))) *Client_PutObject_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.PutObjectInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_PutObject_Call) Return(_a0 *s3.PutObjectOutput, _a1 error) *Client_PutObject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PutObject_Call) RunAndReturn(run func(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)) *Client_PutObject_Call { + _c.Call.Return(run) + return _c +} + // PutObjectTagging provides a mock function with given fields: ctx, params, optFns func (_m *Client) PutObjectTagging(ctx context.Context, params *s3.PutObjectTaggingInput, optFns ...func(*s3.Options)) (*s3.PutObjectTaggingOutput, error) { _va := make([]interface{}, len(optFns)) @@ -476,6 +965,43 @@ func (_m *Client) PutObjectTagging(ctx context.Context, params *s3.PutObjectTagg return r0, r1 } +// Client_PutObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectTagging' +type Client_PutObjectTagging_Call struct { + *mock.Call +} + +// PutObjectTagging is a helper method to define mock.On call +// - ctx context.Context +// - params *s3.PutObjectTaggingInput +// - optFns ...func(*s3.Options) +func (_e *Client_Expecter) PutObjectTagging(ctx interface{}, params interface{}, optFns ...interface{}) *Client_PutObjectTagging_Call { + return &Client_PutObjectTagging_Call{Call: _e.mock.On("PutObjectTagging", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_PutObjectTagging_Call) Run(run func(ctx context.Context, params *s3.PutObjectTaggingInput, optFns ...func(*s3.Options))) *Client_PutObjectTagging_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.PutObjectTaggingInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_PutObjectTagging_Call) Return(_a0 *s3.PutObjectTaggingOutput, _a1 error) *Client_PutObjectTagging_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PutObjectTagging_Call) RunAndReturn(run func(context.Context, *s3.PutObjectTaggingInput, ...func(*s3.Options)) (*s3.PutObjectTaggingOutput, error)) *Client_PutObjectTagging_Call { + _c.Call.Return(run) + return _c +} + // UploadPart provides a mock function with given fields: _a0, _a1, _a2 func (_m *Client) UploadPart(_a0 context.Context, _a1 *s3.UploadPartInput, _a2 ...func(*s3.Options)) (*s3.UploadPartOutput, error) { _va := make([]interface{}, len(_a2)) @@ -509,6 +1035,43 @@ func (_m *Client) UploadPart(_a0 context.Context, _a1 *s3.UploadPartInput, _a2 . return r0, r1 } +// Client_UploadPart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPart' +type Client_UploadPart_Call struct { + *mock.Call +} + +// UploadPart is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *s3.UploadPartInput +// - _a2 ...func(*s3.Options) +func (_e *Client_Expecter) UploadPart(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *Client_UploadPart_Call { + return &Client_UploadPart_Call{Call: _e.mock.On("UploadPart", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *Client_UploadPart_Call) Run(run func(_a0 context.Context, _a1 *s3.UploadPartInput, _a2 ...func(*s3.Options))) *Client_UploadPart_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*s3.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*s3.Options)) + } + } + run(args[0].(context.Context), args[1].(*s3.UploadPartInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_UploadPart_Call) Return(_a0 *s3.UploadPartOutput, _a1 error) *Client_UploadPart_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_UploadPart_Call) RunAndReturn(run func(context.Context, *s3.UploadPartInput, ...func(*s3.Options)) (*s3.UploadPartOutput, error)) *Client_UploadPart_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/sns/mocks/Client.go b/pkg/cloud/aws/sns/mocks/Client.go index bcc37377a..a89d9579f 100644 --- a/pkg/cloud/aws/sns/mocks/Client.go +++ b/pkg/cloud/aws/sns/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // CreateTopic provides a mock function with given fields: ctx, params, optFns func (_m *Client) CreateTopic(ctx context.Context, params *sns.CreateTopicInput, optFns ...func(*sns.Options)) (*sns.CreateTopicOutput, error) { _va := make([]interface{}, len(optFns)) @@ -47,6 +55,43 @@ func (_m *Client) CreateTopic(ctx context.Context, params *sns.CreateTopicInput, return r0, r1 } +// Client_CreateTopic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTopic' +type Client_CreateTopic_Call struct { + *mock.Call +} + +// CreateTopic is a helper method to define mock.On call +// - ctx context.Context +// - params *sns.CreateTopicInput +// - optFns ...func(*sns.Options) +func (_e *Client_Expecter) CreateTopic(ctx interface{}, params interface{}, optFns ...interface{}) *Client_CreateTopic_Call { + return &Client_CreateTopic_Call{Call: _e.mock.On("CreateTopic", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_CreateTopic_Call) Run(run func(ctx context.Context, params *sns.CreateTopicInput, optFns ...func(*sns.Options))) *Client_CreateTopic_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sns.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sns.Options)) + } + } + run(args[0].(context.Context), args[1].(*sns.CreateTopicInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_CreateTopic_Call) Return(_a0 *sns.CreateTopicOutput, _a1 error) *Client_CreateTopic_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_CreateTopic_Call) RunAndReturn(run func(context.Context, *sns.CreateTopicInput, ...func(*sns.Options)) (*sns.CreateTopicOutput, error)) *Client_CreateTopic_Call { + _c.Call.Return(run) + return _c +} + // GetSubscriptionAttributes provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetSubscriptionAttributes(ctx context.Context, params *sns.GetSubscriptionAttributesInput, optFns ...func(*sns.Options)) (*sns.GetSubscriptionAttributesOutput, error) { _va := make([]interface{}, len(optFns)) @@ -80,6 +125,43 @@ func (_m *Client) GetSubscriptionAttributes(ctx context.Context, params *sns.Get return r0, r1 } +// Client_GetSubscriptionAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSubscriptionAttributes' +type Client_GetSubscriptionAttributes_Call struct { + *mock.Call +} + +// GetSubscriptionAttributes is a helper method to define mock.On call +// - ctx context.Context +// - params *sns.GetSubscriptionAttributesInput +// - optFns ...func(*sns.Options) +func (_e *Client_Expecter) GetSubscriptionAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetSubscriptionAttributes_Call { + return &Client_GetSubscriptionAttributes_Call{Call: _e.mock.On("GetSubscriptionAttributes", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetSubscriptionAttributes_Call) Run(run func(ctx context.Context, params *sns.GetSubscriptionAttributesInput, optFns ...func(*sns.Options))) *Client_GetSubscriptionAttributes_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sns.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sns.Options)) + } + } + run(args[0].(context.Context), args[1].(*sns.GetSubscriptionAttributesInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetSubscriptionAttributes_Call) Return(_a0 *sns.GetSubscriptionAttributesOutput, _a1 error) *Client_GetSubscriptionAttributes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetSubscriptionAttributes_Call) RunAndReturn(run func(context.Context, *sns.GetSubscriptionAttributesInput, ...func(*sns.Options)) (*sns.GetSubscriptionAttributesOutput, error)) *Client_GetSubscriptionAttributes_Call { + _c.Call.Return(run) + return _c +} + // ListSubscriptionsByTopic provides a mock function with given fields: ctx, params, optFns func (_m *Client) ListSubscriptionsByTopic(ctx context.Context, params *sns.ListSubscriptionsByTopicInput, optFns ...func(*sns.Options)) (*sns.ListSubscriptionsByTopicOutput, error) { _va := make([]interface{}, len(optFns)) @@ -113,6 +195,43 @@ func (_m *Client) ListSubscriptionsByTopic(ctx context.Context, params *sns.List return r0, r1 } +// Client_ListSubscriptionsByTopic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSubscriptionsByTopic' +type Client_ListSubscriptionsByTopic_Call struct { + *mock.Call +} + +// ListSubscriptionsByTopic is a helper method to define mock.On call +// - ctx context.Context +// - params *sns.ListSubscriptionsByTopicInput +// - optFns ...func(*sns.Options) +func (_e *Client_Expecter) ListSubscriptionsByTopic(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ListSubscriptionsByTopic_Call { + return &Client_ListSubscriptionsByTopic_Call{Call: _e.mock.On("ListSubscriptionsByTopic", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ListSubscriptionsByTopic_Call) Run(run func(ctx context.Context, params *sns.ListSubscriptionsByTopicInput, optFns ...func(*sns.Options))) *Client_ListSubscriptionsByTopic_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sns.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sns.Options)) + } + } + run(args[0].(context.Context), args[1].(*sns.ListSubscriptionsByTopicInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_ListSubscriptionsByTopic_Call) Return(_a0 *sns.ListSubscriptionsByTopicOutput, _a1 error) *Client_ListSubscriptionsByTopic_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ListSubscriptionsByTopic_Call) RunAndReturn(run func(context.Context, *sns.ListSubscriptionsByTopicInput, ...func(*sns.Options)) (*sns.ListSubscriptionsByTopicOutput, error)) *Client_ListSubscriptionsByTopic_Call { + _c.Call.Return(run) + return _c +} + // Publish provides a mock function with given fields: ctx, params, optFns func (_m *Client) Publish(ctx context.Context, params *sns.PublishInput, optFns ...func(*sns.Options)) (*sns.PublishOutput, error) { _va := make([]interface{}, len(optFns)) @@ -146,6 +265,43 @@ func (_m *Client) Publish(ctx context.Context, params *sns.PublishInput, optFns return r0, r1 } +// Client_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish' +type Client_Publish_Call struct { + *mock.Call +} + +// Publish is a helper method to define mock.On call +// - ctx context.Context +// - params *sns.PublishInput +// - optFns ...func(*sns.Options) +func (_e *Client_Expecter) Publish(ctx interface{}, params interface{}, optFns ...interface{}) *Client_Publish_Call { + return &Client_Publish_Call{Call: _e.mock.On("Publish", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_Publish_Call) Run(run func(ctx context.Context, params *sns.PublishInput, optFns ...func(*sns.Options))) *Client_Publish_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sns.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sns.Options)) + } + } + run(args[0].(context.Context), args[1].(*sns.PublishInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_Publish_Call) Return(_a0 *sns.PublishOutput, _a1 error) *Client_Publish_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Publish_Call) RunAndReturn(run func(context.Context, *sns.PublishInput, ...func(*sns.Options)) (*sns.PublishOutput, error)) *Client_Publish_Call { + _c.Call.Return(run) + return _c +} + // PublishBatch provides a mock function with given fields: ctx, input, optFns func (_m *Client) PublishBatch(ctx context.Context, input *sns.PublishBatchInput, optFns ...func(*sns.Options)) (*sns.PublishBatchOutput, error) { _va := make([]interface{}, len(optFns)) @@ -179,6 +335,43 @@ func (_m *Client) PublishBatch(ctx context.Context, input *sns.PublishBatchInput return r0, r1 } +// Client_PublishBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishBatch' +type Client_PublishBatch_Call struct { + *mock.Call +} + +// PublishBatch is a helper method to define mock.On call +// - ctx context.Context +// - input *sns.PublishBatchInput +// - optFns ...func(*sns.Options) +func (_e *Client_Expecter) PublishBatch(ctx interface{}, input interface{}, optFns ...interface{}) *Client_PublishBatch_Call { + return &Client_PublishBatch_Call{Call: _e.mock.On("PublishBatch", + append([]interface{}{ctx, input}, optFns...)...)} +} + +func (_c *Client_PublishBatch_Call) Run(run func(ctx context.Context, input *sns.PublishBatchInput, optFns ...func(*sns.Options))) *Client_PublishBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sns.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sns.Options)) + } + } + run(args[0].(context.Context), args[1].(*sns.PublishBatchInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_PublishBatch_Call) Return(_a0 *sns.PublishBatchOutput, _a1 error) *Client_PublishBatch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PublishBatch_Call) RunAndReturn(run func(context.Context, *sns.PublishBatchInput, ...func(*sns.Options)) (*sns.PublishBatchOutput, error)) *Client_PublishBatch_Call { + _c.Call.Return(run) + return _c +} + // Subscribe provides a mock function with given fields: ctx, params, optFns func (_m *Client) Subscribe(ctx context.Context, params *sns.SubscribeInput, optFns ...func(*sns.Options)) (*sns.SubscribeOutput, error) { _va := make([]interface{}, len(optFns)) @@ -212,6 +405,43 @@ func (_m *Client) Subscribe(ctx context.Context, params *sns.SubscribeInput, opt return r0, r1 } +// Client_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe' +type Client_Subscribe_Call struct { + *mock.Call +} + +// Subscribe is a helper method to define mock.On call +// - ctx context.Context +// - params *sns.SubscribeInput +// - optFns ...func(*sns.Options) +func (_e *Client_Expecter) Subscribe(ctx interface{}, params interface{}, optFns ...interface{}) *Client_Subscribe_Call { + return &Client_Subscribe_Call{Call: _e.mock.On("Subscribe", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_Subscribe_Call) Run(run func(ctx context.Context, params *sns.SubscribeInput, optFns ...func(*sns.Options))) *Client_Subscribe_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sns.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sns.Options)) + } + } + run(args[0].(context.Context), args[1].(*sns.SubscribeInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_Subscribe_Call) Return(_a0 *sns.SubscribeOutput, _a1 error) *Client_Subscribe_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Subscribe_Call) RunAndReturn(run func(context.Context, *sns.SubscribeInput, ...func(*sns.Options)) (*sns.SubscribeOutput, error)) *Client_Subscribe_Call { + _c.Call.Return(run) + return _c +} + // Unsubscribe provides a mock function with given fields: ctx, params, optFns func (_m *Client) Unsubscribe(ctx context.Context, params *sns.UnsubscribeInput, optFns ...func(*sns.Options)) (*sns.UnsubscribeOutput, error) { _va := make([]interface{}, len(optFns)) @@ -245,6 +475,43 @@ func (_m *Client) Unsubscribe(ctx context.Context, params *sns.UnsubscribeInput, return r0, r1 } +// Client_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe' +type Client_Unsubscribe_Call struct { + *mock.Call +} + +// Unsubscribe is a helper method to define mock.On call +// - ctx context.Context +// - params *sns.UnsubscribeInput +// - optFns ...func(*sns.Options) +func (_e *Client_Expecter) Unsubscribe(ctx interface{}, params interface{}, optFns ...interface{}) *Client_Unsubscribe_Call { + return &Client_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_Unsubscribe_Call) Run(run func(ctx context.Context, params *sns.UnsubscribeInput, optFns ...func(*sns.Options))) *Client_Unsubscribe_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sns.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sns.Options)) + } + } + run(args[0].(context.Context), args[1].(*sns.UnsubscribeInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_Unsubscribe_Call) Return(_a0 *sns.UnsubscribeOutput, _a1 error) *Client_Unsubscribe_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Unsubscribe_Call) RunAndReturn(run func(context.Context, *sns.UnsubscribeInput, ...func(*sns.Options)) (*sns.UnsubscribeOutput, error)) *Client_Unsubscribe_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/sns/mocks/Topic.go b/pkg/cloud/aws/sns/mocks/Topic.go index 7ee8e324f..fb598b183 100644 --- a/pkg/cloud/aws/sns/mocks/Topic.go +++ b/pkg/cloud/aws/sns/mocks/Topic.go @@ -13,6 +13,14 @@ type Topic struct { mock.Mock } +type Topic_Expecter struct { + mock *mock.Mock +} + +func (_m *Topic) EXPECT() *Topic_Expecter { + return &Topic_Expecter{mock: &_m.Mock} +} + // Publish provides a mock function with given fields: ctx, msg, attributes func (_m *Topic) Publish(ctx context.Context, msg string, attributes ...map[string]interface{}) error { _va := make([]interface{}, len(attributes)) @@ -34,6 +42,43 @@ func (_m *Topic) Publish(ctx context.Context, msg string, attributes ...map[stri return r0 } +// Topic_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish' +type Topic_Publish_Call struct { + *mock.Call +} + +// Publish is a helper method to define mock.On call +// - ctx context.Context +// - msg string +// - attributes ...map[string]interface{} +func (_e *Topic_Expecter) Publish(ctx interface{}, msg interface{}, attributes ...interface{}) *Topic_Publish_Call { + return &Topic_Publish_Call{Call: _e.mock.On("Publish", + append([]interface{}{ctx, msg}, attributes...)...)} +} + +func (_c *Topic_Publish_Call) Run(run func(ctx context.Context, msg string, attributes ...map[string]interface{})) *Topic_Publish_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *Topic_Publish_Call) Return(_a0 error) *Topic_Publish_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Topic_Publish_Call) RunAndReturn(run func(context.Context, string, ...map[string]interface{}) error) *Topic_Publish_Call { + _c.Call.Return(run) + return _c +} + // PublishBatch provides a mock function with given fields: ctx, messages, attributes func (_m *Topic) PublishBatch(ctx context.Context, messages []string, attributes []map[string]interface{}) error { ret := _m.Called(ctx, messages, attributes) @@ -48,6 +93,36 @@ func (_m *Topic) PublishBatch(ctx context.Context, messages []string, attributes return r0 } +// Topic_PublishBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishBatch' +type Topic_PublishBatch_Call struct { + *mock.Call +} + +// PublishBatch is a helper method to define mock.On call +// - ctx context.Context +// - messages []string +// - attributes []map[string]interface{} +func (_e *Topic_Expecter) PublishBatch(ctx interface{}, messages interface{}, attributes interface{}) *Topic_PublishBatch_Call { + return &Topic_PublishBatch_Call{Call: _e.mock.On("PublishBatch", ctx, messages, attributes)} +} + +func (_c *Topic_PublishBatch_Call) Run(run func(ctx context.Context, messages []string, attributes []map[string]interface{})) *Topic_PublishBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string), args[2].([]map[string]interface{})) + }) + return _c +} + +func (_c *Topic_PublishBatch_Call) Return(_a0 error) *Topic_PublishBatch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Topic_PublishBatch_Call) RunAndReturn(run func(context.Context, []string, []map[string]interface{}) error) *Topic_PublishBatch_Call { + _c.Call.Return(run) + return _c +} + // SubscribeSqs provides a mock function with given fields: ctx, queueArn, attributes func (_m *Topic) SubscribeSqs(ctx context.Context, queueArn string, attributes map[string]interface{}) error { ret := _m.Called(ctx, queueArn, attributes) @@ -62,6 +137,36 @@ func (_m *Topic) SubscribeSqs(ctx context.Context, queueArn string, attributes m return r0 } +// Topic_SubscribeSqs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeSqs' +type Topic_SubscribeSqs_Call struct { + *mock.Call +} + +// SubscribeSqs is a helper method to define mock.On call +// - ctx context.Context +// - queueArn string +// - attributes map[string]interface{} +func (_e *Topic_Expecter) SubscribeSqs(ctx interface{}, queueArn interface{}, attributes interface{}) *Topic_SubscribeSqs_Call { + return &Topic_SubscribeSqs_Call{Call: _e.mock.On("SubscribeSqs", ctx, queueArn, attributes)} +} + +func (_c *Topic_SubscribeSqs_Call) Run(run func(ctx context.Context, queueArn string, attributes map[string]interface{})) *Topic_SubscribeSqs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(map[string]interface{})) + }) + return _c +} + +func (_c *Topic_SubscribeSqs_Call) Return(_a0 error) *Topic_SubscribeSqs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Topic_SubscribeSqs_Call) RunAndReturn(run func(context.Context, string, map[string]interface{}) error) *Topic_SubscribeSqs_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTopic interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/sqs/mocks/Client.go b/pkg/cloud/aws/sqs/mocks/Client.go index fef53d78a..cc92ea904 100644 --- a/pkg/cloud/aws/sqs/mocks/Client.go +++ b/pkg/cloud/aws/sqs/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // CreateQueue provides a mock function with given fields: ctx, params, optFns func (_m *Client) CreateQueue(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error) { _va := make([]interface{}, len(optFns)) @@ -47,6 +55,43 @@ func (_m *Client) CreateQueue(ctx context.Context, params *sqs.CreateQueueInput, return r0, r1 } +// Client_CreateQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateQueue' +type Client_CreateQueue_Call struct { + *mock.Call +} + +// CreateQueue is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.CreateQueueInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) CreateQueue(ctx interface{}, params interface{}, optFns ...interface{}) *Client_CreateQueue_Call { + return &Client_CreateQueue_Call{Call: _e.mock.On("CreateQueue", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_CreateQueue_Call) Run(run func(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options))) *Client_CreateQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.CreateQueueInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_CreateQueue_Call) Return(_a0 *sqs.CreateQueueOutput, _a1 error) *Client_CreateQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_CreateQueue_Call) RunAndReturn(run func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error)) *Client_CreateQueue_Call { + _c.Call.Return(run) + return _c +} + // DeleteMessage provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeleteMessage(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error) { _va := make([]interface{}, len(optFns)) @@ -80,6 +125,43 @@ func (_m *Client) DeleteMessage(ctx context.Context, params *sqs.DeleteMessageIn return r0, r1 } +// Client_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage' +type Client_DeleteMessage_Call struct { + *mock.Call +} + +// DeleteMessage is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.DeleteMessageInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) DeleteMessage(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteMessage_Call { + return &Client_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeleteMessage_Call) Run(run func(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options))) *Client_DeleteMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.DeleteMessageInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeleteMessage_Call) Return(_a0 *sqs.DeleteMessageOutput, _a1 error) *Client_DeleteMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeleteMessage_Call) RunAndReturn(run func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error)) *Client_DeleteMessage_Call { + _c.Call.Return(run) + return _c +} + // DeleteMessageBatch provides a mock function with given fields: ctx, params, optFns func (_m *Client) DeleteMessageBatch(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error) { _va := make([]interface{}, len(optFns)) @@ -113,6 +195,43 @@ func (_m *Client) DeleteMessageBatch(ctx context.Context, params *sqs.DeleteMess return r0, r1 } +// Client_DeleteMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessageBatch' +type Client_DeleteMessageBatch_Call struct { + *mock.Call +} + +// DeleteMessageBatch is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.DeleteMessageBatchInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) DeleteMessageBatch(ctx interface{}, params interface{}, optFns ...interface{}) *Client_DeleteMessageBatch_Call { + return &Client_DeleteMessageBatch_Call{Call: _e.mock.On("DeleteMessageBatch", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_DeleteMessageBatch_Call) Run(run func(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options))) *Client_DeleteMessageBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.DeleteMessageBatchInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_DeleteMessageBatch_Call) Return(_a0 *sqs.DeleteMessageBatchOutput, _a1 error) *Client_DeleteMessageBatch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DeleteMessageBatch_Call) RunAndReturn(run func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error)) *Client_DeleteMessageBatch_Call { + _c.Call.Return(run) + return _c +} + // GetQueueAttributes provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetQueueAttributes(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error) { _va := make([]interface{}, len(optFns)) @@ -146,6 +265,43 @@ func (_m *Client) GetQueueAttributes(ctx context.Context, params *sqs.GetQueueAt return r0, r1 } +// Client_GetQueueAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueueAttributes' +type Client_GetQueueAttributes_Call struct { + *mock.Call +} + +// GetQueueAttributes is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.GetQueueAttributesInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) GetQueueAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetQueueAttributes_Call { + return &Client_GetQueueAttributes_Call{Call: _e.mock.On("GetQueueAttributes", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetQueueAttributes_Call) Run(run func(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options))) *Client_GetQueueAttributes_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.GetQueueAttributesInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetQueueAttributes_Call) Return(_a0 *sqs.GetQueueAttributesOutput, _a1 error) *Client_GetQueueAttributes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetQueueAttributes_Call) RunAndReturn(run func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error)) *Client_GetQueueAttributes_Call { + _c.Call.Return(run) + return _c +} + // GetQueueUrl provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetQueueUrl(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error) { _va := make([]interface{}, len(optFns)) @@ -179,6 +335,43 @@ func (_m *Client) GetQueueUrl(ctx context.Context, params *sqs.GetQueueUrlInput, return r0, r1 } +// Client_GetQueueUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueueUrl' +type Client_GetQueueUrl_Call struct { + *mock.Call +} + +// GetQueueUrl is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.GetQueueUrlInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) GetQueueUrl(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetQueueUrl_Call { + return &Client_GetQueueUrl_Call{Call: _e.mock.On("GetQueueUrl", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetQueueUrl_Call) Run(run func(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options))) *Client_GetQueueUrl_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.GetQueueUrlInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetQueueUrl_Call) Return(_a0 *sqs.GetQueueUrlOutput, _a1 error) *Client_GetQueueUrl_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetQueueUrl_Call) RunAndReturn(run func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error)) *Client_GetQueueUrl_Call { + _c.Call.Return(run) + return _c +} + // PurgeQueue provides a mock function with given fields: ctx, params, optFns func (_m *Client) PurgeQueue(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error) { _va := make([]interface{}, len(optFns)) @@ -212,6 +405,43 @@ func (_m *Client) PurgeQueue(ctx context.Context, params *sqs.PurgeQueueInput, o return r0, r1 } +// Client_PurgeQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurgeQueue' +type Client_PurgeQueue_Call struct { + *mock.Call +} + +// PurgeQueue is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.PurgeQueueInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) PurgeQueue(ctx interface{}, params interface{}, optFns ...interface{}) *Client_PurgeQueue_Call { + return &Client_PurgeQueue_Call{Call: _e.mock.On("PurgeQueue", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_PurgeQueue_Call) Run(run func(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options))) *Client_PurgeQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.PurgeQueueInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_PurgeQueue_Call) Return(_a0 *sqs.PurgeQueueOutput, _a1 error) *Client_PurgeQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PurgeQueue_Call) RunAndReturn(run func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error)) *Client_PurgeQueue_Call { + _c.Call.Return(run) + return _c +} + // ReceiveMessage provides a mock function with given fields: ctx, params, optFns func (_m *Client) ReceiveMessage(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error) { _va := make([]interface{}, len(optFns)) @@ -245,6 +475,43 @@ func (_m *Client) ReceiveMessage(ctx context.Context, params *sqs.ReceiveMessage return r0, r1 } +// Client_ReceiveMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReceiveMessage' +type Client_ReceiveMessage_Call struct { + *mock.Call +} + +// ReceiveMessage is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.ReceiveMessageInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) ReceiveMessage(ctx interface{}, params interface{}, optFns ...interface{}) *Client_ReceiveMessage_Call { + return &Client_ReceiveMessage_Call{Call: _e.mock.On("ReceiveMessage", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_ReceiveMessage_Call) Run(run func(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options))) *Client_ReceiveMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.ReceiveMessageInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_ReceiveMessage_Call) Return(_a0 *sqs.ReceiveMessageOutput, _a1 error) *Client_ReceiveMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ReceiveMessage_Call) RunAndReturn(run func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error)) *Client_ReceiveMessage_Call { + _c.Call.Return(run) + return _c +} + // SendMessage provides a mock function with given fields: ctx, params, optFns func (_m *Client) SendMessage(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageOutput, error) { _va := make([]interface{}, len(optFns)) @@ -278,6 +545,43 @@ func (_m *Client) SendMessage(ctx context.Context, params *sqs.SendMessageInput, return r0, r1 } +// Client_SendMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessage' +type Client_SendMessage_Call struct { + *mock.Call +} + +// SendMessage is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.SendMessageInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) SendMessage(ctx interface{}, params interface{}, optFns ...interface{}) *Client_SendMessage_Call { + return &Client_SendMessage_Call{Call: _e.mock.On("SendMessage", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_SendMessage_Call) Run(run func(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options))) *Client_SendMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.SendMessageInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_SendMessage_Call) Return(_a0 *sqs.SendMessageOutput, _a1 error) *Client_SendMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SendMessage_Call) RunAndReturn(run func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) (*sqs.SendMessageOutput, error)) *Client_SendMessage_Call { + _c.Call.Return(run) + return _c +} + // SendMessageBatch provides a mock function with given fields: ctx, params, optFns func (_m *Client) SendMessageBatch(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error) { _va := make([]interface{}, len(optFns)) @@ -311,6 +615,43 @@ func (_m *Client) SendMessageBatch(ctx context.Context, params *sqs.SendMessageB return r0, r1 } +// Client_SendMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessageBatch' +type Client_SendMessageBatch_Call struct { + *mock.Call +} + +// SendMessageBatch is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.SendMessageBatchInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) SendMessageBatch(ctx interface{}, params interface{}, optFns ...interface{}) *Client_SendMessageBatch_Call { + return &Client_SendMessageBatch_Call{Call: _e.mock.On("SendMessageBatch", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_SendMessageBatch_Call) Run(run func(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options))) *Client_SendMessageBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.SendMessageBatchInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_SendMessageBatch_Call) Return(_a0 *sqs.SendMessageBatchOutput, _a1 error) *Client_SendMessageBatch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SendMessageBatch_Call) RunAndReturn(run func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error)) *Client_SendMessageBatch_Call { + _c.Call.Return(run) + return _c +} + // SetQueueAttributes provides a mock function with given fields: ctx, params, optFns func (_m *Client) SetQueueAttributes(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error) { _va := make([]interface{}, len(optFns)) @@ -344,6 +685,43 @@ func (_m *Client) SetQueueAttributes(ctx context.Context, params *sqs.SetQueueAt return r0, r1 } +// Client_SetQueueAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetQueueAttributes' +type Client_SetQueueAttributes_Call struct { + *mock.Call +} + +// SetQueueAttributes is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.SetQueueAttributesInput +// - optFns ...func(*sqs.Options) +func (_e *Client_Expecter) SetQueueAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *Client_SetQueueAttributes_Call { + return &Client_SetQueueAttributes_Call{Call: _e.mock.On("SetQueueAttributes", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_SetQueueAttributes_Call) Run(run func(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options))) *Client_SetQueueAttributes_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.SetQueueAttributesInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_SetQueueAttributes_Call) Return(_a0 *sqs.SetQueueAttributesOutput, _a1 error) *Client_SetQueueAttributes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SetQueueAttributes_Call) RunAndReturn(run func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error)) *Client_SetQueueAttributes_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/sqs/mocks/Queue.go b/pkg/cloud/aws/sqs/mocks/Queue.go index 531a99369..f5f139551 100644 --- a/pkg/cloud/aws/sqs/mocks/Queue.go +++ b/pkg/cloud/aws/sqs/mocks/Queue.go @@ -16,6 +16,14 @@ type Queue struct { mock.Mock } +type Queue_Expecter struct { + mock *mock.Mock +} + +func (_m *Queue) EXPECT() *Queue_Expecter { + return &Queue_Expecter{mock: &_m.Mock} +} + // DeleteMessage provides a mock function with given fields: ctx, receiptHandle func (_m *Queue) DeleteMessage(ctx context.Context, receiptHandle string) error { ret := _m.Called(ctx, receiptHandle) @@ -30,6 +38,35 @@ func (_m *Queue) DeleteMessage(ctx context.Context, receiptHandle string) error return r0 } +// Queue_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage' +type Queue_DeleteMessage_Call struct { + *mock.Call +} + +// DeleteMessage is a helper method to define mock.On call +// - ctx context.Context +// - receiptHandle string +func (_e *Queue_Expecter) DeleteMessage(ctx interface{}, receiptHandle interface{}) *Queue_DeleteMessage_Call { + return &Queue_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage", ctx, receiptHandle)} +} + +func (_c *Queue_DeleteMessage_Call) Run(run func(ctx context.Context, receiptHandle string)) *Queue_DeleteMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Queue_DeleteMessage_Call) Return(_a0 error) *Queue_DeleteMessage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Queue_DeleteMessage_Call) RunAndReturn(run func(context.Context, string) error) *Queue_DeleteMessage_Call { + _c.Call.Return(run) + return _c +} + // DeleteMessageBatch provides a mock function with given fields: ctx, receiptHandles func (_m *Queue) DeleteMessageBatch(ctx context.Context, receiptHandles []string) error { ret := _m.Called(ctx, receiptHandles) @@ -44,6 +81,35 @@ func (_m *Queue) DeleteMessageBatch(ctx context.Context, receiptHandles []string return r0 } +// Queue_DeleteMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessageBatch' +type Queue_DeleteMessageBatch_Call struct { + *mock.Call +} + +// DeleteMessageBatch is a helper method to define mock.On call +// - ctx context.Context +// - receiptHandles []string +func (_e *Queue_Expecter) DeleteMessageBatch(ctx interface{}, receiptHandles interface{}) *Queue_DeleteMessageBatch_Call { + return &Queue_DeleteMessageBatch_Call{Call: _e.mock.On("DeleteMessageBatch", ctx, receiptHandles)} +} + +func (_c *Queue_DeleteMessageBatch_Call) Run(run func(ctx context.Context, receiptHandles []string)) *Queue_DeleteMessageBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *Queue_DeleteMessageBatch_Call) Return(_a0 error) *Queue_DeleteMessageBatch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Queue_DeleteMessageBatch_Call) RunAndReturn(run func(context.Context, []string) error) *Queue_DeleteMessageBatch_Call { + _c.Call.Return(run) + return _c +} + // GetArn provides a mock function with given fields: func (_m *Queue) GetArn() string { ret := _m.Called() @@ -58,6 +124,33 @@ func (_m *Queue) GetArn() string { return r0 } +// Queue_GetArn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArn' +type Queue_GetArn_Call struct { + *mock.Call +} + +// GetArn is a helper method to define mock.On call +func (_e *Queue_Expecter) GetArn() *Queue_GetArn_Call { + return &Queue_GetArn_Call{Call: _e.mock.On("GetArn")} +} + +func (_c *Queue_GetArn_Call) Run(run func()) *Queue_GetArn_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Queue_GetArn_Call) Return(_a0 string) *Queue_GetArn_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Queue_GetArn_Call) RunAndReturn(run func() string) *Queue_GetArn_Call { + _c.Call.Return(run) + return _c +} + // GetName provides a mock function with given fields: func (_m *Queue) GetName() string { ret := _m.Called() @@ -72,6 +165,33 @@ func (_m *Queue) GetName() string { return r0 } +// Queue_GetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetName' +type Queue_GetName_Call struct { + *mock.Call +} + +// GetName is a helper method to define mock.On call +func (_e *Queue_Expecter) GetName() *Queue_GetName_Call { + return &Queue_GetName_Call{Call: _e.mock.On("GetName")} +} + +func (_c *Queue_GetName_Call) Run(run func()) *Queue_GetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Queue_GetName_Call) Return(_a0 string) *Queue_GetName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Queue_GetName_Call) RunAndReturn(run func() string) *Queue_GetName_Call { + _c.Call.Return(run) + return _c +} + // GetUrl provides a mock function with given fields: func (_m *Queue) GetUrl() string { ret := _m.Called() @@ -86,6 +206,33 @@ func (_m *Queue) GetUrl() string { return r0 } +// Queue_GetUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUrl' +type Queue_GetUrl_Call struct { + *mock.Call +} + +// GetUrl is a helper method to define mock.On call +func (_e *Queue_Expecter) GetUrl() *Queue_GetUrl_Call { + return &Queue_GetUrl_Call{Call: _e.mock.On("GetUrl")} +} + +func (_c *Queue_GetUrl_Call) Run(run func()) *Queue_GetUrl_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Queue_GetUrl_Call) Return(_a0 string) *Queue_GetUrl_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Queue_GetUrl_Call) RunAndReturn(run func() string) *Queue_GetUrl_Call { + _c.Call.Return(run) + return _c +} + // Receive provides a mock function with given fields: ctx, maxNumberOfMessages, waitTime func (_m *Queue) Receive(ctx context.Context, maxNumberOfMessages int32, waitTime int32) ([]types.Message, error) { ret := _m.Called(ctx, maxNumberOfMessages, waitTime) @@ -112,6 +259,36 @@ func (_m *Queue) Receive(ctx context.Context, maxNumberOfMessages int32, waitTim return r0, r1 } +// Queue_Receive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Receive' +type Queue_Receive_Call struct { + *mock.Call +} + +// Receive is a helper method to define mock.On call +// - ctx context.Context +// - maxNumberOfMessages int32 +// - waitTime int32 +func (_e *Queue_Expecter) Receive(ctx interface{}, maxNumberOfMessages interface{}, waitTime interface{}) *Queue_Receive_Call { + return &Queue_Receive_Call{Call: _e.mock.On("Receive", ctx, maxNumberOfMessages, waitTime)} +} + +func (_c *Queue_Receive_Call) Run(run func(ctx context.Context, maxNumberOfMessages int32, waitTime int32)) *Queue_Receive_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int32), args[2].(int32)) + }) + return _c +} + +func (_c *Queue_Receive_Call) Return(_a0 []types.Message, _a1 error) *Queue_Receive_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Queue_Receive_Call) RunAndReturn(run func(context.Context, int32, int32) ([]types.Message, error)) *Queue_Receive_Call { + _c.Call.Return(run) + return _c +} + // Send provides a mock function with given fields: ctx, msg func (_m *Queue) Send(ctx context.Context, msg *sqs.Message) error { ret := _m.Called(ctx, msg) @@ -126,6 +303,35 @@ func (_m *Queue) Send(ctx context.Context, msg *sqs.Message) error { return r0 } +// Queue_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type Queue_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - ctx context.Context +// - msg *sqs.Message +func (_e *Queue_Expecter) Send(ctx interface{}, msg interface{}) *Queue_Send_Call { + return &Queue_Send_Call{Call: _e.mock.On("Send", ctx, msg)} +} + +func (_c *Queue_Send_Call) Run(run func(ctx context.Context, msg *sqs.Message)) *Queue_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*sqs.Message)) + }) + return _c +} + +func (_c *Queue_Send_Call) Return(_a0 error) *Queue_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Queue_Send_Call) RunAndReturn(run func(context.Context, *sqs.Message) error) *Queue_Send_Call { + _c.Call.Return(run) + return _c +} + // SendBatch provides a mock function with given fields: ctx, messages func (_m *Queue) SendBatch(ctx context.Context, messages []*sqs.Message) error { ret := _m.Called(ctx, messages) @@ -140,6 +346,35 @@ func (_m *Queue) SendBatch(ctx context.Context, messages []*sqs.Message) error { return r0 } +// Queue_SendBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendBatch' +type Queue_SendBatch_Call struct { + *mock.Call +} + +// SendBatch is a helper method to define mock.On call +// - ctx context.Context +// - messages []*sqs.Message +func (_e *Queue_Expecter) SendBatch(ctx interface{}, messages interface{}) *Queue_SendBatch_Call { + return &Queue_SendBatch_Call{Call: _e.mock.On("SendBatch", ctx, messages)} +} + +func (_c *Queue_SendBatch_Call) Run(run func(ctx context.Context, messages []*sqs.Message)) *Queue_SendBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*sqs.Message)) + }) + return _c +} + +func (_c *Queue_SendBatch_Call) Return(_a0 error) *Queue_SendBatch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Queue_SendBatch_Call) RunAndReturn(run func(context.Context, []*sqs.Message) error) *Queue_SendBatch_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewQueue interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/sqs/mocks/Service.go b/pkg/cloud/aws/sqs/mocks/Service.go index e2c0d0031..5db3a320d 100644 --- a/pkg/cloud/aws/sqs/mocks/Service.go +++ b/pkg/cloud/aws/sqs/mocks/Service.go @@ -14,6 +14,14 @@ type Service struct { mock.Mock } +type Service_Expecter struct { + mock *mock.Mock +} + +func (_m *Service) EXPECT() *Service_Expecter { + return &Service_Expecter{mock: &_m.Mock} +} + // CreateQueue provides a mock function with given fields: ctx, settings func (_m *Service) CreateQueue(ctx context.Context, settings *sqs.Settings) (*sqs.Properties, error) { ret := _m.Called(ctx, settings) @@ -40,6 +48,35 @@ func (_m *Service) CreateQueue(ctx context.Context, settings *sqs.Settings) (*sq return r0, r1 } +// Service_CreateQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateQueue' +type Service_CreateQueue_Call struct { + *mock.Call +} + +// CreateQueue is a helper method to define mock.On call +// - ctx context.Context +// - settings *sqs.Settings +func (_e *Service_Expecter) CreateQueue(ctx interface{}, settings interface{}) *Service_CreateQueue_Call { + return &Service_CreateQueue_Call{Call: _e.mock.On("CreateQueue", ctx, settings)} +} + +func (_c *Service_CreateQueue_Call) Run(run func(ctx context.Context, settings *sqs.Settings)) *Service_CreateQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*sqs.Settings)) + }) + return _c +} + +func (_c *Service_CreateQueue_Call) Return(_a0 *sqs.Properties, _a1 error) *Service_CreateQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_CreateQueue_Call) RunAndReturn(run func(context.Context, *sqs.Settings) (*sqs.Properties, error)) *Service_CreateQueue_Call { + _c.Call.Return(run) + return _c +} + // GetArn provides a mock function with given fields: ctx, url func (_m *Service) GetArn(ctx context.Context, url string) (string, error) { ret := _m.Called(ctx, url) @@ -64,6 +101,35 @@ func (_m *Service) GetArn(ctx context.Context, url string) (string, error) { return r0, r1 } +// Service_GetArn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArn' +type Service_GetArn_Call struct { + *mock.Call +} + +// GetArn is a helper method to define mock.On call +// - ctx context.Context +// - url string +func (_e *Service_Expecter) GetArn(ctx interface{}, url interface{}) *Service_GetArn_Call { + return &Service_GetArn_Call{Call: _e.mock.On("GetArn", ctx, url)} +} + +func (_c *Service_GetArn_Call) Run(run func(ctx context.Context, url string)) *Service_GetArn_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Service_GetArn_Call) Return(_a0 string, _a1 error) *Service_GetArn_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_GetArn_Call) RunAndReturn(run func(context.Context, string) (string, error)) *Service_GetArn_Call { + _c.Call.Return(run) + return _c +} + // GetPropertiesByArn provides a mock function with given fields: ctx, arn func (_m *Service) GetPropertiesByArn(ctx context.Context, arn string) (*sqs.Properties, error) { ret := _m.Called(ctx, arn) @@ -90,6 +156,35 @@ func (_m *Service) GetPropertiesByArn(ctx context.Context, arn string) (*sqs.Pro return r0, r1 } +// Service_GetPropertiesByArn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertiesByArn' +type Service_GetPropertiesByArn_Call struct { + *mock.Call +} + +// GetPropertiesByArn is a helper method to define mock.On call +// - ctx context.Context +// - arn string +func (_e *Service_Expecter) GetPropertiesByArn(ctx interface{}, arn interface{}) *Service_GetPropertiesByArn_Call { + return &Service_GetPropertiesByArn_Call{Call: _e.mock.On("GetPropertiesByArn", ctx, arn)} +} + +func (_c *Service_GetPropertiesByArn_Call) Run(run func(ctx context.Context, arn string)) *Service_GetPropertiesByArn_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Service_GetPropertiesByArn_Call) Return(_a0 *sqs.Properties, _a1 error) *Service_GetPropertiesByArn_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_GetPropertiesByArn_Call) RunAndReturn(run func(context.Context, string) (*sqs.Properties, error)) *Service_GetPropertiesByArn_Call { + _c.Call.Return(run) + return _c +} + // GetPropertiesByName provides a mock function with given fields: ctx, name func (_m *Service) GetPropertiesByName(ctx context.Context, name string) (*sqs.Properties, error) { ret := _m.Called(ctx, name) @@ -116,6 +211,35 @@ func (_m *Service) GetPropertiesByName(ctx context.Context, name string) (*sqs.P return r0, r1 } +// Service_GetPropertiesByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertiesByName' +type Service_GetPropertiesByName_Call struct { + *mock.Call +} + +// GetPropertiesByName is a helper method to define mock.On call +// - ctx context.Context +// - name string +func (_e *Service_Expecter) GetPropertiesByName(ctx interface{}, name interface{}) *Service_GetPropertiesByName_Call { + return &Service_GetPropertiesByName_Call{Call: _e.mock.On("GetPropertiesByName", ctx, name)} +} + +func (_c *Service_GetPropertiesByName_Call) Run(run func(ctx context.Context, name string)) *Service_GetPropertiesByName_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Service_GetPropertiesByName_Call) Return(_a0 *sqs.Properties, _a1 error) *Service_GetPropertiesByName_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_GetPropertiesByName_Call) RunAndReturn(run func(context.Context, string) (*sqs.Properties, error)) *Service_GetPropertiesByName_Call { + _c.Call.Return(run) + return _c +} + // GetUrl provides a mock function with given fields: ctx, name func (_m *Service) GetUrl(ctx context.Context, name string) (string, error) { ret := _m.Called(ctx, name) @@ -140,6 +264,35 @@ func (_m *Service) GetUrl(ctx context.Context, name string) (string, error) { return r0, r1 } +// Service_GetUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUrl' +type Service_GetUrl_Call struct { + *mock.Call +} + +// GetUrl is a helper method to define mock.On call +// - ctx context.Context +// - name string +func (_e *Service_Expecter) GetUrl(ctx interface{}, name interface{}) *Service_GetUrl_Call { + return &Service_GetUrl_Call{Call: _e.mock.On("GetUrl", ctx, name)} +} + +func (_c *Service_GetUrl_Call) Run(run func(ctx context.Context, name string)) *Service_GetUrl_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Service_GetUrl_Call) Return(_a0 string, _a1 error) *Service_GetUrl_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_GetUrl_Call) RunAndReturn(run func(context.Context, string) (string, error)) *Service_GetUrl_Call { + _c.Call.Return(run) + return _c +} + // Purge provides a mock function with given fields: ctx, url func (_m *Service) Purge(ctx context.Context, url string) error { ret := _m.Called(ctx, url) @@ -154,6 +307,35 @@ func (_m *Service) Purge(ctx context.Context, url string) error { return r0 } +// Service_Purge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Purge' +type Service_Purge_Call struct { + *mock.Call +} + +// Purge is a helper method to define mock.On call +// - ctx context.Context +// - url string +func (_e *Service_Expecter) Purge(ctx interface{}, url interface{}) *Service_Purge_Call { + return &Service_Purge_Call{Call: _e.mock.On("Purge", ctx, url)} +} + +func (_c *Service_Purge_Call) Run(run func(ctx context.Context, url string)) *Service_Purge_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Service_Purge_Call) Return(_a0 error) *Service_Purge_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Service_Purge_Call) RunAndReturn(run func(context.Context, string) error) *Service_Purge_Call { + _c.Call.Return(run) + return _c +} + // QueueExists provides a mock function with given fields: ctx, name func (_m *Service) QueueExists(ctx context.Context, name string) (bool, error) { ret := _m.Called(ctx, name) @@ -178,6 +360,35 @@ func (_m *Service) QueueExists(ctx context.Context, name string) (bool, error) { return r0, r1 } +// Service_QueueExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueueExists' +type Service_QueueExists_Call struct { + *mock.Call +} + +// QueueExists is a helper method to define mock.On call +// - ctx context.Context +// - name string +func (_e *Service_Expecter) QueueExists(ctx interface{}, name interface{}) *Service_QueueExists_Call { + return &Service_QueueExists_Call{Call: _e.mock.On("QueueExists", ctx, name)} +} + +func (_c *Service_QueueExists_Call) Run(run func(ctx context.Context, name string)) *Service_QueueExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Service_QueueExists_Call) Return(_a0 bool, _a1 error) *Service_QueueExists_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_QueueExists_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *Service_QueueExists_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewService interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/ssm/mocks/Client.go b/pkg/cloud/aws/ssm/mocks/Client.go index e8e880d83..350ab0272 100644 --- a/pkg/cloud/aws/ssm/mocks/Client.go +++ b/pkg/cloud/aws/ssm/mocks/Client.go @@ -14,6 +14,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // GetParameter provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetParameter(ctx context.Context, params *ssm.GetParameterInput, optFns ...func(*ssm.Options)) (*ssm.GetParameterOutput, error) { _va := make([]interface{}, len(optFns)) @@ -47,6 +55,43 @@ func (_m *Client) GetParameter(ctx context.Context, params *ssm.GetParameterInpu return r0, r1 } +// Client_GetParameter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParameter' +type Client_GetParameter_Call struct { + *mock.Call +} + +// GetParameter is a helper method to define mock.On call +// - ctx context.Context +// - params *ssm.GetParameterInput +// - optFns ...func(*ssm.Options) +func (_e *Client_Expecter) GetParameter(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetParameter_Call { + return &Client_GetParameter_Call{Call: _e.mock.On("GetParameter", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetParameter_Call) Run(run func(ctx context.Context, params *ssm.GetParameterInput, optFns ...func(*ssm.Options))) *Client_GetParameter_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ssm.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ssm.Options)) + } + } + run(args[0].(context.Context), args[1].(*ssm.GetParameterInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetParameter_Call) Return(_a0 *ssm.GetParameterOutput, _a1 error) *Client_GetParameter_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetParameter_Call) RunAndReturn(run func(context.Context, *ssm.GetParameterInput, ...func(*ssm.Options)) (*ssm.GetParameterOutput, error)) *Client_GetParameter_Call { + _c.Call.Return(run) + return _c +} + // GetParametersByPath provides a mock function with given fields: ctx, params, optFns func (_m *Client) GetParametersByPath(ctx context.Context, params *ssm.GetParametersByPathInput, optFns ...func(*ssm.Options)) (*ssm.GetParametersByPathOutput, error) { _va := make([]interface{}, len(optFns)) @@ -80,6 +125,43 @@ func (_m *Client) GetParametersByPath(ctx context.Context, params *ssm.GetParame return r0, r1 } +// Client_GetParametersByPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParametersByPath' +type Client_GetParametersByPath_Call struct { + *mock.Call +} + +// GetParametersByPath is a helper method to define mock.On call +// - ctx context.Context +// - params *ssm.GetParametersByPathInput +// - optFns ...func(*ssm.Options) +func (_e *Client_Expecter) GetParametersByPath(ctx interface{}, params interface{}, optFns ...interface{}) *Client_GetParametersByPath_Call { + return &Client_GetParametersByPath_Call{Call: _e.mock.On("GetParametersByPath", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *Client_GetParametersByPath_Call) Run(run func(ctx context.Context, params *ssm.GetParametersByPathInput, optFns ...func(*ssm.Options))) *Client_GetParametersByPath_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ssm.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ssm.Options)) + } + } + run(args[0].(context.Context), args[1].(*ssm.GetParametersByPathInput), variadicArgs...) + }) + return _c +} + +func (_c *Client_GetParametersByPath_Call) Return(_a0 *ssm.GetParametersByPathOutput, _a1 error) *Client_GetParametersByPath_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetParametersByPath_Call) RunAndReturn(run func(context.Context, *ssm.GetParametersByPathInput, ...func(*ssm.Options)) (*ssm.GetParametersByPathOutput, error)) *Client_GetParametersByPath_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/aws/ssm/mocks/SimpleSystemsManager.go b/pkg/cloud/aws/ssm/mocks/SimpleSystemsManager.go index 077ccce6e..c8f7cda15 100644 --- a/pkg/cloud/aws/ssm/mocks/SimpleSystemsManager.go +++ b/pkg/cloud/aws/ssm/mocks/SimpleSystemsManager.go @@ -14,6 +14,14 @@ type SimpleSystemsManager struct { mock.Mock } +type SimpleSystemsManager_Expecter struct { + mock *mock.Mock +} + +func (_m *SimpleSystemsManager) EXPECT() *SimpleSystemsManager_Expecter { + return &SimpleSystemsManager_Expecter{mock: &_m.Mock} +} + // GetParameter provides a mock function with given fields: ctx, path func (_m *SimpleSystemsManager) GetParameter(ctx context.Context, path string) (string, error) { ret := _m.Called(ctx, path) @@ -38,6 +46,35 @@ func (_m *SimpleSystemsManager) GetParameter(ctx context.Context, path string) ( return r0, r1 } +// SimpleSystemsManager_GetParameter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParameter' +type SimpleSystemsManager_GetParameter_Call struct { + *mock.Call +} + +// GetParameter is a helper method to define mock.On call +// - ctx context.Context +// - path string +func (_e *SimpleSystemsManager_Expecter) GetParameter(ctx interface{}, path interface{}) *SimpleSystemsManager_GetParameter_Call { + return &SimpleSystemsManager_GetParameter_Call{Call: _e.mock.On("GetParameter", ctx, path)} +} + +func (_c *SimpleSystemsManager_GetParameter_Call) Run(run func(ctx context.Context, path string)) *SimpleSystemsManager_GetParameter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *SimpleSystemsManager_GetParameter_Call) Return(_a0 string, _a1 error) *SimpleSystemsManager_GetParameter_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SimpleSystemsManager_GetParameter_Call) RunAndReturn(run func(context.Context, string) (string, error)) *SimpleSystemsManager_GetParameter_Call { + _c.Call.Return(run) + return _c +} + // GetParameters provides a mock function with given fields: ctx, path func (_m *SimpleSystemsManager) GetParameters(ctx context.Context, path string) (ssm.SsmParameters, error) { ret := _m.Called(ctx, path) @@ -64,6 +101,35 @@ func (_m *SimpleSystemsManager) GetParameters(ctx context.Context, path string) return r0, r1 } +// SimpleSystemsManager_GetParameters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParameters' +type SimpleSystemsManager_GetParameters_Call struct { + *mock.Call +} + +// GetParameters is a helper method to define mock.On call +// - ctx context.Context +// - path string +func (_e *SimpleSystemsManager_Expecter) GetParameters(ctx interface{}, path interface{}) *SimpleSystemsManager_GetParameters_Call { + return &SimpleSystemsManager_GetParameters_Call{Call: _e.mock.On("GetParameters", ctx, path)} +} + +func (_c *SimpleSystemsManager_GetParameters_Call) Run(run func(ctx context.Context, path string)) *SimpleSystemsManager_GetParameters_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *SimpleSystemsManager_GetParameters_Call) Return(_a0 ssm.SsmParameters, _a1 error) *SimpleSystemsManager_GetParameters_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SimpleSystemsManager_GetParameters_Call) RunAndReturn(run func(context.Context, string) (ssm.SsmParameters, error)) *SimpleSystemsManager_GetParameters_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewSimpleSystemsManager interface { mock.TestingT Cleanup(func()) diff --git a/pkg/cloud/mocks/LambdaApi.go b/pkg/cloud/mocks/LambdaApi.go index 7699b1792..138720dbd 100644 --- a/pkg/cloud/mocks/LambdaApi.go +++ b/pkg/cloud/mocks/LambdaApi.go @@ -16,6 +16,14 @@ type LambdaApi struct { mock.Mock } +type LambdaApi_Expecter struct { + mock *mock.Mock +} + +func (_m *LambdaApi) EXPECT() *LambdaApi_Expecter { + return &LambdaApi_Expecter{mock: &_m.Mock} +} + // AddLayerVersionPermission provides a mock function with given fields: _a0 func (_m *LambdaApi) AddLayerVersionPermission(_a0 *lambda.AddLayerVersionPermissionInput) (*lambda.AddLayerVersionPermissionOutput, error) { ret := _m.Called(_a0) @@ -42,6 +50,34 @@ func (_m *LambdaApi) AddLayerVersionPermission(_a0 *lambda.AddLayerVersionPermis return r0, r1 } +// LambdaApi_AddLayerVersionPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddLayerVersionPermission' +type LambdaApi_AddLayerVersionPermission_Call struct { + *mock.Call +} + +// AddLayerVersionPermission is a helper method to define mock.On call +// - _a0 *lambda.AddLayerVersionPermissionInput +func (_e *LambdaApi_Expecter) AddLayerVersionPermission(_a0 interface{}) *LambdaApi_AddLayerVersionPermission_Call { + return &LambdaApi_AddLayerVersionPermission_Call{Call: _e.mock.On("AddLayerVersionPermission", _a0)} +} + +func (_c *LambdaApi_AddLayerVersionPermission_Call) Run(run func(_a0 *lambda.AddLayerVersionPermissionInput)) *LambdaApi_AddLayerVersionPermission_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.AddLayerVersionPermissionInput)) + }) + return _c +} + +func (_c *LambdaApi_AddLayerVersionPermission_Call) Return(_a0 *lambda.AddLayerVersionPermissionOutput, _a1 error) *LambdaApi_AddLayerVersionPermission_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_AddLayerVersionPermission_Call) RunAndReturn(run func(*lambda.AddLayerVersionPermissionInput) (*lambda.AddLayerVersionPermissionOutput, error)) *LambdaApi_AddLayerVersionPermission_Call { + _c.Call.Return(run) + return _c +} + // AddLayerVersionPermissionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) AddLayerVersionPermissionRequest(_a0 *lambda.AddLayerVersionPermissionInput) (*request.Request, *lambda.AddLayerVersionPermissionOutput) { ret := _m.Called(_a0) @@ -70,6 +106,34 @@ func (_m *LambdaApi) AddLayerVersionPermissionRequest(_a0 *lambda.AddLayerVersio return r0, r1 } +// LambdaApi_AddLayerVersionPermissionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddLayerVersionPermissionRequest' +type LambdaApi_AddLayerVersionPermissionRequest_Call struct { + *mock.Call +} + +// AddLayerVersionPermissionRequest is a helper method to define mock.On call +// - _a0 *lambda.AddLayerVersionPermissionInput +func (_e *LambdaApi_Expecter) AddLayerVersionPermissionRequest(_a0 interface{}) *LambdaApi_AddLayerVersionPermissionRequest_Call { + return &LambdaApi_AddLayerVersionPermissionRequest_Call{Call: _e.mock.On("AddLayerVersionPermissionRequest", _a0)} +} + +func (_c *LambdaApi_AddLayerVersionPermissionRequest_Call) Run(run func(_a0 *lambda.AddLayerVersionPermissionInput)) *LambdaApi_AddLayerVersionPermissionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.AddLayerVersionPermissionInput)) + }) + return _c +} + +func (_c *LambdaApi_AddLayerVersionPermissionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.AddLayerVersionPermissionOutput) *LambdaApi_AddLayerVersionPermissionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_AddLayerVersionPermissionRequest_Call) RunAndReturn(run func(*lambda.AddLayerVersionPermissionInput) (*request.Request, *lambda.AddLayerVersionPermissionOutput)) *LambdaApi_AddLayerVersionPermissionRequest_Call { + _c.Call.Return(run) + return _c +} + // AddLayerVersionPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) AddLayerVersionPermissionWithContext(_a0 context.Context, _a1 *lambda.AddLayerVersionPermissionInput, _a2 ...request.Option) (*lambda.AddLayerVersionPermissionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -103,6 +167,43 @@ func (_m *LambdaApi) AddLayerVersionPermissionWithContext(_a0 context.Context, _ return r0, r1 } +// LambdaApi_AddLayerVersionPermissionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddLayerVersionPermissionWithContext' +type LambdaApi_AddLayerVersionPermissionWithContext_Call struct { + *mock.Call +} + +// AddLayerVersionPermissionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.AddLayerVersionPermissionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) AddLayerVersionPermissionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_AddLayerVersionPermissionWithContext_Call { + return &LambdaApi_AddLayerVersionPermissionWithContext_Call{Call: _e.mock.On("AddLayerVersionPermissionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_AddLayerVersionPermissionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.AddLayerVersionPermissionInput, _a2 ...request.Option)) *LambdaApi_AddLayerVersionPermissionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.AddLayerVersionPermissionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_AddLayerVersionPermissionWithContext_Call) Return(_a0 *lambda.AddLayerVersionPermissionOutput, _a1 error) *LambdaApi_AddLayerVersionPermissionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_AddLayerVersionPermissionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.AddLayerVersionPermissionInput, ...request.Option) (*lambda.AddLayerVersionPermissionOutput, error)) *LambdaApi_AddLayerVersionPermissionWithContext_Call { + _c.Call.Return(run) + return _c +} + // AddPermission provides a mock function with given fields: _a0 func (_m *LambdaApi) AddPermission(_a0 *lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error) { ret := _m.Called(_a0) @@ -129,6 +230,34 @@ func (_m *LambdaApi) AddPermission(_a0 *lambda.AddPermissionInput) (*lambda.AddP return r0, r1 } +// LambdaApi_AddPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPermission' +type LambdaApi_AddPermission_Call struct { + *mock.Call +} + +// AddPermission is a helper method to define mock.On call +// - _a0 *lambda.AddPermissionInput +func (_e *LambdaApi_Expecter) AddPermission(_a0 interface{}) *LambdaApi_AddPermission_Call { + return &LambdaApi_AddPermission_Call{Call: _e.mock.On("AddPermission", _a0)} +} + +func (_c *LambdaApi_AddPermission_Call) Run(run func(_a0 *lambda.AddPermissionInput)) *LambdaApi_AddPermission_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.AddPermissionInput)) + }) + return _c +} + +func (_c *LambdaApi_AddPermission_Call) Return(_a0 *lambda.AddPermissionOutput, _a1 error) *LambdaApi_AddPermission_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_AddPermission_Call) RunAndReturn(run func(*lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error)) *LambdaApi_AddPermission_Call { + _c.Call.Return(run) + return _c +} + // AddPermissionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) AddPermissionRequest(_a0 *lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput) { ret := _m.Called(_a0) @@ -157,6 +286,34 @@ func (_m *LambdaApi) AddPermissionRequest(_a0 *lambda.AddPermissionInput) (*requ return r0, r1 } +// LambdaApi_AddPermissionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPermissionRequest' +type LambdaApi_AddPermissionRequest_Call struct { + *mock.Call +} + +// AddPermissionRequest is a helper method to define mock.On call +// - _a0 *lambda.AddPermissionInput +func (_e *LambdaApi_Expecter) AddPermissionRequest(_a0 interface{}) *LambdaApi_AddPermissionRequest_Call { + return &LambdaApi_AddPermissionRequest_Call{Call: _e.mock.On("AddPermissionRequest", _a0)} +} + +func (_c *LambdaApi_AddPermissionRequest_Call) Run(run func(_a0 *lambda.AddPermissionInput)) *LambdaApi_AddPermissionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.AddPermissionInput)) + }) + return _c +} + +func (_c *LambdaApi_AddPermissionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.AddPermissionOutput) *LambdaApi_AddPermissionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_AddPermissionRequest_Call) RunAndReturn(run func(*lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput)) *LambdaApi_AddPermissionRequest_Call { + _c.Call.Return(run) + return _c +} + // AddPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) AddPermissionWithContext(_a0 context.Context, _a1 *lambda.AddPermissionInput, _a2 ...request.Option) (*lambda.AddPermissionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -190,6 +347,43 @@ func (_m *LambdaApi) AddPermissionWithContext(_a0 context.Context, _a1 *lambda.A return r0, r1 } +// LambdaApi_AddPermissionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPermissionWithContext' +type LambdaApi_AddPermissionWithContext_Call struct { + *mock.Call +} + +// AddPermissionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.AddPermissionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) AddPermissionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_AddPermissionWithContext_Call { + return &LambdaApi_AddPermissionWithContext_Call{Call: _e.mock.On("AddPermissionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_AddPermissionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.AddPermissionInput, _a2 ...request.Option)) *LambdaApi_AddPermissionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.AddPermissionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_AddPermissionWithContext_Call) Return(_a0 *lambda.AddPermissionOutput, _a1 error) *LambdaApi_AddPermissionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_AddPermissionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.AddPermissionInput, ...request.Option) (*lambda.AddPermissionOutput, error)) *LambdaApi_AddPermissionWithContext_Call { + _c.Call.Return(run) + return _c +} + // CreateAlias provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateAlias(_a0 *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) { ret := _m.Called(_a0) @@ -216,6 +410,34 @@ func (_m *LambdaApi) CreateAlias(_a0 *lambda.CreateAliasInput) (*lambda.AliasCon return r0, r1 } +// LambdaApi_CreateAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAlias' +type LambdaApi_CreateAlias_Call struct { + *mock.Call +} + +// CreateAlias is a helper method to define mock.On call +// - _a0 *lambda.CreateAliasInput +func (_e *LambdaApi_Expecter) CreateAlias(_a0 interface{}) *LambdaApi_CreateAlias_Call { + return &LambdaApi_CreateAlias_Call{Call: _e.mock.On("CreateAlias", _a0)} +} + +func (_c *LambdaApi_CreateAlias_Call) Run(run func(_a0 *lambda.CreateAliasInput)) *LambdaApi_CreateAlias_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateAliasInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateAlias_Call) Return(_a0 *lambda.AliasConfiguration, _a1 error) *LambdaApi_CreateAlias_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateAlias_Call) RunAndReturn(run func(*lambda.CreateAliasInput) (*lambda.AliasConfiguration, error)) *LambdaApi_CreateAlias_Call { + _c.Call.Return(run) + return _c +} + // CreateAliasRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateAliasRequest(_a0 *lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration) { ret := _m.Called(_a0) @@ -244,6 +466,34 @@ func (_m *LambdaApi) CreateAliasRequest(_a0 *lambda.CreateAliasInput) (*request. return r0, r1 } +// LambdaApi_CreateAliasRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAliasRequest' +type LambdaApi_CreateAliasRequest_Call struct { + *mock.Call +} + +// CreateAliasRequest is a helper method to define mock.On call +// - _a0 *lambda.CreateAliasInput +func (_e *LambdaApi_Expecter) CreateAliasRequest(_a0 interface{}) *LambdaApi_CreateAliasRequest_Call { + return &LambdaApi_CreateAliasRequest_Call{Call: _e.mock.On("CreateAliasRequest", _a0)} +} + +func (_c *LambdaApi_CreateAliasRequest_Call) Run(run func(_a0 *lambda.CreateAliasInput)) *LambdaApi_CreateAliasRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateAliasInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateAliasRequest_Call) Return(_a0 *request.Request, _a1 *lambda.AliasConfiguration) *LambdaApi_CreateAliasRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateAliasRequest_Call) RunAndReturn(run func(*lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration)) *LambdaApi_CreateAliasRequest_Call { + _c.Call.Return(run) + return _c +} + // CreateAliasWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) CreateAliasWithContext(_a0 context.Context, _a1 *lambda.CreateAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -277,6 +527,43 @@ func (_m *LambdaApi) CreateAliasWithContext(_a0 context.Context, _a1 *lambda.Cre return r0, r1 } +// LambdaApi_CreateAliasWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAliasWithContext' +type LambdaApi_CreateAliasWithContext_Call struct { + *mock.Call +} + +// CreateAliasWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.CreateAliasInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) CreateAliasWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_CreateAliasWithContext_Call { + return &LambdaApi_CreateAliasWithContext_Call{Call: _e.mock.On("CreateAliasWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_CreateAliasWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.CreateAliasInput, _a2 ...request.Option)) *LambdaApi_CreateAliasWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.CreateAliasInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_CreateAliasWithContext_Call) Return(_a0 *lambda.AliasConfiguration, _a1 error) *LambdaApi_CreateAliasWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateAliasWithContext_Call) RunAndReturn(run func(context.Context, *lambda.CreateAliasInput, ...request.Option) (*lambda.AliasConfiguration, error)) *LambdaApi_CreateAliasWithContext_Call { + _c.Call.Return(run) + return _c +} + // CreateCodeSigningConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateCodeSigningConfig(_a0 *lambda.CreateCodeSigningConfigInput) (*lambda.CreateCodeSigningConfigOutput, error) { ret := _m.Called(_a0) @@ -303,6 +590,34 @@ func (_m *LambdaApi) CreateCodeSigningConfig(_a0 *lambda.CreateCodeSigningConfig return r0, r1 } +// LambdaApi_CreateCodeSigningConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCodeSigningConfig' +type LambdaApi_CreateCodeSigningConfig_Call struct { + *mock.Call +} + +// CreateCodeSigningConfig is a helper method to define mock.On call +// - _a0 *lambda.CreateCodeSigningConfigInput +func (_e *LambdaApi_Expecter) CreateCodeSigningConfig(_a0 interface{}) *LambdaApi_CreateCodeSigningConfig_Call { + return &LambdaApi_CreateCodeSigningConfig_Call{Call: _e.mock.On("CreateCodeSigningConfig", _a0)} +} + +func (_c *LambdaApi_CreateCodeSigningConfig_Call) Run(run func(_a0 *lambda.CreateCodeSigningConfigInput)) *LambdaApi_CreateCodeSigningConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateCodeSigningConfig_Call) Return(_a0 *lambda.CreateCodeSigningConfigOutput, _a1 error) *LambdaApi_CreateCodeSigningConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateCodeSigningConfig_Call) RunAndReturn(run func(*lambda.CreateCodeSigningConfigInput) (*lambda.CreateCodeSigningConfigOutput, error)) *LambdaApi_CreateCodeSigningConfig_Call { + _c.Call.Return(run) + return _c +} + // CreateCodeSigningConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateCodeSigningConfigRequest(_a0 *lambda.CreateCodeSigningConfigInput) (*request.Request, *lambda.CreateCodeSigningConfigOutput) { ret := _m.Called(_a0) @@ -331,6 +646,34 @@ func (_m *LambdaApi) CreateCodeSigningConfigRequest(_a0 *lambda.CreateCodeSignin return r0, r1 } +// LambdaApi_CreateCodeSigningConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCodeSigningConfigRequest' +type LambdaApi_CreateCodeSigningConfigRequest_Call struct { + *mock.Call +} + +// CreateCodeSigningConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.CreateCodeSigningConfigInput +func (_e *LambdaApi_Expecter) CreateCodeSigningConfigRequest(_a0 interface{}) *LambdaApi_CreateCodeSigningConfigRequest_Call { + return &LambdaApi_CreateCodeSigningConfigRequest_Call{Call: _e.mock.On("CreateCodeSigningConfigRequest", _a0)} +} + +func (_c *LambdaApi_CreateCodeSigningConfigRequest_Call) Run(run func(_a0 *lambda.CreateCodeSigningConfigInput)) *LambdaApi_CreateCodeSigningConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateCodeSigningConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.CreateCodeSigningConfigOutput) *LambdaApi_CreateCodeSigningConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateCodeSigningConfigRequest_Call) RunAndReturn(run func(*lambda.CreateCodeSigningConfigInput) (*request.Request, *lambda.CreateCodeSigningConfigOutput)) *LambdaApi_CreateCodeSigningConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // CreateCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) CreateCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.CreateCodeSigningConfigInput, _a2 ...request.Option) (*lambda.CreateCodeSigningConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -364,6 +707,43 @@ func (_m *LambdaApi) CreateCodeSigningConfigWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_CreateCodeSigningConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCodeSigningConfigWithContext' +type LambdaApi_CreateCodeSigningConfigWithContext_Call struct { + *mock.Call +} + +// CreateCodeSigningConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.CreateCodeSigningConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) CreateCodeSigningConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_CreateCodeSigningConfigWithContext_Call { + return &LambdaApi_CreateCodeSigningConfigWithContext_Call{Call: _e.mock.On("CreateCodeSigningConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_CreateCodeSigningConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.CreateCodeSigningConfigInput, _a2 ...request.Option)) *LambdaApi_CreateCodeSigningConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.CreateCodeSigningConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_CreateCodeSigningConfigWithContext_Call) Return(_a0 *lambda.CreateCodeSigningConfigOutput, _a1 error) *LambdaApi_CreateCodeSigningConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateCodeSigningConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.CreateCodeSigningConfigInput, ...request.Option) (*lambda.CreateCodeSigningConfigOutput, error)) *LambdaApi_CreateCodeSigningConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // CreateEventSourceMapping provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateEventSourceMapping(_a0 *lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) { ret := _m.Called(_a0) @@ -390,6 +770,34 @@ func (_m *LambdaApi) CreateEventSourceMapping(_a0 *lambda.CreateEventSourceMappi return r0, r1 } +// LambdaApi_CreateEventSourceMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEventSourceMapping' +type LambdaApi_CreateEventSourceMapping_Call struct { + *mock.Call +} + +// CreateEventSourceMapping is a helper method to define mock.On call +// - _a0 *lambda.CreateEventSourceMappingInput +func (_e *LambdaApi_Expecter) CreateEventSourceMapping(_a0 interface{}) *LambdaApi_CreateEventSourceMapping_Call { + return &LambdaApi_CreateEventSourceMapping_Call{Call: _e.mock.On("CreateEventSourceMapping", _a0)} +} + +func (_c *LambdaApi_CreateEventSourceMapping_Call) Run(run func(_a0 *lambda.CreateEventSourceMappingInput)) *LambdaApi_CreateEventSourceMapping_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateEventSourceMappingInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateEventSourceMapping_Call) Return(_a0 *lambda.EventSourceMappingConfiguration, _a1 error) *LambdaApi_CreateEventSourceMapping_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateEventSourceMapping_Call) RunAndReturn(run func(*lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error)) *LambdaApi_CreateEventSourceMapping_Call { + _c.Call.Return(run) + return _c +} + // CreateEventSourceMappingRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateEventSourceMappingRequest(_a0 *lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) { ret := _m.Called(_a0) @@ -418,6 +826,34 @@ func (_m *LambdaApi) CreateEventSourceMappingRequest(_a0 *lambda.CreateEventSour return r0, r1 } +// LambdaApi_CreateEventSourceMappingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEventSourceMappingRequest' +type LambdaApi_CreateEventSourceMappingRequest_Call struct { + *mock.Call +} + +// CreateEventSourceMappingRequest is a helper method to define mock.On call +// - _a0 *lambda.CreateEventSourceMappingInput +func (_e *LambdaApi_Expecter) CreateEventSourceMappingRequest(_a0 interface{}) *LambdaApi_CreateEventSourceMappingRequest_Call { + return &LambdaApi_CreateEventSourceMappingRequest_Call{Call: _e.mock.On("CreateEventSourceMappingRequest", _a0)} +} + +func (_c *LambdaApi_CreateEventSourceMappingRequest_Call) Run(run func(_a0 *lambda.CreateEventSourceMappingInput)) *LambdaApi_CreateEventSourceMappingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateEventSourceMappingInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateEventSourceMappingRequest_Call) Return(_a0 *request.Request, _a1 *lambda.EventSourceMappingConfiguration) *LambdaApi_CreateEventSourceMappingRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateEventSourceMappingRequest_Call) RunAndReturn(run func(*lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration)) *LambdaApi_CreateEventSourceMappingRequest_Call { + _c.Call.Return(run) + return _c +} + // CreateEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) CreateEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.CreateEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -451,6 +887,43 @@ func (_m *LambdaApi) CreateEventSourceMappingWithContext(_a0 context.Context, _a return r0, r1 } +// LambdaApi_CreateEventSourceMappingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEventSourceMappingWithContext' +type LambdaApi_CreateEventSourceMappingWithContext_Call struct { + *mock.Call +} + +// CreateEventSourceMappingWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.CreateEventSourceMappingInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) CreateEventSourceMappingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_CreateEventSourceMappingWithContext_Call { + return &LambdaApi_CreateEventSourceMappingWithContext_Call{Call: _e.mock.On("CreateEventSourceMappingWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_CreateEventSourceMappingWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.CreateEventSourceMappingInput, _a2 ...request.Option)) *LambdaApi_CreateEventSourceMappingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.CreateEventSourceMappingInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_CreateEventSourceMappingWithContext_Call) Return(_a0 *lambda.EventSourceMappingConfiguration, _a1 error) *LambdaApi_CreateEventSourceMappingWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateEventSourceMappingWithContext_Call) RunAndReturn(run func(context.Context, *lambda.CreateEventSourceMappingInput, ...request.Option) (*lambda.EventSourceMappingConfiguration, error)) *LambdaApi_CreateEventSourceMappingWithContext_Call { + _c.Call.Return(run) + return _c +} + // CreateFunction provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateFunction(_a0 *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) { ret := _m.Called(_a0) @@ -477,6 +950,34 @@ func (_m *LambdaApi) CreateFunction(_a0 *lambda.CreateFunctionInput) (*lambda.Fu return r0, r1 } +// LambdaApi_CreateFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFunction' +type LambdaApi_CreateFunction_Call struct { + *mock.Call +} + +// CreateFunction is a helper method to define mock.On call +// - _a0 *lambda.CreateFunctionInput +func (_e *LambdaApi_Expecter) CreateFunction(_a0 interface{}) *LambdaApi_CreateFunction_Call { + return &LambdaApi_CreateFunction_Call{Call: _e.mock.On("CreateFunction", _a0)} +} + +func (_c *LambdaApi_CreateFunction_Call) Run(run func(_a0 *lambda.CreateFunctionInput)) *LambdaApi_CreateFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateFunction_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_CreateFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateFunction_Call) RunAndReturn(run func(*lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error)) *LambdaApi_CreateFunction_Call { + _c.Call.Return(run) + return _c +} + // CreateFunctionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateFunctionRequest(_a0 *lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration) { ret := _m.Called(_a0) @@ -505,6 +1006,34 @@ func (_m *LambdaApi) CreateFunctionRequest(_a0 *lambda.CreateFunctionInput) (*re return r0, r1 } +// LambdaApi_CreateFunctionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFunctionRequest' +type LambdaApi_CreateFunctionRequest_Call struct { + *mock.Call +} + +// CreateFunctionRequest is a helper method to define mock.On call +// - _a0 *lambda.CreateFunctionInput +func (_e *LambdaApi_Expecter) CreateFunctionRequest(_a0 interface{}) *LambdaApi_CreateFunctionRequest_Call { + return &LambdaApi_CreateFunctionRequest_Call{Call: _e.mock.On("CreateFunctionRequest", _a0)} +} + +func (_c *LambdaApi_CreateFunctionRequest_Call) Run(run func(_a0 *lambda.CreateFunctionInput)) *LambdaApi_CreateFunctionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateFunctionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.FunctionConfiguration) *LambdaApi_CreateFunctionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateFunctionRequest_Call) RunAndReturn(run func(*lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration)) *LambdaApi_CreateFunctionRequest_Call { + _c.Call.Return(run) + return _c +} + // CreateFunctionUrlConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateFunctionUrlConfig(_a0 *lambda.CreateFunctionUrlConfigInput) (*lambda.CreateFunctionUrlConfigOutput, error) { ret := _m.Called(_a0) @@ -531,6 +1060,34 @@ func (_m *LambdaApi) CreateFunctionUrlConfig(_a0 *lambda.CreateFunctionUrlConfig return r0, r1 } +// LambdaApi_CreateFunctionUrlConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFunctionUrlConfig' +type LambdaApi_CreateFunctionUrlConfig_Call struct { + *mock.Call +} + +// CreateFunctionUrlConfig is a helper method to define mock.On call +// - _a0 *lambda.CreateFunctionUrlConfigInput +func (_e *LambdaApi_Expecter) CreateFunctionUrlConfig(_a0 interface{}) *LambdaApi_CreateFunctionUrlConfig_Call { + return &LambdaApi_CreateFunctionUrlConfig_Call{Call: _e.mock.On("CreateFunctionUrlConfig", _a0)} +} + +func (_c *LambdaApi_CreateFunctionUrlConfig_Call) Run(run func(_a0 *lambda.CreateFunctionUrlConfigInput)) *LambdaApi_CreateFunctionUrlConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateFunctionUrlConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateFunctionUrlConfig_Call) Return(_a0 *lambda.CreateFunctionUrlConfigOutput, _a1 error) *LambdaApi_CreateFunctionUrlConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateFunctionUrlConfig_Call) RunAndReturn(run func(*lambda.CreateFunctionUrlConfigInput) (*lambda.CreateFunctionUrlConfigOutput, error)) *LambdaApi_CreateFunctionUrlConfig_Call { + _c.Call.Return(run) + return _c +} + // CreateFunctionUrlConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) CreateFunctionUrlConfigRequest(_a0 *lambda.CreateFunctionUrlConfigInput) (*request.Request, *lambda.CreateFunctionUrlConfigOutput) { ret := _m.Called(_a0) @@ -559,6 +1116,34 @@ func (_m *LambdaApi) CreateFunctionUrlConfigRequest(_a0 *lambda.CreateFunctionUr return r0, r1 } +// LambdaApi_CreateFunctionUrlConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFunctionUrlConfigRequest' +type LambdaApi_CreateFunctionUrlConfigRequest_Call struct { + *mock.Call +} + +// CreateFunctionUrlConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.CreateFunctionUrlConfigInput +func (_e *LambdaApi_Expecter) CreateFunctionUrlConfigRequest(_a0 interface{}) *LambdaApi_CreateFunctionUrlConfigRequest_Call { + return &LambdaApi_CreateFunctionUrlConfigRequest_Call{Call: _e.mock.On("CreateFunctionUrlConfigRequest", _a0)} +} + +func (_c *LambdaApi_CreateFunctionUrlConfigRequest_Call) Run(run func(_a0 *lambda.CreateFunctionUrlConfigInput)) *LambdaApi_CreateFunctionUrlConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.CreateFunctionUrlConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_CreateFunctionUrlConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.CreateFunctionUrlConfigOutput) *LambdaApi_CreateFunctionUrlConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateFunctionUrlConfigRequest_Call) RunAndReturn(run func(*lambda.CreateFunctionUrlConfigInput) (*request.Request, *lambda.CreateFunctionUrlConfigOutput)) *LambdaApi_CreateFunctionUrlConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // CreateFunctionUrlConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) CreateFunctionUrlConfigWithContext(_a0 context.Context, _a1 *lambda.CreateFunctionUrlConfigInput, _a2 ...request.Option) (*lambda.CreateFunctionUrlConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -592,6 +1177,43 @@ func (_m *LambdaApi) CreateFunctionUrlConfigWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_CreateFunctionUrlConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFunctionUrlConfigWithContext' +type LambdaApi_CreateFunctionUrlConfigWithContext_Call struct { + *mock.Call +} + +// CreateFunctionUrlConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.CreateFunctionUrlConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) CreateFunctionUrlConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_CreateFunctionUrlConfigWithContext_Call { + return &LambdaApi_CreateFunctionUrlConfigWithContext_Call{Call: _e.mock.On("CreateFunctionUrlConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_CreateFunctionUrlConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.CreateFunctionUrlConfigInput, _a2 ...request.Option)) *LambdaApi_CreateFunctionUrlConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.CreateFunctionUrlConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_CreateFunctionUrlConfigWithContext_Call) Return(_a0 *lambda.CreateFunctionUrlConfigOutput, _a1 error) *LambdaApi_CreateFunctionUrlConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateFunctionUrlConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.CreateFunctionUrlConfigInput, ...request.Option) (*lambda.CreateFunctionUrlConfigOutput, error)) *LambdaApi_CreateFunctionUrlConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // CreateFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) CreateFunctionWithContext(_a0 context.Context, _a1 *lambda.CreateFunctionInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -625,6 +1247,43 @@ func (_m *LambdaApi) CreateFunctionWithContext(_a0 context.Context, _a1 *lambda. return r0, r1 } +// LambdaApi_CreateFunctionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFunctionWithContext' +type LambdaApi_CreateFunctionWithContext_Call struct { + *mock.Call +} + +// CreateFunctionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.CreateFunctionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) CreateFunctionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_CreateFunctionWithContext_Call { + return &LambdaApi_CreateFunctionWithContext_Call{Call: _e.mock.On("CreateFunctionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_CreateFunctionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.CreateFunctionInput, _a2 ...request.Option)) *LambdaApi_CreateFunctionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.CreateFunctionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_CreateFunctionWithContext_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_CreateFunctionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_CreateFunctionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.CreateFunctionInput, ...request.Option) (*lambda.FunctionConfiguration, error)) *LambdaApi_CreateFunctionWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteAlias provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteAlias(_a0 *lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error) { ret := _m.Called(_a0) @@ -651,6 +1310,34 @@ func (_m *LambdaApi) DeleteAlias(_a0 *lambda.DeleteAliasInput) (*lambda.DeleteAl return r0, r1 } +// LambdaApi_DeleteAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAlias' +type LambdaApi_DeleteAlias_Call struct { + *mock.Call +} + +// DeleteAlias is a helper method to define mock.On call +// - _a0 *lambda.DeleteAliasInput +func (_e *LambdaApi_Expecter) DeleteAlias(_a0 interface{}) *LambdaApi_DeleteAlias_Call { + return &LambdaApi_DeleteAlias_Call{Call: _e.mock.On("DeleteAlias", _a0)} +} + +func (_c *LambdaApi_DeleteAlias_Call) Run(run func(_a0 *lambda.DeleteAliasInput)) *LambdaApi_DeleteAlias_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteAliasInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteAlias_Call) Return(_a0 *lambda.DeleteAliasOutput, _a1 error) *LambdaApi_DeleteAlias_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteAlias_Call) RunAndReturn(run func(*lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error)) *LambdaApi_DeleteAlias_Call { + _c.Call.Return(run) + return _c +} + // DeleteAliasRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteAliasRequest(_a0 *lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput) { ret := _m.Called(_a0) @@ -679,6 +1366,34 @@ func (_m *LambdaApi) DeleteAliasRequest(_a0 *lambda.DeleteAliasInput) (*request. return r0, r1 } +// LambdaApi_DeleteAliasRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAliasRequest' +type LambdaApi_DeleteAliasRequest_Call struct { + *mock.Call +} + +// DeleteAliasRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteAliasInput +func (_e *LambdaApi_Expecter) DeleteAliasRequest(_a0 interface{}) *LambdaApi_DeleteAliasRequest_Call { + return &LambdaApi_DeleteAliasRequest_Call{Call: _e.mock.On("DeleteAliasRequest", _a0)} +} + +func (_c *LambdaApi_DeleteAliasRequest_Call) Run(run func(_a0 *lambda.DeleteAliasInput)) *LambdaApi_DeleteAliasRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteAliasInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteAliasRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteAliasOutput) *LambdaApi_DeleteAliasRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteAliasRequest_Call) RunAndReturn(run func(*lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput)) *LambdaApi_DeleteAliasRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteAliasWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteAliasWithContext(_a0 context.Context, _a1 *lambda.DeleteAliasInput, _a2 ...request.Option) (*lambda.DeleteAliasOutput, error) { _va := make([]interface{}, len(_a2)) @@ -712,6 +1427,43 @@ func (_m *LambdaApi) DeleteAliasWithContext(_a0 context.Context, _a1 *lambda.Del return r0, r1 } +// LambdaApi_DeleteAliasWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAliasWithContext' +type LambdaApi_DeleteAliasWithContext_Call struct { + *mock.Call +} + +// DeleteAliasWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteAliasInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteAliasWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteAliasWithContext_Call { + return &LambdaApi_DeleteAliasWithContext_Call{Call: _e.mock.On("DeleteAliasWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteAliasWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteAliasInput, _a2 ...request.Option)) *LambdaApi_DeleteAliasWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteAliasInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteAliasWithContext_Call) Return(_a0 *lambda.DeleteAliasOutput, _a1 error) *LambdaApi_DeleteAliasWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteAliasWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteAliasInput, ...request.Option) (*lambda.DeleteAliasOutput, error)) *LambdaApi_DeleteAliasWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteCodeSigningConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteCodeSigningConfig(_a0 *lambda.DeleteCodeSigningConfigInput) (*lambda.DeleteCodeSigningConfigOutput, error) { ret := _m.Called(_a0) @@ -738,9 +1490,37 @@ func (_m *LambdaApi) DeleteCodeSigningConfig(_a0 *lambda.DeleteCodeSigningConfig return r0, r1 } -// DeleteCodeSigningConfigRequest provides a mock function with given fields: _a0 -func (_m *LambdaApi) DeleteCodeSigningConfigRequest(_a0 *lambda.DeleteCodeSigningConfigInput) (*request.Request, *lambda.DeleteCodeSigningConfigOutput) { - ret := _m.Called(_a0) +// LambdaApi_DeleteCodeSigningConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCodeSigningConfig' +type LambdaApi_DeleteCodeSigningConfig_Call struct { + *mock.Call +} + +// DeleteCodeSigningConfig is a helper method to define mock.On call +// - _a0 *lambda.DeleteCodeSigningConfigInput +func (_e *LambdaApi_Expecter) DeleteCodeSigningConfig(_a0 interface{}) *LambdaApi_DeleteCodeSigningConfig_Call { + return &LambdaApi_DeleteCodeSigningConfig_Call{Call: _e.mock.On("DeleteCodeSigningConfig", _a0)} +} + +func (_c *LambdaApi_DeleteCodeSigningConfig_Call) Run(run func(_a0 *lambda.DeleteCodeSigningConfigInput)) *LambdaApi_DeleteCodeSigningConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteCodeSigningConfig_Call) Return(_a0 *lambda.DeleteCodeSigningConfigOutput, _a1 error) *LambdaApi_DeleteCodeSigningConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteCodeSigningConfig_Call) RunAndReturn(run func(*lambda.DeleteCodeSigningConfigInput) (*lambda.DeleteCodeSigningConfigOutput, error)) *LambdaApi_DeleteCodeSigningConfig_Call { + _c.Call.Return(run) + return _c +} + +// DeleteCodeSigningConfigRequest provides a mock function with given fields: _a0 +func (_m *LambdaApi) DeleteCodeSigningConfigRequest(_a0 *lambda.DeleteCodeSigningConfigInput) (*request.Request, *lambda.DeleteCodeSigningConfigOutput) { + ret := _m.Called(_a0) var r0 *request.Request var r1 *lambda.DeleteCodeSigningConfigOutput @@ -766,6 +1546,34 @@ func (_m *LambdaApi) DeleteCodeSigningConfigRequest(_a0 *lambda.DeleteCodeSignin return r0, r1 } +// LambdaApi_DeleteCodeSigningConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCodeSigningConfigRequest' +type LambdaApi_DeleteCodeSigningConfigRequest_Call struct { + *mock.Call +} + +// DeleteCodeSigningConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteCodeSigningConfigInput +func (_e *LambdaApi_Expecter) DeleteCodeSigningConfigRequest(_a0 interface{}) *LambdaApi_DeleteCodeSigningConfigRequest_Call { + return &LambdaApi_DeleteCodeSigningConfigRequest_Call{Call: _e.mock.On("DeleteCodeSigningConfigRequest", _a0)} +} + +func (_c *LambdaApi_DeleteCodeSigningConfigRequest_Call) Run(run func(_a0 *lambda.DeleteCodeSigningConfigInput)) *LambdaApi_DeleteCodeSigningConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteCodeSigningConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteCodeSigningConfigOutput) *LambdaApi_DeleteCodeSigningConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteCodeSigningConfigRequest_Call) RunAndReturn(run func(*lambda.DeleteCodeSigningConfigInput) (*request.Request, *lambda.DeleteCodeSigningConfigOutput)) *LambdaApi_DeleteCodeSigningConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteCodeSigningConfigInput, _a2 ...request.Option) (*lambda.DeleteCodeSigningConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -799,6 +1607,43 @@ func (_m *LambdaApi) DeleteCodeSigningConfigWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_DeleteCodeSigningConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCodeSigningConfigWithContext' +type LambdaApi_DeleteCodeSigningConfigWithContext_Call struct { + *mock.Call +} + +// DeleteCodeSigningConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteCodeSigningConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteCodeSigningConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteCodeSigningConfigWithContext_Call { + return &LambdaApi_DeleteCodeSigningConfigWithContext_Call{Call: _e.mock.On("DeleteCodeSigningConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteCodeSigningConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteCodeSigningConfigInput, _a2 ...request.Option)) *LambdaApi_DeleteCodeSigningConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteCodeSigningConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteCodeSigningConfigWithContext_Call) Return(_a0 *lambda.DeleteCodeSigningConfigOutput, _a1 error) *LambdaApi_DeleteCodeSigningConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteCodeSigningConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteCodeSigningConfigInput, ...request.Option) (*lambda.DeleteCodeSigningConfigOutput, error)) *LambdaApi_DeleteCodeSigningConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteEventSourceMapping provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteEventSourceMapping(_a0 *lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) { ret := _m.Called(_a0) @@ -825,6 +1670,34 @@ func (_m *LambdaApi) DeleteEventSourceMapping(_a0 *lambda.DeleteEventSourceMappi return r0, r1 } +// LambdaApi_DeleteEventSourceMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteEventSourceMapping' +type LambdaApi_DeleteEventSourceMapping_Call struct { + *mock.Call +} + +// DeleteEventSourceMapping is a helper method to define mock.On call +// - _a0 *lambda.DeleteEventSourceMappingInput +func (_e *LambdaApi_Expecter) DeleteEventSourceMapping(_a0 interface{}) *LambdaApi_DeleteEventSourceMapping_Call { + return &LambdaApi_DeleteEventSourceMapping_Call{Call: _e.mock.On("DeleteEventSourceMapping", _a0)} +} + +func (_c *LambdaApi_DeleteEventSourceMapping_Call) Run(run func(_a0 *lambda.DeleteEventSourceMappingInput)) *LambdaApi_DeleteEventSourceMapping_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteEventSourceMappingInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteEventSourceMapping_Call) Return(_a0 *lambda.EventSourceMappingConfiguration, _a1 error) *LambdaApi_DeleteEventSourceMapping_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteEventSourceMapping_Call) RunAndReturn(run func(*lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error)) *LambdaApi_DeleteEventSourceMapping_Call { + _c.Call.Return(run) + return _c +} + // DeleteEventSourceMappingRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteEventSourceMappingRequest(_a0 *lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) { ret := _m.Called(_a0) @@ -853,6 +1726,34 @@ func (_m *LambdaApi) DeleteEventSourceMappingRequest(_a0 *lambda.DeleteEventSour return r0, r1 } +// LambdaApi_DeleteEventSourceMappingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteEventSourceMappingRequest' +type LambdaApi_DeleteEventSourceMappingRequest_Call struct { + *mock.Call +} + +// DeleteEventSourceMappingRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteEventSourceMappingInput +func (_e *LambdaApi_Expecter) DeleteEventSourceMappingRequest(_a0 interface{}) *LambdaApi_DeleteEventSourceMappingRequest_Call { + return &LambdaApi_DeleteEventSourceMappingRequest_Call{Call: _e.mock.On("DeleteEventSourceMappingRequest", _a0)} +} + +func (_c *LambdaApi_DeleteEventSourceMappingRequest_Call) Run(run func(_a0 *lambda.DeleteEventSourceMappingInput)) *LambdaApi_DeleteEventSourceMappingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteEventSourceMappingInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteEventSourceMappingRequest_Call) Return(_a0 *request.Request, _a1 *lambda.EventSourceMappingConfiguration) *LambdaApi_DeleteEventSourceMappingRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteEventSourceMappingRequest_Call) RunAndReturn(run func(*lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration)) *LambdaApi_DeleteEventSourceMappingRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.DeleteEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -886,6 +1787,43 @@ func (_m *LambdaApi) DeleteEventSourceMappingWithContext(_a0 context.Context, _a return r0, r1 } +// LambdaApi_DeleteEventSourceMappingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteEventSourceMappingWithContext' +type LambdaApi_DeleteEventSourceMappingWithContext_Call struct { + *mock.Call +} + +// DeleteEventSourceMappingWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteEventSourceMappingInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteEventSourceMappingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteEventSourceMappingWithContext_Call { + return &LambdaApi_DeleteEventSourceMappingWithContext_Call{Call: _e.mock.On("DeleteEventSourceMappingWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteEventSourceMappingWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteEventSourceMappingInput, _a2 ...request.Option)) *LambdaApi_DeleteEventSourceMappingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteEventSourceMappingInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteEventSourceMappingWithContext_Call) Return(_a0 *lambda.EventSourceMappingConfiguration, _a1 error) *LambdaApi_DeleteEventSourceMappingWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteEventSourceMappingWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteEventSourceMappingInput, ...request.Option) (*lambda.EventSourceMappingConfiguration, error)) *LambdaApi_DeleteEventSourceMappingWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunction provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunction(_a0 *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) { ret := _m.Called(_a0) @@ -912,6 +1850,34 @@ func (_m *LambdaApi) DeleteFunction(_a0 *lambda.DeleteFunctionInput) (*lambda.De return r0, r1 } +// LambdaApi_DeleteFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunction' +type LambdaApi_DeleteFunction_Call struct { + *mock.Call +} + +// DeleteFunction is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionInput +func (_e *LambdaApi_Expecter) DeleteFunction(_a0 interface{}) *LambdaApi_DeleteFunction_Call { + return &LambdaApi_DeleteFunction_Call{Call: _e.mock.On("DeleteFunction", _a0)} +} + +func (_c *LambdaApi_DeleteFunction_Call) Run(run func(_a0 *lambda.DeleteFunctionInput)) *LambdaApi_DeleteFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunction_Call) Return(_a0 *lambda.DeleteFunctionOutput, _a1 error) *LambdaApi_DeleteFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunction_Call) RunAndReturn(run func(*lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error)) *LambdaApi_DeleteFunction_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionCodeSigningConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionCodeSigningConfig(_a0 *lambda.DeleteFunctionCodeSigningConfigInput) (*lambda.DeleteFunctionCodeSigningConfigOutput, error) { ret := _m.Called(_a0) @@ -938,6 +1904,34 @@ func (_m *LambdaApi) DeleteFunctionCodeSigningConfig(_a0 *lambda.DeleteFunctionC return r0, r1 } +// LambdaApi_DeleteFunctionCodeSigningConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionCodeSigningConfig' +type LambdaApi_DeleteFunctionCodeSigningConfig_Call struct { + *mock.Call +} + +// DeleteFunctionCodeSigningConfig is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionCodeSigningConfigInput +func (_e *LambdaApi_Expecter) DeleteFunctionCodeSigningConfig(_a0 interface{}) *LambdaApi_DeleteFunctionCodeSigningConfig_Call { + return &LambdaApi_DeleteFunctionCodeSigningConfig_Call{Call: _e.mock.On("DeleteFunctionCodeSigningConfig", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfig_Call) Run(run func(_a0 *lambda.DeleteFunctionCodeSigningConfigInput)) *LambdaApi_DeleteFunctionCodeSigningConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfig_Call) Return(_a0 *lambda.DeleteFunctionCodeSigningConfigOutput, _a1 error) *LambdaApi_DeleteFunctionCodeSigningConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfig_Call) RunAndReturn(run func(*lambda.DeleteFunctionCodeSigningConfigInput) (*lambda.DeleteFunctionCodeSigningConfigOutput, error)) *LambdaApi_DeleteFunctionCodeSigningConfig_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionCodeSigningConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionCodeSigningConfigRequest(_a0 *lambda.DeleteFunctionCodeSigningConfigInput) (*request.Request, *lambda.DeleteFunctionCodeSigningConfigOutput) { ret := _m.Called(_a0) @@ -966,6 +1960,34 @@ func (_m *LambdaApi) DeleteFunctionCodeSigningConfigRequest(_a0 *lambda.DeleteFu return r0, r1 } +// LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionCodeSigningConfigRequest' +type LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call struct { + *mock.Call +} + +// DeleteFunctionCodeSigningConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionCodeSigningConfigInput +func (_e *LambdaApi_Expecter) DeleteFunctionCodeSigningConfigRequest(_a0 interface{}) *LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call { + return &LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call{Call: _e.mock.On("DeleteFunctionCodeSigningConfigRequest", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call) Run(run func(_a0 *lambda.DeleteFunctionCodeSigningConfigInput)) *LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteFunctionCodeSigningConfigOutput) *LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call) RunAndReturn(run func(*lambda.DeleteFunctionCodeSigningConfigInput) (*request.Request, *lambda.DeleteFunctionCodeSigningConfigOutput)) *LambdaApi_DeleteFunctionCodeSigningConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteFunctionCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionCodeSigningConfigInput, _a2 ...request.Option) (*lambda.DeleteFunctionCodeSigningConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -999,6 +2021,43 @@ func (_m *LambdaApi) DeleteFunctionCodeSigningConfigWithContext(_a0 context.Cont return r0, r1 } +// LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionCodeSigningConfigWithContext' +type LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call struct { + *mock.Call +} + +// DeleteFunctionCodeSigningConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteFunctionCodeSigningConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteFunctionCodeSigningConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call { + return &LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call{Call: _e.mock.On("DeleteFunctionCodeSigningConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteFunctionCodeSigningConfigInput, _a2 ...request.Option)) *LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteFunctionCodeSigningConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call) Return(_a0 *lambda.DeleteFunctionCodeSigningConfigOutput, _a1 error) *LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteFunctionCodeSigningConfigInput, ...request.Option) (*lambda.DeleteFunctionCodeSigningConfigOutput, error)) *LambdaApi_DeleteFunctionCodeSigningConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionConcurrency provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionConcurrency(_a0 *lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error) { ret := _m.Called(_a0) @@ -1025,6 +2084,34 @@ func (_m *LambdaApi) DeleteFunctionConcurrency(_a0 *lambda.DeleteFunctionConcurr return r0, r1 } +// LambdaApi_DeleteFunctionConcurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionConcurrency' +type LambdaApi_DeleteFunctionConcurrency_Call struct { + *mock.Call +} + +// DeleteFunctionConcurrency is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionConcurrencyInput +func (_e *LambdaApi_Expecter) DeleteFunctionConcurrency(_a0 interface{}) *LambdaApi_DeleteFunctionConcurrency_Call { + return &LambdaApi_DeleteFunctionConcurrency_Call{Call: _e.mock.On("DeleteFunctionConcurrency", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionConcurrency_Call) Run(run func(_a0 *lambda.DeleteFunctionConcurrencyInput)) *LambdaApi_DeleteFunctionConcurrency_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionConcurrencyInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionConcurrency_Call) Return(_a0 *lambda.DeleteFunctionConcurrencyOutput, _a1 error) *LambdaApi_DeleteFunctionConcurrency_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionConcurrency_Call) RunAndReturn(run func(*lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error)) *LambdaApi_DeleteFunctionConcurrency_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionConcurrencyRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionConcurrencyRequest(_a0 *lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput) { ret := _m.Called(_a0) @@ -1053,6 +2140,34 @@ func (_m *LambdaApi) DeleteFunctionConcurrencyRequest(_a0 *lambda.DeleteFunction return r0, r1 } +// LambdaApi_DeleteFunctionConcurrencyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionConcurrencyRequest' +type LambdaApi_DeleteFunctionConcurrencyRequest_Call struct { + *mock.Call +} + +// DeleteFunctionConcurrencyRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionConcurrencyInput +func (_e *LambdaApi_Expecter) DeleteFunctionConcurrencyRequest(_a0 interface{}) *LambdaApi_DeleteFunctionConcurrencyRequest_Call { + return &LambdaApi_DeleteFunctionConcurrencyRequest_Call{Call: _e.mock.On("DeleteFunctionConcurrencyRequest", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionConcurrencyRequest_Call) Run(run func(_a0 *lambda.DeleteFunctionConcurrencyInput)) *LambdaApi_DeleteFunctionConcurrencyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionConcurrencyInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionConcurrencyRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteFunctionConcurrencyOutput) *LambdaApi_DeleteFunctionConcurrencyRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionConcurrencyRequest_Call) RunAndReturn(run func(*lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput)) *LambdaApi_DeleteFunctionConcurrencyRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1086,6 +2201,43 @@ func (_m *LambdaApi) DeleteFunctionConcurrencyWithContext(_a0 context.Context, _ return r0, r1 } +// LambdaApi_DeleteFunctionConcurrencyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionConcurrencyWithContext' +type LambdaApi_DeleteFunctionConcurrencyWithContext_Call struct { + *mock.Call +} + +// DeleteFunctionConcurrencyWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteFunctionConcurrencyInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteFunctionConcurrencyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteFunctionConcurrencyWithContext_Call { + return &LambdaApi_DeleteFunctionConcurrencyWithContext_Call{Call: _e.mock.On("DeleteFunctionConcurrencyWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteFunctionConcurrencyWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteFunctionConcurrencyInput, _a2 ...request.Option)) *LambdaApi_DeleteFunctionConcurrencyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteFunctionConcurrencyInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionConcurrencyWithContext_Call) Return(_a0 *lambda.DeleteFunctionConcurrencyOutput, _a1 error) *LambdaApi_DeleteFunctionConcurrencyWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionConcurrencyWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteFunctionConcurrencyInput, ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error)) *LambdaApi_DeleteFunctionConcurrencyWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionEventInvokeConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionEventInvokeConfig(_a0 *lambda.DeleteFunctionEventInvokeConfigInput) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) { ret := _m.Called(_a0) @@ -1112,6 +2264,34 @@ func (_m *LambdaApi) DeleteFunctionEventInvokeConfig(_a0 *lambda.DeleteFunctionE return r0, r1 } +// LambdaApi_DeleteFunctionEventInvokeConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionEventInvokeConfig' +type LambdaApi_DeleteFunctionEventInvokeConfig_Call struct { + *mock.Call +} + +// DeleteFunctionEventInvokeConfig is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionEventInvokeConfigInput +func (_e *LambdaApi_Expecter) DeleteFunctionEventInvokeConfig(_a0 interface{}) *LambdaApi_DeleteFunctionEventInvokeConfig_Call { + return &LambdaApi_DeleteFunctionEventInvokeConfig_Call{Call: _e.mock.On("DeleteFunctionEventInvokeConfig", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfig_Call) Run(run func(_a0 *lambda.DeleteFunctionEventInvokeConfigInput)) *LambdaApi_DeleteFunctionEventInvokeConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionEventInvokeConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfig_Call) Return(_a0 *lambda.DeleteFunctionEventInvokeConfigOutput, _a1 error) *LambdaApi_DeleteFunctionEventInvokeConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfig_Call) RunAndReturn(run func(*lambda.DeleteFunctionEventInvokeConfigInput) (*lambda.DeleteFunctionEventInvokeConfigOutput, error)) *LambdaApi_DeleteFunctionEventInvokeConfig_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionEventInvokeConfigRequest(_a0 *lambda.DeleteFunctionEventInvokeConfigInput) (*request.Request, *lambda.DeleteFunctionEventInvokeConfigOutput) { ret := _m.Called(_a0) @@ -1140,6 +2320,34 @@ func (_m *LambdaApi) DeleteFunctionEventInvokeConfigRequest(_a0 *lambda.DeleteFu return r0, r1 } +// LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionEventInvokeConfigRequest' +type LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call struct { + *mock.Call +} + +// DeleteFunctionEventInvokeConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionEventInvokeConfigInput +func (_e *LambdaApi_Expecter) DeleteFunctionEventInvokeConfigRequest(_a0 interface{}) *LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call { + return &LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call{Call: _e.mock.On("DeleteFunctionEventInvokeConfigRequest", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call) Run(run func(_a0 *lambda.DeleteFunctionEventInvokeConfigInput)) *LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionEventInvokeConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteFunctionEventInvokeConfigOutput) *LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call) RunAndReturn(run func(*lambda.DeleteFunctionEventInvokeConfigInput) (*request.Request, *lambda.DeleteFunctionEventInvokeConfigOutput)) *LambdaApi_DeleteFunctionEventInvokeConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1173,6 +2381,43 @@ func (_m *LambdaApi) DeleteFunctionEventInvokeConfigWithContext(_a0 context.Cont return r0, r1 } +// LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionEventInvokeConfigWithContext' +type LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call struct { + *mock.Call +} + +// DeleteFunctionEventInvokeConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteFunctionEventInvokeConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteFunctionEventInvokeConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call { + return &LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call{Call: _e.mock.On("DeleteFunctionEventInvokeConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteFunctionEventInvokeConfigInput, _a2 ...request.Option)) *LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteFunctionEventInvokeConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call) Return(_a0 *lambda.DeleteFunctionEventInvokeConfigOutput, _a1 error) *LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteFunctionEventInvokeConfigInput, ...request.Option) (*lambda.DeleteFunctionEventInvokeConfigOutput, error)) *LambdaApi_DeleteFunctionEventInvokeConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionRequest(_a0 *lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput) { ret := _m.Called(_a0) @@ -1201,6 +2446,34 @@ func (_m *LambdaApi) DeleteFunctionRequest(_a0 *lambda.DeleteFunctionInput) (*re return r0, r1 } +// LambdaApi_DeleteFunctionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionRequest' +type LambdaApi_DeleteFunctionRequest_Call struct { + *mock.Call +} + +// DeleteFunctionRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionInput +func (_e *LambdaApi_Expecter) DeleteFunctionRequest(_a0 interface{}) *LambdaApi_DeleteFunctionRequest_Call { + return &LambdaApi_DeleteFunctionRequest_Call{Call: _e.mock.On("DeleteFunctionRequest", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionRequest_Call) Run(run func(_a0 *lambda.DeleteFunctionInput)) *LambdaApi_DeleteFunctionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteFunctionOutput) *LambdaApi_DeleteFunctionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionRequest_Call) RunAndReturn(run func(*lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput)) *LambdaApi_DeleteFunctionRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionUrlConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionUrlConfig(_a0 *lambda.DeleteFunctionUrlConfigInput) (*lambda.DeleteFunctionUrlConfigOutput, error) { ret := _m.Called(_a0) @@ -1227,6 +2500,34 @@ func (_m *LambdaApi) DeleteFunctionUrlConfig(_a0 *lambda.DeleteFunctionUrlConfig return r0, r1 } +// LambdaApi_DeleteFunctionUrlConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionUrlConfig' +type LambdaApi_DeleteFunctionUrlConfig_Call struct { + *mock.Call +} + +// DeleteFunctionUrlConfig is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionUrlConfigInput +func (_e *LambdaApi_Expecter) DeleteFunctionUrlConfig(_a0 interface{}) *LambdaApi_DeleteFunctionUrlConfig_Call { + return &LambdaApi_DeleteFunctionUrlConfig_Call{Call: _e.mock.On("DeleteFunctionUrlConfig", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionUrlConfig_Call) Run(run func(_a0 *lambda.DeleteFunctionUrlConfigInput)) *LambdaApi_DeleteFunctionUrlConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionUrlConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionUrlConfig_Call) Return(_a0 *lambda.DeleteFunctionUrlConfigOutput, _a1 error) *LambdaApi_DeleteFunctionUrlConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionUrlConfig_Call) RunAndReturn(run func(*lambda.DeleteFunctionUrlConfigInput) (*lambda.DeleteFunctionUrlConfigOutput, error)) *LambdaApi_DeleteFunctionUrlConfig_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionUrlConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteFunctionUrlConfigRequest(_a0 *lambda.DeleteFunctionUrlConfigInput) (*request.Request, *lambda.DeleteFunctionUrlConfigOutput) { ret := _m.Called(_a0) @@ -1255,6 +2556,34 @@ func (_m *LambdaApi) DeleteFunctionUrlConfigRequest(_a0 *lambda.DeleteFunctionUr return r0, r1 } +// LambdaApi_DeleteFunctionUrlConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionUrlConfigRequest' +type LambdaApi_DeleteFunctionUrlConfigRequest_Call struct { + *mock.Call +} + +// DeleteFunctionUrlConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteFunctionUrlConfigInput +func (_e *LambdaApi_Expecter) DeleteFunctionUrlConfigRequest(_a0 interface{}) *LambdaApi_DeleteFunctionUrlConfigRequest_Call { + return &LambdaApi_DeleteFunctionUrlConfigRequest_Call{Call: _e.mock.On("DeleteFunctionUrlConfigRequest", _a0)} +} + +func (_c *LambdaApi_DeleteFunctionUrlConfigRequest_Call) Run(run func(_a0 *lambda.DeleteFunctionUrlConfigInput)) *LambdaApi_DeleteFunctionUrlConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteFunctionUrlConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionUrlConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteFunctionUrlConfigOutput) *LambdaApi_DeleteFunctionUrlConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionUrlConfigRequest_Call) RunAndReturn(run func(*lambda.DeleteFunctionUrlConfigInput) (*request.Request, *lambda.DeleteFunctionUrlConfigOutput)) *LambdaApi_DeleteFunctionUrlConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionUrlConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteFunctionUrlConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionUrlConfigInput, _a2 ...request.Option) (*lambda.DeleteFunctionUrlConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1288,6 +2617,43 @@ func (_m *LambdaApi) DeleteFunctionUrlConfigWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_DeleteFunctionUrlConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionUrlConfigWithContext' +type LambdaApi_DeleteFunctionUrlConfigWithContext_Call struct { + *mock.Call +} + +// DeleteFunctionUrlConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteFunctionUrlConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteFunctionUrlConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteFunctionUrlConfigWithContext_Call { + return &LambdaApi_DeleteFunctionUrlConfigWithContext_Call{Call: _e.mock.On("DeleteFunctionUrlConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteFunctionUrlConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteFunctionUrlConfigInput, _a2 ...request.Option)) *LambdaApi_DeleteFunctionUrlConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteFunctionUrlConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionUrlConfigWithContext_Call) Return(_a0 *lambda.DeleteFunctionUrlConfigOutput, _a1 error) *LambdaApi_DeleteFunctionUrlConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionUrlConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteFunctionUrlConfigInput, ...request.Option) (*lambda.DeleteFunctionUrlConfigOutput, error)) *LambdaApi_DeleteFunctionUrlConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteFunctionWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionInput, _a2 ...request.Option) (*lambda.DeleteFunctionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1321,6 +2687,43 @@ func (_m *LambdaApi) DeleteFunctionWithContext(_a0 context.Context, _a1 *lambda. return r0, r1 } +// LambdaApi_DeleteFunctionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFunctionWithContext' +type LambdaApi_DeleteFunctionWithContext_Call struct { + *mock.Call +} + +// DeleteFunctionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteFunctionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteFunctionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteFunctionWithContext_Call { + return &LambdaApi_DeleteFunctionWithContext_Call{Call: _e.mock.On("DeleteFunctionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteFunctionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteFunctionInput, _a2 ...request.Option)) *LambdaApi_DeleteFunctionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteFunctionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteFunctionWithContext_Call) Return(_a0 *lambda.DeleteFunctionOutput, _a1 error) *LambdaApi_DeleteFunctionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteFunctionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteFunctionInput, ...request.Option) (*lambda.DeleteFunctionOutput, error)) *LambdaApi_DeleteFunctionWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteLayerVersion provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteLayerVersion(_a0 *lambda.DeleteLayerVersionInput) (*lambda.DeleteLayerVersionOutput, error) { ret := _m.Called(_a0) @@ -1347,6 +2750,34 @@ func (_m *LambdaApi) DeleteLayerVersion(_a0 *lambda.DeleteLayerVersionInput) (*l return r0, r1 } +// LambdaApi_DeleteLayerVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLayerVersion' +type LambdaApi_DeleteLayerVersion_Call struct { + *mock.Call +} + +// DeleteLayerVersion is a helper method to define mock.On call +// - _a0 *lambda.DeleteLayerVersionInput +func (_e *LambdaApi_Expecter) DeleteLayerVersion(_a0 interface{}) *LambdaApi_DeleteLayerVersion_Call { + return &LambdaApi_DeleteLayerVersion_Call{Call: _e.mock.On("DeleteLayerVersion", _a0)} +} + +func (_c *LambdaApi_DeleteLayerVersion_Call) Run(run func(_a0 *lambda.DeleteLayerVersionInput)) *LambdaApi_DeleteLayerVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteLayerVersionInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteLayerVersion_Call) Return(_a0 *lambda.DeleteLayerVersionOutput, _a1 error) *LambdaApi_DeleteLayerVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteLayerVersion_Call) RunAndReturn(run func(*lambda.DeleteLayerVersionInput) (*lambda.DeleteLayerVersionOutput, error)) *LambdaApi_DeleteLayerVersion_Call { + _c.Call.Return(run) + return _c +} + // DeleteLayerVersionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteLayerVersionRequest(_a0 *lambda.DeleteLayerVersionInput) (*request.Request, *lambda.DeleteLayerVersionOutput) { ret := _m.Called(_a0) @@ -1375,6 +2806,34 @@ func (_m *LambdaApi) DeleteLayerVersionRequest(_a0 *lambda.DeleteLayerVersionInp return r0, r1 } +// LambdaApi_DeleteLayerVersionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLayerVersionRequest' +type LambdaApi_DeleteLayerVersionRequest_Call struct { + *mock.Call +} + +// DeleteLayerVersionRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteLayerVersionInput +func (_e *LambdaApi_Expecter) DeleteLayerVersionRequest(_a0 interface{}) *LambdaApi_DeleteLayerVersionRequest_Call { + return &LambdaApi_DeleteLayerVersionRequest_Call{Call: _e.mock.On("DeleteLayerVersionRequest", _a0)} +} + +func (_c *LambdaApi_DeleteLayerVersionRequest_Call) Run(run func(_a0 *lambda.DeleteLayerVersionInput)) *LambdaApi_DeleteLayerVersionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteLayerVersionInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteLayerVersionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteLayerVersionOutput) *LambdaApi_DeleteLayerVersionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteLayerVersionRequest_Call) RunAndReturn(run func(*lambda.DeleteLayerVersionInput) (*request.Request, *lambda.DeleteLayerVersionOutput)) *LambdaApi_DeleteLayerVersionRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteLayerVersionWithContext(_a0 context.Context, _a1 *lambda.DeleteLayerVersionInput, _a2 ...request.Option) (*lambda.DeleteLayerVersionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1408,6 +2867,43 @@ func (_m *LambdaApi) DeleteLayerVersionWithContext(_a0 context.Context, _a1 *lam return r0, r1 } +// LambdaApi_DeleteLayerVersionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLayerVersionWithContext' +type LambdaApi_DeleteLayerVersionWithContext_Call struct { + *mock.Call +} + +// DeleteLayerVersionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteLayerVersionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteLayerVersionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteLayerVersionWithContext_Call { + return &LambdaApi_DeleteLayerVersionWithContext_Call{Call: _e.mock.On("DeleteLayerVersionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteLayerVersionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteLayerVersionInput, _a2 ...request.Option)) *LambdaApi_DeleteLayerVersionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteLayerVersionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteLayerVersionWithContext_Call) Return(_a0 *lambda.DeleteLayerVersionOutput, _a1 error) *LambdaApi_DeleteLayerVersionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteLayerVersionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteLayerVersionInput, ...request.Option) (*lambda.DeleteLayerVersionOutput, error)) *LambdaApi_DeleteLayerVersionWithContext_Call { + _c.Call.Return(run) + return _c +} + // DeleteProvisionedConcurrencyConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) DeleteProvisionedConcurrencyConfig(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) { ret := _m.Called(_a0) @@ -1434,12 +2930,40 @@ func (_m *LambdaApi) DeleteProvisionedConcurrencyConfig(_a0 *lambda.DeleteProvis return r0, r1 } -// DeleteProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0 -func (_m *LambdaApi) DeleteProvisionedConcurrencyConfigRequest(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*request.Request, *lambda.DeleteProvisionedConcurrencyConfigOutput) { - ret := _m.Called(_a0) +// LambdaApi_DeleteProvisionedConcurrencyConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProvisionedConcurrencyConfig' +type LambdaApi_DeleteProvisionedConcurrencyConfig_Call struct { + *mock.Call +} - var r0 *request.Request - var r1 *lambda.DeleteProvisionedConcurrencyConfigOutput +// DeleteProvisionedConcurrencyConfig is a helper method to define mock.On call +// - _a0 *lambda.DeleteProvisionedConcurrencyConfigInput +func (_e *LambdaApi_Expecter) DeleteProvisionedConcurrencyConfig(_a0 interface{}) *LambdaApi_DeleteProvisionedConcurrencyConfig_Call { + return &LambdaApi_DeleteProvisionedConcurrencyConfig_Call{Call: _e.mock.On("DeleteProvisionedConcurrencyConfig", _a0)} +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfig_Call) Run(run func(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput)) *LambdaApi_DeleteProvisionedConcurrencyConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteProvisionedConcurrencyConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfig_Call) Return(_a0 *lambda.DeleteProvisionedConcurrencyConfigOutput, _a1 error) *LambdaApi_DeleteProvisionedConcurrencyConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfig_Call) RunAndReturn(run func(*lambda.DeleteProvisionedConcurrencyConfigInput) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error)) *LambdaApi_DeleteProvisionedConcurrencyConfig_Call { + _c.Call.Return(run) + return _c +} + +// DeleteProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0 +func (_m *LambdaApi) DeleteProvisionedConcurrencyConfigRequest(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*request.Request, *lambda.DeleteProvisionedConcurrencyConfigOutput) { + ret := _m.Called(_a0) + + var r0 *request.Request + var r1 *lambda.DeleteProvisionedConcurrencyConfigOutput if rf, ok := ret.Get(0).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) (*request.Request, *lambda.DeleteProvisionedConcurrencyConfigOutput)); ok { return rf(_a0) } @@ -1462,6 +2986,34 @@ func (_m *LambdaApi) DeleteProvisionedConcurrencyConfigRequest(_a0 *lambda.Delet return r0, r1 } +// LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProvisionedConcurrencyConfigRequest' +type LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call struct { + *mock.Call +} + +// DeleteProvisionedConcurrencyConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.DeleteProvisionedConcurrencyConfigInput +func (_e *LambdaApi_Expecter) DeleteProvisionedConcurrencyConfigRequest(_a0 interface{}) *LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call { + return &LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call{Call: _e.mock.On("DeleteProvisionedConcurrencyConfigRequest", _a0)} +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call) Run(run func(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput)) *LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.DeleteProvisionedConcurrencyConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.DeleteProvisionedConcurrencyConfigOutput) *LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call) RunAndReturn(run func(*lambda.DeleteProvisionedConcurrencyConfigInput) (*request.Request, *lambda.DeleteProvisionedConcurrencyConfigOutput)) *LambdaApi_DeleteProvisionedConcurrencyConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // DeleteProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) DeleteProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1495,6 +3047,43 @@ func (_m *LambdaApi) DeleteProvisionedConcurrencyConfigWithContext(_a0 context.C return r0, r1 } +// LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProvisionedConcurrencyConfigWithContext' +type LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call struct { + *mock.Call +} + +// DeleteProvisionedConcurrencyConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.DeleteProvisionedConcurrencyConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) DeleteProvisionedConcurrencyConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call { + return &LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call{Call: _e.mock.On("DeleteProvisionedConcurrencyConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.DeleteProvisionedConcurrencyConfigInput, _a2 ...request.Option)) *LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.DeleteProvisionedConcurrencyConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call) Return(_a0 *lambda.DeleteProvisionedConcurrencyConfigOutput, _a1 error) *LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.DeleteProvisionedConcurrencyConfigInput, ...request.Option) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error)) *LambdaApi_DeleteProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetAccountSettings provides a mock function with given fields: _a0 func (_m *LambdaApi) GetAccountSettings(_a0 *lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error) { ret := _m.Called(_a0) @@ -1521,6 +3110,34 @@ func (_m *LambdaApi) GetAccountSettings(_a0 *lambda.GetAccountSettingsInput) (*l return r0, r1 } +// LambdaApi_GetAccountSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccountSettings' +type LambdaApi_GetAccountSettings_Call struct { + *mock.Call +} + +// GetAccountSettings is a helper method to define mock.On call +// - _a0 *lambda.GetAccountSettingsInput +func (_e *LambdaApi_Expecter) GetAccountSettings(_a0 interface{}) *LambdaApi_GetAccountSettings_Call { + return &LambdaApi_GetAccountSettings_Call{Call: _e.mock.On("GetAccountSettings", _a0)} +} + +func (_c *LambdaApi_GetAccountSettings_Call) Run(run func(_a0 *lambda.GetAccountSettingsInput)) *LambdaApi_GetAccountSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetAccountSettingsInput)) + }) + return _c +} + +func (_c *LambdaApi_GetAccountSettings_Call) Return(_a0 *lambda.GetAccountSettingsOutput, _a1 error) *LambdaApi_GetAccountSettings_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetAccountSettings_Call) RunAndReturn(run func(*lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error)) *LambdaApi_GetAccountSettings_Call { + _c.Call.Return(run) + return _c +} + // GetAccountSettingsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetAccountSettingsRequest(_a0 *lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput) { ret := _m.Called(_a0) @@ -1549,6 +3166,34 @@ func (_m *LambdaApi) GetAccountSettingsRequest(_a0 *lambda.GetAccountSettingsInp return r0, r1 } +// LambdaApi_GetAccountSettingsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccountSettingsRequest' +type LambdaApi_GetAccountSettingsRequest_Call struct { + *mock.Call +} + +// GetAccountSettingsRequest is a helper method to define mock.On call +// - _a0 *lambda.GetAccountSettingsInput +func (_e *LambdaApi_Expecter) GetAccountSettingsRequest(_a0 interface{}) *LambdaApi_GetAccountSettingsRequest_Call { + return &LambdaApi_GetAccountSettingsRequest_Call{Call: _e.mock.On("GetAccountSettingsRequest", _a0)} +} + +func (_c *LambdaApi_GetAccountSettingsRequest_Call) Run(run func(_a0 *lambda.GetAccountSettingsInput)) *LambdaApi_GetAccountSettingsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetAccountSettingsInput)) + }) + return _c +} + +func (_c *LambdaApi_GetAccountSettingsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetAccountSettingsOutput) *LambdaApi_GetAccountSettingsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetAccountSettingsRequest_Call) RunAndReturn(run func(*lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput)) *LambdaApi_GetAccountSettingsRequest_Call { + _c.Call.Return(run) + return _c +} + // GetAccountSettingsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetAccountSettingsWithContext(_a0 context.Context, _a1 *lambda.GetAccountSettingsInput, _a2 ...request.Option) (*lambda.GetAccountSettingsOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1582,6 +3227,43 @@ func (_m *LambdaApi) GetAccountSettingsWithContext(_a0 context.Context, _a1 *lam return r0, r1 } +// LambdaApi_GetAccountSettingsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccountSettingsWithContext' +type LambdaApi_GetAccountSettingsWithContext_Call struct { + *mock.Call +} + +// GetAccountSettingsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetAccountSettingsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetAccountSettingsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetAccountSettingsWithContext_Call { + return &LambdaApi_GetAccountSettingsWithContext_Call{Call: _e.mock.On("GetAccountSettingsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetAccountSettingsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetAccountSettingsInput, _a2 ...request.Option)) *LambdaApi_GetAccountSettingsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetAccountSettingsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetAccountSettingsWithContext_Call) Return(_a0 *lambda.GetAccountSettingsOutput, _a1 error) *LambdaApi_GetAccountSettingsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetAccountSettingsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetAccountSettingsInput, ...request.Option) (*lambda.GetAccountSettingsOutput, error)) *LambdaApi_GetAccountSettingsWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetAlias provides a mock function with given fields: _a0 func (_m *LambdaApi) GetAlias(_a0 *lambda.GetAliasInput) (*lambda.AliasConfiguration, error) { ret := _m.Called(_a0) @@ -1608,6 +3290,34 @@ func (_m *LambdaApi) GetAlias(_a0 *lambda.GetAliasInput) (*lambda.AliasConfigura return r0, r1 } +// LambdaApi_GetAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlias' +type LambdaApi_GetAlias_Call struct { + *mock.Call +} + +// GetAlias is a helper method to define mock.On call +// - _a0 *lambda.GetAliasInput +func (_e *LambdaApi_Expecter) GetAlias(_a0 interface{}) *LambdaApi_GetAlias_Call { + return &LambdaApi_GetAlias_Call{Call: _e.mock.On("GetAlias", _a0)} +} + +func (_c *LambdaApi_GetAlias_Call) Run(run func(_a0 *lambda.GetAliasInput)) *LambdaApi_GetAlias_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetAliasInput)) + }) + return _c +} + +func (_c *LambdaApi_GetAlias_Call) Return(_a0 *lambda.AliasConfiguration, _a1 error) *LambdaApi_GetAlias_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetAlias_Call) RunAndReturn(run func(*lambda.GetAliasInput) (*lambda.AliasConfiguration, error)) *LambdaApi_GetAlias_Call { + _c.Call.Return(run) + return _c +} + // GetAliasRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetAliasRequest(_a0 *lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration) { ret := _m.Called(_a0) @@ -1636,6 +3346,34 @@ func (_m *LambdaApi) GetAliasRequest(_a0 *lambda.GetAliasInput) (*request.Reques return r0, r1 } +// LambdaApi_GetAliasRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAliasRequest' +type LambdaApi_GetAliasRequest_Call struct { + *mock.Call +} + +// GetAliasRequest is a helper method to define mock.On call +// - _a0 *lambda.GetAliasInput +func (_e *LambdaApi_Expecter) GetAliasRequest(_a0 interface{}) *LambdaApi_GetAliasRequest_Call { + return &LambdaApi_GetAliasRequest_Call{Call: _e.mock.On("GetAliasRequest", _a0)} +} + +func (_c *LambdaApi_GetAliasRequest_Call) Run(run func(_a0 *lambda.GetAliasInput)) *LambdaApi_GetAliasRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetAliasInput)) + }) + return _c +} + +func (_c *LambdaApi_GetAliasRequest_Call) Return(_a0 *request.Request, _a1 *lambda.AliasConfiguration) *LambdaApi_GetAliasRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetAliasRequest_Call) RunAndReturn(run func(*lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration)) *LambdaApi_GetAliasRequest_Call { + _c.Call.Return(run) + return _c +} + // GetAliasWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetAliasWithContext(_a0 context.Context, _a1 *lambda.GetAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -1669,6 +3407,43 @@ func (_m *LambdaApi) GetAliasWithContext(_a0 context.Context, _a1 *lambda.GetAli return r0, r1 } +// LambdaApi_GetAliasWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAliasWithContext' +type LambdaApi_GetAliasWithContext_Call struct { + *mock.Call +} + +// GetAliasWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetAliasInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetAliasWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetAliasWithContext_Call { + return &LambdaApi_GetAliasWithContext_Call{Call: _e.mock.On("GetAliasWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetAliasWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetAliasInput, _a2 ...request.Option)) *LambdaApi_GetAliasWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetAliasInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetAliasWithContext_Call) Return(_a0 *lambda.AliasConfiguration, _a1 error) *LambdaApi_GetAliasWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetAliasWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetAliasInput, ...request.Option) (*lambda.AliasConfiguration, error)) *LambdaApi_GetAliasWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetCodeSigningConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) GetCodeSigningConfig(_a0 *lambda.GetCodeSigningConfigInput) (*lambda.GetCodeSigningConfigOutput, error) { ret := _m.Called(_a0) @@ -1695,6 +3470,34 @@ func (_m *LambdaApi) GetCodeSigningConfig(_a0 *lambda.GetCodeSigningConfigInput) return r0, r1 } +// LambdaApi_GetCodeSigningConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCodeSigningConfig' +type LambdaApi_GetCodeSigningConfig_Call struct { + *mock.Call +} + +// GetCodeSigningConfig is a helper method to define mock.On call +// - _a0 *lambda.GetCodeSigningConfigInput +func (_e *LambdaApi_Expecter) GetCodeSigningConfig(_a0 interface{}) *LambdaApi_GetCodeSigningConfig_Call { + return &LambdaApi_GetCodeSigningConfig_Call{Call: _e.mock.On("GetCodeSigningConfig", _a0)} +} + +func (_c *LambdaApi_GetCodeSigningConfig_Call) Run(run func(_a0 *lambda.GetCodeSigningConfigInput)) *LambdaApi_GetCodeSigningConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetCodeSigningConfig_Call) Return(_a0 *lambda.GetCodeSigningConfigOutput, _a1 error) *LambdaApi_GetCodeSigningConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetCodeSigningConfig_Call) RunAndReturn(run func(*lambda.GetCodeSigningConfigInput) (*lambda.GetCodeSigningConfigOutput, error)) *LambdaApi_GetCodeSigningConfig_Call { + _c.Call.Return(run) + return _c +} + // GetCodeSigningConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetCodeSigningConfigRequest(_a0 *lambda.GetCodeSigningConfigInput) (*request.Request, *lambda.GetCodeSigningConfigOutput) { ret := _m.Called(_a0) @@ -1723,6 +3526,34 @@ func (_m *LambdaApi) GetCodeSigningConfigRequest(_a0 *lambda.GetCodeSigningConfi return r0, r1 } +// LambdaApi_GetCodeSigningConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCodeSigningConfigRequest' +type LambdaApi_GetCodeSigningConfigRequest_Call struct { + *mock.Call +} + +// GetCodeSigningConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.GetCodeSigningConfigInput +func (_e *LambdaApi_Expecter) GetCodeSigningConfigRequest(_a0 interface{}) *LambdaApi_GetCodeSigningConfigRequest_Call { + return &LambdaApi_GetCodeSigningConfigRequest_Call{Call: _e.mock.On("GetCodeSigningConfigRequest", _a0)} +} + +func (_c *LambdaApi_GetCodeSigningConfigRequest_Call) Run(run func(_a0 *lambda.GetCodeSigningConfigInput)) *LambdaApi_GetCodeSigningConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetCodeSigningConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetCodeSigningConfigOutput) *LambdaApi_GetCodeSigningConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetCodeSigningConfigRequest_Call) RunAndReturn(run func(*lambda.GetCodeSigningConfigInput) (*request.Request, *lambda.GetCodeSigningConfigOutput)) *LambdaApi_GetCodeSigningConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // GetCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.GetCodeSigningConfigInput, _a2 ...request.Option) (*lambda.GetCodeSigningConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1756,6 +3587,43 @@ func (_m *LambdaApi) GetCodeSigningConfigWithContext(_a0 context.Context, _a1 *l return r0, r1 } +// LambdaApi_GetCodeSigningConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCodeSigningConfigWithContext' +type LambdaApi_GetCodeSigningConfigWithContext_Call struct { + *mock.Call +} + +// GetCodeSigningConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetCodeSigningConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetCodeSigningConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetCodeSigningConfigWithContext_Call { + return &LambdaApi_GetCodeSigningConfigWithContext_Call{Call: _e.mock.On("GetCodeSigningConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetCodeSigningConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetCodeSigningConfigInput, _a2 ...request.Option)) *LambdaApi_GetCodeSigningConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetCodeSigningConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetCodeSigningConfigWithContext_Call) Return(_a0 *lambda.GetCodeSigningConfigOutput, _a1 error) *LambdaApi_GetCodeSigningConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetCodeSigningConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetCodeSigningConfigInput, ...request.Option) (*lambda.GetCodeSigningConfigOutput, error)) *LambdaApi_GetCodeSigningConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetEventSourceMapping provides a mock function with given fields: _a0 func (_m *LambdaApi) GetEventSourceMapping(_a0 *lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) { ret := _m.Called(_a0) @@ -1782,6 +3650,34 @@ func (_m *LambdaApi) GetEventSourceMapping(_a0 *lambda.GetEventSourceMappingInpu return r0, r1 } +// LambdaApi_GetEventSourceMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEventSourceMapping' +type LambdaApi_GetEventSourceMapping_Call struct { + *mock.Call +} + +// GetEventSourceMapping is a helper method to define mock.On call +// - _a0 *lambda.GetEventSourceMappingInput +func (_e *LambdaApi_Expecter) GetEventSourceMapping(_a0 interface{}) *LambdaApi_GetEventSourceMapping_Call { + return &LambdaApi_GetEventSourceMapping_Call{Call: _e.mock.On("GetEventSourceMapping", _a0)} +} + +func (_c *LambdaApi_GetEventSourceMapping_Call) Run(run func(_a0 *lambda.GetEventSourceMappingInput)) *LambdaApi_GetEventSourceMapping_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetEventSourceMappingInput)) + }) + return _c +} + +func (_c *LambdaApi_GetEventSourceMapping_Call) Return(_a0 *lambda.EventSourceMappingConfiguration, _a1 error) *LambdaApi_GetEventSourceMapping_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetEventSourceMapping_Call) RunAndReturn(run func(*lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error)) *LambdaApi_GetEventSourceMapping_Call { + _c.Call.Return(run) + return _c +} + // GetEventSourceMappingRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetEventSourceMappingRequest(_a0 *lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) { ret := _m.Called(_a0) @@ -1810,6 +3706,34 @@ func (_m *LambdaApi) GetEventSourceMappingRequest(_a0 *lambda.GetEventSourceMapp return r0, r1 } +// LambdaApi_GetEventSourceMappingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEventSourceMappingRequest' +type LambdaApi_GetEventSourceMappingRequest_Call struct { + *mock.Call +} + +// GetEventSourceMappingRequest is a helper method to define mock.On call +// - _a0 *lambda.GetEventSourceMappingInput +func (_e *LambdaApi_Expecter) GetEventSourceMappingRequest(_a0 interface{}) *LambdaApi_GetEventSourceMappingRequest_Call { + return &LambdaApi_GetEventSourceMappingRequest_Call{Call: _e.mock.On("GetEventSourceMappingRequest", _a0)} +} + +func (_c *LambdaApi_GetEventSourceMappingRequest_Call) Run(run func(_a0 *lambda.GetEventSourceMappingInput)) *LambdaApi_GetEventSourceMappingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetEventSourceMappingInput)) + }) + return _c +} + +func (_c *LambdaApi_GetEventSourceMappingRequest_Call) Return(_a0 *request.Request, _a1 *lambda.EventSourceMappingConfiguration) *LambdaApi_GetEventSourceMappingRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetEventSourceMappingRequest_Call) RunAndReturn(run func(*lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration)) *LambdaApi_GetEventSourceMappingRequest_Call { + _c.Call.Return(run) + return _c +} + // GetEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.GetEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -1843,6 +3767,43 @@ func (_m *LambdaApi) GetEventSourceMappingWithContext(_a0 context.Context, _a1 * return r0, r1 } +// LambdaApi_GetEventSourceMappingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEventSourceMappingWithContext' +type LambdaApi_GetEventSourceMappingWithContext_Call struct { + *mock.Call +} + +// GetEventSourceMappingWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetEventSourceMappingInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetEventSourceMappingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetEventSourceMappingWithContext_Call { + return &LambdaApi_GetEventSourceMappingWithContext_Call{Call: _e.mock.On("GetEventSourceMappingWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetEventSourceMappingWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetEventSourceMappingInput, _a2 ...request.Option)) *LambdaApi_GetEventSourceMappingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetEventSourceMappingInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetEventSourceMappingWithContext_Call) Return(_a0 *lambda.EventSourceMappingConfiguration, _a1 error) *LambdaApi_GetEventSourceMappingWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetEventSourceMappingWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetEventSourceMappingInput, ...request.Option) (*lambda.EventSourceMappingConfiguration, error)) *LambdaApi_GetEventSourceMappingWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetFunction provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunction(_a0 *lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error) { ret := _m.Called(_a0) @@ -1869,6 +3830,34 @@ func (_m *LambdaApi) GetFunction(_a0 *lambda.GetFunctionInput) (*lambda.GetFunct return r0, r1 } +// LambdaApi_GetFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunction' +type LambdaApi_GetFunction_Call struct { + *mock.Call +} + +// GetFunction is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionInput +func (_e *LambdaApi_Expecter) GetFunction(_a0 interface{}) *LambdaApi_GetFunction_Call { + return &LambdaApi_GetFunction_Call{Call: _e.mock.On("GetFunction", _a0)} +} + +func (_c *LambdaApi_GetFunction_Call) Run(run func(_a0 *lambda.GetFunctionInput)) *LambdaApi_GetFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunction_Call) Return(_a0 *lambda.GetFunctionOutput, _a1 error) *LambdaApi_GetFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunction_Call) RunAndReturn(run func(*lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error)) *LambdaApi_GetFunction_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionCodeSigningConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionCodeSigningConfig(_a0 *lambda.GetFunctionCodeSigningConfigInput) (*lambda.GetFunctionCodeSigningConfigOutput, error) { ret := _m.Called(_a0) @@ -1895,6 +3884,34 @@ func (_m *LambdaApi) GetFunctionCodeSigningConfig(_a0 *lambda.GetFunctionCodeSig return r0, r1 } +// LambdaApi_GetFunctionCodeSigningConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionCodeSigningConfig' +type LambdaApi_GetFunctionCodeSigningConfig_Call struct { + *mock.Call +} + +// GetFunctionCodeSigningConfig is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionCodeSigningConfigInput +func (_e *LambdaApi_Expecter) GetFunctionCodeSigningConfig(_a0 interface{}) *LambdaApi_GetFunctionCodeSigningConfig_Call { + return &LambdaApi_GetFunctionCodeSigningConfig_Call{Call: _e.mock.On("GetFunctionCodeSigningConfig", _a0)} +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfig_Call) Run(run func(_a0 *lambda.GetFunctionCodeSigningConfigInput)) *LambdaApi_GetFunctionCodeSigningConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfig_Call) Return(_a0 *lambda.GetFunctionCodeSigningConfigOutput, _a1 error) *LambdaApi_GetFunctionCodeSigningConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfig_Call) RunAndReturn(run func(*lambda.GetFunctionCodeSigningConfigInput) (*lambda.GetFunctionCodeSigningConfigOutput, error)) *LambdaApi_GetFunctionCodeSigningConfig_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionCodeSigningConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionCodeSigningConfigRequest(_a0 *lambda.GetFunctionCodeSigningConfigInput) (*request.Request, *lambda.GetFunctionCodeSigningConfigOutput) { ret := _m.Called(_a0) @@ -1923,6 +3940,34 @@ func (_m *LambdaApi) GetFunctionCodeSigningConfigRequest(_a0 *lambda.GetFunction return r0, r1 } +// LambdaApi_GetFunctionCodeSigningConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionCodeSigningConfigRequest' +type LambdaApi_GetFunctionCodeSigningConfigRequest_Call struct { + *mock.Call +} + +// GetFunctionCodeSigningConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionCodeSigningConfigInput +func (_e *LambdaApi_Expecter) GetFunctionCodeSigningConfigRequest(_a0 interface{}) *LambdaApi_GetFunctionCodeSigningConfigRequest_Call { + return &LambdaApi_GetFunctionCodeSigningConfigRequest_Call{Call: _e.mock.On("GetFunctionCodeSigningConfigRequest", _a0)} +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfigRequest_Call) Run(run func(_a0 *lambda.GetFunctionCodeSigningConfigInput)) *LambdaApi_GetFunctionCodeSigningConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetFunctionCodeSigningConfigOutput) *LambdaApi_GetFunctionCodeSigningConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfigRequest_Call) RunAndReturn(run func(*lambda.GetFunctionCodeSigningConfigInput) (*request.Request, *lambda.GetFunctionCodeSigningConfigOutput)) *LambdaApi_GetFunctionCodeSigningConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetFunctionCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.GetFunctionCodeSigningConfigInput, _a2 ...request.Option) (*lambda.GetFunctionCodeSigningConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -1956,6 +4001,43 @@ func (_m *LambdaApi) GetFunctionCodeSigningConfigWithContext(_a0 context.Context return r0, r1 } +// LambdaApi_GetFunctionCodeSigningConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionCodeSigningConfigWithContext' +type LambdaApi_GetFunctionCodeSigningConfigWithContext_Call struct { + *mock.Call +} + +// GetFunctionCodeSigningConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionCodeSigningConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetFunctionCodeSigningConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetFunctionCodeSigningConfigWithContext_Call { + return &LambdaApi_GetFunctionCodeSigningConfigWithContext_Call{Call: _e.mock.On("GetFunctionCodeSigningConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionCodeSigningConfigInput, _a2 ...request.Option)) *LambdaApi_GetFunctionCodeSigningConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionCodeSigningConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfigWithContext_Call) Return(_a0 *lambda.GetFunctionCodeSigningConfigOutput, _a1 error) *LambdaApi_GetFunctionCodeSigningConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionCodeSigningConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionCodeSigningConfigInput, ...request.Option) (*lambda.GetFunctionCodeSigningConfigOutput, error)) *LambdaApi_GetFunctionCodeSigningConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionConcurrency provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionConcurrency(_a0 *lambda.GetFunctionConcurrencyInput) (*lambda.GetFunctionConcurrencyOutput, error) { ret := _m.Called(_a0) @@ -1982,6 +4064,34 @@ func (_m *LambdaApi) GetFunctionConcurrency(_a0 *lambda.GetFunctionConcurrencyIn return r0, r1 } +// LambdaApi_GetFunctionConcurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionConcurrency' +type LambdaApi_GetFunctionConcurrency_Call struct { + *mock.Call +} + +// GetFunctionConcurrency is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionConcurrencyInput +func (_e *LambdaApi_Expecter) GetFunctionConcurrency(_a0 interface{}) *LambdaApi_GetFunctionConcurrency_Call { + return &LambdaApi_GetFunctionConcurrency_Call{Call: _e.mock.On("GetFunctionConcurrency", _a0)} +} + +func (_c *LambdaApi_GetFunctionConcurrency_Call) Run(run func(_a0 *lambda.GetFunctionConcurrencyInput)) *LambdaApi_GetFunctionConcurrency_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionConcurrencyInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionConcurrency_Call) Return(_a0 *lambda.GetFunctionConcurrencyOutput, _a1 error) *LambdaApi_GetFunctionConcurrency_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionConcurrency_Call) RunAndReturn(run func(*lambda.GetFunctionConcurrencyInput) (*lambda.GetFunctionConcurrencyOutput, error)) *LambdaApi_GetFunctionConcurrency_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionConcurrencyRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionConcurrencyRequest(_a0 *lambda.GetFunctionConcurrencyInput) (*request.Request, *lambda.GetFunctionConcurrencyOutput) { ret := _m.Called(_a0) @@ -2010,6 +4120,34 @@ func (_m *LambdaApi) GetFunctionConcurrencyRequest(_a0 *lambda.GetFunctionConcur return r0, r1 } +// LambdaApi_GetFunctionConcurrencyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionConcurrencyRequest' +type LambdaApi_GetFunctionConcurrencyRequest_Call struct { + *mock.Call +} + +// GetFunctionConcurrencyRequest is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionConcurrencyInput +func (_e *LambdaApi_Expecter) GetFunctionConcurrencyRequest(_a0 interface{}) *LambdaApi_GetFunctionConcurrencyRequest_Call { + return &LambdaApi_GetFunctionConcurrencyRequest_Call{Call: _e.mock.On("GetFunctionConcurrencyRequest", _a0)} +} + +func (_c *LambdaApi_GetFunctionConcurrencyRequest_Call) Run(run func(_a0 *lambda.GetFunctionConcurrencyInput)) *LambdaApi_GetFunctionConcurrencyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionConcurrencyInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionConcurrencyRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetFunctionConcurrencyOutput) *LambdaApi_GetFunctionConcurrencyRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionConcurrencyRequest_Call) RunAndReturn(run func(*lambda.GetFunctionConcurrencyInput) (*request.Request, *lambda.GetFunctionConcurrencyOutput)) *LambdaApi_GetFunctionConcurrencyRequest_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.GetFunctionConcurrencyOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2043,6 +4181,43 @@ func (_m *LambdaApi) GetFunctionConcurrencyWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_GetFunctionConcurrencyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionConcurrencyWithContext' +type LambdaApi_GetFunctionConcurrencyWithContext_Call struct { + *mock.Call +} + +// GetFunctionConcurrencyWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionConcurrencyInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetFunctionConcurrencyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetFunctionConcurrencyWithContext_Call { + return &LambdaApi_GetFunctionConcurrencyWithContext_Call{Call: _e.mock.On("GetFunctionConcurrencyWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetFunctionConcurrencyWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionConcurrencyInput, _a2 ...request.Option)) *LambdaApi_GetFunctionConcurrencyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionConcurrencyInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionConcurrencyWithContext_Call) Return(_a0 *lambda.GetFunctionConcurrencyOutput, _a1 error) *LambdaApi_GetFunctionConcurrencyWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionConcurrencyWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionConcurrencyInput, ...request.Option) (*lambda.GetFunctionConcurrencyOutput, error)) *LambdaApi_GetFunctionConcurrencyWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionConfiguration provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionConfiguration(_a0 *lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) { ret := _m.Called(_a0) @@ -2069,6 +4244,34 @@ func (_m *LambdaApi) GetFunctionConfiguration(_a0 *lambda.GetFunctionConfigurati return r0, r1 } +// LambdaApi_GetFunctionConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionConfiguration' +type LambdaApi_GetFunctionConfiguration_Call struct { + *mock.Call +} + +// GetFunctionConfiguration is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionConfigurationInput +func (_e *LambdaApi_Expecter) GetFunctionConfiguration(_a0 interface{}) *LambdaApi_GetFunctionConfiguration_Call { + return &LambdaApi_GetFunctionConfiguration_Call{Call: _e.mock.On("GetFunctionConfiguration", _a0)} +} + +func (_c *LambdaApi_GetFunctionConfiguration_Call) Run(run func(_a0 *lambda.GetFunctionConfigurationInput)) *LambdaApi_GetFunctionConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionConfigurationInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionConfiguration_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_GetFunctionConfiguration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionConfiguration_Call) RunAndReturn(run func(*lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error)) *LambdaApi_GetFunctionConfiguration_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionConfigurationRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionConfigurationRequest(_a0 *lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) { ret := _m.Called(_a0) @@ -2097,6 +4300,34 @@ func (_m *LambdaApi) GetFunctionConfigurationRequest(_a0 *lambda.GetFunctionConf return r0, r1 } +// LambdaApi_GetFunctionConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionConfigurationRequest' +type LambdaApi_GetFunctionConfigurationRequest_Call struct { + *mock.Call +} + +// GetFunctionConfigurationRequest is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionConfigurationInput +func (_e *LambdaApi_Expecter) GetFunctionConfigurationRequest(_a0 interface{}) *LambdaApi_GetFunctionConfigurationRequest_Call { + return &LambdaApi_GetFunctionConfigurationRequest_Call{Call: _e.mock.On("GetFunctionConfigurationRequest", _a0)} +} + +func (_c *LambdaApi_GetFunctionConfigurationRequest_Call) Run(run func(_a0 *lambda.GetFunctionConfigurationInput)) *LambdaApi_GetFunctionConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionConfigurationInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *lambda.FunctionConfiguration) *LambdaApi_GetFunctionConfigurationRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionConfigurationRequest_Call) RunAndReturn(run func(*lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration)) *LambdaApi_GetFunctionConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetFunctionConfigurationWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -2130,11 +4361,48 @@ func (_m *LambdaApi) GetFunctionConfigurationWithContext(_a0 context.Context, _a return r0, r1 } -// GetFunctionEventInvokeConfig provides a mock function with given fields: _a0 -func (_m *LambdaApi) GetFunctionEventInvokeConfig(_a0 *lambda.GetFunctionEventInvokeConfigInput) (*lambda.GetFunctionEventInvokeConfigOutput, error) { - ret := _m.Called(_a0) +// LambdaApi_GetFunctionConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionConfigurationWithContext' +type LambdaApi_GetFunctionConfigurationWithContext_Call struct { + *mock.Call +} - var r0 *lambda.GetFunctionEventInvokeConfigOutput +// GetFunctionConfigurationWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionConfigurationInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetFunctionConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetFunctionConfigurationWithContext_Call { + return &LambdaApi_GetFunctionConfigurationWithContext_Call{Call: _e.mock.On("GetFunctionConfigurationWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetFunctionConfigurationWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.Option)) *LambdaApi_GetFunctionConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionConfigurationInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionConfigurationWithContext_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_GetFunctionConfigurationWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionConfigurationWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.Option) (*lambda.FunctionConfiguration, error)) *LambdaApi_GetFunctionConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetFunctionEventInvokeConfig provides a mock function with given fields: _a0 +func (_m *LambdaApi) GetFunctionEventInvokeConfig(_a0 *lambda.GetFunctionEventInvokeConfigInput) (*lambda.GetFunctionEventInvokeConfigOutput, error) { + ret := _m.Called(_a0) + + var r0 *lambda.GetFunctionEventInvokeConfigOutput var r1 error if rf, ok := ret.Get(0).(func(*lambda.GetFunctionEventInvokeConfigInput) (*lambda.GetFunctionEventInvokeConfigOutput, error)); ok { return rf(_a0) @@ -2156,6 +4424,34 @@ func (_m *LambdaApi) GetFunctionEventInvokeConfig(_a0 *lambda.GetFunctionEventIn return r0, r1 } +// LambdaApi_GetFunctionEventInvokeConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionEventInvokeConfig' +type LambdaApi_GetFunctionEventInvokeConfig_Call struct { + *mock.Call +} + +// GetFunctionEventInvokeConfig is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionEventInvokeConfigInput +func (_e *LambdaApi_Expecter) GetFunctionEventInvokeConfig(_a0 interface{}) *LambdaApi_GetFunctionEventInvokeConfig_Call { + return &LambdaApi_GetFunctionEventInvokeConfig_Call{Call: _e.mock.On("GetFunctionEventInvokeConfig", _a0)} +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfig_Call) Run(run func(_a0 *lambda.GetFunctionEventInvokeConfigInput)) *LambdaApi_GetFunctionEventInvokeConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionEventInvokeConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfig_Call) Return(_a0 *lambda.GetFunctionEventInvokeConfigOutput, _a1 error) *LambdaApi_GetFunctionEventInvokeConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfig_Call) RunAndReturn(run func(*lambda.GetFunctionEventInvokeConfigInput) (*lambda.GetFunctionEventInvokeConfigOutput, error)) *LambdaApi_GetFunctionEventInvokeConfig_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionEventInvokeConfigRequest(_a0 *lambda.GetFunctionEventInvokeConfigInput) (*request.Request, *lambda.GetFunctionEventInvokeConfigOutput) { ret := _m.Called(_a0) @@ -2184,6 +4480,34 @@ func (_m *LambdaApi) GetFunctionEventInvokeConfigRequest(_a0 *lambda.GetFunction return r0, r1 } +// LambdaApi_GetFunctionEventInvokeConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionEventInvokeConfigRequest' +type LambdaApi_GetFunctionEventInvokeConfigRequest_Call struct { + *mock.Call +} + +// GetFunctionEventInvokeConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionEventInvokeConfigInput +func (_e *LambdaApi_Expecter) GetFunctionEventInvokeConfigRequest(_a0 interface{}) *LambdaApi_GetFunctionEventInvokeConfigRequest_Call { + return &LambdaApi_GetFunctionEventInvokeConfigRequest_Call{Call: _e.mock.On("GetFunctionEventInvokeConfigRequest", _a0)} +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfigRequest_Call) Run(run func(_a0 *lambda.GetFunctionEventInvokeConfigInput)) *LambdaApi_GetFunctionEventInvokeConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionEventInvokeConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetFunctionEventInvokeConfigOutput) *LambdaApi_GetFunctionEventInvokeConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfigRequest_Call) RunAndReturn(run func(*lambda.GetFunctionEventInvokeConfigInput) (*request.Request, *lambda.GetFunctionEventInvokeConfigOutput)) *LambdaApi_GetFunctionEventInvokeConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.GetFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.GetFunctionEventInvokeConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2217,6 +4541,43 @@ func (_m *LambdaApi) GetFunctionEventInvokeConfigWithContext(_a0 context.Context return r0, r1 } +// LambdaApi_GetFunctionEventInvokeConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionEventInvokeConfigWithContext' +type LambdaApi_GetFunctionEventInvokeConfigWithContext_Call struct { + *mock.Call +} + +// GetFunctionEventInvokeConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionEventInvokeConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetFunctionEventInvokeConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetFunctionEventInvokeConfigWithContext_Call { + return &LambdaApi_GetFunctionEventInvokeConfigWithContext_Call{Call: _e.mock.On("GetFunctionEventInvokeConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionEventInvokeConfigInput, _a2 ...request.Option)) *LambdaApi_GetFunctionEventInvokeConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionEventInvokeConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfigWithContext_Call) Return(_a0 *lambda.GetFunctionEventInvokeConfigOutput, _a1 error) *LambdaApi_GetFunctionEventInvokeConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionEventInvokeConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionEventInvokeConfigInput, ...request.Option) (*lambda.GetFunctionEventInvokeConfigOutput, error)) *LambdaApi_GetFunctionEventInvokeConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionRequest(_a0 *lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput) { ret := _m.Called(_a0) @@ -2245,6 +4606,34 @@ func (_m *LambdaApi) GetFunctionRequest(_a0 *lambda.GetFunctionInput) (*request. return r0, r1 } +// LambdaApi_GetFunctionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionRequest' +type LambdaApi_GetFunctionRequest_Call struct { + *mock.Call +} + +// GetFunctionRequest is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionInput +func (_e *LambdaApi_Expecter) GetFunctionRequest(_a0 interface{}) *LambdaApi_GetFunctionRequest_Call { + return &LambdaApi_GetFunctionRequest_Call{Call: _e.mock.On("GetFunctionRequest", _a0)} +} + +func (_c *LambdaApi_GetFunctionRequest_Call) Run(run func(_a0 *lambda.GetFunctionInput)) *LambdaApi_GetFunctionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetFunctionOutput) *LambdaApi_GetFunctionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionRequest_Call) RunAndReturn(run func(*lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput)) *LambdaApi_GetFunctionRequest_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionUrlConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionUrlConfig(_a0 *lambda.GetFunctionUrlConfigInput) (*lambda.GetFunctionUrlConfigOutput, error) { ret := _m.Called(_a0) @@ -2271,6 +4660,34 @@ func (_m *LambdaApi) GetFunctionUrlConfig(_a0 *lambda.GetFunctionUrlConfigInput) return r0, r1 } +// LambdaApi_GetFunctionUrlConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionUrlConfig' +type LambdaApi_GetFunctionUrlConfig_Call struct { + *mock.Call +} + +// GetFunctionUrlConfig is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionUrlConfigInput +func (_e *LambdaApi_Expecter) GetFunctionUrlConfig(_a0 interface{}) *LambdaApi_GetFunctionUrlConfig_Call { + return &LambdaApi_GetFunctionUrlConfig_Call{Call: _e.mock.On("GetFunctionUrlConfig", _a0)} +} + +func (_c *LambdaApi_GetFunctionUrlConfig_Call) Run(run func(_a0 *lambda.GetFunctionUrlConfigInput)) *LambdaApi_GetFunctionUrlConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionUrlConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionUrlConfig_Call) Return(_a0 *lambda.GetFunctionUrlConfigOutput, _a1 error) *LambdaApi_GetFunctionUrlConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionUrlConfig_Call) RunAndReturn(run func(*lambda.GetFunctionUrlConfigInput) (*lambda.GetFunctionUrlConfigOutput, error)) *LambdaApi_GetFunctionUrlConfig_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionUrlConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetFunctionUrlConfigRequest(_a0 *lambda.GetFunctionUrlConfigInput) (*request.Request, *lambda.GetFunctionUrlConfigOutput) { ret := _m.Called(_a0) @@ -2299,6 +4716,34 @@ func (_m *LambdaApi) GetFunctionUrlConfigRequest(_a0 *lambda.GetFunctionUrlConfi return r0, r1 } +// LambdaApi_GetFunctionUrlConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionUrlConfigRequest' +type LambdaApi_GetFunctionUrlConfigRequest_Call struct { + *mock.Call +} + +// GetFunctionUrlConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionUrlConfigInput +func (_e *LambdaApi_Expecter) GetFunctionUrlConfigRequest(_a0 interface{}) *LambdaApi_GetFunctionUrlConfigRequest_Call { + return &LambdaApi_GetFunctionUrlConfigRequest_Call{Call: _e.mock.On("GetFunctionUrlConfigRequest", _a0)} +} + +func (_c *LambdaApi_GetFunctionUrlConfigRequest_Call) Run(run func(_a0 *lambda.GetFunctionUrlConfigInput)) *LambdaApi_GetFunctionUrlConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionUrlConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionUrlConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetFunctionUrlConfigOutput) *LambdaApi_GetFunctionUrlConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionUrlConfigRequest_Call) RunAndReturn(run func(*lambda.GetFunctionUrlConfigInput) (*request.Request, *lambda.GetFunctionUrlConfigOutput)) *LambdaApi_GetFunctionUrlConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionUrlConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetFunctionUrlConfigWithContext(_a0 context.Context, _a1 *lambda.GetFunctionUrlConfigInput, _a2 ...request.Option) (*lambda.GetFunctionUrlConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2332,6 +4777,43 @@ func (_m *LambdaApi) GetFunctionUrlConfigWithContext(_a0 context.Context, _a1 *l return r0, r1 } +// LambdaApi_GetFunctionUrlConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionUrlConfigWithContext' +type LambdaApi_GetFunctionUrlConfigWithContext_Call struct { + *mock.Call +} + +// GetFunctionUrlConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionUrlConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetFunctionUrlConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetFunctionUrlConfigWithContext_Call { + return &LambdaApi_GetFunctionUrlConfigWithContext_Call{Call: _e.mock.On("GetFunctionUrlConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetFunctionUrlConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionUrlConfigInput, _a2 ...request.Option)) *LambdaApi_GetFunctionUrlConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionUrlConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionUrlConfigWithContext_Call) Return(_a0 *lambda.GetFunctionUrlConfigOutput, _a1 error) *LambdaApi_GetFunctionUrlConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionUrlConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionUrlConfigInput, ...request.Option) (*lambda.GetFunctionUrlConfigOutput, error)) *LambdaApi_GetFunctionUrlConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetFunctionWithContext(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.Option) (*lambda.GetFunctionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2365,6 +4847,43 @@ func (_m *LambdaApi) GetFunctionWithContext(_a0 context.Context, _a1 *lambda.Get return r0, r1 } +// LambdaApi_GetFunctionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionWithContext' +type LambdaApi_GetFunctionWithContext_Call struct { + *mock.Call +} + +// GetFunctionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetFunctionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetFunctionWithContext_Call { + return &LambdaApi_GetFunctionWithContext_Call{Call: _e.mock.On("GetFunctionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetFunctionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.Option)) *LambdaApi_GetFunctionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetFunctionWithContext_Call) Return(_a0 *lambda.GetFunctionOutput, _a1 error) *LambdaApi_GetFunctionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetFunctionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionInput, ...request.Option) (*lambda.GetFunctionOutput, error)) *LambdaApi_GetFunctionWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersion provides a mock function with given fields: _a0 func (_m *LambdaApi) GetLayerVersion(_a0 *lambda.GetLayerVersionInput) (*lambda.GetLayerVersionOutput, error) { ret := _m.Called(_a0) @@ -2391,6 +4910,34 @@ func (_m *LambdaApi) GetLayerVersion(_a0 *lambda.GetLayerVersionInput) (*lambda. return r0, r1 } +// LambdaApi_GetLayerVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersion' +type LambdaApi_GetLayerVersion_Call struct { + *mock.Call +} + +// GetLayerVersion is a helper method to define mock.On call +// - _a0 *lambda.GetLayerVersionInput +func (_e *LambdaApi_Expecter) GetLayerVersion(_a0 interface{}) *LambdaApi_GetLayerVersion_Call { + return &LambdaApi_GetLayerVersion_Call{Call: _e.mock.On("GetLayerVersion", _a0)} +} + +func (_c *LambdaApi_GetLayerVersion_Call) Run(run func(_a0 *lambda.GetLayerVersionInput)) *LambdaApi_GetLayerVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetLayerVersionInput)) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersion_Call) Return(_a0 *lambda.GetLayerVersionOutput, _a1 error) *LambdaApi_GetLayerVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersion_Call) RunAndReturn(run func(*lambda.GetLayerVersionInput) (*lambda.GetLayerVersionOutput, error)) *LambdaApi_GetLayerVersion_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersionByArn provides a mock function with given fields: _a0 func (_m *LambdaApi) GetLayerVersionByArn(_a0 *lambda.GetLayerVersionByArnInput) (*lambda.GetLayerVersionByArnOutput, error) { ret := _m.Called(_a0) @@ -2417,6 +4964,34 @@ func (_m *LambdaApi) GetLayerVersionByArn(_a0 *lambda.GetLayerVersionByArnInput) return r0, r1 } +// LambdaApi_GetLayerVersionByArn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersionByArn' +type LambdaApi_GetLayerVersionByArn_Call struct { + *mock.Call +} + +// GetLayerVersionByArn is a helper method to define mock.On call +// - _a0 *lambda.GetLayerVersionByArnInput +func (_e *LambdaApi_Expecter) GetLayerVersionByArn(_a0 interface{}) *LambdaApi_GetLayerVersionByArn_Call { + return &LambdaApi_GetLayerVersionByArn_Call{Call: _e.mock.On("GetLayerVersionByArn", _a0)} +} + +func (_c *LambdaApi_GetLayerVersionByArn_Call) Run(run func(_a0 *lambda.GetLayerVersionByArnInput)) *LambdaApi_GetLayerVersionByArn_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetLayerVersionByArnInput)) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersionByArn_Call) Return(_a0 *lambda.GetLayerVersionByArnOutput, _a1 error) *LambdaApi_GetLayerVersionByArn_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersionByArn_Call) RunAndReturn(run func(*lambda.GetLayerVersionByArnInput) (*lambda.GetLayerVersionByArnOutput, error)) *LambdaApi_GetLayerVersionByArn_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersionByArnRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetLayerVersionByArnRequest(_a0 *lambda.GetLayerVersionByArnInput) (*request.Request, *lambda.GetLayerVersionByArnOutput) { ret := _m.Called(_a0) @@ -2445,6 +5020,34 @@ func (_m *LambdaApi) GetLayerVersionByArnRequest(_a0 *lambda.GetLayerVersionByAr return r0, r1 } +// LambdaApi_GetLayerVersionByArnRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersionByArnRequest' +type LambdaApi_GetLayerVersionByArnRequest_Call struct { + *mock.Call +} + +// GetLayerVersionByArnRequest is a helper method to define mock.On call +// - _a0 *lambda.GetLayerVersionByArnInput +func (_e *LambdaApi_Expecter) GetLayerVersionByArnRequest(_a0 interface{}) *LambdaApi_GetLayerVersionByArnRequest_Call { + return &LambdaApi_GetLayerVersionByArnRequest_Call{Call: _e.mock.On("GetLayerVersionByArnRequest", _a0)} +} + +func (_c *LambdaApi_GetLayerVersionByArnRequest_Call) Run(run func(_a0 *lambda.GetLayerVersionByArnInput)) *LambdaApi_GetLayerVersionByArnRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetLayerVersionByArnInput)) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersionByArnRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetLayerVersionByArnOutput) *LambdaApi_GetLayerVersionByArnRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersionByArnRequest_Call) RunAndReturn(run func(*lambda.GetLayerVersionByArnInput) (*request.Request, *lambda.GetLayerVersionByArnOutput)) *LambdaApi_GetLayerVersionByArnRequest_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersionByArnWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetLayerVersionByArnWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionByArnInput, _a2 ...request.Option) (*lambda.GetLayerVersionByArnOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2478,6 +5081,43 @@ func (_m *LambdaApi) GetLayerVersionByArnWithContext(_a0 context.Context, _a1 *l return r0, r1 } +// LambdaApi_GetLayerVersionByArnWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersionByArnWithContext' +type LambdaApi_GetLayerVersionByArnWithContext_Call struct { + *mock.Call +} + +// GetLayerVersionByArnWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetLayerVersionByArnInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetLayerVersionByArnWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetLayerVersionByArnWithContext_Call { + return &LambdaApi_GetLayerVersionByArnWithContext_Call{Call: _e.mock.On("GetLayerVersionByArnWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetLayerVersionByArnWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetLayerVersionByArnInput, _a2 ...request.Option)) *LambdaApi_GetLayerVersionByArnWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetLayerVersionByArnInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersionByArnWithContext_Call) Return(_a0 *lambda.GetLayerVersionByArnOutput, _a1 error) *LambdaApi_GetLayerVersionByArnWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersionByArnWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetLayerVersionByArnInput, ...request.Option) (*lambda.GetLayerVersionByArnOutput, error)) *LambdaApi_GetLayerVersionByArnWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersionPolicy provides a mock function with given fields: _a0 func (_m *LambdaApi) GetLayerVersionPolicy(_a0 *lambda.GetLayerVersionPolicyInput) (*lambda.GetLayerVersionPolicyOutput, error) { ret := _m.Called(_a0) @@ -2504,6 +5144,34 @@ func (_m *LambdaApi) GetLayerVersionPolicy(_a0 *lambda.GetLayerVersionPolicyInpu return r0, r1 } +// LambdaApi_GetLayerVersionPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersionPolicy' +type LambdaApi_GetLayerVersionPolicy_Call struct { + *mock.Call +} + +// GetLayerVersionPolicy is a helper method to define mock.On call +// - _a0 *lambda.GetLayerVersionPolicyInput +func (_e *LambdaApi_Expecter) GetLayerVersionPolicy(_a0 interface{}) *LambdaApi_GetLayerVersionPolicy_Call { + return &LambdaApi_GetLayerVersionPolicy_Call{Call: _e.mock.On("GetLayerVersionPolicy", _a0)} +} + +func (_c *LambdaApi_GetLayerVersionPolicy_Call) Run(run func(_a0 *lambda.GetLayerVersionPolicyInput)) *LambdaApi_GetLayerVersionPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetLayerVersionPolicyInput)) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersionPolicy_Call) Return(_a0 *lambda.GetLayerVersionPolicyOutput, _a1 error) *LambdaApi_GetLayerVersionPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersionPolicy_Call) RunAndReturn(run func(*lambda.GetLayerVersionPolicyInput) (*lambda.GetLayerVersionPolicyOutput, error)) *LambdaApi_GetLayerVersionPolicy_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersionPolicyRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetLayerVersionPolicyRequest(_a0 *lambda.GetLayerVersionPolicyInput) (*request.Request, *lambda.GetLayerVersionPolicyOutput) { ret := _m.Called(_a0) @@ -2532,6 +5200,34 @@ func (_m *LambdaApi) GetLayerVersionPolicyRequest(_a0 *lambda.GetLayerVersionPol return r0, r1 } +// LambdaApi_GetLayerVersionPolicyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersionPolicyRequest' +type LambdaApi_GetLayerVersionPolicyRequest_Call struct { + *mock.Call +} + +// GetLayerVersionPolicyRequest is a helper method to define mock.On call +// - _a0 *lambda.GetLayerVersionPolicyInput +func (_e *LambdaApi_Expecter) GetLayerVersionPolicyRequest(_a0 interface{}) *LambdaApi_GetLayerVersionPolicyRequest_Call { + return &LambdaApi_GetLayerVersionPolicyRequest_Call{Call: _e.mock.On("GetLayerVersionPolicyRequest", _a0)} +} + +func (_c *LambdaApi_GetLayerVersionPolicyRequest_Call) Run(run func(_a0 *lambda.GetLayerVersionPolicyInput)) *LambdaApi_GetLayerVersionPolicyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetLayerVersionPolicyInput)) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersionPolicyRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetLayerVersionPolicyOutput) *LambdaApi_GetLayerVersionPolicyRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersionPolicyRequest_Call) RunAndReturn(run func(*lambda.GetLayerVersionPolicyInput) (*request.Request, *lambda.GetLayerVersionPolicyOutput)) *LambdaApi_GetLayerVersionPolicyRequest_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersionPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetLayerVersionPolicyWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionPolicyInput, _a2 ...request.Option) (*lambda.GetLayerVersionPolicyOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2565,6 +5261,43 @@ func (_m *LambdaApi) GetLayerVersionPolicyWithContext(_a0 context.Context, _a1 * return r0, r1 } +// LambdaApi_GetLayerVersionPolicyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersionPolicyWithContext' +type LambdaApi_GetLayerVersionPolicyWithContext_Call struct { + *mock.Call +} + +// GetLayerVersionPolicyWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetLayerVersionPolicyInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetLayerVersionPolicyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetLayerVersionPolicyWithContext_Call { + return &LambdaApi_GetLayerVersionPolicyWithContext_Call{Call: _e.mock.On("GetLayerVersionPolicyWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetLayerVersionPolicyWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetLayerVersionPolicyInput, _a2 ...request.Option)) *LambdaApi_GetLayerVersionPolicyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetLayerVersionPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersionPolicyWithContext_Call) Return(_a0 *lambda.GetLayerVersionPolicyOutput, _a1 error) *LambdaApi_GetLayerVersionPolicyWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersionPolicyWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetLayerVersionPolicyInput, ...request.Option) (*lambda.GetLayerVersionPolicyOutput, error)) *LambdaApi_GetLayerVersionPolicyWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetLayerVersionRequest(_a0 *lambda.GetLayerVersionInput) (*request.Request, *lambda.GetLayerVersionOutput) { ret := _m.Called(_a0) @@ -2593,6 +5326,34 @@ func (_m *LambdaApi) GetLayerVersionRequest(_a0 *lambda.GetLayerVersionInput) (* return r0, r1 } +// LambdaApi_GetLayerVersionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersionRequest' +type LambdaApi_GetLayerVersionRequest_Call struct { + *mock.Call +} + +// GetLayerVersionRequest is a helper method to define mock.On call +// - _a0 *lambda.GetLayerVersionInput +func (_e *LambdaApi_Expecter) GetLayerVersionRequest(_a0 interface{}) *LambdaApi_GetLayerVersionRequest_Call { + return &LambdaApi_GetLayerVersionRequest_Call{Call: _e.mock.On("GetLayerVersionRequest", _a0)} +} + +func (_c *LambdaApi_GetLayerVersionRequest_Call) Run(run func(_a0 *lambda.GetLayerVersionInput)) *LambdaApi_GetLayerVersionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetLayerVersionInput)) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetLayerVersionOutput) *LambdaApi_GetLayerVersionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersionRequest_Call) RunAndReturn(run func(*lambda.GetLayerVersionInput) (*request.Request, *lambda.GetLayerVersionOutput)) *LambdaApi_GetLayerVersionRequest_Call { + _c.Call.Return(run) + return _c +} + // GetLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetLayerVersionWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionInput, _a2 ...request.Option) (*lambda.GetLayerVersionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2626,6 +5387,43 @@ func (_m *LambdaApi) GetLayerVersionWithContext(_a0 context.Context, _a1 *lambda return r0, r1 } +// LambdaApi_GetLayerVersionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLayerVersionWithContext' +type LambdaApi_GetLayerVersionWithContext_Call struct { + *mock.Call +} + +// GetLayerVersionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetLayerVersionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetLayerVersionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetLayerVersionWithContext_Call { + return &LambdaApi_GetLayerVersionWithContext_Call{Call: _e.mock.On("GetLayerVersionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetLayerVersionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetLayerVersionInput, _a2 ...request.Option)) *LambdaApi_GetLayerVersionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetLayerVersionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetLayerVersionWithContext_Call) Return(_a0 *lambda.GetLayerVersionOutput, _a1 error) *LambdaApi_GetLayerVersionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetLayerVersionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetLayerVersionInput, ...request.Option) (*lambda.GetLayerVersionOutput, error)) *LambdaApi_GetLayerVersionWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetPolicy provides a mock function with given fields: _a0 func (_m *LambdaApi) GetPolicy(_a0 *lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error) { ret := _m.Called(_a0) @@ -2652,6 +5450,34 @@ func (_m *LambdaApi) GetPolicy(_a0 *lambda.GetPolicyInput) (*lambda.GetPolicyOut return r0, r1 } +// LambdaApi_GetPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicy' +type LambdaApi_GetPolicy_Call struct { + *mock.Call +} + +// GetPolicy is a helper method to define mock.On call +// - _a0 *lambda.GetPolicyInput +func (_e *LambdaApi_Expecter) GetPolicy(_a0 interface{}) *LambdaApi_GetPolicy_Call { + return &LambdaApi_GetPolicy_Call{Call: _e.mock.On("GetPolicy", _a0)} +} + +func (_c *LambdaApi_GetPolicy_Call) Run(run func(_a0 *lambda.GetPolicyInput)) *LambdaApi_GetPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetPolicyInput)) + }) + return _c +} + +func (_c *LambdaApi_GetPolicy_Call) Return(_a0 *lambda.GetPolicyOutput, _a1 error) *LambdaApi_GetPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetPolicy_Call) RunAndReturn(run func(*lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error)) *LambdaApi_GetPolicy_Call { + _c.Call.Return(run) + return _c +} + // GetPolicyRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetPolicyRequest(_a0 *lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput) { ret := _m.Called(_a0) @@ -2680,6 +5506,34 @@ func (_m *LambdaApi) GetPolicyRequest(_a0 *lambda.GetPolicyInput) (*request.Requ return r0, r1 } +// LambdaApi_GetPolicyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicyRequest' +type LambdaApi_GetPolicyRequest_Call struct { + *mock.Call +} + +// GetPolicyRequest is a helper method to define mock.On call +// - _a0 *lambda.GetPolicyInput +func (_e *LambdaApi_Expecter) GetPolicyRequest(_a0 interface{}) *LambdaApi_GetPolicyRequest_Call { + return &LambdaApi_GetPolicyRequest_Call{Call: _e.mock.On("GetPolicyRequest", _a0)} +} + +func (_c *LambdaApi_GetPolicyRequest_Call) Run(run func(_a0 *lambda.GetPolicyInput)) *LambdaApi_GetPolicyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetPolicyInput)) + }) + return _c +} + +func (_c *LambdaApi_GetPolicyRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetPolicyOutput) *LambdaApi_GetPolicyRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetPolicyRequest_Call) RunAndReturn(run func(*lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput)) *LambdaApi_GetPolicyRequest_Call { + _c.Call.Return(run) + return _c +} + // GetPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetPolicyWithContext(_a0 context.Context, _a1 *lambda.GetPolicyInput, _a2 ...request.Option) (*lambda.GetPolicyOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2713,6 +5567,43 @@ func (_m *LambdaApi) GetPolicyWithContext(_a0 context.Context, _a1 *lambda.GetPo return r0, r1 } +// LambdaApi_GetPolicyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicyWithContext' +type LambdaApi_GetPolicyWithContext_Call struct { + *mock.Call +} + +// GetPolicyWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetPolicyInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetPolicyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetPolicyWithContext_Call { + return &LambdaApi_GetPolicyWithContext_Call{Call: _e.mock.On("GetPolicyWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetPolicyWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetPolicyInput, _a2 ...request.Option)) *LambdaApi_GetPolicyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetPolicyWithContext_Call) Return(_a0 *lambda.GetPolicyOutput, _a1 error) *LambdaApi_GetPolicyWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetPolicyWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetPolicyInput, ...request.Option) (*lambda.GetPolicyOutput, error)) *LambdaApi_GetPolicyWithContext_Call { + _c.Call.Return(run) + return _c +} + // GetProvisionedConcurrencyConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) GetProvisionedConcurrencyConfig(_a0 *lambda.GetProvisionedConcurrencyConfigInput) (*lambda.GetProvisionedConcurrencyConfigOutput, error) { ret := _m.Called(_a0) @@ -2739,6 +5630,34 @@ func (_m *LambdaApi) GetProvisionedConcurrencyConfig(_a0 *lambda.GetProvisionedC return r0, r1 } +// LambdaApi_GetProvisionedConcurrencyConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProvisionedConcurrencyConfig' +type LambdaApi_GetProvisionedConcurrencyConfig_Call struct { + *mock.Call +} + +// GetProvisionedConcurrencyConfig is a helper method to define mock.On call +// - _a0 *lambda.GetProvisionedConcurrencyConfigInput +func (_e *LambdaApi_Expecter) GetProvisionedConcurrencyConfig(_a0 interface{}) *LambdaApi_GetProvisionedConcurrencyConfig_Call { + return &LambdaApi_GetProvisionedConcurrencyConfig_Call{Call: _e.mock.On("GetProvisionedConcurrencyConfig", _a0)} +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfig_Call) Run(run func(_a0 *lambda.GetProvisionedConcurrencyConfigInput)) *LambdaApi_GetProvisionedConcurrencyConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetProvisionedConcurrencyConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfig_Call) Return(_a0 *lambda.GetProvisionedConcurrencyConfigOutput, _a1 error) *LambdaApi_GetProvisionedConcurrencyConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfig_Call) RunAndReturn(run func(*lambda.GetProvisionedConcurrencyConfigInput) (*lambda.GetProvisionedConcurrencyConfigOutput, error)) *LambdaApi_GetProvisionedConcurrencyConfig_Call { + _c.Call.Return(run) + return _c +} + // GetProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) GetProvisionedConcurrencyConfigRequest(_a0 *lambda.GetProvisionedConcurrencyConfigInput) (*request.Request, *lambda.GetProvisionedConcurrencyConfigOutput) { ret := _m.Called(_a0) @@ -2767,6 +5686,34 @@ func (_m *LambdaApi) GetProvisionedConcurrencyConfigRequest(_a0 *lambda.GetProvi return r0, r1 } +// LambdaApi_GetProvisionedConcurrencyConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProvisionedConcurrencyConfigRequest' +type LambdaApi_GetProvisionedConcurrencyConfigRequest_Call struct { + *mock.Call +} + +// GetProvisionedConcurrencyConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.GetProvisionedConcurrencyConfigInput +func (_e *LambdaApi_Expecter) GetProvisionedConcurrencyConfigRequest(_a0 interface{}) *LambdaApi_GetProvisionedConcurrencyConfigRequest_Call { + return &LambdaApi_GetProvisionedConcurrencyConfigRequest_Call{Call: _e.mock.On("GetProvisionedConcurrencyConfigRequest", _a0)} +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfigRequest_Call) Run(run func(_a0 *lambda.GetProvisionedConcurrencyConfigInput)) *LambdaApi_GetProvisionedConcurrencyConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetProvisionedConcurrencyConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.GetProvisionedConcurrencyConfigOutput) *LambdaApi_GetProvisionedConcurrencyConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfigRequest_Call) RunAndReturn(run func(*lambda.GetProvisionedConcurrencyConfigInput) (*request.Request, *lambda.GetProvisionedConcurrencyConfigOutput)) *LambdaApi_GetProvisionedConcurrencyConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // GetProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) GetProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.GetProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.GetProvisionedConcurrencyConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2800,6 +5747,43 @@ func (_m *LambdaApi) GetProvisionedConcurrencyConfigWithContext(_a0 context.Cont return r0, r1 } +// LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProvisionedConcurrencyConfigWithContext' +type LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call struct { + *mock.Call +} + +// GetProvisionedConcurrencyConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetProvisionedConcurrencyConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) GetProvisionedConcurrencyConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call { + return &LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call{Call: _e.mock.On("GetProvisionedConcurrencyConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetProvisionedConcurrencyConfigInput, _a2 ...request.Option)) *LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetProvisionedConcurrencyConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call) Return(_a0 *lambda.GetProvisionedConcurrencyConfigOutput, _a1 error) *LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetProvisionedConcurrencyConfigInput, ...request.Option) (*lambda.GetProvisionedConcurrencyConfigOutput, error)) *LambdaApi_GetProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // Invoke provides a mock function with given fields: _a0 func (_m *LambdaApi) Invoke(_a0 *lambda.InvokeInput) (*lambda.InvokeOutput, error) { ret := _m.Called(_a0) @@ -2826,9 +5810,37 @@ func (_m *LambdaApi) Invoke(_a0 *lambda.InvokeInput) (*lambda.InvokeOutput, erro return r0, r1 } -// InvokeAsync provides a mock function with given fields: _a0 -func (_m *LambdaApi) InvokeAsync(_a0 *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) { - ret := _m.Called(_a0) +// LambdaApi_Invoke_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Invoke' +type LambdaApi_Invoke_Call struct { + *mock.Call +} + +// Invoke is a helper method to define mock.On call +// - _a0 *lambda.InvokeInput +func (_e *LambdaApi_Expecter) Invoke(_a0 interface{}) *LambdaApi_Invoke_Call { + return &LambdaApi_Invoke_Call{Call: _e.mock.On("Invoke", _a0)} +} + +func (_c *LambdaApi_Invoke_Call) Run(run func(_a0 *lambda.InvokeInput)) *LambdaApi_Invoke_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.InvokeInput)) + }) + return _c +} + +func (_c *LambdaApi_Invoke_Call) Return(_a0 *lambda.InvokeOutput, _a1 error) *LambdaApi_Invoke_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_Invoke_Call) RunAndReturn(run func(*lambda.InvokeInput) (*lambda.InvokeOutput, error)) *LambdaApi_Invoke_Call { + _c.Call.Return(run) + return _c +} + +// InvokeAsync provides a mock function with given fields: _a0 +func (_m *LambdaApi) InvokeAsync(_a0 *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) { + ret := _m.Called(_a0) var r0 *lambda.InvokeAsyncOutput var r1 error @@ -2852,6 +5864,34 @@ func (_m *LambdaApi) InvokeAsync(_a0 *lambda.InvokeAsyncInput) (*lambda.InvokeAs return r0, r1 } +// LambdaApi_InvokeAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvokeAsync' +type LambdaApi_InvokeAsync_Call struct { + *mock.Call +} + +// InvokeAsync is a helper method to define mock.On call +// - _a0 *lambda.InvokeAsyncInput +func (_e *LambdaApi_Expecter) InvokeAsync(_a0 interface{}) *LambdaApi_InvokeAsync_Call { + return &LambdaApi_InvokeAsync_Call{Call: _e.mock.On("InvokeAsync", _a0)} +} + +func (_c *LambdaApi_InvokeAsync_Call) Run(run func(_a0 *lambda.InvokeAsyncInput)) *LambdaApi_InvokeAsync_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.InvokeAsyncInput)) + }) + return _c +} + +func (_c *LambdaApi_InvokeAsync_Call) Return(_a0 *lambda.InvokeAsyncOutput, _a1 error) *LambdaApi_InvokeAsync_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_InvokeAsync_Call) RunAndReturn(run func(*lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error)) *LambdaApi_InvokeAsync_Call { + _c.Call.Return(run) + return _c +} + // InvokeAsyncRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) InvokeAsyncRequest(_a0 *lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput) { ret := _m.Called(_a0) @@ -2880,6 +5920,34 @@ func (_m *LambdaApi) InvokeAsyncRequest(_a0 *lambda.InvokeAsyncInput) (*request. return r0, r1 } +// LambdaApi_InvokeAsyncRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvokeAsyncRequest' +type LambdaApi_InvokeAsyncRequest_Call struct { + *mock.Call +} + +// InvokeAsyncRequest is a helper method to define mock.On call +// - _a0 *lambda.InvokeAsyncInput +func (_e *LambdaApi_Expecter) InvokeAsyncRequest(_a0 interface{}) *LambdaApi_InvokeAsyncRequest_Call { + return &LambdaApi_InvokeAsyncRequest_Call{Call: _e.mock.On("InvokeAsyncRequest", _a0)} +} + +func (_c *LambdaApi_InvokeAsyncRequest_Call) Run(run func(_a0 *lambda.InvokeAsyncInput)) *LambdaApi_InvokeAsyncRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.InvokeAsyncInput)) + }) + return _c +} + +func (_c *LambdaApi_InvokeAsyncRequest_Call) Return(_a0 *request.Request, _a1 *lambda.InvokeAsyncOutput) *LambdaApi_InvokeAsyncRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_InvokeAsyncRequest_Call) RunAndReturn(run func(*lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput)) *LambdaApi_InvokeAsyncRequest_Call { + _c.Call.Return(run) + return _c +} + // InvokeAsyncWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) InvokeAsyncWithContext(_a0 context.Context, _a1 *lambda.InvokeAsyncInput, _a2 ...request.Option) (*lambda.InvokeAsyncOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2913,6 +5981,43 @@ func (_m *LambdaApi) InvokeAsyncWithContext(_a0 context.Context, _a1 *lambda.Inv return r0, r1 } +// LambdaApi_InvokeAsyncWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvokeAsyncWithContext' +type LambdaApi_InvokeAsyncWithContext_Call struct { + *mock.Call +} + +// InvokeAsyncWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.InvokeAsyncInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) InvokeAsyncWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_InvokeAsyncWithContext_Call { + return &LambdaApi_InvokeAsyncWithContext_Call{Call: _e.mock.On("InvokeAsyncWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_InvokeAsyncWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.InvokeAsyncInput, _a2 ...request.Option)) *LambdaApi_InvokeAsyncWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.InvokeAsyncInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_InvokeAsyncWithContext_Call) Return(_a0 *lambda.InvokeAsyncOutput, _a1 error) *LambdaApi_InvokeAsyncWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_InvokeAsyncWithContext_Call) RunAndReturn(run func(context.Context, *lambda.InvokeAsyncInput, ...request.Option) (*lambda.InvokeAsyncOutput, error)) *LambdaApi_InvokeAsyncWithContext_Call { + _c.Call.Return(run) + return _c +} + // InvokeRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) InvokeRequest(_a0 *lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput) { ret := _m.Called(_a0) @@ -2941,6 +6046,34 @@ func (_m *LambdaApi) InvokeRequest(_a0 *lambda.InvokeInput) (*request.Request, * return r0, r1 } +// LambdaApi_InvokeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvokeRequest' +type LambdaApi_InvokeRequest_Call struct { + *mock.Call +} + +// InvokeRequest is a helper method to define mock.On call +// - _a0 *lambda.InvokeInput +func (_e *LambdaApi_Expecter) InvokeRequest(_a0 interface{}) *LambdaApi_InvokeRequest_Call { + return &LambdaApi_InvokeRequest_Call{Call: _e.mock.On("InvokeRequest", _a0)} +} + +func (_c *LambdaApi_InvokeRequest_Call) Run(run func(_a0 *lambda.InvokeInput)) *LambdaApi_InvokeRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.InvokeInput)) + }) + return _c +} + +func (_c *LambdaApi_InvokeRequest_Call) Return(_a0 *request.Request, _a1 *lambda.InvokeOutput) *LambdaApi_InvokeRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_InvokeRequest_Call) RunAndReturn(run func(*lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput)) *LambdaApi_InvokeRequest_Call { + _c.Call.Return(run) + return _c +} + // InvokeWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) InvokeWithContext(_a0 context.Context, _a1 *lambda.InvokeInput, _a2 ...request.Option) (*lambda.InvokeOutput, error) { _va := make([]interface{}, len(_a2)) @@ -2974,6 +6107,43 @@ func (_m *LambdaApi) InvokeWithContext(_a0 context.Context, _a1 *lambda.InvokeIn return r0, r1 } +// LambdaApi_InvokeWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvokeWithContext' +type LambdaApi_InvokeWithContext_Call struct { + *mock.Call +} + +// InvokeWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.InvokeInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) InvokeWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_InvokeWithContext_Call { + return &LambdaApi_InvokeWithContext_Call{Call: _e.mock.On("InvokeWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_InvokeWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.InvokeInput, _a2 ...request.Option)) *LambdaApi_InvokeWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.InvokeInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_InvokeWithContext_Call) Return(_a0 *lambda.InvokeOutput, _a1 error) *LambdaApi_InvokeWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_InvokeWithContext_Call) RunAndReturn(run func(context.Context, *lambda.InvokeInput, ...request.Option) (*lambda.InvokeOutput, error)) *LambdaApi_InvokeWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListAliases provides a mock function with given fields: _a0 func (_m *LambdaApi) ListAliases(_a0 *lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error) { ret := _m.Called(_a0) @@ -3000,6 +6170,34 @@ func (_m *LambdaApi) ListAliases(_a0 *lambda.ListAliasesInput) (*lambda.ListAlia return r0, r1 } +// LambdaApi_ListAliases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAliases' +type LambdaApi_ListAliases_Call struct { + *mock.Call +} + +// ListAliases is a helper method to define mock.On call +// - _a0 *lambda.ListAliasesInput +func (_e *LambdaApi_Expecter) ListAliases(_a0 interface{}) *LambdaApi_ListAliases_Call { + return &LambdaApi_ListAliases_Call{Call: _e.mock.On("ListAliases", _a0)} +} + +func (_c *LambdaApi_ListAliases_Call) Run(run func(_a0 *lambda.ListAliasesInput)) *LambdaApi_ListAliases_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListAliasesInput)) + }) + return _c +} + +func (_c *LambdaApi_ListAliases_Call) Return(_a0 *lambda.ListAliasesOutput, _a1 error) *LambdaApi_ListAliases_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListAliases_Call) RunAndReturn(run func(*lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error)) *LambdaApi_ListAliases_Call { + _c.Call.Return(run) + return _c +} + // ListAliasesPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListAliasesPages(_a0 *lambda.ListAliasesInput, _a1 func(*lambda.ListAliasesOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3014,6 +6212,35 @@ func (_m *LambdaApi) ListAliasesPages(_a0 *lambda.ListAliasesInput, _a1 func(*la return r0 } +// LambdaApi_ListAliasesPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAliasesPages' +type LambdaApi_ListAliasesPages_Call struct { + *mock.Call +} + +// ListAliasesPages is a helper method to define mock.On call +// - _a0 *lambda.ListAliasesInput +// - _a1 func(*lambda.ListAliasesOutput , bool) bool +func (_e *LambdaApi_Expecter) ListAliasesPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListAliasesPages_Call { + return &LambdaApi_ListAliasesPages_Call{Call: _e.mock.On("ListAliasesPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListAliasesPages_Call) Run(run func(_a0 *lambda.ListAliasesInput, _a1 func(*lambda.ListAliasesOutput, bool) bool)) *LambdaApi_ListAliasesPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListAliasesInput), args[1].(func(*lambda.ListAliasesOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListAliasesPages_Call) Return(_a0 error) *LambdaApi_ListAliasesPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListAliasesPages_Call) RunAndReturn(run func(*lambda.ListAliasesInput, func(*lambda.ListAliasesOutput, bool) bool) error) *LambdaApi_ListAliasesPages_Call { + _c.Call.Return(run) + return _c +} + // ListAliasesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListAliasesPagesWithContext(_a0 context.Context, _a1 *lambda.ListAliasesInput, _a2 func(*lambda.ListAliasesOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -3035,6 +6262,44 @@ func (_m *LambdaApi) ListAliasesPagesWithContext(_a0 context.Context, _a1 *lambd return r0 } +// LambdaApi_ListAliasesPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAliasesPagesWithContext' +type LambdaApi_ListAliasesPagesWithContext_Call struct { + *mock.Call +} + +// ListAliasesPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListAliasesInput +// - _a2 func(*lambda.ListAliasesOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListAliasesPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListAliasesPagesWithContext_Call { + return &LambdaApi_ListAliasesPagesWithContext_Call{Call: _e.mock.On("ListAliasesPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListAliasesPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListAliasesInput, _a2 func(*lambda.ListAliasesOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListAliasesPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListAliasesInput), args[2].(func(*lambda.ListAliasesOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListAliasesPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListAliasesPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListAliasesPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListAliasesInput, func(*lambda.ListAliasesOutput, bool) bool, ...request.Option) error) *LambdaApi_ListAliasesPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListAliasesRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListAliasesRequest(_a0 *lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput) { ret := _m.Called(_a0) @@ -3063,6 +6328,34 @@ func (_m *LambdaApi) ListAliasesRequest(_a0 *lambda.ListAliasesInput) (*request. return r0, r1 } +// LambdaApi_ListAliasesRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAliasesRequest' +type LambdaApi_ListAliasesRequest_Call struct { + *mock.Call +} + +// ListAliasesRequest is a helper method to define mock.On call +// - _a0 *lambda.ListAliasesInput +func (_e *LambdaApi_Expecter) ListAliasesRequest(_a0 interface{}) *LambdaApi_ListAliasesRequest_Call { + return &LambdaApi_ListAliasesRequest_Call{Call: _e.mock.On("ListAliasesRequest", _a0)} +} + +func (_c *LambdaApi_ListAliasesRequest_Call) Run(run func(_a0 *lambda.ListAliasesInput)) *LambdaApi_ListAliasesRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListAliasesInput)) + }) + return _c +} + +func (_c *LambdaApi_ListAliasesRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListAliasesOutput) *LambdaApi_ListAliasesRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListAliasesRequest_Call) RunAndReturn(run func(*lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput)) *LambdaApi_ListAliasesRequest_Call { + _c.Call.Return(run) + return _c +} + // ListAliasesWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListAliasesWithContext(_a0 context.Context, _a1 *lambda.ListAliasesInput, _a2 ...request.Option) (*lambda.ListAliasesOutput, error) { _va := make([]interface{}, len(_a2)) @@ -3096,6 +6389,43 @@ func (_m *LambdaApi) ListAliasesWithContext(_a0 context.Context, _a1 *lambda.Lis return r0, r1 } +// LambdaApi_ListAliasesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAliasesWithContext' +type LambdaApi_ListAliasesWithContext_Call struct { + *mock.Call +} + +// ListAliasesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListAliasesInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListAliasesWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListAliasesWithContext_Call { + return &LambdaApi_ListAliasesWithContext_Call{Call: _e.mock.On("ListAliasesWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListAliasesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListAliasesInput, _a2 ...request.Option)) *LambdaApi_ListAliasesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListAliasesInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListAliasesWithContext_Call) Return(_a0 *lambda.ListAliasesOutput, _a1 error) *LambdaApi_ListAliasesWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListAliasesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListAliasesInput, ...request.Option) (*lambda.ListAliasesOutput, error)) *LambdaApi_ListAliasesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListCodeSigningConfigs provides a mock function with given fields: _a0 func (_m *LambdaApi) ListCodeSigningConfigs(_a0 *lambda.ListCodeSigningConfigsInput) (*lambda.ListCodeSigningConfigsOutput, error) { ret := _m.Called(_a0) @@ -3122,6 +6452,34 @@ func (_m *LambdaApi) ListCodeSigningConfigs(_a0 *lambda.ListCodeSigningConfigsIn return r0, r1 } +// LambdaApi_ListCodeSigningConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCodeSigningConfigs' +type LambdaApi_ListCodeSigningConfigs_Call struct { + *mock.Call +} + +// ListCodeSigningConfigs is a helper method to define mock.On call +// - _a0 *lambda.ListCodeSigningConfigsInput +func (_e *LambdaApi_Expecter) ListCodeSigningConfigs(_a0 interface{}) *LambdaApi_ListCodeSigningConfigs_Call { + return &LambdaApi_ListCodeSigningConfigs_Call{Call: _e.mock.On("ListCodeSigningConfigs", _a0)} +} + +func (_c *LambdaApi_ListCodeSigningConfigs_Call) Run(run func(_a0 *lambda.ListCodeSigningConfigsInput)) *LambdaApi_ListCodeSigningConfigs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListCodeSigningConfigsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigs_Call) Return(_a0 *lambda.ListCodeSigningConfigsOutput, _a1 error) *LambdaApi_ListCodeSigningConfigs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigs_Call) RunAndReturn(run func(*lambda.ListCodeSigningConfigsInput) (*lambda.ListCodeSigningConfigsOutput, error)) *LambdaApi_ListCodeSigningConfigs_Call { + _c.Call.Return(run) + return _c +} + // ListCodeSigningConfigsPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListCodeSigningConfigsPages(_a0 *lambda.ListCodeSigningConfigsInput, _a1 func(*lambda.ListCodeSigningConfigsOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3136,6 +6494,35 @@ func (_m *LambdaApi) ListCodeSigningConfigsPages(_a0 *lambda.ListCodeSigningConf return r0 } +// LambdaApi_ListCodeSigningConfigsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCodeSigningConfigsPages' +type LambdaApi_ListCodeSigningConfigsPages_Call struct { + *mock.Call +} + +// ListCodeSigningConfigsPages is a helper method to define mock.On call +// - _a0 *lambda.ListCodeSigningConfigsInput +// - _a1 func(*lambda.ListCodeSigningConfigsOutput , bool) bool +func (_e *LambdaApi_Expecter) ListCodeSigningConfigsPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListCodeSigningConfigsPages_Call { + return &LambdaApi_ListCodeSigningConfigsPages_Call{Call: _e.mock.On("ListCodeSigningConfigsPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListCodeSigningConfigsPages_Call) Run(run func(_a0 *lambda.ListCodeSigningConfigsInput, _a1 func(*lambda.ListCodeSigningConfigsOutput, bool) bool)) *LambdaApi_ListCodeSigningConfigsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListCodeSigningConfigsInput), args[1].(func(*lambda.ListCodeSigningConfigsOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigsPages_Call) Return(_a0 error) *LambdaApi_ListCodeSigningConfigsPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigsPages_Call) RunAndReturn(run func(*lambda.ListCodeSigningConfigsInput, func(*lambda.ListCodeSigningConfigsOutput, bool) bool) error) *LambdaApi_ListCodeSigningConfigsPages_Call { + _c.Call.Return(run) + return _c +} + // ListCodeSigningConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListCodeSigningConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListCodeSigningConfigsInput, _a2 func(*lambda.ListCodeSigningConfigsOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -3157,6 +6544,44 @@ func (_m *LambdaApi) ListCodeSigningConfigsPagesWithContext(_a0 context.Context, return r0 } +// LambdaApi_ListCodeSigningConfigsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCodeSigningConfigsPagesWithContext' +type LambdaApi_ListCodeSigningConfigsPagesWithContext_Call struct { + *mock.Call +} + +// ListCodeSigningConfigsPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListCodeSigningConfigsInput +// - _a2 func(*lambda.ListCodeSigningConfigsOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListCodeSigningConfigsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListCodeSigningConfigsPagesWithContext_Call { + return &LambdaApi_ListCodeSigningConfigsPagesWithContext_Call{Call: _e.mock.On("ListCodeSigningConfigsPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListCodeSigningConfigsPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListCodeSigningConfigsInput, _a2 func(*lambda.ListCodeSigningConfigsOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListCodeSigningConfigsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListCodeSigningConfigsInput), args[2].(func(*lambda.ListCodeSigningConfigsOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigsPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListCodeSigningConfigsPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigsPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListCodeSigningConfigsInput, func(*lambda.ListCodeSigningConfigsOutput, bool) bool, ...request.Option) error) *LambdaApi_ListCodeSigningConfigsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListCodeSigningConfigsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListCodeSigningConfigsRequest(_a0 *lambda.ListCodeSigningConfigsInput) (*request.Request, *lambda.ListCodeSigningConfigsOutput) { ret := _m.Called(_a0) @@ -3185,6 +6610,34 @@ func (_m *LambdaApi) ListCodeSigningConfigsRequest(_a0 *lambda.ListCodeSigningCo return r0, r1 } +// LambdaApi_ListCodeSigningConfigsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCodeSigningConfigsRequest' +type LambdaApi_ListCodeSigningConfigsRequest_Call struct { + *mock.Call +} + +// ListCodeSigningConfigsRequest is a helper method to define mock.On call +// - _a0 *lambda.ListCodeSigningConfigsInput +func (_e *LambdaApi_Expecter) ListCodeSigningConfigsRequest(_a0 interface{}) *LambdaApi_ListCodeSigningConfigsRequest_Call { + return &LambdaApi_ListCodeSigningConfigsRequest_Call{Call: _e.mock.On("ListCodeSigningConfigsRequest", _a0)} +} + +func (_c *LambdaApi_ListCodeSigningConfigsRequest_Call) Run(run func(_a0 *lambda.ListCodeSigningConfigsInput)) *LambdaApi_ListCodeSigningConfigsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListCodeSigningConfigsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListCodeSigningConfigsOutput) *LambdaApi_ListCodeSigningConfigsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigsRequest_Call) RunAndReturn(run func(*lambda.ListCodeSigningConfigsInput) (*request.Request, *lambda.ListCodeSigningConfigsOutput)) *LambdaApi_ListCodeSigningConfigsRequest_Call { + _c.Call.Return(run) + return _c +} + // ListCodeSigningConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListCodeSigningConfigsWithContext(_a0 context.Context, _a1 *lambda.ListCodeSigningConfigsInput, _a2 ...request.Option) (*lambda.ListCodeSigningConfigsOutput, error) { _va := make([]interface{}, len(_a2)) @@ -3218,6 +6671,43 @@ func (_m *LambdaApi) ListCodeSigningConfigsWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_ListCodeSigningConfigsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCodeSigningConfigsWithContext' +type LambdaApi_ListCodeSigningConfigsWithContext_Call struct { + *mock.Call +} + +// ListCodeSigningConfigsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListCodeSigningConfigsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListCodeSigningConfigsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListCodeSigningConfigsWithContext_Call { + return &LambdaApi_ListCodeSigningConfigsWithContext_Call{Call: _e.mock.On("ListCodeSigningConfigsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListCodeSigningConfigsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListCodeSigningConfigsInput, _a2 ...request.Option)) *LambdaApi_ListCodeSigningConfigsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListCodeSigningConfigsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigsWithContext_Call) Return(_a0 *lambda.ListCodeSigningConfigsOutput, _a1 error) *LambdaApi_ListCodeSigningConfigsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListCodeSigningConfigsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListCodeSigningConfigsInput, ...request.Option) (*lambda.ListCodeSigningConfigsOutput, error)) *LambdaApi_ListCodeSigningConfigsWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListEventSourceMappings provides a mock function with given fields: _a0 func (_m *LambdaApi) ListEventSourceMappings(_a0 *lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error) { ret := _m.Called(_a0) @@ -3244,6 +6734,34 @@ func (_m *LambdaApi) ListEventSourceMappings(_a0 *lambda.ListEventSourceMappings return r0, r1 } +// LambdaApi_ListEventSourceMappings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEventSourceMappings' +type LambdaApi_ListEventSourceMappings_Call struct { + *mock.Call +} + +// ListEventSourceMappings is a helper method to define mock.On call +// - _a0 *lambda.ListEventSourceMappingsInput +func (_e *LambdaApi_Expecter) ListEventSourceMappings(_a0 interface{}) *LambdaApi_ListEventSourceMappings_Call { + return &LambdaApi_ListEventSourceMappings_Call{Call: _e.mock.On("ListEventSourceMappings", _a0)} +} + +func (_c *LambdaApi_ListEventSourceMappings_Call) Run(run func(_a0 *lambda.ListEventSourceMappingsInput)) *LambdaApi_ListEventSourceMappings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListEventSourceMappingsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappings_Call) Return(_a0 *lambda.ListEventSourceMappingsOutput, _a1 error) *LambdaApi_ListEventSourceMappings_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappings_Call) RunAndReturn(run func(*lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error)) *LambdaApi_ListEventSourceMappings_Call { + _c.Call.Return(run) + return _c +} + // ListEventSourceMappingsPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListEventSourceMappingsPages(_a0 *lambda.ListEventSourceMappingsInput, _a1 func(*lambda.ListEventSourceMappingsOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3258,6 +6776,35 @@ func (_m *LambdaApi) ListEventSourceMappingsPages(_a0 *lambda.ListEventSourceMap return r0 } +// LambdaApi_ListEventSourceMappingsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEventSourceMappingsPages' +type LambdaApi_ListEventSourceMappingsPages_Call struct { + *mock.Call +} + +// ListEventSourceMappingsPages is a helper method to define mock.On call +// - _a0 *lambda.ListEventSourceMappingsInput +// - _a1 func(*lambda.ListEventSourceMappingsOutput , bool) bool +func (_e *LambdaApi_Expecter) ListEventSourceMappingsPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListEventSourceMappingsPages_Call { + return &LambdaApi_ListEventSourceMappingsPages_Call{Call: _e.mock.On("ListEventSourceMappingsPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListEventSourceMappingsPages_Call) Run(run func(_a0 *lambda.ListEventSourceMappingsInput, _a1 func(*lambda.ListEventSourceMappingsOutput, bool) bool)) *LambdaApi_ListEventSourceMappingsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListEventSourceMappingsInput), args[1].(func(*lambda.ListEventSourceMappingsOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappingsPages_Call) Return(_a0 error) *LambdaApi_ListEventSourceMappingsPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappingsPages_Call) RunAndReturn(run func(*lambda.ListEventSourceMappingsInput, func(*lambda.ListEventSourceMappingsOutput, bool) bool) error) *LambdaApi_ListEventSourceMappingsPages_Call { + _c.Call.Return(run) + return _c +} + // ListEventSourceMappingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListEventSourceMappingsPagesWithContext(_a0 context.Context, _a1 *lambda.ListEventSourceMappingsInput, _a2 func(*lambda.ListEventSourceMappingsOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -3279,6 +6826,44 @@ func (_m *LambdaApi) ListEventSourceMappingsPagesWithContext(_a0 context.Context return r0 } +// LambdaApi_ListEventSourceMappingsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEventSourceMappingsPagesWithContext' +type LambdaApi_ListEventSourceMappingsPagesWithContext_Call struct { + *mock.Call +} + +// ListEventSourceMappingsPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListEventSourceMappingsInput +// - _a2 func(*lambda.ListEventSourceMappingsOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListEventSourceMappingsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListEventSourceMappingsPagesWithContext_Call { + return &LambdaApi_ListEventSourceMappingsPagesWithContext_Call{Call: _e.mock.On("ListEventSourceMappingsPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListEventSourceMappingsPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListEventSourceMappingsInput, _a2 func(*lambda.ListEventSourceMappingsOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListEventSourceMappingsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListEventSourceMappingsInput), args[2].(func(*lambda.ListEventSourceMappingsOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappingsPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListEventSourceMappingsPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappingsPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListEventSourceMappingsInput, func(*lambda.ListEventSourceMappingsOutput, bool) bool, ...request.Option) error) *LambdaApi_ListEventSourceMappingsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListEventSourceMappingsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListEventSourceMappingsRequest(_a0 *lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput) { ret := _m.Called(_a0) @@ -3307,6 +6892,34 @@ func (_m *LambdaApi) ListEventSourceMappingsRequest(_a0 *lambda.ListEventSourceM return r0, r1 } +// LambdaApi_ListEventSourceMappingsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEventSourceMappingsRequest' +type LambdaApi_ListEventSourceMappingsRequest_Call struct { + *mock.Call +} + +// ListEventSourceMappingsRequest is a helper method to define mock.On call +// - _a0 *lambda.ListEventSourceMappingsInput +func (_e *LambdaApi_Expecter) ListEventSourceMappingsRequest(_a0 interface{}) *LambdaApi_ListEventSourceMappingsRequest_Call { + return &LambdaApi_ListEventSourceMappingsRequest_Call{Call: _e.mock.On("ListEventSourceMappingsRequest", _a0)} +} + +func (_c *LambdaApi_ListEventSourceMappingsRequest_Call) Run(run func(_a0 *lambda.ListEventSourceMappingsInput)) *LambdaApi_ListEventSourceMappingsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListEventSourceMappingsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappingsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListEventSourceMappingsOutput) *LambdaApi_ListEventSourceMappingsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappingsRequest_Call) RunAndReturn(run func(*lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput)) *LambdaApi_ListEventSourceMappingsRequest_Call { + _c.Call.Return(run) + return _c +} + // ListEventSourceMappingsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListEventSourceMappingsWithContext(_a0 context.Context, _a1 *lambda.ListEventSourceMappingsInput, _a2 ...request.Option) (*lambda.ListEventSourceMappingsOutput, error) { _va := make([]interface{}, len(_a2)) @@ -3340,6 +6953,43 @@ func (_m *LambdaApi) ListEventSourceMappingsWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_ListEventSourceMappingsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEventSourceMappingsWithContext' +type LambdaApi_ListEventSourceMappingsWithContext_Call struct { + *mock.Call +} + +// ListEventSourceMappingsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListEventSourceMappingsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListEventSourceMappingsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListEventSourceMappingsWithContext_Call { + return &LambdaApi_ListEventSourceMappingsWithContext_Call{Call: _e.mock.On("ListEventSourceMappingsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListEventSourceMappingsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListEventSourceMappingsInput, _a2 ...request.Option)) *LambdaApi_ListEventSourceMappingsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListEventSourceMappingsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappingsWithContext_Call) Return(_a0 *lambda.ListEventSourceMappingsOutput, _a1 error) *LambdaApi_ListEventSourceMappingsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListEventSourceMappingsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListEventSourceMappingsInput, ...request.Option) (*lambda.ListEventSourceMappingsOutput, error)) *LambdaApi_ListEventSourceMappingsWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionEventInvokeConfigs provides a mock function with given fields: _a0 func (_m *LambdaApi) ListFunctionEventInvokeConfigs(_a0 *lambda.ListFunctionEventInvokeConfigsInput) (*lambda.ListFunctionEventInvokeConfigsOutput, error) { ret := _m.Called(_a0) @@ -3366,6 +7016,34 @@ func (_m *LambdaApi) ListFunctionEventInvokeConfigs(_a0 *lambda.ListFunctionEven return r0, r1 } +// LambdaApi_ListFunctionEventInvokeConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionEventInvokeConfigs' +type LambdaApi_ListFunctionEventInvokeConfigs_Call struct { + *mock.Call +} + +// ListFunctionEventInvokeConfigs is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionEventInvokeConfigsInput +func (_e *LambdaApi_Expecter) ListFunctionEventInvokeConfigs(_a0 interface{}) *LambdaApi_ListFunctionEventInvokeConfigs_Call { + return &LambdaApi_ListFunctionEventInvokeConfigs_Call{Call: _e.mock.On("ListFunctionEventInvokeConfigs", _a0)} +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigs_Call) Run(run func(_a0 *lambda.ListFunctionEventInvokeConfigsInput)) *LambdaApi_ListFunctionEventInvokeConfigs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionEventInvokeConfigsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigs_Call) Return(_a0 *lambda.ListFunctionEventInvokeConfigsOutput, _a1 error) *LambdaApi_ListFunctionEventInvokeConfigs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigs_Call) RunAndReturn(run func(*lambda.ListFunctionEventInvokeConfigsInput) (*lambda.ListFunctionEventInvokeConfigsOutput, error)) *LambdaApi_ListFunctionEventInvokeConfigs_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionEventInvokeConfigsPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListFunctionEventInvokeConfigsPages(_a0 *lambda.ListFunctionEventInvokeConfigsInput, _a1 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3380,6 +7058,35 @@ func (_m *LambdaApi) ListFunctionEventInvokeConfigsPages(_a0 *lambda.ListFunctio return r0 } +// LambdaApi_ListFunctionEventInvokeConfigsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionEventInvokeConfigsPages' +type LambdaApi_ListFunctionEventInvokeConfigsPages_Call struct { + *mock.Call +} + +// ListFunctionEventInvokeConfigsPages is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionEventInvokeConfigsInput +// - _a1 func(*lambda.ListFunctionEventInvokeConfigsOutput , bool) bool +func (_e *LambdaApi_Expecter) ListFunctionEventInvokeConfigsPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListFunctionEventInvokeConfigsPages_Call { + return &LambdaApi_ListFunctionEventInvokeConfigsPages_Call{Call: _e.mock.On("ListFunctionEventInvokeConfigsPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsPages_Call) Run(run func(_a0 *lambda.ListFunctionEventInvokeConfigsInput, _a1 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool)) *LambdaApi_ListFunctionEventInvokeConfigsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionEventInvokeConfigsInput), args[1].(func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsPages_Call) Return(_a0 error) *LambdaApi_ListFunctionEventInvokeConfigsPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsPages_Call) RunAndReturn(run func(*lambda.ListFunctionEventInvokeConfigsInput, func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) error) *LambdaApi_ListFunctionEventInvokeConfigsPages_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionEventInvokeConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListFunctionEventInvokeConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -3401,6 +7108,44 @@ func (_m *LambdaApi) ListFunctionEventInvokeConfigsPagesWithContext(_a0 context. return r0 } +// LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionEventInvokeConfigsPagesWithContext' +type LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call struct { + *mock.Call +} + +// ListFunctionEventInvokeConfigsPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListFunctionEventInvokeConfigsInput +// - _a2 func(*lambda.ListFunctionEventInvokeConfigsOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListFunctionEventInvokeConfigsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call { + return &LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call{Call: _e.mock.On("ListFunctionEventInvokeConfigsPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListFunctionEventInvokeConfigsInput), args[2].(func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListFunctionEventInvokeConfigsInput, func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, ...request.Option) error) *LambdaApi_ListFunctionEventInvokeConfigsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionEventInvokeConfigsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListFunctionEventInvokeConfigsRequest(_a0 *lambda.ListFunctionEventInvokeConfigsInput) (*request.Request, *lambda.ListFunctionEventInvokeConfigsOutput) { ret := _m.Called(_a0) @@ -3429,11 +7174,39 @@ func (_m *LambdaApi) ListFunctionEventInvokeConfigsRequest(_a0 *lambda.ListFunct return r0, r1 } -// ListFunctionEventInvokeConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *LambdaApi) ListFunctionEventInvokeConfigsWithContext(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 ...request.Option) (*lambda.ListFunctionEventInvokeConfigsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// LambdaApi_ListFunctionEventInvokeConfigsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionEventInvokeConfigsRequest' +type LambdaApi_ListFunctionEventInvokeConfigsRequest_Call struct { + *mock.Call +} + +// ListFunctionEventInvokeConfigsRequest is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionEventInvokeConfigsInput +func (_e *LambdaApi_Expecter) ListFunctionEventInvokeConfigsRequest(_a0 interface{}) *LambdaApi_ListFunctionEventInvokeConfigsRequest_Call { + return &LambdaApi_ListFunctionEventInvokeConfigsRequest_Call{Call: _e.mock.On("ListFunctionEventInvokeConfigsRequest", _a0)} +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsRequest_Call) Run(run func(_a0 *lambda.ListFunctionEventInvokeConfigsInput)) *LambdaApi_ListFunctionEventInvokeConfigsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionEventInvokeConfigsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListFunctionEventInvokeConfigsOutput) *LambdaApi_ListFunctionEventInvokeConfigsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsRequest_Call) RunAndReturn(run func(*lambda.ListFunctionEventInvokeConfigsInput) (*request.Request, *lambda.ListFunctionEventInvokeConfigsOutput)) *LambdaApi_ListFunctionEventInvokeConfigsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListFunctionEventInvokeConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2 +func (_m *LambdaApi) ListFunctionEventInvokeConfigsWithContext(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 ...request.Option) (*lambda.ListFunctionEventInvokeConfigsOutput, error) { + _va := make([]interface{}, len(_a2)) + for _i := range _a2 { + _va[_i] = _a2[_i] } var _ca []interface{} _ca = append(_ca, _a0, _a1) @@ -3462,6 +7235,43 @@ func (_m *LambdaApi) ListFunctionEventInvokeConfigsWithContext(_a0 context.Conte return r0, r1 } +// LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionEventInvokeConfigsWithContext' +type LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call struct { + *mock.Call +} + +// ListFunctionEventInvokeConfigsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListFunctionEventInvokeConfigsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListFunctionEventInvokeConfigsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call { + return &LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call{Call: _e.mock.On("ListFunctionEventInvokeConfigsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 ...request.Option)) *LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListFunctionEventInvokeConfigsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call) Return(_a0 *lambda.ListFunctionEventInvokeConfigsOutput, _a1 error) *LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListFunctionEventInvokeConfigsInput, ...request.Option) (*lambda.ListFunctionEventInvokeConfigsOutput, error)) *LambdaApi_ListFunctionEventInvokeConfigsWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionUrlConfigs provides a mock function with given fields: _a0 func (_m *LambdaApi) ListFunctionUrlConfigs(_a0 *lambda.ListFunctionUrlConfigsInput) (*lambda.ListFunctionUrlConfigsOutput, error) { ret := _m.Called(_a0) @@ -3488,6 +7298,34 @@ func (_m *LambdaApi) ListFunctionUrlConfigs(_a0 *lambda.ListFunctionUrlConfigsIn return r0, r1 } +// LambdaApi_ListFunctionUrlConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionUrlConfigs' +type LambdaApi_ListFunctionUrlConfigs_Call struct { + *mock.Call +} + +// ListFunctionUrlConfigs is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionUrlConfigsInput +func (_e *LambdaApi_Expecter) ListFunctionUrlConfigs(_a0 interface{}) *LambdaApi_ListFunctionUrlConfigs_Call { + return &LambdaApi_ListFunctionUrlConfigs_Call{Call: _e.mock.On("ListFunctionUrlConfigs", _a0)} +} + +func (_c *LambdaApi_ListFunctionUrlConfigs_Call) Run(run func(_a0 *lambda.ListFunctionUrlConfigsInput)) *LambdaApi_ListFunctionUrlConfigs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionUrlConfigsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigs_Call) Return(_a0 *lambda.ListFunctionUrlConfigsOutput, _a1 error) *LambdaApi_ListFunctionUrlConfigs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigs_Call) RunAndReturn(run func(*lambda.ListFunctionUrlConfigsInput) (*lambda.ListFunctionUrlConfigsOutput, error)) *LambdaApi_ListFunctionUrlConfigs_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionUrlConfigsPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListFunctionUrlConfigsPages(_a0 *lambda.ListFunctionUrlConfigsInput, _a1 func(*lambda.ListFunctionUrlConfigsOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3502,6 +7340,35 @@ func (_m *LambdaApi) ListFunctionUrlConfigsPages(_a0 *lambda.ListFunctionUrlConf return r0 } +// LambdaApi_ListFunctionUrlConfigsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionUrlConfigsPages' +type LambdaApi_ListFunctionUrlConfigsPages_Call struct { + *mock.Call +} + +// ListFunctionUrlConfigsPages is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionUrlConfigsInput +// - _a1 func(*lambda.ListFunctionUrlConfigsOutput , bool) bool +func (_e *LambdaApi_Expecter) ListFunctionUrlConfigsPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListFunctionUrlConfigsPages_Call { + return &LambdaApi_ListFunctionUrlConfigsPages_Call{Call: _e.mock.On("ListFunctionUrlConfigsPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListFunctionUrlConfigsPages_Call) Run(run func(_a0 *lambda.ListFunctionUrlConfigsInput, _a1 func(*lambda.ListFunctionUrlConfigsOutput, bool) bool)) *LambdaApi_ListFunctionUrlConfigsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionUrlConfigsInput), args[1].(func(*lambda.ListFunctionUrlConfigsOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigsPages_Call) Return(_a0 error) *LambdaApi_ListFunctionUrlConfigsPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigsPages_Call) RunAndReturn(run func(*lambda.ListFunctionUrlConfigsInput, func(*lambda.ListFunctionUrlConfigsOutput, bool) bool) error) *LambdaApi_ListFunctionUrlConfigsPages_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionUrlConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListFunctionUrlConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionUrlConfigsInput, _a2 func(*lambda.ListFunctionUrlConfigsOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -3523,6 +7390,44 @@ func (_m *LambdaApi) ListFunctionUrlConfigsPagesWithContext(_a0 context.Context, return r0 } +// LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionUrlConfigsPagesWithContext' +type LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call struct { + *mock.Call +} + +// ListFunctionUrlConfigsPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListFunctionUrlConfigsInput +// - _a2 func(*lambda.ListFunctionUrlConfigsOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListFunctionUrlConfigsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call { + return &LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call{Call: _e.mock.On("ListFunctionUrlConfigsPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListFunctionUrlConfigsInput, _a2 func(*lambda.ListFunctionUrlConfigsOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListFunctionUrlConfigsInput), args[2].(func(*lambda.ListFunctionUrlConfigsOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListFunctionUrlConfigsInput, func(*lambda.ListFunctionUrlConfigsOutput, bool) bool, ...request.Option) error) *LambdaApi_ListFunctionUrlConfigsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionUrlConfigsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListFunctionUrlConfigsRequest(_a0 *lambda.ListFunctionUrlConfigsInput) (*request.Request, *lambda.ListFunctionUrlConfigsOutput) { ret := _m.Called(_a0) @@ -3551,6 +7456,34 @@ func (_m *LambdaApi) ListFunctionUrlConfigsRequest(_a0 *lambda.ListFunctionUrlCo return r0, r1 } +// LambdaApi_ListFunctionUrlConfigsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionUrlConfigsRequest' +type LambdaApi_ListFunctionUrlConfigsRequest_Call struct { + *mock.Call +} + +// ListFunctionUrlConfigsRequest is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionUrlConfigsInput +func (_e *LambdaApi_Expecter) ListFunctionUrlConfigsRequest(_a0 interface{}) *LambdaApi_ListFunctionUrlConfigsRequest_Call { + return &LambdaApi_ListFunctionUrlConfigsRequest_Call{Call: _e.mock.On("ListFunctionUrlConfigsRequest", _a0)} +} + +func (_c *LambdaApi_ListFunctionUrlConfigsRequest_Call) Run(run func(_a0 *lambda.ListFunctionUrlConfigsInput)) *LambdaApi_ListFunctionUrlConfigsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionUrlConfigsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListFunctionUrlConfigsOutput) *LambdaApi_ListFunctionUrlConfigsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigsRequest_Call) RunAndReturn(run func(*lambda.ListFunctionUrlConfigsInput) (*request.Request, *lambda.ListFunctionUrlConfigsOutput)) *LambdaApi_ListFunctionUrlConfigsRequest_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionUrlConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListFunctionUrlConfigsWithContext(_a0 context.Context, _a1 *lambda.ListFunctionUrlConfigsInput, _a2 ...request.Option) (*lambda.ListFunctionUrlConfigsOutput, error) { _va := make([]interface{}, len(_a2)) @@ -3584,6 +7517,43 @@ func (_m *LambdaApi) ListFunctionUrlConfigsWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_ListFunctionUrlConfigsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionUrlConfigsWithContext' +type LambdaApi_ListFunctionUrlConfigsWithContext_Call struct { + *mock.Call +} + +// ListFunctionUrlConfigsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListFunctionUrlConfigsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListFunctionUrlConfigsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListFunctionUrlConfigsWithContext_Call { + return &LambdaApi_ListFunctionUrlConfigsWithContext_Call{Call: _e.mock.On("ListFunctionUrlConfigsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListFunctionUrlConfigsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListFunctionUrlConfigsInput, _a2 ...request.Option)) *LambdaApi_ListFunctionUrlConfigsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListFunctionUrlConfigsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigsWithContext_Call) Return(_a0 *lambda.ListFunctionUrlConfigsOutput, _a1 error) *LambdaApi_ListFunctionUrlConfigsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionUrlConfigsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListFunctionUrlConfigsInput, ...request.Option) (*lambda.ListFunctionUrlConfigsOutput, error)) *LambdaApi_ListFunctionUrlConfigsWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListFunctions provides a mock function with given fields: _a0 func (_m *LambdaApi) ListFunctions(_a0 *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) { ret := _m.Called(_a0) @@ -3610,6 +7580,34 @@ func (_m *LambdaApi) ListFunctions(_a0 *lambda.ListFunctionsInput) (*lambda.List return r0, r1 } +// LambdaApi_ListFunctions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctions' +type LambdaApi_ListFunctions_Call struct { + *mock.Call +} + +// ListFunctions is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionsInput +func (_e *LambdaApi_Expecter) ListFunctions(_a0 interface{}) *LambdaApi_ListFunctions_Call { + return &LambdaApi_ListFunctions_Call{Call: _e.mock.On("ListFunctions", _a0)} +} + +func (_c *LambdaApi_ListFunctions_Call) Run(run func(_a0 *lambda.ListFunctionsInput)) *LambdaApi_ListFunctions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctions_Call) Return(_a0 *lambda.ListFunctionsOutput, _a1 error) *LambdaApi_ListFunctions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctions_Call) RunAndReturn(run func(*lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error)) *LambdaApi_ListFunctions_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsByCodeSigningConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) ListFunctionsByCodeSigningConfig(_a0 *lambda.ListFunctionsByCodeSigningConfigInput) (*lambda.ListFunctionsByCodeSigningConfigOutput, error) { ret := _m.Called(_a0) @@ -3636,6 +7634,34 @@ func (_m *LambdaApi) ListFunctionsByCodeSigningConfig(_a0 *lambda.ListFunctionsB return r0, r1 } +// LambdaApi_ListFunctionsByCodeSigningConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsByCodeSigningConfig' +type LambdaApi_ListFunctionsByCodeSigningConfig_Call struct { + *mock.Call +} + +// ListFunctionsByCodeSigningConfig is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionsByCodeSigningConfigInput +func (_e *LambdaApi_Expecter) ListFunctionsByCodeSigningConfig(_a0 interface{}) *LambdaApi_ListFunctionsByCodeSigningConfig_Call { + return &LambdaApi_ListFunctionsByCodeSigningConfig_Call{Call: _e.mock.On("ListFunctionsByCodeSigningConfig", _a0)} +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfig_Call) Run(run func(_a0 *lambda.ListFunctionsByCodeSigningConfigInput)) *LambdaApi_ListFunctionsByCodeSigningConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionsByCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfig_Call) Return(_a0 *lambda.ListFunctionsByCodeSigningConfigOutput, _a1 error) *LambdaApi_ListFunctionsByCodeSigningConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfig_Call) RunAndReturn(run func(*lambda.ListFunctionsByCodeSigningConfigInput) (*lambda.ListFunctionsByCodeSigningConfigOutput, error)) *LambdaApi_ListFunctionsByCodeSigningConfig_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsByCodeSigningConfigPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListFunctionsByCodeSigningConfigPages(_a0 *lambda.ListFunctionsByCodeSigningConfigInput, _a1 func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3650,6 +7676,35 @@ func (_m *LambdaApi) ListFunctionsByCodeSigningConfigPages(_a0 *lambda.ListFunct return r0 } +// LambdaApi_ListFunctionsByCodeSigningConfigPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsByCodeSigningConfigPages' +type LambdaApi_ListFunctionsByCodeSigningConfigPages_Call struct { + *mock.Call +} + +// ListFunctionsByCodeSigningConfigPages is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionsByCodeSigningConfigInput +// - _a1 func(*lambda.ListFunctionsByCodeSigningConfigOutput , bool) bool +func (_e *LambdaApi_Expecter) ListFunctionsByCodeSigningConfigPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListFunctionsByCodeSigningConfigPages_Call { + return &LambdaApi_ListFunctionsByCodeSigningConfigPages_Call{Call: _e.mock.On("ListFunctionsByCodeSigningConfigPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigPages_Call) Run(run func(_a0 *lambda.ListFunctionsByCodeSigningConfigInput, _a1 func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool)) *LambdaApi_ListFunctionsByCodeSigningConfigPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionsByCodeSigningConfigInput), args[1].(func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigPages_Call) Return(_a0 error) *LambdaApi_ListFunctionsByCodeSigningConfigPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigPages_Call) RunAndReturn(run func(*lambda.ListFunctionsByCodeSigningConfigInput, func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool) error) *LambdaApi_ListFunctionsByCodeSigningConfigPages_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsByCodeSigningConfigPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListFunctionsByCodeSigningConfigPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsByCodeSigningConfigInput, _a2 func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -3671,6 +7726,44 @@ func (_m *LambdaApi) ListFunctionsByCodeSigningConfigPagesWithContext(_a0 contex return r0 } +// LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsByCodeSigningConfigPagesWithContext' +type LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call struct { + *mock.Call +} + +// ListFunctionsByCodeSigningConfigPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListFunctionsByCodeSigningConfigInput +// - _a2 func(*lambda.ListFunctionsByCodeSigningConfigOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListFunctionsByCodeSigningConfigPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call { + return &LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call{Call: _e.mock.On("ListFunctionsByCodeSigningConfigPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListFunctionsByCodeSigningConfigInput, _a2 func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListFunctionsByCodeSigningConfigInput), args[2].(func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListFunctionsByCodeSigningConfigInput, func(*lambda.ListFunctionsByCodeSigningConfigOutput, bool) bool, ...request.Option) error) *LambdaApi_ListFunctionsByCodeSigningConfigPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsByCodeSigningConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListFunctionsByCodeSigningConfigRequest(_a0 *lambda.ListFunctionsByCodeSigningConfigInput) (*request.Request, *lambda.ListFunctionsByCodeSigningConfigOutput) { ret := _m.Called(_a0) @@ -3699,6 +7792,34 @@ func (_m *LambdaApi) ListFunctionsByCodeSigningConfigRequest(_a0 *lambda.ListFun return r0, r1 } +// LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsByCodeSigningConfigRequest' +type LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call struct { + *mock.Call +} + +// ListFunctionsByCodeSigningConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionsByCodeSigningConfigInput +func (_e *LambdaApi_Expecter) ListFunctionsByCodeSigningConfigRequest(_a0 interface{}) *LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call { + return &LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call{Call: _e.mock.On("ListFunctionsByCodeSigningConfigRequest", _a0)} +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call) Run(run func(_a0 *lambda.ListFunctionsByCodeSigningConfigInput)) *LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionsByCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListFunctionsByCodeSigningConfigOutput) *LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call) RunAndReturn(run func(*lambda.ListFunctionsByCodeSigningConfigInput) (*request.Request, *lambda.ListFunctionsByCodeSigningConfigOutput)) *LambdaApi_ListFunctionsByCodeSigningConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsByCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListFunctionsByCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsByCodeSigningConfigInput, _a2 ...request.Option) (*lambda.ListFunctionsByCodeSigningConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -3732,6 +7853,43 @@ func (_m *LambdaApi) ListFunctionsByCodeSigningConfigWithContext(_a0 context.Con return r0, r1 } +// LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsByCodeSigningConfigWithContext' +type LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call struct { + *mock.Call +} + +// ListFunctionsByCodeSigningConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListFunctionsByCodeSigningConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListFunctionsByCodeSigningConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call { + return &LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call{Call: _e.mock.On("ListFunctionsByCodeSigningConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListFunctionsByCodeSigningConfigInput, _a2 ...request.Option)) *LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListFunctionsByCodeSigningConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call) Return(_a0 *lambda.ListFunctionsByCodeSigningConfigOutput, _a1 error) *LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListFunctionsByCodeSigningConfigInput, ...request.Option) (*lambda.ListFunctionsByCodeSigningConfigOutput, error)) *LambdaApi_ListFunctionsByCodeSigningConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListFunctionsPages(_a0 *lambda.ListFunctionsInput, _a1 func(*lambda.ListFunctionsOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3746,6 +7904,35 @@ func (_m *LambdaApi) ListFunctionsPages(_a0 *lambda.ListFunctionsInput, _a1 func return r0 } +// LambdaApi_ListFunctionsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsPages' +type LambdaApi_ListFunctionsPages_Call struct { + *mock.Call +} + +// ListFunctionsPages is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionsInput +// - _a1 func(*lambda.ListFunctionsOutput , bool) bool +func (_e *LambdaApi_Expecter) ListFunctionsPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListFunctionsPages_Call { + return &LambdaApi_ListFunctionsPages_Call{Call: _e.mock.On("ListFunctionsPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListFunctionsPages_Call) Run(run func(_a0 *lambda.ListFunctionsInput, _a1 func(*lambda.ListFunctionsOutput, bool) bool)) *LambdaApi_ListFunctionsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionsInput), args[1].(func(*lambda.ListFunctionsOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsPages_Call) Return(_a0 error) *LambdaApi_ListFunctionsPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListFunctionsPages_Call) RunAndReturn(run func(*lambda.ListFunctionsInput, func(*lambda.ListFunctionsOutput, bool) bool) error) *LambdaApi_ListFunctionsPages_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListFunctionsPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsInput, _a2 func(*lambda.ListFunctionsOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -3767,6 +7954,44 @@ func (_m *LambdaApi) ListFunctionsPagesWithContext(_a0 context.Context, _a1 *lam return r0 } +// LambdaApi_ListFunctionsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsPagesWithContext' +type LambdaApi_ListFunctionsPagesWithContext_Call struct { + *mock.Call +} + +// ListFunctionsPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListFunctionsInput +// - _a2 func(*lambda.ListFunctionsOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListFunctionsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListFunctionsPagesWithContext_Call { + return &LambdaApi_ListFunctionsPagesWithContext_Call{Call: _e.mock.On("ListFunctionsPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListFunctionsPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListFunctionsInput, _a2 func(*lambda.ListFunctionsOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListFunctionsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListFunctionsInput), args[2].(func(*lambda.ListFunctionsOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListFunctionsPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListFunctionsPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListFunctionsInput, func(*lambda.ListFunctionsOutput, bool) bool, ...request.Option) error) *LambdaApi_ListFunctionsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListFunctionsRequest(_a0 *lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput) { ret := _m.Called(_a0) @@ -3795,6 +8020,34 @@ func (_m *LambdaApi) ListFunctionsRequest(_a0 *lambda.ListFunctionsInput) (*requ return r0, r1 } +// LambdaApi_ListFunctionsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsRequest' +type LambdaApi_ListFunctionsRequest_Call struct { + *mock.Call +} + +// ListFunctionsRequest is a helper method to define mock.On call +// - _a0 *lambda.ListFunctionsInput +func (_e *LambdaApi_Expecter) ListFunctionsRequest(_a0 interface{}) *LambdaApi_ListFunctionsRequest_Call { + return &LambdaApi_ListFunctionsRequest_Call{Call: _e.mock.On("ListFunctionsRequest", _a0)} +} + +func (_c *LambdaApi_ListFunctionsRequest_Call) Run(run func(_a0 *lambda.ListFunctionsInput)) *LambdaApi_ListFunctionsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListFunctionsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListFunctionsOutput) *LambdaApi_ListFunctionsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionsRequest_Call) RunAndReturn(run func(*lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput)) *LambdaApi_ListFunctionsRequest_Call { + _c.Call.Return(run) + return _c +} + // ListFunctionsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListFunctionsWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsInput, _a2 ...request.Option) (*lambda.ListFunctionsOutput, error) { _va := make([]interface{}, len(_a2)) @@ -3828,6 +8081,43 @@ func (_m *LambdaApi) ListFunctionsWithContext(_a0 context.Context, _a1 *lambda.L return r0, r1 } +// LambdaApi_ListFunctionsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFunctionsWithContext' +type LambdaApi_ListFunctionsWithContext_Call struct { + *mock.Call +} + +// ListFunctionsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListFunctionsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListFunctionsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListFunctionsWithContext_Call { + return &LambdaApi_ListFunctionsWithContext_Call{Call: _e.mock.On("ListFunctionsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListFunctionsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListFunctionsInput, _a2 ...request.Option)) *LambdaApi_ListFunctionsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListFunctionsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListFunctionsWithContext_Call) Return(_a0 *lambda.ListFunctionsOutput, _a1 error) *LambdaApi_ListFunctionsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListFunctionsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListFunctionsInput, ...request.Option) (*lambda.ListFunctionsOutput, error)) *LambdaApi_ListFunctionsWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListLayerVersions provides a mock function with given fields: _a0 func (_m *LambdaApi) ListLayerVersions(_a0 *lambda.ListLayerVersionsInput) (*lambda.ListLayerVersionsOutput, error) { ret := _m.Called(_a0) @@ -3854,6 +8144,34 @@ func (_m *LambdaApi) ListLayerVersions(_a0 *lambda.ListLayerVersionsInput) (*lam return r0, r1 } +// LambdaApi_ListLayerVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayerVersions' +type LambdaApi_ListLayerVersions_Call struct { + *mock.Call +} + +// ListLayerVersions is a helper method to define mock.On call +// - _a0 *lambda.ListLayerVersionsInput +func (_e *LambdaApi_Expecter) ListLayerVersions(_a0 interface{}) *LambdaApi_ListLayerVersions_Call { + return &LambdaApi_ListLayerVersions_Call{Call: _e.mock.On("ListLayerVersions", _a0)} +} + +func (_c *LambdaApi_ListLayerVersions_Call) Run(run func(_a0 *lambda.ListLayerVersionsInput)) *LambdaApi_ListLayerVersions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListLayerVersionsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListLayerVersions_Call) Return(_a0 *lambda.ListLayerVersionsOutput, _a1 error) *LambdaApi_ListLayerVersions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListLayerVersions_Call) RunAndReturn(run func(*lambda.ListLayerVersionsInput) (*lambda.ListLayerVersionsOutput, error)) *LambdaApi_ListLayerVersions_Call { + _c.Call.Return(run) + return _c +} + // ListLayerVersionsPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListLayerVersionsPages(_a0 *lambda.ListLayerVersionsInput, _a1 func(*lambda.ListLayerVersionsOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3868,6 +8186,35 @@ func (_m *LambdaApi) ListLayerVersionsPages(_a0 *lambda.ListLayerVersionsInput, return r0 } +// LambdaApi_ListLayerVersionsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayerVersionsPages' +type LambdaApi_ListLayerVersionsPages_Call struct { + *mock.Call +} + +// ListLayerVersionsPages is a helper method to define mock.On call +// - _a0 *lambda.ListLayerVersionsInput +// - _a1 func(*lambda.ListLayerVersionsOutput , bool) bool +func (_e *LambdaApi_Expecter) ListLayerVersionsPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListLayerVersionsPages_Call { + return &LambdaApi_ListLayerVersionsPages_Call{Call: _e.mock.On("ListLayerVersionsPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListLayerVersionsPages_Call) Run(run func(_a0 *lambda.ListLayerVersionsInput, _a1 func(*lambda.ListLayerVersionsOutput, bool) bool)) *LambdaApi_ListLayerVersionsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListLayerVersionsInput), args[1].(func(*lambda.ListLayerVersionsOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListLayerVersionsPages_Call) Return(_a0 error) *LambdaApi_ListLayerVersionsPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListLayerVersionsPages_Call) RunAndReturn(run func(*lambda.ListLayerVersionsInput, func(*lambda.ListLayerVersionsOutput, bool) bool) error) *LambdaApi_ListLayerVersionsPages_Call { + _c.Call.Return(run) + return _c +} + // ListLayerVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListLayerVersionsPagesWithContext(_a0 context.Context, _a1 *lambda.ListLayerVersionsInput, _a2 func(*lambda.ListLayerVersionsOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -3889,6 +8236,44 @@ func (_m *LambdaApi) ListLayerVersionsPagesWithContext(_a0 context.Context, _a1 return r0 } +// LambdaApi_ListLayerVersionsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayerVersionsPagesWithContext' +type LambdaApi_ListLayerVersionsPagesWithContext_Call struct { + *mock.Call +} + +// ListLayerVersionsPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListLayerVersionsInput +// - _a2 func(*lambda.ListLayerVersionsOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListLayerVersionsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListLayerVersionsPagesWithContext_Call { + return &LambdaApi_ListLayerVersionsPagesWithContext_Call{Call: _e.mock.On("ListLayerVersionsPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListLayerVersionsPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListLayerVersionsInput, _a2 func(*lambda.ListLayerVersionsOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListLayerVersionsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListLayerVersionsInput), args[2].(func(*lambda.ListLayerVersionsOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListLayerVersionsPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListLayerVersionsPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListLayerVersionsPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListLayerVersionsInput, func(*lambda.ListLayerVersionsOutput, bool) bool, ...request.Option) error) *LambdaApi_ListLayerVersionsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListLayerVersionsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListLayerVersionsRequest(_a0 *lambda.ListLayerVersionsInput) (*request.Request, *lambda.ListLayerVersionsOutput) { ret := _m.Called(_a0) @@ -3917,6 +8302,34 @@ func (_m *LambdaApi) ListLayerVersionsRequest(_a0 *lambda.ListLayerVersionsInput return r0, r1 } +// LambdaApi_ListLayerVersionsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayerVersionsRequest' +type LambdaApi_ListLayerVersionsRequest_Call struct { + *mock.Call +} + +// ListLayerVersionsRequest is a helper method to define mock.On call +// - _a0 *lambda.ListLayerVersionsInput +func (_e *LambdaApi_Expecter) ListLayerVersionsRequest(_a0 interface{}) *LambdaApi_ListLayerVersionsRequest_Call { + return &LambdaApi_ListLayerVersionsRequest_Call{Call: _e.mock.On("ListLayerVersionsRequest", _a0)} +} + +func (_c *LambdaApi_ListLayerVersionsRequest_Call) Run(run func(_a0 *lambda.ListLayerVersionsInput)) *LambdaApi_ListLayerVersionsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListLayerVersionsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListLayerVersionsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListLayerVersionsOutput) *LambdaApi_ListLayerVersionsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListLayerVersionsRequest_Call) RunAndReturn(run func(*lambda.ListLayerVersionsInput) (*request.Request, *lambda.ListLayerVersionsOutput)) *LambdaApi_ListLayerVersionsRequest_Call { + _c.Call.Return(run) + return _c +} + // ListLayerVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListLayerVersionsWithContext(_a0 context.Context, _a1 *lambda.ListLayerVersionsInput, _a2 ...request.Option) (*lambda.ListLayerVersionsOutput, error) { _va := make([]interface{}, len(_a2)) @@ -3950,6 +8363,43 @@ func (_m *LambdaApi) ListLayerVersionsWithContext(_a0 context.Context, _a1 *lamb return r0, r1 } +// LambdaApi_ListLayerVersionsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayerVersionsWithContext' +type LambdaApi_ListLayerVersionsWithContext_Call struct { + *mock.Call +} + +// ListLayerVersionsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListLayerVersionsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListLayerVersionsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListLayerVersionsWithContext_Call { + return &LambdaApi_ListLayerVersionsWithContext_Call{Call: _e.mock.On("ListLayerVersionsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListLayerVersionsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListLayerVersionsInput, _a2 ...request.Option)) *LambdaApi_ListLayerVersionsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListLayerVersionsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListLayerVersionsWithContext_Call) Return(_a0 *lambda.ListLayerVersionsOutput, _a1 error) *LambdaApi_ListLayerVersionsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListLayerVersionsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListLayerVersionsInput, ...request.Option) (*lambda.ListLayerVersionsOutput, error)) *LambdaApi_ListLayerVersionsWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListLayers provides a mock function with given fields: _a0 func (_m *LambdaApi) ListLayers(_a0 *lambda.ListLayersInput) (*lambda.ListLayersOutput, error) { ret := _m.Called(_a0) @@ -3976,6 +8426,34 @@ func (_m *LambdaApi) ListLayers(_a0 *lambda.ListLayersInput) (*lambda.ListLayers return r0, r1 } +// LambdaApi_ListLayers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayers' +type LambdaApi_ListLayers_Call struct { + *mock.Call +} + +// ListLayers is a helper method to define mock.On call +// - _a0 *lambda.ListLayersInput +func (_e *LambdaApi_Expecter) ListLayers(_a0 interface{}) *LambdaApi_ListLayers_Call { + return &LambdaApi_ListLayers_Call{Call: _e.mock.On("ListLayers", _a0)} +} + +func (_c *LambdaApi_ListLayers_Call) Run(run func(_a0 *lambda.ListLayersInput)) *LambdaApi_ListLayers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListLayersInput)) + }) + return _c +} + +func (_c *LambdaApi_ListLayers_Call) Return(_a0 *lambda.ListLayersOutput, _a1 error) *LambdaApi_ListLayers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListLayers_Call) RunAndReturn(run func(*lambda.ListLayersInput) (*lambda.ListLayersOutput, error)) *LambdaApi_ListLayers_Call { + _c.Call.Return(run) + return _c +} + // ListLayersPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListLayersPages(_a0 *lambda.ListLayersInput, _a1 func(*lambda.ListLayersOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -3990,6 +8468,35 @@ func (_m *LambdaApi) ListLayersPages(_a0 *lambda.ListLayersInput, _a1 func(*lamb return r0 } +// LambdaApi_ListLayersPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayersPages' +type LambdaApi_ListLayersPages_Call struct { + *mock.Call +} + +// ListLayersPages is a helper method to define mock.On call +// - _a0 *lambda.ListLayersInput +// - _a1 func(*lambda.ListLayersOutput , bool) bool +func (_e *LambdaApi_Expecter) ListLayersPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListLayersPages_Call { + return &LambdaApi_ListLayersPages_Call{Call: _e.mock.On("ListLayersPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListLayersPages_Call) Run(run func(_a0 *lambda.ListLayersInput, _a1 func(*lambda.ListLayersOutput, bool) bool)) *LambdaApi_ListLayersPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListLayersInput), args[1].(func(*lambda.ListLayersOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListLayersPages_Call) Return(_a0 error) *LambdaApi_ListLayersPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListLayersPages_Call) RunAndReturn(run func(*lambda.ListLayersInput, func(*lambda.ListLayersOutput, bool) bool) error) *LambdaApi_ListLayersPages_Call { + _c.Call.Return(run) + return _c +} + // ListLayersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListLayersPagesWithContext(_a0 context.Context, _a1 *lambda.ListLayersInput, _a2 func(*lambda.ListLayersOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -4011,6 +8518,44 @@ func (_m *LambdaApi) ListLayersPagesWithContext(_a0 context.Context, _a1 *lambda return r0 } +// LambdaApi_ListLayersPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayersPagesWithContext' +type LambdaApi_ListLayersPagesWithContext_Call struct { + *mock.Call +} + +// ListLayersPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListLayersInput +// - _a2 func(*lambda.ListLayersOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListLayersPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListLayersPagesWithContext_Call { + return &LambdaApi_ListLayersPagesWithContext_Call{Call: _e.mock.On("ListLayersPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListLayersPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListLayersInput, _a2 func(*lambda.ListLayersOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListLayersPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListLayersInput), args[2].(func(*lambda.ListLayersOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListLayersPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListLayersPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListLayersPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListLayersInput, func(*lambda.ListLayersOutput, bool) bool, ...request.Option) error) *LambdaApi_ListLayersPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListLayersRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListLayersRequest(_a0 *lambda.ListLayersInput) (*request.Request, *lambda.ListLayersOutput) { ret := _m.Called(_a0) @@ -4039,6 +8584,34 @@ func (_m *LambdaApi) ListLayersRequest(_a0 *lambda.ListLayersInput) (*request.Re return r0, r1 } +// LambdaApi_ListLayersRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayersRequest' +type LambdaApi_ListLayersRequest_Call struct { + *mock.Call +} + +// ListLayersRequest is a helper method to define mock.On call +// - _a0 *lambda.ListLayersInput +func (_e *LambdaApi_Expecter) ListLayersRequest(_a0 interface{}) *LambdaApi_ListLayersRequest_Call { + return &LambdaApi_ListLayersRequest_Call{Call: _e.mock.On("ListLayersRequest", _a0)} +} + +func (_c *LambdaApi_ListLayersRequest_Call) Run(run func(_a0 *lambda.ListLayersInput)) *LambdaApi_ListLayersRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListLayersInput)) + }) + return _c +} + +func (_c *LambdaApi_ListLayersRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListLayersOutput) *LambdaApi_ListLayersRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListLayersRequest_Call) RunAndReturn(run func(*lambda.ListLayersInput) (*request.Request, *lambda.ListLayersOutput)) *LambdaApi_ListLayersRequest_Call { + _c.Call.Return(run) + return _c +} + // ListLayersWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListLayersWithContext(_a0 context.Context, _a1 *lambda.ListLayersInput, _a2 ...request.Option) (*lambda.ListLayersOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4072,6 +8645,43 @@ func (_m *LambdaApi) ListLayersWithContext(_a0 context.Context, _a1 *lambda.List return r0, r1 } +// LambdaApi_ListLayersWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLayersWithContext' +type LambdaApi_ListLayersWithContext_Call struct { + *mock.Call +} + +// ListLayersWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListLayersInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListLayersWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListLayersWithContext_Call { + return &LambdaApi_ListLayersWithContext_Call{Call: _e.mock.On("ListLayersWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListLayersWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListLayersInput, _a2 ...request.Option)) *LambdaApi_ListLayersWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListLayersInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListLayersWithContext_Call) Return(_a0 *lambda.ListLayersOutput, _a1 error) *LambdaApi_ListLayersWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListLayersWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListLayersInput, ...request.Option) (*lambda.ListLayersOutput, error)) *LambdaApi_ListLayersWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListProvisionedConcurrencyConfigs provides a mock function with given fields: _a0 func (_m *LambdaApi) ListProvisionedConcurrencyConfigs(_a0 *lambda.ListProvisionedConcurrencyConfigsInput) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) { ret := _m.Called(_a0) @@ -4089,13 +8699,41 @@ func (_m *LambdaApi) ListProvisionedConcurrencyConfigs(_a0 *lambda.ListProvision } } - if rf, ok := ret.Get(1).(func(*lambda.ListProvisionedConcurrencyConfigsInput) error); ok { - r1 = rf(_a0) - } else { - r1 = ret.Error(1) - } + if rf, ok := ret.Get(1).(func(*lambda.ListProvisionedConcurrencyConfigsInput) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// LambdaApi_ListProvisionedConcurrencyConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProvisionedConcurrencyConfigs' +type LambdaApi_ListProvisionedConcurrencyConfigs_Call struct { + *mock.Call +} + +// ListProvisionedConcurrencyConfigs is a helper method to define mock.On call +// - _a0 *lambda.ListProvisionedConcurrencyConfigsInput +func (_e *LambdaApi_Expecter) ListProvisionedConcurrencyConfigs(_a0 interface{}) *LambdaApi_ListProvisionedConcurrencyConfigs_Call { + return &LambdaApi_ListProvisionedConcurrencyConfigs_Call{Call: _e.mock.On("ListProvisionedConcurrencyConfigs", _a0)} +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigs_Call) Run(run func(_a0 *lambda.ListProvisionedConcurrencyConfigsInput)) *LambdaApi_ListProvisionedConcurrencyConfigs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListProvisionedConcurrencyConfigsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigs_Call) Return(_a0 *lambda.ListProvisionedConcurrencyConfigsOutput, _a1 error) *LambdaApi_ListProvisionedConcurrencyConfigs_Call { + _c.Call.Return(_a0, _a1) + return _c +} - return r0, r1 +func (_c *LambdaApi_ListProvisionedConcurrencyConfigs_Call) RunAndReturn(run func(*lambda.ListProvisionedConcurrencyConfigsInput) (*lambda.ListProvisionedConcurrencyConfigsOutput, error)) *LambdaApi_ListProvisionedConcurrencyConfigs_Call { + _c.Call.Return(run) + return _c } // ListProvisionedConcurrencyConfigsPages provides a mock function with given fields: _a0, _a1 @@ -4112,6 +8750,35 @@ func (_m *LambdaApi) ListProvisionedConcurrencyConfigsPages(_a0 *lambda.ListProv return r0 } +// LambdaApi_ListProvisionedConcurrencyConfigsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProvisionedConcurrencyConfigsPages' +type LambdaApi_ListProvisionedConcurrencyConfigsPages_Call struct { + *mock.Call +} + +// ListProvisionedConcurrencyConfigsPages is a helper method to define mock.On call +// - _a0 *lambda.ListProvisionedConcurrencyConfigsInput +// - _a1 func(*lambda.ListProvisionedConcurrencyConfigsOutput , bool) bool +func (_e *LambdaApi_Expecter) ListProvisionedConcurrencyConfigsPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListProvisionedConcurrencyConfigsPages_Call { + return &LambdaApi_ListProvisionedConcurrencyConfigsPages_Call{Call: _e.mock.On("ListProvisionedConcurrencyConfigsPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsPages_Call) Run(run func(_a0 *lambda.ListProvisionedConcurrencyConfigsInput, _a1 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool)) *LambdaApi_ListProvisionedConcurrencyConfigsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListProvisionedConcurrencyConfigsInput), args[1].(func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsPages_Call) Return(_a0 error) *LambdaApi_ListProvisionedConcurrencyConfigsPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsPages_Call) RunAndReturn(run func(*lambda.ListProvisionedConcurrencyConfigsInput, func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool) error) *LambdaApi_ListProvisionedConcurrencyConfigsPages_Call { + _c.Call.Return(run) + return _c +} + // ListProvisionedConcurrencyConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListProvisionedConcurrencyConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListProvisionedConcurrencyConfigsInput, _a2 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -4133,6 +8800,44 @@ func (_m *LambdaApi) ListProvisionedConcurrencyConfigsPagesWithContext(_a0 conte return r0 } +// LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProvisionedConcurrencyConfigsPagesWithContext' +type LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call struct { + *mock.Call +} + +// ListProvisionedConcurrencyConfigsPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListProvisionedConcurrencyConfigsInput +// - _a2 func(*lambda.ListProvisionedConcurrencyConfigsOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListProvisionedConcurrencyConfigsPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call { + return &LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call{Call: _e.mock.On("ListProvisionedConcurrencyConfigsPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListProvisionedConcurrencyConfigsInput, _a2 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListProvisionedConcurrencyConfigsInput), args[2].(func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListProvisionedConcurrencyConfigsInput, func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, ...request.Option) error) *LambdaApi_ListProvisionedConcurrencyConfigsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListProvisionedConcurrencyConfigsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListProvisionedConcurrencyConfigsRequest(_a0 *lambda.ListProvisionedConcurrencyConfigsInput) (*request.Request, *lambda.ListProvisionedConcurrencyConfigsOutput) { ret := _m.Called(_a0) @@ -4161,6 +8866,34 @@ func (_m *LambdaApi) ListProvisionedConcurrencyConfigsRequest(_a0 *lambda.ListPr return r0, r1 } +// LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProvisionedConcurrencyConfigsRequest' +type LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call struct { + *mock.Call +} + +// ListProvisionedConcurrencyConfigsRequest is a helper method to define mock.On call +// - _a0 *lambda.ListProvisionedConcurrencyConfigsInput +func (_e *LambdaApi_Expecter) ListProvisionedConcurrencyConfigsRequest(_a0 interface{}) *LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call { + return &LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call{Call: _e.mock.On("ListProvisionedConcurrencyConfigsRequest", _a0)} +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call) Run(run func(_a0 *lambda.ListProvisionedConcurrencyConfigsInput)) *LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListProvisionedConcurrencyConfigsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListProvisionedConcurrencyConfigsOutput) *LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call) RunAndReturn(run func(*lambda.ListProvisionedConcurrencyConfigsInput) (*request.Request, *lambda.ListProvisionedConcurrencyConfigsOutput)) *LambdaApi_ListProvisionedConcurrencyConfigsRequest_Call { + _c.Call.Return(run) + return _c +} + // ListProvisionedConcurrencyConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListProvisionedConcurrencyConfigsWithContext(_a0 context.Context, _a1 *lambda.ListProvisionedConcurrencyConfigsInput, _a2 ...request.Option) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4194,6 +8927,43 @@ func (_m *LambdaApi) ListProvisionedConcurrencyConfigsWithContext(_a0 context.Co return r0, r1 } +// LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProvisionedConcurrencyConfigsWithContext' +type LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call struct { + *mock.Call +} + +// ListProvisionedConcurrencyConfigsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListProvisionedConcurrencyConfigsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListProvisionedConcurrencyConfigsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call { + return &LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call{Call: _e.mock.On("ListProvisionedConcurrencyConfigsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListProvisionedConcurrencyConfigsInput, _a2 ...request.Option)) *LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListProvisionedConcurrencyConfigsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call) Return(_a0 *lambda.ListProvisionedConcurrencyConfigsOutput, _a1 error) *LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListProvisionedConcurrencyConfigsInput, ...request.Option) (*lambda.ListProvisionedConcurrencyConfigsOutput, error)) *LambdaApi_ListProvisionedConcurrencyConfigsWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListTags provides a mock function with given fields: _a0 func (_m *LambdaApi) ListTags(_a0 *lambda.ListTagsInput) (*lambda.ListTagsOutput, error) { ret := _m.Called(_a0) @@ -4220,6 +8990,34 @@ func (_m *LambdaApi) ListTags(_a0 *lambda.ListTagsInput) (*lambda.ListTagsOutput return r0, r1 } +// LambdaApi_ListTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTags' +type LambdaApi_ListTags_Call struct { + *mock.Call +} + +// ListTags is a helper method to define mock.On call +// - _a0 *lambda.ListTagsInput +func (_e *LambdaApi_Expecter) ListTags(_a0 interface{}) *LambdaApi_ListTags_Call { + return &LambdaApi_ListTags_Call{Call: _e.mock.On("ListTags", _a0)} +} + +func (_c *LambdaApi_ListTags_Call) Run(run func(_a0 *lambda.ListTagsInput)) *LambdaApi_ListTags_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListTagsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListTags_Call) Return(_a0 *lambda.ListTagsOutput, _a1 error) *LambdaApi_ListTags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListTags_Call) RunAndReturn(run func(*lambda.ListTagsInput) (*lambda.ListTagsOutput, error)) *LambdaApi_ListTags_Call { + _c.Call.Return(run) + return _c +} + // ListTagsRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListTagsRequest(_a0 *lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput) { ret := _m.Called(_a0) @@ -4248,6 +9046,34 @@ func (_m *LambdaApi) ListTagsRequest(_a0 *lambda.ListTagsInput) (*request.Reques return r0, r1 } +// LambdaApi_ListTagsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTagsRequest' +type LambdaApi_ListTagsRequest_Call struct { + *mock.Call +} + +// ListTagsRequest is a helper method to define mock.On call +// - _a0 *lambda.ListTagsInput +func (_e *LambdaApi_Expecter) ListTagsRequest(_a0 interface{}) *LambdaApi_ListTagsRequest_Call { + return &LambdaApi_ListTagsRequest_Call{Call: _e.mock.On("ListTagsRequest", _a0)} +} + +func (_c *LambdaApi_ListTagsRequest_Call) Run(run func(_a0 *lambda.ListTagsInput)) *LambdaApi_ListTagsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListTagsInput)) + }) + return _c +} + +func (_c *LambdaApi_ListTagsRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListTagsOutput) *LambdaApi_ListTagsRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListTagsRequest_Call) RunAndReturn(run func(*lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput)) *LambdaApi_ListTagsRequest_Call { + _c.Call.Return(run) + return _c +} + // ListTagsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListTagsWithContext(_a0 context.Context, _a1 *lambda.ListTagsInput, _a2 ...request.Option) (*lambda.ListTagsOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4281,6 +9107,43 @@ func (_m *LambdaApi) ListTagsWithContext(_a0 context.Context, _a1 *lambda.ListTa return r0, r1 } +// LambdaApi_ListTagsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTagsWithContext' +type LambdaApi_ListTagsWithContext_Call struct { + *mock.Call +} + +// ListTagsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListTagsInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListTagsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListTagsWithContext_Call { + return &LambdaApi_ListTagsWithContext_Call{Call: _e.mock.On("ListTagsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListTagsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListTagsInput, _a2 ...request.Option)) *LambdaApi_ListTagsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListTagsInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListTagsWithContext_Call) Return(_a0 *lambda.ListTagsOutput, _a1 error) *LambdaApi_ListTagsWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListTagsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListTagsInput, ...request.Option) (*lambda.ListTagsOutput, error)) *LambdaApi_ListTagsWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListVersionsByFunction provides a mock function with given fields: _a0 func (_m *LambdaApi) ListVersionsByFunction(_a0 *lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error) { ret := _m.Called(_a0) @@ -4307,6 +9170,34 @@ func (_m *LambdaApi) ListVersionsByFunction(_a0 *lambda.ListVersionsByFunctionIn return r0, r1 } +// LambdaApi_ListVersionsByFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVersionsByFunction' +type LambdaApi_ListVersionsByFunction_Call struct { + *mock.Call +} + +// ListVersionsByFunction is a helper method to define mock.On call +// - _a0 *lambda.ListVersionsByFunctionInput +func (_e *LambdaApi_Expecter) ListVersionsByFunction(_a0 interface{}) *LambdaApi_ListVersionsByFunction_Call { + return &LambdaApi_ListVersionsByFunction_Call{Call: _e.mock.On("ListVersionsByFunction", _a0)} +} + +func (_c *LambdaApi_ListVersionsByFunction_Call) Run(run func(_a0 *lambda.ListVersionsByFunctionInput)) *LambdaApi_ListVersionsByFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListVersionsByFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunction_Call) Return(_a0 *lambda.ListVersionsByFunctionOutput, _a1 error) *LambdaApi_ListVersionsByFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunction_Call) RunAndReturn(run func(*lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error)) *LambdaApi_ListVersionsByFunction_Call { + _c.Call.Return(run) + return _c +} + // ListVersionsByFunctionPages provides a mock function with given fields: _a0, _a1 func (_m *LambdaApi) ListVersionsByFunctionPages(_a0 *lambda.ListVersionsByFunctionInput, _a1 func(*lambda.ListVersionsByFunctionOutput, bool) bool) error { ret := _m.Called(_a0, _a1) @@ -4321,6 +9212,35 @@ func (_m *LambdaApi) ListVersionsByFunctionPages(_a0 *lambda.ListVersionsByFunct return r0 } +// LambdaApi_ListVersionsByFunctionPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVersionsByFunctionPages' +type LambdaApi_ListVersionsByFunctionPages_Call struct { + *mock.Call +} + +// ListVersionsByFunctionPages is a helper method to define mock.On call +// - _a0 *lambda.ListVersionsByFunctionInput +// - _a1 func(*lambda.ListVersionsByFunctionOutput , bool) bool +func (_e *LambdaApi_Expecter) ListVersionsByFunctionPages(_a0 interface{}, _a1 interface{}) *LambdaApi_ListVersionsByFunctionPages_Call { + return &LambdaApi_ListVersionsByFunctionPages_Call{Call: _e.mock.On("ListVersionsByFunctionPages", _a0, _a1)} +} + +func (_c *LambdaApi_ListVersionsByFunctionPages_Call) Run(run func(_a0 *lambda.ListVersionsByFunctionInput, _a1 func(*lambda.ListVersionsByFunctionOutput, bool) bool)) *LambdaApi_ListVersionsByFunctionPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListVersionsByFunctionInput), args[1].(func(*lambda.ListVersionsByFunctionOutput, bool) bool)) + }) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunctionPages_Call) Return(_a0 error) *LambdaApi_ListVersionsByFunctionPages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunctionPages_Call) RunAndReturn(run func(*lambda.ListVersionsByFunctionInput, func(*lambda.ListVersionsByFunctionOutput, bool) bool) error) *LambdaApi_ListVersionsByFunctionPages_Call { + _c.Call.Return(run) + return _c +} + // ListVersionsByFunctionPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 func (_m *LambdaApi) ListVersionsByFunctionPagesWithContext(_a0 context.Context, _a1 *lambda.ListVersionsByFunctionInput, _a2 func(*lambda.ListVersionsByFunctionOutput, bool) bool, _a3 ...request.Option) error { _va := make([]interface{}, len(_a3)) @@ -4342,6 +9262,44 @@ func (_m *LambdaApi) ListVersionsByFunctionPagesWithContext(_a0 context.Context, return r0 } +// LambdaApi_ListVersionsByFunctionPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVersionsByFunctionPagesWithContext' +type LambdaApi_ListVersionsByFunctionPagesWithContext_Call struct { + *mock.Call +} + +// ListVersionsByFunctionPagesWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListVersionsByFunctionInput +// - _a2 func(*lambda.ListVersionsByFunctionOutput , bool) bool +// - _a3 ...request.Option +func (_e *LambdaApi_Expecter) ListVersionsByFunctionPagesWithContext(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 ...interface{}) *LambdaApi_ListVersionsByFunctionPagesWithContext_Call { + return &LambdaApi_ListVersionsByFunctionPagesWithContext_Call{Call: _e.mock.On("ListVersionsByFunctionPagesWithContext", + append([]interface{}{_a0, _a1, _a2}, _a3...)...)} +} + +func (_c *LambdaApi_ListVersionsByFunctionPagesWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListVersionsByFunctionInput, _a2 func(*lambda.ListVersionsByFunctionOutput, bool) bool, _a3 ...request.Option)) *LambdaApi_ListVersionsByFunctionPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListVersionsByFunctionInput), args[2].(func(*lambda.ListVersionsByFunctionOutput, bool) bool), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunctionPagesWithContext_Call) Return(_a0 error) *LambdaApi_ListVersionsByFunctionPagesWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunctionPagesWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListVersionsByFunctionInput, func(*lambda.ListVersionsByFunctionOutput, bool) bool, ...request.Option) error) *LambdaApi_ListVersionsByFunctionPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + // ListVersionsByFunctionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) ListVersionsByFunctionRequest(_a0 *lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput) { ret := _m.Called(_a0) @@ -4370,6 +9328,34 @@ func (_m *LambdaApi) ListVersionsByFunctionRequest(_a0 *lambda.ListVersionsByFun return r0, r1 } +// LambdaApi_ListVersionsByFunctionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVersionsByFunctionRequest' +type LambdaApi_ListVersionsByFunctionRequest_Call struct { + *mock.Call +} + +// ListVersionsByFunctionRequest is a helper method to define mock.On call +// - _a0 *lambda.ListVersionsByFunctionInput +func (_e *LambdaApi_Expecter) ListVersionsByFunctionRequest(_a0 interface{}) *LambdaApi_ListVersionsByFunctionRequest_Call { + return &LambdaApi_ListVersionsByFunctionRequest_Call{Call: _e.mock.On("ListVersionsByFunctionRequest", _a0)} +} + +func (_c *LambdaApi_ListVersionsByFunctionRequest_Call) Run(run func(_a0 *lambda.ListVersionsByFunctionInput)) *LambdaApi_ListVersionsByFunctionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.ListVersionsByFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunctionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.ListVersionsByFunctionOutput) *LambdaApi_ListVersionsByFunctionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunctionRequest_Call) RunAndReturn(run func(*lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput)) *LambdaApi_ListVersionsByFunctionRequest_Call { + _c.Call.Return(run) + return _c +} + // ListVersionsByFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) ListVersionsByFunctionWithContext(_a0 context.Context, _a1 *lambda.ListVersionsByFunctionInput, _a2 ...request.Option) (*lambda.ListVersionsByFunctionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4403,6 +9389,43 @@ func (_m *LambdaApi) ListVersionsByFunctionWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_ListVersionsByFunctionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVersionsByFunctionWithContext' +type LambdaApi_ListVersionsByFunctionWithContext_Call struct { + *mock.Call +} + +// ListVersionsByFunctionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.ListVersionsByFunctionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) ListVersionsByFunctionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_ListVersionsByFunctionWithContext_Call { + return &LambdaApi_ListVersionsByFunctionWithContext_Call{Call: _e.mock.On("ListVersionsByFunctionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_ListVersionsByFunctionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.ListVersionsByFunctionInput, _a2 ...request.Option)) *LambdaApi_ListVersionsByFunctionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.ListVersionsByFunctionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunctionWithContext_Call) Return(_a0 *lambda.ListVersionsByFunctionOutput, _a1 error) *LambdaApi_ListVersionsByFunctionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_ListVersionsByFunctionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.ListVersionsByFunctionInput, ...request.Option) (*lambda.ListVersionsByFunctionOutput, error)) *LambdaApi_ListVersionsByFunctionWithContext_Call { + _c.Call.Return(run) + return _c +} + // PublishLayerVersion provides a mock function with given fields: _a0 func (_m *LambdaApi) PublishLayerVersion(_a0 *lambda.PublishLayerVersionInput) (*lambda.PublishLayerVersionOutput, error) { ret := _m.Called(_a0) @@ -4429,6 +9452,34 @@ func (_m *LambdaApi) PublishLayerVersion(_a0 *lambda.PublishLayerVersionInput) ( return r0, r1 } +// LambdaApi_PublishLayerVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishLayerVersion' +type LambdaApi_PublishLayerVersion_Call struct { + *mock.Call +} + +// PublishLayerVersion is a helper method to define mock.On call +// - _a0 *lambda.PublishLayerVersionInput +func (_e *LambdaApi_Expecter) PublishLayerVersion(_a0 interface{}) *LambdaApi_PublishLayerVersion_Call { + return &LambdaApi_PublishLayerVersion_Call{Call: _e.mock.On("PublishLayerVersion", _a0)} +} + +func (_c *LambdaApi_PublishLayerVersion_Call) Run(run func(_a0 *lambda.PublishLayerVersionInput)) *LambdaApi_PublishLayerVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PublishLayerVersionInput)) + }) + return _c +} + +func (_c *LambdaApi_PublishLayerVersion_Call) Return(_a0 *lambda.PublishLayerVersionOutput, _a1 error) *LambdaApi_PublishLayerVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PublishLayerVersion_Call) RunAndReturn(run func(*lambda.PublishLayerVersionInput) (*lambda.PublishLayerVersionOutput, error)) *LambdaApi_PublishLayerVersion_Call { + _c.Call.Return(run) + return _c +} + // PublishLayerVersionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) PublishLayerVersionRequest(_a0 *lambda.PublishLayerVersionInput) (*request.Request, *lambda.PublishLayerVersionOutput) { ret := _m.Called(_a0) @@ -4457,6 +9508,34 @@ func (_m *LambdaApi) PublishLayerVersionRequest(_a0 *lambda.PublishLayerVersionI return r0, r1 } +// LambdaApi_PublishLayerVersionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishLayerVersionRequest' +type LambdaApi_PublishLayerVersionRequest_Call struct { + *mock.Call +} + +// PublishLayerVersionRequest is a helper method to define mock.On call +// - _a0 *lambda.PublishLayerVersionInput +func (_e *LambdaApi_Expecter) PublishLayerVersionRequest(_a0 interface{}) *LambdaApi_PublishLayerVersionRequest_Call { + return &LambdaApi_PublishLayerVersionRequest_Call{Call: _e.mock.On("PublishLayerVersionRequest", _a0)} +} + +func (_c *LambdaApi_PublishLayerVersionRequest_Call) Run(run func(_a0 *lambda.PublishLayerVersionInput)) *LambdaApi_PublishLayerVersionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PublishLayerVersionInput)) + }) + return _c +} + +func (_c *LambdaApi_PublishLayerVersionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.PublishLayerVersionOutput) *LambdaApi_PublishLayerVersionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PublishLayerVersionRequest_Call) RunAndReturn(run func(*lambda.PublishLayerVersionInput) (*request.Request, *lambda.PublishLayerVersionOutput)) *LambdaApi_PublishLayerVersionRequest_Call { + _c.Call.Return(run) + return _c +} + // PublishLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) PublishLayerVersionWithContext(_a0 context.Context, _a1 *lambda.PublishLayerVersionInput, _a2 ...request.Option) (*lambda.PublishLayerVersionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4490,6 +9569,43 @@ func (_m *LambdaApi) PublishLayerVersionWithContext(_a0 context.Context, _a1 *la return r0, r1 } +// LambdaApi_PublishLayerVersionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishLayerVersionWithContext' +type LambdaApi_PublishLayerVersionWithContext_Call struct { + *mock.Call +} + +// PublishLayerVersionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.PublishLayerVersionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) PublishLayerVersionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_PublishLayerVersionWithContext_Call { + return &LambdaApi_PublishLayerVersionWithContext_Call{Call: _e.mock.On("PublishLayerVersionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_PublishLayerVersionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.PublishLayerVersionInput, _a2 ...request.Option)) *LambdaApi_PublishLayerVersionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.PublishLayerVersionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_PublishLayerVersionWithContext_Call) Return(_a0 *lambda.PublishLayerVersionOutput, _a1 error) *LambdaApi_PublishLayerVersionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PublishLayerVersionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.PublishLayerVersionInput, ...request.Option) (*lambda.PublishLayerVersionOutput, error)) *LambdaApi_PublishLayerVersionWithContext_Call { + _c.Call.Return(run) + return _c +} + // PublishVersion provides a mock function with given fields: _a0 func (_m *LambdaApi) PublishVersion(_a0 *lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error) { ret := _m.Called(_a0) @@ -4516,6 +9632,34 @@ func (_m *LambdaApi) PublishVersion(_a0 *lambda.PublishVersionInput) (*lambda.Fu return r0, r1 } +// LambdaApi_PublishVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishVersion' +type LambdaApi_PublishVersion_Call struct { + *mock.Call +} + +// PublishVersion is a helper method to define mock.On call +// - _a0 *lambda.PublishVersionInput +func (_e *LambdaApi_Expecter) PublishVersion(_a0 interface{}) *LambdaApi_PublishVersion_Call { + return &LambdaApi_PublishVersion_Call{Call: _e.mock.On("PublishVersion", _a0)} +} + +func (_c *LambdaApi_PublishVersion_Call) Run(run func(_a0 *lambda.PublishVersionInput)) *LambdaApi_PublishVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PublishVersionInput)) + }) + return _c +} + +func (_c *LambdaApi_PublishVersion_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_PublishVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PublishVersion_Call) RunAndReturn(run func(*lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error)) *LambdaApi_PublishVersion_Call { + _c.Call.Return(run) + return _c +} + // PublishVersionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) PublishVersionRequest(_a0 *lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration) { ret := _m.Called(_a0) @@ -4544,6 +9688,34 @@ func (_m *LambdaApi) PublishVersionRequest(_a0 *lambda.PublishVersionInput) (*re return r0, r1 } +// LambdaApi_PublishVersionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishVersionRequest' +type LambdaApi_PublishVersionRequest_Call struct { + *mock.Call +} + +// PublishVersionRequest is a helper method to define mock.On call +// - _a0 *lambda.PublishVersionInput +func (_e *LambdaApi_Expecter) PublishVersionRequest(_a0 interface{}) *LambdaApi_PublishVersionRequest_Call { + return &LambdaApi_PublishVersionRequest_Call{Call: _e.mock.On("PublishVersionRequest", _a0)} +} + +func (_c *LambdaApi_PublishVersionRequest_Call) Run(run func(_a0 *lambda.PublishVersionInput)) *LambdaApi_PublishVersionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PublishVersionInput)) + }) + return _c +} + +func (_c *LambdaApi_PublishVersionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.FunctionConfiguration) *LambdaApi_PublishVersionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PublishVersionRequest_Call) RunAndReturn(run func(*lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration)) *LambdaApi_PublishVersionRequest_Call { + _c.Call.Return(run) + return _c +} + // PublishVersionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) PublishVersionWithContext(_a0 context.Context, _a1 *lambda.PublishVersionInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -4577,6 +9749,43 @@ func (_m *LambdaApi) PublishVersionWithContext(_a0 context.Context, _a1 *lambda. return r0, r1 } +// LambdaApi_PublishVersionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishVersionWithContext' +type LambdaApi_PublishVersionWithContext_Call struct { + *mock.Call +} + +// PublishVersionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.PublishVersionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) PublishVersionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_PublishVersionWithContext_Call { + return &LambdaApi_PublishVersionWithContext_Call{Call: _e.mock.On("PublishVersionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_PublishVersionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.PublishVersionInput, _a2 ...request.Option)) *LambdaApi_PublishVersionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.PublishVersionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_PublishVersionWithContext_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_PublishVersionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PublishVersionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.PublishVersionInput, ...request.Option) (*lambda.FunctionConfiguration, error)) *LambdaApi_PublishVersionWithContext_Call { + _c.Call.Return(run) + return _c +} + // PutFunctionCodeSigningConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) PutFunctionCodeSigningConfig(_a0 *lambda.PutFunctionCodeSigningConfigInput) (*lambda.PutFunctionCodeSigningConfigOutput, error) { ret := _m.Called(_a0) @@ -4603,6 +9812,34 @@ func (_m *LambdaApi) PutFunctionCodeSigningConfig(_a0 *lambda.PutFunctionCodeSig return r0, r1 } +// LambdaApi_PutFunctionCodeSigningConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionCodeSigningConfig' +type LambdaApi_PutFunctionCodeSigningConfig_Call struct { + *mock.Call +} + +// PutFunctionCodeSigningConfig is a helper method to define mock.On call +// - _a0 *lambda.PutFunctionCodeSigningConfigInput +func (_e *LambdaApi_Expecter) PutFunctionCodeSigningConfig(_a0 interface{}) *LambdaApi_PutFunctionCodeSigningConfig_Call { + return &LambdaApi_PutFunctionCodeSigningConfig_Call{Call: _e.mock.On("PutFunctionCodeSigningConfig", _a0)} +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfig_Call) Run(run func(_a0 *lambda.PutFunctionCodeSigningConfigInput)) *LambdaApi_PutFunctionCodeSigningConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PutFunctionCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfig_Call) Return(_a0 *lambda.PutFunctionCodeSigningConfigOutput, _a1 error) *LambdaApi_PutFunctionCodeSigningConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfig_Call) RunAndReturn(run func(*lambda.PutFunctionCodeSigningConfigInput) (*lambda.PutFunctionCodeSigningConfigOutput, error)) *LambdaApi_PutFunctionCodeSigningConfig_Call { + _c.Call.Return(run) + return _c +} + // PutFunctionCodeSigningConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) PutFunctionCodeSigningConfigRequest(_a0 *lambda.PutFunctionCodeSigningConfigInput) (*request.Request, *lambda.PutFunctionCodeSigningConfigOutput) { ret := _m.Called(_a0) @@ -4631,6 +9868,34 @@ func (_m *LambdaApi) PutFunctionCodeSigningConfigRequest(_a0 *lambda.PutFunction return r0, r1 } +// LambdaApi_PutFunctionCodeSigningConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionCodeSigningConfigRequest' +type LambdaApi_PutFunctionCodeSigningConfigRequest_Call struct { + *mock.Call +} + +// PutFunctionCodeSigningConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.PutFunctionCodeSigningConfigInput +func (_e *LambdaApi_Expecter) PutFunctionCodeSigningConfigRequest(_a0 interface{}) *LambdaApi_PutFunctionCodeSigningConfigRequest_Call { + return &LambdaApi_PutFunctionCodeSigningConfigRequest_Call{Call: _e.mock.On("PutFunctionCodeSigningConfigRequest", _a0)} +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfigRequest_Call) Run(run func(_a0 *lambda.PutFunctionCodeSigningConfigInput)) *LambdaApi_PutFunctionCodeSigningConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PutFunctionCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.PutFunctionCodeSigningConfigOutput) *LambdaApi_PutFunctionCodeSigningConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfigRequest_Call) RunAndReturn(run func(*lambda.PutFunctionCodeSigningConfigInput) (*request.Request, *lambda.PutFunctionCodeSigningConfigOutput)) *LambdaApi_PutFunctionCodeSigningConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // PutFunctionCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) PutFunctionCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.PutFunctionCodeSigningConfigInput, _a2 ...request.Option) (*lambda.PutFunctionCodeSigningConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4664,6 +9929,43 @@ func (_m *LambdaApi) PutFunctionCodeSigningConfigWithContext(_a0 context.Context return r0, r1 } +// LambdaApi_PutFunctionCodeSigningConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionCodeSigningConfigWithContext' +type LambdaApi_PutFunctionCodeSigningConfigWithContext_Call struct { + *mock.Call +} + +// PutFunctionCodeSigningConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.PutFunctionCodeSigningConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) PutFunctionCodeSigningConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_PutFunctionCodeSigningConfigWithContext_Call { + return &LambdaApi_PutFunctionCodeSigningConfigWithContext_Call{Call: _e.mock.On("PutFunctionCodeSigningConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.PutFunctionCodeSigningConfigInput, _a2 ...request.Option)) *LambdaApi_PutFunctionCodeSigningConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.PutFunctionCodeSigningConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfigWithContext_Call) Return(_a0 *lambda.PutFunctionCodeSigningConfigOutput, _a1 error) *LambdaApi_PutFunctionCodeSigningConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionCodeSigningConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.PutFunctionCodeSigningConfigInput, ...request.Option) (*lambda.PutFunctionCodeSigningConfigOutput, error)) *LambdaApi_PutFunctionCodeSigningConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // PutFunctionConcurrency provides a mock function with given fields: _a0 func (_m *LambdaApi) PutFunctionConcurrency(_a0 *lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error) { ret := _m.Called(_a0) @@ -4690,6 +9992,34 @@ func (_m *LambdaApi) PutFunctionConcurrency(_a0 *lambda.PutFunctionConcurrencyIn return r0, r1 } +// LambdaApi_PutFunctionConcurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionConcurrency' +type LambdaApi_PutFunctionConcurrency_Call struct { + *mock.Call +} + +// PutFunctionConcurrency is a helper method to define mock.On call +// - _a0 *lambda.PutFunctionConcurrencyInput +func (_e *LambdaApi_Expecter) PutFunctionConcurrency(_a0 interface{}) *LambdaApi_PutFunctionConcurrency_Call { + return &LambdaApi_PutFunctionConcurrency_Call{Call: _e.mock.On("PutFunctionConcurrency", _a0)} +} + +func (_c *LambdaApi_PutFunctionConcurrency_Call) Run(run func(_a0 *lambda.PutFunctionConcurrencyInput)) *LambdaApi_PutFunctionConcurrency_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PutFunctionConcurrencyInput)) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionConcurrency_Call) Return(_a0 *lambda.PutFunctionConcurrencyOutput, _a1 error) *LambdaApi_PutFunctionConcurrency_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionConcurrency_Call) RunAndReturn(run func(*lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error)) *LambdaApi_PutFunctionConcurrency_Call { + _c.Call.Return(run) + return _c +} + // PutFunctionConcurrencyRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) PutFunctionConcurrencyRequest(_a0 *lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput) { ret := _m.Called(_a0) @@ -4718,6 +10048,34 @@ func (_m *LambdaApi) PutFunctionConcurrencyRequest(_a0 *lambda.PutFunctionConcur return r0, r1 } +// LambdaApi_PutFunctionConcurrencyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionConcurrencyRequest' +type LambdaApi_PutFunctionConcurrencyRequest_Call struct { + *mock.Call +} + +// PutFunctionConcurrencyRequest is a helper method to define mock.On call +// - _a0 *lambda.PutFunctionConcurrencyInput +func (_e *LambdaApi_Expecter) PutFunctionConcurrencyRequest(_a0 interface{}) *LambdaApi_PutFunctionConcurrencyRequest_Call { + return &LambdaApi_PutFunctionConcurrencyRequest_Call{Call: _e.mock.On("PutFunctionConcurrencyRequest", _a0)} +} + +func (_c *LambdaApi_PutFunctionConcurrencyRequest_Call) Run(run func(_a0 *lambda.PutFunctionConcurrencyInput)) *LambdaApi_PutFunctionConcurrencyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PutFunctionConcurrencyInput)) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionConcurrencyRequest_Call) Return(_a0 *request.Request, _a1 *lambda.PutFunctionConcurrencyOutput) *LambdaApi_PutFunctionConcurrencyRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionConcurrencyRequest_Call) RunAndReturn(run func(*lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput)) *LambdaApi_PutFunctionConcurrencyRequest_Call { + _c.Call.Return(run) + return _c +} + // PutFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) PutFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.PutFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4748,7 +10106,44 @@ func (_m *LambdaApi) PutFunctionConcurrencyWithContext(_a0 context.Context, _a1 r1 = ret.Error(1) } - return r0, r1 + return r0, r1 +} + +// LambdaApi_PutFunctionConcurrencyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionConcurrencyWithContext' +type LambdaApi_PutFunctionConcurrencyWithContext_Call struct { + *mock.Call +} + +// PutFunctionConcurrencyWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.PutFunctionConcurrencyInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) PutFunctionConcurrencyWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_PutFunctionConcurrencyWithContext_Call { + return &LambdaApi_PutFunctionConcurrencyWithContext_Call{Call: _e.mock.On("PutFunctionConcurrencyWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_PutFunctionConcurrencyWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.PutFunctionConcurrencyInput, _a2 ...request.Option)) *LambdaApi_PutFunctionConcurrencyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.PutFunctionConcurrencyInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionConcurrencyWithContext_Call) Return(_a0 *lambda.PutFunctionConcurrencyOutput, _a1 error) *LambdaApi_PutFunctionConcurrencyWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionConcurrencyWithContext_Call) RunAndReturn(run func(context.Context, *lambda.PutFunctionConcurrencyInput, ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error)) *LambdaApi_PutFunctionConcurrencyWithContext_Call { + _c.Call.Return(run) + return _c } // PutFunctionEventInvokeConfig provides a mock function with given fields: _a0 @@ -4777,6 +10172,34 @@ func (_m *LambdaApi) PutFunctionEventInvokeConfig(_a0 *lambda.PutFunctionEventIn return r0, r1 } +// LambdaApi_PutFunctionEventInvokeConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionEventInvokeConfig' +type LambdaApi_PutFunctionEventInvokeConfig_Call struct { + *mock.Call +} + +// PutFunctionEventInvokeConfig is a helper method to define mock.On call +// - _a0 *lambda.PutFunctionEventInvokeConfigInput +func (_e *LambdaApi_Expecter) PutFunctionEventInvokeConfig(_a0 interface{}) *LambdaApi_PutFunctionEventInvokeConfig_Call { + return &LambdaApi_PutFunctionEventInvokeConfig_Call{Call: _e.mock.On("PutFunctionEventInvokeConfig", _a0)} +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfig_Call) Run(run func(_a0 *lambda.PutFunctionEventInvokeConfigInput)) *LambdaApi_PutFunctionEventInvokeConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PutFunctionEventInvokeConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfig_Call) Return(_a0 *lambda.PutFunctionEventInvokeConfigOutput, _a1 error) *LambdaApi_PutFunctionEventInvokeConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfig_Call) RunAndReturn(run func(*lambda.PutFunctionEventInvokeConfigInput) (*lambda.PutFunctionEventInvokeConfigOutput, error)) *LambdaApi_PutFunctionEventInvokeConfig_Call { + _c.Call.Return(run) + return _c +} + // PutFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) PutFunctionEventInvokeConfigRequest(_a0 *lambda.PutFunctionEventInvokeConfigInput) (*request.Request, *lambda.PutFunctionEventInvokeConfigOutput) { ret := _m.Called(_a0) @@ -4805,6 +10228,34 @@ func (_m *LambdaApi) PutFunctionEventInvokeConfigRequest(_a0 *lambda.PutFunction return r0, r1 } +// LambdaApi_PutFunctionEventInvokeConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionEventInvokeConfigRequest' +type LambdaApi_PutFunctionEventInvokeConfigRequest_Call struct { + *mock.Call +} + +// PutFunctionEventInvokeConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.PutFunctionEventInvokeConfigInput +func (_e *LambdaApi_Expecter) PutFunctionEventInvokeConfigRequest(_a0 interface{}) *LambdaApi_PutFunctionEventInvokeConfigRequest_Call { + return &LambdaApi_PutFunctionEventInvokeConfigRequest_Call{Call: _e.mock.On("PutFunctionEventInvokeConfigRequest", _a0)} +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfigRequest_Call) Run(run func(_a0 *lambda.PutFunctionEventInvokeConfigInput)) *LambdaApi_PutFunctionEventInvokeConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PutFunctionEventInvokeConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.PutFunctionEventInvokeConfigOutput) *LambdaApi_PutFunctionEventInvokeConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfigRequest_Call) RunAndReturn(run func(*lambda.PutFunctionEventInvokeConfigInput) (*request.Request, *lambda.PutFunctionEventInvokeConfigOutput)) *LambdaApi_PutFunctionEventInvokeConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // PutFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) PutFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.PutFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.PutFunctionEventInvokeConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4838,6 +10289,43 @@ func (_m *LambdaApi) PutFunctionEventInvokeConfigWithContext(_a0 context.Context return r0, r1 } +// LambdaApi_PutFunctionEventInvokeConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutFunctionEventInvokeConfigWithContext' +type LambdaApi_PutFunctionEventInvokeConfigWithContext_Call struct { + *mock.Call +} + +// PutFunctionEventInvokeConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.PutFunctionEventInvokeConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) PutFunctionEventInvokeConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_PutFunctionEventInvokeConfigWithContext_Call { + return &LambdaApi_PutFunctionEventInvokeConfigWithContext_Call{Call: _e.mock.On("PutFunctionEventInvokeConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.PutFunctionEventInvokeConfigInput, _a2 ...request.Option)) *LambdaApi_PutFunctionEventInvokeConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.PutFunctionEventInvokeConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfigWithContext_Call) Return(_a0 *lambda.PutFunctionEventInvokeConfigOutput, _a1 error) *LambdaApi_PutFunctionEventInvokeConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutFunctionEventInvokeConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.PutFunctionEventInvokeConfigInput, ...request.Option) (*lambda.PutFunctionEventInvokeConfigOutput, error)) *LambdaApi_PutFunctionEventInvokeConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // PutProvisionedConcurrencyConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) PutProvisionedConcurrencyConfig(_a0 *lambda.PutProvisionedConcurrencyConfigInput) (*lambda.PutProvisionedConcurrencyConfigOutput, error) { ret := _m.Called(_a0) @@ -4864,6 +10352,34 @@ func (_m *LambdaApi) PutProvisionedConcurrencyConfig(_a0 *lambda.PutProvisionedC return r0, r1 } +// LambdaApi_PutProvisionedConcurrencyConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutProvisionedConcurrencyConfig' +type LambdaApi_PutProvisionedConcurrencyConfig_Call struct { + *mock.Call +} + +// PutProvisionedConcurrencyConfig is a helper method to define mock.On call +// - _a0 *lambda.PutProvisionedConcurrencyConfigInput +func (_e *LambdaApi_Expecter) PutProvisionedConcurrencyConfig(_a0 interface{}) *LambdaApi_PutProvisionedConcurrencyConfig_Call { + return &LambdaApi_PutProvisionedConcurrencyConfig_Call{Call: _e.mock.On("PutProvisionedConcurrencyConfig", _a0)} +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfig_Call) Run(run func(_a0 *lambda.PutProvisionedConcurrencyConfigInput)) *LambdaApi_PutProvisionedConcurrencyConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PutProvisionedConcurrencyConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfig_Call) Return(_a0 *lambda.PutProvisionedConcurrencyConfigOutput, _a1 error) *LambdaApi_PutProvisionedConcurrencyConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfig_Call) RunAndReturn(run func(*lambda.PutProvisionedConcurrencyConfigInput) (*lambda.PutProvisionedConcurrencyConfigOutput, error)) *LambdaApi_PutProvisionedConcurrencyConfig_Call { + _c.Call.Return(run) + return _c +} + // PutProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) PutProvisionedConcurrencyConfigRequest(_a0 *lambda.PutProvisionedConcurrencyConfigInput) (*request.Request, *lambda.PutProvisionedConcurrencyConfigOutput) { ret := _m.Called(_a0) @@ -4892,6 +10408,34 @@ func (_m *LambdaApi) PutProvisionedConcurrencyConfigRequest(_a0 *lambda.PutProvi return r0, r1 } +// LambdaApi_PutProvisionedConcurrencyConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutProvisionedConcurrencyConfigRequest' +type LambdaApi_PutProvisionedConcurrencyConfigRequest_Call struct { + *mock.Call +} + +// PutProvisionedConcurrencyConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.PutProvisionedConcurrencyConfigInput +func (_e *LambdaApi_Expecter) PutProvisionedConcurrencyConfigRequest(_a0 interface{}) *LambdaApi_PutProvisionedConcurrencyConfigRequest_Call { + return &LambdaApi_PutProvisionedConcurrencyConfigRequest_Call{Call: _e.mock.On("PutProvisionedConcurrencyConfigRequest", _a0)} +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfigRequest_Call) Run(run func(_a0 *lambda.PutProvisionedConcurrencyConfigInput)) *LambdaApi_PutProvisionedConcurrencyConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.PutProvisionedConcurrencyConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.PutProvisionedConcurrencyConfigOutput) *LambdaApi_PutProvisionedConcurrencyConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfigRequest_Call) RunAndReturn(run func(*lambda.PutProvisionedConcurrencyConfigInput) (*request.Request, *lambda.PutProvisionedConcurrencyConfigOutput)) *LambdaApi_PutProvisionedConcurrencyConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // PutProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) PutProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.PutProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.PutProvisionedConcurrencyConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -4925,6 +10469,43 @@ func (_m *LambdaApi) PutProvisionedConcurrencyConfigWithContext(_a0 context.Cont return r0, r1 } +// LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutProvisionedConcurrencyConfigWithContext' +type LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call struct { + *mock.Call +} + +// PutProvisionedConcurrencyConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.PutProvisionedConcurrencyConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) PutProvisionedConcurrencyConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call { + return &LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call{Call: _e.mock.On("PutProvisionedConcurrencyConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.PutProvisionedConcurrencyConfigInput, _a2 ...request.Option)) *LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.PutProvisionedConcurrencyConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call) Return(_a0 *lambda.PutProvisionedConcurrencyConfigOutput, _a1 error) *LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.PutProvisionedConcurrencyConfigInput, ...request.Option) (*lambda.PutProvisionedConcurrencyConfigOutput, error)) *LambdaApi_PutProvisionedConcurrencyConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // RemoveLayerVersionPermission provides a mock function with given fields: _a0 func (_m *LambdaApi) RemoveLayerVersionPermission(_a0 *lambda.RemoveLayerVersionPermissionInput) (*lambda.RemoveLayerVersionPermissionOutput, error) { ret := _m.Called(_a0) @@ -4951,6 +10532,34 @@ func (_m *LambdaApi) RemoveLayerVersionPermission(_a0 *lambda.RemoveLayerVersion return r0, r1 } +// LambdaApi_RemoveLayerVersionPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveLayerVersionPermission' +type LambdaApi_RemoveLayerVersionPermission_Call struct { + *mock.Call +} + +// RemoveLayerVersionPermission is a helper method to define mock.On call +// - _a0 *lambda.RemoveLayerVersionPermissionInput +func (_e *LambdaApi_Expecter) RemoveLayerVersionPermission(_a0 interface{}) *LambdaApi_RemoveLayerVersionPermission_Call { + return &LambdaApi_RemoveLayerVersionPermission_Call{Call: _e.mock.On("RemoveLayerVersionPermission", _a0)} +} + +func (_c *LambdaApi_RemoveLayerVersionPermission_Call) Run(run func(_a0 *lambda.RemoveLayerVersionPermissionInput)) *LambdaApi_RemoveLayerVersionPermission_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.RemoveLayerVersionPermissionInput)) + }) + return _c +} + +func (_c *LambdaApi_RemoveLayerVersionPermission_Call) Return(_a0 *lambda.RemoveLayerVersionPermissionOutput, _a1 error) *LambdaApi_RemoveLayerVersionPermission_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_RemoveLayerVersionPermission_Call) RunAndReturn(run func(*lambda.RemoveLayerVersionPermissionInput) (*lambda.RemoveLayerVersionPermissionOutput, error)) *LambdaApi_RemoveLayerVersionPermission_Call { + _c.Call.Return(run) + return _c +} + // RemoveLayerVersionPermissionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) RemoveLayerVersionPermissionRequest(_a0 *lambda.RemoveLayerVersionPermissionInput) (*request.Request, *lambda.RemoveLayerVersionPermissionOutput) { ret := _m.Called(_a0) @@ -4979,6 +10588,34 @@ func (_m *LambdaApi) RemoveLayerVersionPermissionRequest(_a0 *lambda.RemoveLayer return r0, r1 } +// LambdaApi_RemoveLayerVersionPermissionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveLayerVersionPermissionRequest' +type LambdaApi_RemoveLayerVersionPermissionRequest_Call struct { + *mock.Call +} + +// RemoveLayerVersionPermissionRequest is a helper method to define mock.On call +// - _a0 *lambda.RemoveLayerVersionPermissionInput +func (_e *LambdaApi_Expecter) RemoveLayerVersionPermissionRequest(_a0 interface{}) *LambdaApi_RemoveLayerVersionPermissionRequest_Call { + return &LambdaApi_RemoveLayerVersionPermissionRequest_Call{Call: _e.mock.On("RemoveLayerVersionPermissionRequest", _a0)} +} + +func (_c *LambdaApi_RemoveLayerVersionPermissionRequest_Call) Run(run func(_a0 *lambda.RemoveLayerVersionPermissionInput)) *LambdaApi_RemoveLayerVersionPermissionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.RemoveLayerVersionPermissionInput)) + }) + return _c +} + +func (_c *LambdaApi_RemoveLayerVersionPermissionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.RemoveLayerVersionPermissionOutput) *LambdaApi_RemoveLayerVersionPermissionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_RemoveLayerVersionPermissionRequest_Call) RunAndReturn(run func(*lambda.RemoveLayerVersionPermissionInput) (*request.Request, *lambda.RemoveLayerVersionPermissionOutput)) *LambdaApi_RemoveLayerVersionPermissionRequest_Call { + _c.Call.Return(run) + return _c +} + // RemoveLayerVersionPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) RemoveLayerVersionPermissionWithContext(_a0 context.Context, _a1 *lambda.RemoveLayerVersionPermissionInput, _a2 ...request.Option) (*lambda.RemoveLayerVersionPermissionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -5012,6 +10649,43 @@ func (_m *LambdaApi) RemoveLayerVersionPermissionWithContext(_a0 context.Context return r0, r1 } +// LambdaApi_RemoveLayerVersionPermissionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveLayerVersionPermissionWithContext' +type LambdaApi_RemoveLayerVersionPermissionWithContext_Call struct { + *mock.Call +} + +// RemoveLayerVersionPermissionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.RemoveLayerVersionPermissionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) RemoveLayerVersionPermissionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_RemoveLayerVersionPermissionWithContext_Call { + return &LambdaApi_RemoveLayerVersionPermissionWithContext_Call{Call: _e.mock.On("RemoveLayerVersionPermissionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_RemoveLayerVersionPermissionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.RemoveLayerVersionPermissionInput, _a2 ...request.Option)) *LambdaApi_RemoveLayerVersionPermissionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.RemoveLayerVersionPermissionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_RemoveLayerVersionPermissionWithContext_Call) Return(_a0 *lambda.RemoveLayerVersionPermissionOutput, _a1 error) *LambdaApi_RemoveLayerVersionPermissionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_RemoveLayerVersionPermissionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.RemoveLayerVersionPermissionInput, ...request.Option) (*lambda.RemoveLayerVersionPermissionOutput, error)) *LambdaApi_RemoveLayerVersionPermissionWithContext_Call { + _c.Call.Return(run) + return _c +} + // RemovePermission provides a mock function with given fields: _a0 func (_m *LambdaApi) RemovePermission(_a0 *lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error) { ret := _m.Called(_a0) @@ -5038,6 +10712,34 @@ func (_m *LambdaApi) RemovePermission(_a0 *lambda.RemovePermissionInput) (*lambd return r0, r1 } +// LambdaApi_RemovePermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePermission' +type LambdaApi_RemovePermission_Call struct { + *mock.Call +} + +// RemovePermission is a helper method to define mock.On call +// - _a0 *lambda.RemovePermissionInput +func (_e *LambdaApi_Expecter) RemovePermission(_a0 interface{}) *LambdaApi_RemovePermission_Call { + return &LambdaApi_RemovePermission_Call{Call: _e.mock.On("RemovePermission", _a0)} +} + +func (_c *LambdaApi_RemovePermission_Call) Run(run func(_a0 *lambda.RemovePermissionInput)) *LambdaApi_RemovePermission_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.RemovePermissionInput)) + }) + return _c +} + +func (_c *LambdaApi_RemovePermission_Call) Return(_a0 *lambda.RemovePermissionOutput, _a1 error) *LambdaApi_RemovePermission_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_RemovePermission_Call) RunAndReturn(run func(*lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error)) *LambdaApi_RemovePermission_Call { + _c.Call.Return(run) + return _c +} + // RemovePermissionRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) RemovePermissionRequest(_a0 *lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput) { ret := _m.Called(_a0) @@ -5066,6 +10768,34 @@ func (_m *LambdaApi) RemovePermissionRequest(_a0 *lambda.RemovePermissionInput) return r0, r1 } +// LambdaApi_RemovePermissionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePermissionRequest' +type LambdaApi_RemovePermissionRequest_Call struct { + *mock.Call +} + +// RemovePermissionRequest is a helper method to define mock.On call +// - _a0 *lambda.RemovePermissionInput +func (_e *LambdaApi_Expecter) RemovePermissionRequest(_a0 interface{}) *LambdaApi_RemovePermissionRequest_Call { + return &LambdaApi_RemovePermissionRequest_Call{Call: _e.mock.On("RemovePermissionRequest", _a0)} +} + +func (_c *LambdaApi_RemovePermissionRequest_Call) Run(run func(_a0 *lambda.RemovePermissionInput)) *LambdaApi_RemovePermissionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.RemovePermissionInput)) + }) + return _c +} + +func (_c *LambdaApi_RemovePermissionRequest_Call) Return(_a0 *request.Request, _a1 *lambda.RemovePermissionOutput) *LambdaApi_RemovePermissionRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_RemovePermissionRequest_Call) RunAndReturn(run func(*lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput)) *LambdaApi_RemovePermissionRequest_Call { + _c.Call.Return(run) + return _c +} + // RemovePermissionWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) RemovePermissionWithContext(_a0 context.Context, _a1 *lambda.RemovePermissionInput, _a2 ...request.Option) (*lambda.RemovePermissionOutput, error) { _va := make([]interface{}, len(_a2)) @@ -5099,6 +10829,43 @@ func (_m *LambdaApi) RemovePermissionWithContext(_a0 context.Context, _a1 *lambd return r0, r1 } +// LambdaApi_RemovePermissionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePermissionWithContext' +type LambdaApi_RemovePermissionWithContext_Call struct { + *mock.Call +} + +// RemovePermissionWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.RemovePermissionInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) RemovePermissionWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_RemovePermissionWithContext_Call { + return &LambdaApi_RemovePermissionWithContext_Call{Call: _e.mock.On("RemovePermissionWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_RemovePermissionWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.RemovePermissionInput, _a2 ...request.Option)) *LambdaApi_RemovePermissionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.RemovePermissionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_RemovePermissionWithContext_Call) Return(_a0 *lambda.RemovePermissionOutput, _a1 error) *LambdaApi_RemovePermissionWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_RemovePermissionWithContext_Call) RunAndReturn(run func(context.Context, *lambda.RemovePermissionInput, ...request.Option) (*lambda.RemovePermissionOutput, error)) *LambdaApi_RemovePermissionWithContext_Call { + _c.Call.Return(run) + return _c +} + // TagResource provides a mock function with given fields: _a0 func (_m *LambdaApi) TagResource(_a0 *lambda.TagResourceInput) (*lambda.TagResourceOutput, error) { ret := _m.Called(_a0) @@ -5125,6 +10892,34 @@ func (_m *LambdaApi) TagResource(_a0 *lambda.TagResourceInput) (*lambda.TagResou return r0, r1 } +// LambdaApi_TagResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagResource' +type LambdaApi_TagResource_Call struct { + *mock.Call +} + +// TagResource is a helper method to define mock.On call +// - _a0 *lambda.TagResourceInput +func (_e *LambdaApi_Expecter) TagResource(_a0 interface{}) *LambdaApi_TagResource_Call { + return &LambdaApi_TagResource_Call{Call: _e.mock.On("TagResource", _a0)} +} + +func (_c *LambdaApi_TagResource_Call) Run(run func(_a0 *lambda.TagResourceInput)) *LambdaApi_TagResource_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.TagResourceInput)) + }) + return _c +} + +func (_c *LambdaApi_TagResource_Call) Return(_a0 *lambda.TagResourceOutput, _a1 error) *LambdaApi_TagResource_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_TagResource_Call) RunAndReturn(run func(*lambda.TagResourceInput) (*lambda.TagResourceOutput, error)) *LambdaApi_TagResource_Call { + _c.Call.Return(run) + return _c +} + // TagResourceRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) TagResourceRequest(_a0 *lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput) { ret := _m.Called(_a0) @@ -5153,6 +10948,34 @@ func (_m *LambdaApi) TagResourceRequest(_a0 *lambda.TagResourceInput) (*request. return r0, r1 } +// LambdaApi_TagResourceRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagResourceRequest' +type LambdaApi_TagResourceRequest_Call struct { + *mock.Call +} + +// TagResourceRequest is a helper method to define mock.On call +// - _a0 *lambda.TagResourceInput +func (_e *LambdaApi_Expecter) TagResourceRequest(_a0 interface{}) *LambdaApi_TagResourceRequest_Call { + return &LambdaApi_TagResourceRequest_Call{Call: _e.mock.On("TagResourceRequest", _a0)} +} + +func (_c *LambdaApi_TagResourceRequest_Call) Run(run func(_a0 *lambda.TagResourceInput)) *LambdaApi_TagResourceRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.TagResourceInput)) + }) + return _c +} + +func (_c *LambdaApi_TagResourceRequest_Call) Return(_a0 *request.Request, _a1 *lambda.TagResourceOutput) *LambdaApi_TagResourceRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_TagResourceRequest_Call) RunAndReturn(run func(*lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput)) *LambdaApi_TagResourceRequest_Call { + _c.Call.Return(run) + return _c +} + // TagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) TagResourceWithContext(_a0 context.Context, _a1 *lambda.TagResourceInput, _a2 ...request.Option) (*lambda.TagResourceOutput, error) { _va := make([]interface{}, len(_a2)) @@ -5186,6 +11009,43 @@ func (_m *LambdaApi) TagResourceWithContext(_a0 context.Context, _a1 *lambda.Tag return r0, r1 } +// LambdaApi_TagResourceWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagResourceWithContext' +type LambdaApi_TagResourceWithContext_Call struct { + *mock.Call +} + +// TagResourceWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.TagResourceInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) TagResourceWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_TagResourceWithContext_Call { + return &LambdaApi_TagResourceWithContext_Call{Call: _e.mock.On("TagResourceWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_TagResourceWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.TagResourceInput, _a2 ...request.Option)) *LambdaApi_TagResourceWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.TagResourceInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_TagResourceWithContext_Call) Return(_a0 *lambda.TagResourceOutput, _a1 error) *LambdaApi_TagResourceWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_TagResourceWithContext_Call) RunAndReturn(run func(context.Context, *lambda.TagResourceInput, ...request.Option) (*lambda.TagResourceOutput, error)) *LambdaApi_TagResourceWithContext_Call { + _c.Call.Return(run) + return _c +} + // UntagResource provides a mock function with given fields: _a0 func (_m *LambdaApi) UntagResource(_a0 *lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error) { ret := _m.Called(_a0) @@ -5212,6 +11072,34 @@ func (_m *LambdaApi) UntagResource(_a0 *lambda.UntagResourceInput) (*lambda.Unta return r0, r1 } +// LambdaApi_UntagResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagResource' +type LambdaApi_UntagResource_Call struct { + *mock.Call +} + +// UntagResource is a helper method to define mock.On call +// - _a0 *lambda.UntagResourceInput +func (_e *LambdaApi_Expecter) UntagResource(_a0 interface{}) *LambdaApi_UntagResource_Call { + return &LambdaApi_UntagResource_Call{Call: _e.mock.On("UntagResource", _a0)} +} + +func (_c *LambdaApi_UntagResource_Call) Run(run func(_a0 *lambda.UntagResourceInput)) *LambdaApi_UntagResource_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UntagResourceInput)) + }) + return _c +} + +func (_c *LambdaApi_UntagResource_Call) Return(_a0 *lambda.UntagResourceOutput, _a1 error) *LambdaApi_UntagResource_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UntagResource_Call) RunAndReturn(run func(*lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error)) *LambdaApi_UntagResource_Call { + _c.Call.Return(run) + return _c +} + // UntagResourceRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) UntagResourceRequest(_a0 *lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput) { ret := _m.Called(_a0) @@ -5240,6 +11128,34 @@ func (_m *LambdaApi) UntagResourceRequest(_a0 *lambda.UntagResourceInput) (*requ return r0, r1 } +// LambdaApi_UntagResourceRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagResourceRequest' +type LambdaApi_UntagResourceRequest_Call struct { + *mock.Call +} + +// UntagResourceRequest is a helper method to define mock.On call +// - _a0 *lambda.UntagResourceInput +func (_e *LambdaApi_Expecter) UntagResourceRequest(_a0 interface{}) *LambdaApi_UntagResourceRequest_Call { + return &LambdaApi_UntagResourceRequest_Call{Call: _e.mock.On("UntagResourceRequest", _a0)} +} + +func (_c *LambdaApi_UntagResourceRequest_Call) Run(run func(_a0 *lambda.UntagResourceInput)) *LambdaApi_UntagResourceRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UntagResourceInput)) + }) + return _c +} + +func (_c *LambdaApi_UntagResourceRequest_Call) Return(_a0 *request.Request, _a1 *lambda.UntagResourceOutput) *LambdaApi_UntagResourceRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UntagResourceRequest_Call) RunAndReturn(run func(*lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput)) *LambdaApi_UntagResourceRequest_Call { + _c.Call.Return(run) + return _c +} + // UntagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) UntagResourceWithContext(_a0 context.Context, _a1 *lambda.UntagResourceInput, _a2 ...request.Option) (*lambda.UntagResourceOutput, error) { _va := make([]interface{}, len(_a2)) @@ -5273,6 +11189,43 @@ func (_m *LambdaApi) UntagResourceWithContext(_a0 context.Context, _a1 *lambda.U return r0, r1 } +// LambdaApi_UntagResourceWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagResourceWithContext' +type LambdaApi_UntagResourceWithContext_Call struct { + *mock.Call +} + +// UntagResourceWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.UntagResourceInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) UntagResourceWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_UntagResourceWithContext_Call { + return &LambdaApi_UntagResourceWithContext_Call{Call: _e.mock.On("UntagResourceWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_UntagResourceWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.UntagResourceInput, _a2 ...request.Option)) *LambdaApi_UntagResourceWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.UntagResourceInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_UntagResourceWithContext_Call) Return(_a0 *lambda.UntagResourceOutput, _a1 error) *LambdaApi_UntagResourceWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UntagResourceWithContext_Call) RunAndReturn(run func(context.Context, *lambda.UntagResourceInput, ...request.Option) (*lambda.UntagResourceOutput, error)) *LambdaApi_UntagResourceWithContext_Call { + _c.Call.Return(run) + return _c +} + // UpdateAlias provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateAlias(_a0 *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) { ret := _m.Called(_a0) @@ -5299,6 +11252,34 @@ func (_m *LambdaApi) UpdateAlias(_a0 *lambda.UpdateAliasInput) (*lambda.AliasCon return r0, r1 } +// LambdaApi_UpdateAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAlias' +type LambdaApi_UpdateAlias_Call struct { + *mock.Call +} + +// UpdateAlias is a helper method to define mock.On call +// - _a0 *lambda.UpdateAliasInput +func (_e *LambdaApi_Expecter) UpdateAlias(_a0 interface{}) *LambdaApi_UpdateAlias_Call { + return &LambdaApi_UpdateAlias_Call{Call: _e.mock.On("UpdateAlias", _a0)} +} + +func (_c *LambdaApi_UpdateAlias_Call) Run(run func(_a0 *lambda.UpdateAliasInput)) *LambdaApi_UpdateAlias_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateAliasInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateAlias_Call) Return(_a0 *lambda.AliasConfiguration, _a1 error) *LambdaApi_UpdateAlias_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateAlias_Call) RunAndReturn(run func(*lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error)) *LambdaApi_UpdateAlias_Call { + _c.Call.Return(run) + return _c +} + // UpdateAliasRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateAliasRequest(_a0 *lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration) { ret := _m.Called(_a0) @@ -5327,6 +11308,34 @@ func (_m *LambdaApi) UpdateAliasRequest(_a0 *lambda.UpdateAliasInput) (*request. return r0, r1 } +// LambdaApi_UpdateAliasRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAliasRequest' +type LambdaApi_UpdateAliasRequest_Call struct { + *mock.Call +} + +// UpdateAliasRequest is a helper method to define mock.On call +// - _a0 *lambda.UpdateAliasInput +func (_e *LambdaApi_Expecter) UpdateAliasRequest(_a0 interface{}) *LambdaApi_UpdateAliasRequest_Call { + return &LambdaApi_UpdateAliasRequest_Call{Call: _e.mock.On("UpdateAliasRequest", _a0)} +} + +func (_c *LambdaApi_UpdateAliasRequest_Call) Run(run func(_a0 *lambda.UpdateAliasInput)) *LambdaApi_UpdateAliasRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateAliasInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateAliasRequest_Call) Return(_a0 *request.Request, _a1 *lambda.AliasConfiguration) *LambdaApi_UpdateAliasRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateAliasRequest_Call) RunAndReturn(run func(*lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration)) *LambdaApi_UpdateAliasRequest_Call { + _c.Call.Return(run) + return _c +} + // UpdateAliasWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) UpdateAliasWithContext(_a0 context.Context, _a1 *lambda.UpdateAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -5360,6 +11369,43 @@ func (_m *LambdaApi) UpdateAliasWithContext(_a0 context.Context, _a1 *lambda.Upd return r0, r1 } +// LambdaApi_UpdateAliasWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAliasWithContext' +type LambdaApi_UpdateAliasWithContext_Call struct { + *mock.Call +} + +// UpdateAliasWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.UpdateAliasInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) UpdateAliasWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_UpdateAliasWithContext_Call { + return &LambdaApi_UpdateAliasWithContext_Call{Call: _e.mock.On("UpdateAliasWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_UpdateAliasWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.UpdateAliasInput, _a2 ...request.Option)) *LambdaApi_UpdateAliasWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.UpdateAliasInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_UpdateAliasWithContext_Call) Return(_a0 *lambda.AliasConfiguration, _a1 error) *LambdaApi_UpdateAliasWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateAliasWithContext_Call) RunAndReturn(run func(context.Context, *lambda.UpdateAliasInput, ...request.Option) (*lambda.AliasConfiguration, error)) *LambdaApi_UpdateAliasWithContext_Call { + _c.Call.Return(run) + return _c +} + // UpdateCodeSigningConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateCodeSigningConfig(_a0 *lambda.UpdateCodeSigningConfigInput) (*lambda.UpdateCodeSigningConfigOutput, error) { ret := _m.Called(_a0) @@ -5386,6 +11432,34 @@ func (_m *LambdaApi) UpdateCodeSigningConfig(_a0 *lambda.UpdateCodeSigningConfig return r0, r1 } +// LambdaApi_UpdateCodeSigningConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCodeSigningConfig' +type LambdaApi_UpdateCodeSigningConfig_Call struct { + *mock.Call +} + +// UpdateCodeSigningConfig is a helper method to define mock.On call +// - _a0 *lambda.UpdateCodeSigningConfigInput +func (_e *LambdaApi_Expecter) UpdateCodeSigningConfig(_a0 interface{}) *LambdaApi_UpdateCodeSigningConfig_Call { + return &LambdaApi_UpdateCodeSigningConfig_Call{Call: _e.mock.On("UpdateCodeSigningConfig", _a0)} +} + +func (_c *LambdaApi_UpdateCodeSigningConfig_Call) Run(run func(_a0 *lambda.UpdateCodeSigningConfigInput)) *LambdaApi_UpdateCodeSigningConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateCodeSigningConfig_Call) Return(_a0 *lambda.UpdateCodeSigningConfigOutput, _a1 error) *LambdaApi_UpdateCodeSigningConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateCodeSigningConfig_Call) RunAndReturn(run func(*lambda.UpdateCodeSigningConfigInput) (*lambda.UpdateCodeSigningConfigOutput, error)) *LambdaApi_UpdateCodeSigningConfig_Call { + _c.Call.Return(run) + return _c +} + // UpdateCodeSigningConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateCodeSigningConfigRequest(_a0 *lambda.UpdateCodeSigningConfigInput) (*request.Request, *lambda.UpdateCodeSigningConfigOutput) { ret := _m.Called(_a0) @@ -5414,6 +11488,34 @@ func (_m *LambdaApi) UpdateCodeSigningConfigRequest(_a0 *lambda.UpdateCodeSignin return r0, r1 } +// LambdaApi_UpdateCodeSigningConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCodeSigningConfigRequest' +type LambdaApi_UpdateCodeSigningConfigRequest_Call struct { + *mock.Call +} + +// UpdateCodeSigningConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.UpdateCodeSigningConfigInput +func (_e *LambdaApi_Expecter) UpdateCodeSigningConfigRequest(_a0 interface{}) *LambdaApi_UpdateCodeSigningConfigRequest_Call { + return &LambdaApi_UpdateCodeSigningConfigRequest_Call{Call: _e.mock.On("UpdateCodeSigningConfigRequest", _a0)} +} + +func (_c *LambdaApi_UpdateCodeSigningConfigRequest_Call) Run(run func(_a0 *lambda.UpdateCodeSigningConfigInput)) *LambdaApi_UpdateCodeSigningConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateCodeSigningConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateCodeSigningConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.UpdateCodeSigningConfigOutput) *LambdaApi_UpdateCodeSigningConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateCodeSigningConfigRequest_Call) RunAndReturn(run func(*lambda.UpdateCodeSigningConfigInput) (*request.Request, *lambda.UpdateCodeSigningConfigOutput)) *LambdaApi_UpdateCodeSigningConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // UpdateCodeSigningConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) UpdateCodeSigningConfigWithContext(_a0 context.Context, _a1 *lambda.UpdateCodeSigningConfigInput, _a2 ...request.Option) (*lambda.UpdateCodeSigningConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -5447,6 +11549,43 @@ func (_m *LambdaApi) UpdateCodeSigningConfigWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_UpdateCodeSigningConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCodeSigningConfigWithContext' +type LambdaApi_UpdateCodeSigningConfigWithContext_Call struct { + *mock.Call +} + +// UpdateCodeSigningConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.UpdateCodeSigningConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) UpdateCodeSigningConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_UpdateCodeSigningConfigWithContext_Call { + return &LambdaApi_UpdateCodeSigningConfigWithContext_Call{Call: _e.mock.On("UpdateCodeSigningConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_UpdateCodeSigningConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.UpdateCodeSigningConfigInput, _a2 ...request.Option)) *LambdaApi_UpdateCodeSigningConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.UpdateCodeSigningConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_UpdateCodeSigningConfigWithContext_Call) Return(_a0 *lambda.UpdateCodeSigningConfigOutput, _a1 error) *LambdaApi_UpdateCodeSigningConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateCodeSigningConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.UpdateCodeSigningConfigInput, ...request.Option) (*lambda.UpdateCodeSigningConfigOutput, error)) *LambdaApi_UpdateCodeSigningConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // UpdateEventSourceMapping provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateEventSourceMapping(_a0 *lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) { ret := _m.Called(_a0) @@ -5470,7 +11609,35 @@ func (_m *LambdaApi) UpdateEventSourceMapping(_a0 *lambda.UpdateEventSourceMappi r1 = ret.Error(1) } - return r0, r1 + return r0, r1 +} + +// LambdaApi_UpdateEventSourceMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEventSourceMapping' +type LambdaApi_UpdateEventSourceMapping_Call struct { + *mock.Call +} + +// UpdateEventSourceMapping is a helper method to define mock.On call +// - _a0 *lambda.UpdateEventSourceMappingInput +func (_e *LambdaApi_Expecter) UpdateEventSourceMapping(_a0 interface{}) *LambdaApi_UpdateEventSourceMapping_Call { + return &LambdaApi_UpdateEventSourceMapping_Call{Call: _e.mock.On("UpdateEventSourceMapping", _a0)} +} + +func (_c *LambdaApi_UpdateEventSourceMapping_Call) Run(run func(_a0 *lambda.UpdateEventSourceMappingInput)) *LambdaApi_UpdateEventSourceMapping_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateEventSourceMappingInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateEventSourceMapping_Call) Return(_a0 *lambda.EventSourceMappingConfiguration, _a1 error) *LambdaApi_UpdateEventSourceMapping_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateEventSourceMapping_Call) RunAndReturn(run func(*lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error)) *LambdaApi_UpdateEventSourceMapping_Call { + _c.Call.Return(run) + return _c } // UpdateEventSourceMappingRequest provides a mock function with given fields: _a0 @@ -5501,6 +11668,34 @@ func (_m *LambdaApi) UpdateEventSourceMappingRequest(_a0 *lambda.UpdateEventSour return r0, r1 } +// LambdaApi_UpdateEventSourceMappingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEventSourceMappingRequest' +type LambdaApi_UpdateEventSourceMappingRequest_Call struct { + *mock.Call +} + +// UpdateEventSourceMappingRequest is a helper method to define mock.On call +// - _a0 *lambda.UpdateEventSourceMappingInput +func (_e *LambdaApi_Expecter) UpdateEventSourceMappingRequest(_a0 interface{}) *LambdaApi_UpdateEventSourceMappingRequest_Call { + return &LambdaApi_UpdateEventSourceMappingRequest_Call{Call: _e.mock.On("UpdateEventSourceMappingRequest", _a0)} +} + +func (_c *LambdaApi_UpdateEventSourceMappingRequest_Call) Run(run func(_a0 *lambda.UpdateEventSourceMappingInput)) *LambdaApi_UpdateEventSourceMappingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateEventSourceMappingInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateEventSourceMappingRequest_Call) Return(_a0 *request.Request, _a1 *lambda.EventSourceMappingConfiguration) *LambdaApi_UpdateEventSourceMappingRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateEventSourceMappingRequest_Call) RunAndReturn(run func(*lambda.UpdateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration)) *LambdaApi_UpdateEventSourceMappingRequest_Call { + _c.Call.Return(run) + return _c +} + // UpdateEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) UpdateEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.UpdateEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -5534,6 +11729,43 @@ func (_m *LambdaApi) UpdateEventSourceMappingWithContext(_a0 context.Context, _a return r0, r1 } +// LambdaApi_UpdateEventSourceMappingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEventSourceMappingWithContext' +type LambdaApi_UpdateEventSourceMappingWithContext_Call struct { + *mock.Call +} + +// UpdateEventSourceMappingWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.UpdateEventSourceMappingInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) UpdateEventSourceMappingWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_UpdateEventSourceMappingWithContext_Call { + return &LambdaApi_UpdateEventSourceMappingWithContext_Call{Call: _e.mock.On("UpdateEventSourceMappingWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_UpdateEventSourceMappingWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.UpdateEventSourceMappingInput, _a2 ...request.Option)) *LambdaApi_UpdateEventSourceMappingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.UpdateEventSourceMappingInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_UpdateEventSourceMappingWithContext_Call) Return(_a0 *lambda.EventSourceMappingConfiguration, _a1 error) *LambdaApi_UpdateEventSourceMappingWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateEventSourceMappingWithContext_Call) RunAndReturn(run func(context.Context, *lambda.UpdateEventSourceMappingInput, ...request.Option) (*lambda.EventSourceMappingConfiguration, error)) *LambdaApi_UpdateEventSourceMappingWithContext_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionCode provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateFunctionCode(_a0 *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) { ret := _m.Called(_a0) @@ -5560,6 +11792,34 @@ func (_m *LambdaApi) UpdateFunctionCode(_a0 *lambda.UpdateFunctionCodeInput) (*l return r0, r1 } +// LambdaApi_UpdateFunctionCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionCode' +type LambdaApi_UpdateFunctionCode_Call struct { + *mock.Call +} + +// UpdateFunctionCode is a helper method to define mock.On call +// - _a0 *lambda.UpdateFunctionCodeInput +func (_e *LambdaApi_Expecter) UpdateFunctionCode(_a0 interface{}) *LambdaApi_UpdateFunctionCode_Call { + return &LambdaApi_UpdateFunctionCode_Call{Call: _e.mock.On("UpdateFunctionCode", _a0)} +} + +func (_c *LambdaApi_UpdateFunctionCode_Call) Run(run func(_a0 *lambda.UpdateFunctionCodeInput)) *LambdaApi_UpdateFunctionCode_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateFunctionCodeInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionCode_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_UpdateFunctionCode_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionCode_Call) RunAndReturn(run func(*lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error)) *LambdaApi_UpdateFunctionCode_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionCodeRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateFunctionCodeRequest(_a0 *lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration) { ret := _m.Called(_a0) @@ -5588,6 +11848,34 @@ func (_m *LambdaApi) UpdateFunctionCodeRequest(_a0 *lambda.UpdateFunctionCodeInp return r0, r1 } +// LambdaApi_UpdateFunctionCodeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionCodeRequest' +type LambdaApi_UpdateFunctionCodeRequest_Call struct { + *mock.Call +} + +// UpdateFunctionCodeRequest is a helper method to define mock.On call +// - _a0 *lambda.UpdateFunctionCodeInput +func (_e *LambdaApi_Expecter) UpdateFunctionCodeRequest(_a0 interface{}) *LambdaApi_UpdateFunctionCodeRequest_Call { + return &LambdaApi_UpdateFunctionCodeRequest_Call{Call: _e.mock.On("UpdateFunctionCodeRequest", _a0)} +} + +func (_c *LambdaApi_UpdateFunctionCodeRequest_Call) Run(run func(_a0 *lambda.UpdateFunctionCodeInput)) *LambdaApi_UpdateFunctionCodeRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateFunctionCodeInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionCodeRequest_Call) Return(_a0 *request.Request, _a1 *lambda.FunctionConfiguration) *LambdaApi_UpdateFunctionCodeRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionCodeRequest_Call) RunAndReturn(run func(*lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration)) *LambdaApi_UpdateFunctionCodeRequest_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionCodeWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) UpdateFunctionCodeWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionCodeInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -5621,6 +11909,43 @@ func (_m *LambdaApi) UpdateFunctionCodeWithContext(_a0 context.Context, _a1 *lam return r0, r1 } +// LambdaApi_UpdateFunctionCodeWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionCodeWithContext' +type LambdaApi_UpdateFunctionCodeWithContext_Call struct { + *mock.Call +} + +// UpdateFunctionCodeWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.UpdateFunctionCodeInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) UpdateFunctionCodeWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_UpdateFunctionCodeWithContext_Call { + return &LambdaApi_UpdateFunctionCodeWithContext_Call{Call: _e.mock.On("UpdateFunctionCodeWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_UpdateFunctionCodeWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.UpdateFunctionCodeInput, _a2 ...request.Option)) *LambdaApi_UpdateFunctionCodeWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.UpdateFunctionCodeInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionCodeWithContext_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_UpdateFunctionCodeWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionCodeWithContext_Call) RunAndReturn(run func(context.Context, *lambda.UpdateFunctionCodeInput, ...request.Option) (*lambda.FunctionConfiguration, error)) *LambdaApi_UpdateFunctionCodeWithContext_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionConfiguration provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateFunctionConfiguration(_a0 *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) { ret := _m.Called(_a0) @@ -5647,6 +11972,34 @@ func (_m *LambdaApi) UpdateFunctionConfiguration(_a0 *lambda.UpdateFunctionConfi return r0, r1 } +// LambdaApi_UpdateFunctionConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionConfiguration' +type LambdaApi_UpdateFunctionConfiguration_Call struct { + *mock.Call +} + +// UpdateFunctionConfiguration is a helper method to define mock.On call +// - _a0 *lambda.UpdateFunctionConfigurationInput +func (_e *LambdaApi_Expecter) UpdateFunctionConfiguration(_a0 interface{}) *LambdaApi_UpdateFunctionConfiguration_Call { + return &LambdaApi_UpdateFunctionConfiguration_Call{Call: _e.mock.On("UpdateFunctionConfiguration", _a0)} +} + +func (_c *LambdaApi_UpdateFunctionConfiguration_Call) Run(run func(_a0 *lambda.UpdateFunctionConfigurationInput)) *LambdaApi_UpdateFunctionConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateFunctionConfigurationInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionConfiguration_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_UpdateFunctionConfiguration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionConfiguration_Call) RunAndReturn(run func(*lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error)) *LambdaApi_UpdateFunctionConfiguration_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionConfigurationRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateFunctionConfigurationRequest(_a0 *lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) { ret := _m.Called(_a0) @@ -5675,6 +12028,34 @@ func (_m *LambdaApi) UpdateFunctionConfigurationRequest(_a0 *lambda.UpdateFuncti return r0, r1 } +// LambdaApi_UpdateFunctionConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionConfigurationRequest' +type LambdaApi_UpdateFunctionConfigurationRequest_Call struct { + *mock.Call +} + +// UpdateFunctionConfigurationRequest is a helper method to define mock.On call +// - _a0 *lambda.UpdateFunctionConfigurationInput +func (_e *LambdaApi_Expecter) UpdateFunctionConfigurationRequest(_a0 interface{}) *LambdaApi_UpdateFunctionConfigurationRequest_Call { + return &LambdaApi_UpdateFunctionConfigurationRequest_Call{Call: _e.mock.On("UpdateFunctionConfigurationRequest", _a0)} +} + +func (_c *LambdaApi_UpdateFunctionConfigurationRequest_Call) Run(run func(_a0 *lambda.UpdateFunctionConfigurationInput)) *LambdaApi_UpdateFunctionConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateFunctionConfigurationInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionConfigurationRequest_Call) Return(_a0 *request.Request, _a1 *lambda.FunctionConfiguration) *LambdaApi_UpdateFunctionConfigurationRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionConfigurationRequest_Call) RunAndReturn(run func(*lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration)) *LambdaApi_UpdateFunctionConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) UpdateFunctionConfigurationWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionConfigurationInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) { _va := make([]interface{}, len(_a2)) @@ -5708,6 +12089,43 @@ func (_m *LambdaApi) UpdateFunctionConfigurationWithContext(_a0 context.Context, return r0, r1 } +// LambdaApi_UpdateFunctionConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionConfigurationWithContext' +type LambdaApi_UpdateFunctionConfigurationWithContext_Call struct { + *mock.Call +} + +// UpdateFunctionConfigurationWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.UpdateFunctionConfigurationInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) UpdateFunctionConfigurationWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_UpdateFunctionConfigurationWithContext_Call { + return &LambdaApi_UpdateFunctionConfigurationWithContext_Call{Call: _e.mock.On("UpdateFunctionConfigurationWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_UpdateFunctionConfigurationWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.UpdateFunctionConfigurationInput, _a2 ...request.Option)) *LambdaApi_UpdateFunctionConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.UpdateFunctionConfigurationInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionConfigurationWithContext_Call) Return(_a0 *lambda.FunctionConfiguration, _a1 error) *LambdaApi_UpdateFunctionConfigurationWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionConfigurationWithContext_Call) RunAndReturn(run func(context.Context, *lambda.UpdateFunctionConfigurationInput, ...request.Option) (*lambda.FunctionConfiguration, error)) *LambdaApi_UpdateFunctionConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionEventInvokeConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateFunctionEventInvokeConfig(_a0 *lambda.UpdateFunctionEventInvokeConfigInput) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) { ret := _m.Called(_a0) @@ -5734,6 +12152,34 @@ func (_m *LambdaApi) UpdateFunctionEventInvokeConfig(_a0 *lambda.UpdateFunctionE return r0, r1 } +// LambdaApi_UpdateFunctionEventInvokeConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionEventInvokeConfig' +type LambdaApi_UpdateFunctionEventInvokeConfig_Call struct { + *mock.Call +} + +// UpdateFunctionEventInvokeConfig is a helper method to define mock.On call +// - _a0 *lambda.UpdateFunctionEventInvokeConfigInput +func (_e *LambdaApi_Expecter) UpdateFunctionEventInvokeConfig(_a0 interface{}) *LambdaApi_UpdateFunctionEventInvokeConfig_Call { + return &LambdaApi_UpdateFunctionEventInvokeConfig_Call{Call: _e.mock.On("UpdateFunctionEventInvokeConfig", _a0)} +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfig_Call) Run(run func(_a0 *lambda.UpdateFunctionEventInvokeConfigInput)) *LambdaApi_UpdateFunctionEventInvokeConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateFunctionEventInvokeConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfig_Call) Return(_a0 *lambda.UpdateFunctionEventInvokeConfigOutput, _a1 error) *LambdaApi_UpdateFunctionEventInvokeConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfig_Call) RunAndReturn(run func(*lambda.UpdateFunctionEventInvokeConfigInput) (*lambda.UpdateFunctionEventInvokeConfigOutput, error)) *LambdaApi_UpdateFunctionEventInvokeConfig_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateFunctionEventInvokeConfigRequest(_a0 *lambda.UpdateFunctionEventInvokeConfigInput) (*request.Request, *lambda.UpdateFunctionEventInvokeConfigOutput) { ret := _m.Called(_a0) @@ -5762,6 +12208,34 @@ func (_m *LambdaApi) UpdateFunctionEventInvokeConfigRequest(_a0 *lambda.UpdateFu return r0, r1 } +// LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionEventInvokeConfigRequest' +type LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call struct { + *mock.Call +} + +// UpdateFunctionEventInvokeConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.UpdateFunctionEventInvokeConfigInput +func (_e *LambdaApi_Expecter) UpdateFunctionEventInvokeConfigRequest(_a0 interface{}) *LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call { + return &LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call{Call: _e.mock.On("UpdateFunctionEventInvokeConfigRequest", _a0)} +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call) Run(run func(_a0 *lambda.UpdateFunctionEventInvokeConfigInput)) *LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateFunctionEventInvokeConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.UpdateFunctionEventInvokeConfigOutput) *LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call) RunAndReturn(run func(*lambda.UpdateFunctionEventInvokeConfigInput) (*request.Request, *lambda.UpdateFunctionEventInvokeConfigOutput)) *LambdaApi_UpdateFunctionEventInvokeConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) UpdateFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -5795,6 +12269,43 @@ func (_m *LambdaApi) UpdateFunctionEventInvokeConfigWithContext(_a0 context.Cont return r0, r1 } +// LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionEventInvokeConfigWithContext' +type LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call struct { + *mock.Call +} + +// UpdateFunctionEventInvokeConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.UpdateFunctionEventInvokeConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) UpdateFunctionEventInvokeConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call { + return &LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call{Call: _e.mock.On("UpdateFunctionEventInvokeConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.UpdateFunctionEventInvokeConfigInput, _a2 ...request.Option)) *LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.UpdateFunctionEventInvokeConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call) Return(_a0 *lambda.UpdateFunctionEventInvokeConfigOutput, _a1 error) *LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.UpdateFunctionEventInvokeConfigInput, ...request.Option) (*lambda.UpdateFunctionEventInvokeConfigOutput, error)) *LambdaApi_UpdateFunctionEventInvokeConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionUrlConfig provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateFunctionUrlConfig(_a0 *lambda.UpdateFunctionUrlConfigInput) (*lambda.UpdateFunctionUrlConfigOutput, error) { ret := _m.Called(_a0) @@ -5821,6 +12332,34 @@ func (_m *LambdaApi) UpdateFunctionUrlConfig(_a0 *lambda.UpdateFunctionUrlConfig return r0, r1 } +// LambdaApi_UpdateFunctionUrlConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionUrlConfig' +type LambdaApi_UpdateFunctionUrlConfig_Call struct { + *mock.Call +} + +// UpdateFunctionUrlConfig is a helper method to define mock.On call +// - _a0 *lambda.UpdateFunctionUrlConfigInput +func (_e *LambdaApi_Expecter) UpdateFunctionUrlConfig(_a0 interface{}) *LambdaApi_UpdateFunctionUrlConfig_Call { + return &LambdaApi_UpdateFunctionUrlConfig_Call{Call: _e.mock.On("UpdateFunctionUrlConfig", _a0)} +} + +func (_c *LambdaApi_UpdateFunctionUrlConfig_Call) Run(run func(_a0 *lambda.UpdateFunctionUrlConfigInput)) *LambdaApi_UpdateFunctionUrlConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateFunctionUrlConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionUrlConfig_Call) Return(_a0 *lambda.UpdateFunctionUrlConfigOutput, _a1 error) *LambdaApi_UpdateFunctionUrlConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionUrlConfig_Call) RunAndReturn(run func(*lambda.UpdateFunctionUrlConfigInput) (*lambda.UpdateFunctionUrlConfigOutput, error)) *LambdaApi_UpdateFunctionUrlConfig_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionUrlConfigRequest provides a mock function with given fields: _a0 func (_m *LambdaApi) UpdateFunctionUrlConfigRequest(_a0 *lambda.UpdateFunctionUrlConfigInput) (*request.Request, *lambda.UpdateFunctionUrlConfigOutput) { ret := _m.Called(_a0) @@ -5849,6 +12388,34 @@ func (_m *LambdaApi) UpdateFunctionUrlConfigRequest(_a0 *lambda.UpdateFunctionUr return r0, r1 } +// LambdaApi_UpdateFunctionUrlConfigRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionUrlConfigRequest' +type LambdaApi_UpdateFunctionUrlConfigRequest_Call struct { + *mock.Call +} + +// UpdateFunctionUrlConfigRequest is a helper method to define mock.On call +// - _a0 *lambda.UpdateFunctionUrlConfigInput +func (_e *LambdaApi_Expecter) UpdateFunctionUrlConfigRequest(_a0 interface{}) *LambdaApi_UpdateFunctionUrlConfigRequest_Call { + return &LambdaApi_UpdateFunctionUrlConfigRequest_Call{Call: _e.mock.On("UpdateFunctionUrlConfigRequest", _a0)} +} + +func (_c *LambdaApi_UpdateFunctionUrlConfigRequest_Call) Run(run func(_a0 *lambda.UpdateFunctionUrlConfigInput)) *LambdaApi_UpdateFunctionUrlConfigRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.UpdateFunctionUrlConfigInput)) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionUrlConfigRequest_Call) Return(_a0 *request.Request, _a1 *lambda.UpdateFunctionUrlConfigOutput) *LambdaApi_UpdateFunctionUrlConfigRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionUrlConfigRequest_Call) RunAndReturn(run func(*lambda.UpdateFunctionUrlConfigInput) (*request.Request, *lambda.UpdateFunctionUrlConfigOutput)) *LambdaApi_UpdateFunctionUrlConfigRequest_Call { + _c.Call.Return(run) + return _c +} + // UpdateFunctionUrlConfigWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) UpdateFunctionUrlConfigWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionUrlConfigInput, _a2 ...request.Option) (*lambda.UpdateFunctionUrlConfigOutput, error) { _va := make([]interface{}, len(_a2)) @@ -5882,6 +12449,43 @@ func (_m *LambdaApi) UpdateFunctionUrlConfigWithContext(_a0 context.Context, _a1 return r0, r1 } +// LambdaApi_UpdateFunctionUrlConfigWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFunctionUrlConfigWithContext' +type LambdaApi_UpdateFunctionUrlConfigWithContext_Call struct { + *mock.Call +} + +// UpdateFunctionUrlConfigWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.UpdateFunctionUrlConfigInput +// - _a2 ...request.Option +func (_e *LambdaApi_Expecter) UpdateFunctionUrlConfigWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_UpdateFunctionUrlConfigWithContext_Call { + return &LambdaApi_UpdateFunctionUrlConfigWithContext_Call{Call: _e.mock.On("UpdateFunctionUrlConfigWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_UpdateFunctionUrlConfigWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.UpdateFunctionUrlConfigInput, _a2 ...request.Option)) *LambdaApi_UpdateFunctionUrlConfigWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.Option, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.Option) + } + } + run(args[0].(context.Context), args[1].(*lambda.UpdateFunctionUrlConfigInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_UpdateFunctionUrlConfigWithContext_Call) Return(_a0 *lambda.UpdateFunctionUrlConfigOutput, _a1 error) *LambdaApi_UpdateFunctionUrlConfigWithContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LambdaApi_UpdateFunctionUrlConfigWithContext_Call) RunAndReturn(run func(context.Context, *lambda.UpdateFunctionUrlConfigInput, ...request.Option) (*lambda.UpdateFunctionUrlConfigOutput, error)) *LambdaApi_UpdateFunctionUrlConfigWithContext_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionActive provides a mock function with given fields: _a0 func (_m *LambdaApi) WaitUntilFunctionActive(_a0 *lambda.GetFunctionConfigurationInput) error { ret := _m.Called(_a0) @@ -5896,6 +12500,34 @@ func (_m *LambdaApi) WaitUntilFunctionActive(_a0 *lambda.GetFunctionConfiguratio return r0 } +// LambdaApi_WaitUntilFunctionActive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionActive' +type LambdaApi_WaitUntilFunctionActive_Call struct { + *mock.Call +} + +// WaitUntilFunctionActive is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionConfigurationInput +func (_e *LambdaApi_Expecter) WaitUntilFunctionActive(_a0 interface{}) *LambdaApi_WaitUntilFunctionActive_Call { + return &LambdaApi_WaitUntilFunctionActive_Call{Call: _e.mock.On("WaitUntilFunctionActive", _a0)} +} + +func (_c *LambdaApi_WaitUntilFunctionActive_Call) Run(run func(_a0 *lambda.GetFunctionConfigurationInput)) *LambdaApi_WaitUntilFunctionActive_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionConfigurationInput)) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionActive_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionActive_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionActive_Call) RunAndReturn(run func(*lambda.GetFunctionConfigurationInput) error) *LambdaApi_WaitUntilFunctionActive_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionActiveV2 provides a mock function with given fields: _a0 func (_m *LambdaApi) WaitUntilFunctionActiveV2(_a0 *lambda.GetFunctionInput) error { ret := _m.Called(_a0) @@ -5910,6 +12542,34 @@ func (_m *LambdaApi) WaitUntilFunctionActiveV2(_a0 *lambda.GetFunctionInput) err return r0 } +// LambdaApi_WaitUntilFunctionActiveV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionActiveV2' +type LambdaApi_WaitUntilFunctionActiveV2_Call struct { + *mock.Call +} + +// WaitUntilFunctionActiveV2 is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionInput +func (_e *LambdaApi_Expecter) WaitUntilFunctionActiveV2(_a0 interface{}) *LambdaApi_WaitUntilFunctionActiveV2_Call { + return &LambdaApi_WaitUntilFunctionActiveV2_Call{Call: _e.mock.On("WaitUntilFunctionActiveV2", _a0)} +} + +func (_c *LambdaApi_WaitUntilFunctionActiveV2_Call) Run(run func(_a0 *lambda.GetFunctionInput)) *LambdaApi_WaitUntilFunctionActiveV2_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionActiveV2_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionActiveV2_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionActiveV2_Call) RunAndReturn(run func(*lambda.GetFunctionInput) error) *LambdaApi_WaitUntilFunctionActiveV2_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionActiveV2WithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) WaitUntilFunctionActiveV2WithContext(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.WaiterOption) error { _va := make([]interface{}, len(_a2)) @@ -5931,6 +12591,43 @@ func (_m *LambdaApi) WaitUntilFunctionActiveV2WithContext(_a0 context.Context, _ return r0 } +// LambdaApi_WaitUntilFunctionActiveV2WithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionActiveV2WithContext' +type LambdaApi_WaitUntilFunctionActiveV2WithContext_Call struct { + *mock.Call +} + +// WaitUntilFunctionActiveV2WithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionInput +// - _a2 ...request.WaiterOption +func (_e *LambdaApi_Expecter) WaitUntilFunctionActiveV2WithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_WaitUntilFunctionActiveV2WithContext_Call { + return &LambdaApi_WaitUntilFunctionActiveV2WithContext_Call{Call: _e.mock.On("WaitUntilFunctionActiveV2WithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_WaitUntilFunctionActiveV2WithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.WaiterOption)) *LambdaApi_WaitUntilFunctionActiveV2WithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.WaiterOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.WaiterOption) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionActiveV2WithContext_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionActiveV2WithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionActiveV2WithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionInput, ...request.WaiterOption) error) *LambdaApi_WaitUntilFunctionActiveV2WithContext_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionActiveWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) WaitUntilFunctionActiveWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.WaiterOption) error { _va := make([]interface{}, len(_a2)) @@ -5952,6 +12649,43 @@ func (_m *LambdaApi) WaitUntilFunctionActiveWithContext(_a0 context.Context, _a1 return r0 } +// LambdaApi_WaitUntilFunctionActiveWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionActiveWithContext' +type LambdaApi_WaitUntilFunctionActiveWithContext_Call struct { + *mock.Call +} + +// WaitUntilFunctionActiveWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionConfigurationInput +// - _a2 ...request.WaiterOption +func (_e *LambdaApi_Expecter) WaitUntilFunctionActiveWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_WaitUntilFunctionActiveWithContext_Call { + return &LambdaApi_WaitUntilFunctionActiveWithContext_Call{Call: _e.mock.On("WaitUntilFunctionActiveWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_WaitUntilFunctionActiveWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.WaiterOption)) *LambdaApi_WaitUntilFunctionActiveWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.WaiterOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.WaiterOption) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionConfigurationInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionActiveWithContext_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionActiveWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionActiveWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.WaiterOption) error) *LambdaApi_WaitUntilFunctionActiveWithContext_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionExists provides a mock function with given fields: _a0 func (_m *LambdaApi) WaitUntilFunctionExists(_a0 *lambda.GetFunctionInput) error { ret := _m.Called(_a0) @@ -5966,6 +12700,34 @@ func (_m *LambdaApi) WaitUntilFunctionExists(_a0 *lambda.GetFunctionInput) error return r0 } +// LambdaApi_WaitUntilFunctionExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionExists' +type LambdaApi_WaitUntilFunctionExists_Call struct { + *mock.Call +} + +// WaitUntilFunctionExists is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionInput +func (_e *LambdaApi_Expecter) WaitUntilFunctionExists(_a0 interface{}) *LambdaApi_WaitUntilFunctionExists_Call { + return &LambdaApi_WaitUntilFunctionExists_Call{Call: _e.mock.On("WaitUntilFunctionExists", _a0)} +} + +func (_c *LambdaApi_WaitUntilFunctionExists_Call) Run(run func(_a0 *lambda.GetFunctionInput)) *LambdaApi_WaitUntilFunctionExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionExists_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionExists_Call) RunAndReturn(run func(*lambda.GetFunctionInput) error) *LambdaApi_WaitUntilFunctionExists_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionExistsWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) WaitUntilFunctionExistsWithContext(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.WaiterOption) error { _va := make([]interface{}, len(_a2)) @@ -5987,6 +12749,43 @@ func (_m *LambdaApi) WaitUntilFunctionExistsWithContext(_a0 context.Context, _a1 return r0 } +// LambdaApi_WaitUntilFunctionExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionExistsWithContext' +type LambdaApi_WaitUntilFunctionExistsWithContext_Call struct { + *mock.Call +} + +// WaitUntilFunctionExistsWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionInput +// - _a2 ...request.WaiterOption +func (_e *LambdaApi_Expecter) WaitUntilFunctionExistsWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_WaitUntilFunctionExistsWithContext_Call { + return &LambdaApi_WaitUntilFunctionExistsWithContext_Call{Call: _e.mock.On("WaitUntilFunctionExistsWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_WaitUntilFunctionExistsWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.WaiterOption)) *LambdaApi_WaitUntilFunctionExistsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.WaiterOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.WaiterOption) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionExistsWithContext_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionExistsWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionExistsWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionInput, ...request.WaiterOption) error) *LambdaApi_WaitUntilFunctionExistsWithContext_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionUpdated provides a mock function with given fields: _a0 func (_m *LambdaApi) WaitUntilFunctionUpdated(_a0 *lambda.GetFunctionConfigurationInput) error { ret := _m.Called(_a0) @@ -6001,6 +12800,34 @@ func (_m *LambdaApi) WaitUntilFunctionUpdated(_a0 *lambda.GetFunctionConfigurati return r0 } +// LambdaApi_WaitUntilFunctionUpdated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionUpdated' +type LambdaApi_WaitUntilFunctionUpdated_Call struct { + *mock.Call +} + +// WaitUntilFunctionUpdated is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionConfigurationInput +func (_e *LambdaApi_Expecter) WaitUntilFunctionUpdated(_a0 interface{}) *LambdaApi_WaitUntilFunctionUpdated_Call { + return &LambdaApi_WaitUntilFunctionUpdated_Call{Call: _e.mock.On("WaitUntilFunctionUpdated", _a0)} +} + +func (_c *LambdaApi_WaitUntilFunctionUpdated_Call) Run(run func(_a0 *lambda.GetFunctionConfigurationInput)) *LambdaApi_WaitUntilFunctionUpdated_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionConfigurationInput)) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionUpdated_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionUpdated_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionUpdated_Call) RunAndReturn(run func(*lambda.GetFunctionConfigurationInput) error) *LambdaApi_WaitUntilFunctionUpdated_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionUpdatedV2 provides a mock function with given fields: _a0 func (_m *LambdaApi) WaitUntilFunctionUpdatedV2(_a0 *lambda.GetFunctionInput) error { ret := _m.Called(_a0) @@ -6015,6 +12842,34 @@ func (_m *LambdaApi) WaitUntilFunctionUpdatedV2(_a0 *lambda.GetFunctionInput) er return r0 } +// LambdaApi_WaitUntilFunctionUpdatedV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionUpdatedV2' +type LambdaApi_WaitUntilFunctionUpdatedV2_Call struct { + *mock.Call +} + +// WaitUntilFunctionUpdatedV2 is a helper method to define mock.On call +// - _a0 *lambda.GetFunctionInput +func (_e *LambdaApi_Expecter) WaitUntilFunctionUpdatedV2(_a0 interface{}) *LambdaApi_WaitUntilFunctionUpdatedV2_Call { + return &LambdaApi_WaitUntilFunctionUpdatedV2_Call{Call: _e.mock.On("WaitUntilFunctionUpdatedV2", _a0)} +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedV2_Call) Run(run func(_a0 *lambda.GetFunctionInput)) *LambdaApi_WaitUntilFunctionUpdatedV2_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*lambda.GetFunctionInput)) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedV2_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionUpdatedV2_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedV2_Call) RunAndReturn(run func(*lambda.GetFunctionInput) error) *LambdaApi_WaitUntilFunctionUpdatedV2_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionUpdatedV2WithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) WaitUntilFunctionUpdatedV2WithContext(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.WaiterOption) error { _va := make([]interface{}, len(_a2)) @@ -6036,6 +12891,43 @@ func (_m *LambdaApi) WaitUntilFunctionUpdatedV2WithContext(_a0 context.Context, return r0 } +// LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionUpdatedV2WithContext' +type LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call struct { + *mock.Call +} + +// WaitUntilFunctionUpdatedV2WithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionInput +// - _a2 ...request.WaiterOption +func (_e *LambdaApi_Expecter) WaitUntilFunctionUpdatedV2WithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call { + return &LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call{Call: _e.mock.On("WaitUntilFunctionUpdatedV2WithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.WaiterOption)) *LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.WaiterOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.WaiterOption) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionInput, ...request.WaiterOption) error) *LambdaApi_WaitUntilFunctionUpdatedV2WithContext_Call { + _c.Call.Return(run) + return _c +} + // WaitUntilFunctionUpdatedWithContext provides a mock function with given fields: _a0, _a1, _a2 func (_m *LambdaApi) WaitUntilFunctionUpdatedWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.WaiterOption) error { _va := make([]interface{}, len(_a2)) @@ -6057,6 +12949,43 @@ func (_m *LambdaApi) WaitUntilFunctionUpdatedWithContext(_a0 context.Context, _a return r0 } +// LambdaApi_WaitUntilFunctionUpdatedWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilFunctionUpdatedWithContext' +type LambdaApi_WaitUntilFunctionUpdatedWithContext_Call struct { + *mock.Call +} + +// WaitUntilFunctionUpdatedWithContext is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *lambda.GetFunctionConfigurationInput +// - _a2 ...request.WaiterOption +func (_e *LambdaApi_Expecter) WaitUntilFunctionUpdatedWithContext(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *LambdaApi_WaitUntilFunctionUpdatedWithContext_Call { + return &LambdaApi_WaitUntilFunctionUpdatedWithContext_Call{Call: _e.mock.On("WaitUntilFunctionUpdatedWithContext", + append([]interface{}{_a0, _a1}, _a2...)...)} +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedWithContext_Call) Run(run func(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.WaiterOption)) *LambdaApi_WaitUntilFunctionUpdatedWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]request.WaiterOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(request.WaiterOption) + } + } + run(args[0].(context.Context), args[1].(*lambda.GetFunctionConfigurationInput), variadicArgs...) + }) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedWithContext_Call) Return(_a0 error) *LambdaApi_WaitUntilFunctionUpdatedWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LambdaApi_WaitUntilFunctionUpdatedWithContext_Call) RunAndReturn(run func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.WaiterOption) error) *LambdaApi_WaitUntilFunctionUpdatedWithContext_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewLambdaApi interface { mock.TestingT Cleanup(func()) diff --git a/pkg/conc/ddb/mocks/LeaderElection.go b/pkg/conc/ddb/mocks/LeaderElection.go index 41e9531aa..2983c9c94 100644 --- a/pkg/conc/ddb/mocks/LeaderElection.go +++ b/pkg/conc/ddb/mocks/LeaderElection.go @@ -13,6 +13,14 @@ type LeaderElection struct { mock.Mock } +type LeaderElection_Expecter struct { + mock *mock.Mock +} + +func (_m *LeaderElection) EXPECT() *LeaderElection_Expecter { + return &LeaderElection_Expecter{mock: &_m.Mock} +} + // IsLeader provides a mock function with given fields: ctx, memberId func (_m *LeaderElection) IsLeader(ctx context.Context, memberId string) (bool, error) { ret := _m.Called(ctx, memberId) @@ -37,6 +45,35 @@ func (_m *LeaderElection) IsLeader(ctx context.Context, memberId string) (bool, return r0, r1 } +// LeaderElection_IsLeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLeader' +type LeaderElection_IsLeader_Call struct { + *mock.Call +} + +// IsLeader is a helper method to define mock.On call +// - ctx context.Context +// - memberId string +func (_e *LeaderElection_Expecter) IsLeader(ctx interface{}, memberId interface{}) *LeaderElection_IsLeader_Call { + return &LeaderElection_IsLeader_Call{Call: _e.mock.On("IsLeader", ctx, memberId)} +} + +func (_c *LeaderElection_IsLeader_Call) Run(run func(ctx context.Context, memberId string)) *LeaderElection_IsLeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *LeaderElection_IsLeader_Call) Return(_a0 bool, _a1 error) *LeaderElection_IsLeader_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *LeaderElection_IsLeader_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *LeaderElection_IsLeader_Call { + _c.Call.Return(run) + return _c +} + // Resign provides a mock function with given fields: ctx, memberId func (_m *LeaderElection) Resign(ctx context.Context, memberId string) error { ret := _m.Called(ctx, memberId) @@ -51,6 +88,35 @@ func (_m *LeaderElection) Resign(ctx context.Context, memberId string) error { return r0 } +// LeaderElection_Resign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resign' +type LeaderElection_Resign_Call struct { + *mock.Call +} + +// Resign is a helper method to define mock.On call +// - ctx context.Context +// - memberId string +func (_e *LeaderElection_Expecter) Resign(ctx interface{}, memberId interface{}) *LeaderElection_Resign_Call { + return &LeaderElection_Resign_Call{Call: _e.mock.On("Resign", ctx, memberId)} +} + +func (_c *LeaderElection_Resign_Call) Run(run func(ctx context.Context, memberId string)) *LeaderElection_Resign_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *LeaderElection_Resign_Call) Return(_a0 error) *LeaderElection_Resign_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LeaderElection_Resign_Call) RunAndReturn(run func(context.Context, string) error) *LeaderElection_Resign_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewLeaderElection interface { mock.TestingT Cleanup(func()) diff --git a/pkg/conc/mocks/DistributedLock.go b/pkg/conc/mocks/DistributedLock.go index 96365905d..70a09e065 100644 --- a/pkg/conc/mocks/DistributedLock.go +++ b/pkg/conc/mocks/DistributedLock.go @@ -14,6 +14,14 @@ type DistributedLock struct { mock.Mock } +type DistributedLock_Expecter struct { + mock *mock.Mock +} + +func (_m *DistributedLock) EXPECT() *DistributedLock_Expecter { + return &DistributedLock_Expecter{mock: &_m.Mock} +} + // Release provides a mock function with given fields: func (_m *DistributedLock) Release() error { ret := _m.Called() @@ -28,6 +36,33 @@ func (_m *DistributedLock) Release() error { return r0 } +// DistributedLock_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release' +type DistributedLock_Release_Call struct { + *mock.Call +} + +// Release is a helper method to define mock.On call +func (_e *DistributedLock_Expecter) Release() *DistributedLock_Release_Call { + return &DistributedLock_Release_Call{Call: _e.mock.On("Release")} +} + +func (_c *DistributedLock_Release_Call) Run(run func()) *DistributedLock_Release_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DistributedLock_Release_Call) Return(_a0 error) *DistributedLock_Release_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DistributedLock_Release_Call) RunAndReturn(run func() error) *DistributedLock_Release_Call { + _c.Call.Return(run) + return _c +} + // Renew provides a mock function with given fields: ctx, lockTime func (_m *DistributedLock) Renew(ctx context.Context, lockTime time.Duration) error { ret := _m.Called(ctx, lockTime) @@ -42,6 +77,35 @@ func (_m *DistributedLock) Renew(ctx context.Context, lockTime time.Duration) er return r0 } +// DistributedLock_Renew_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Renew' +type DistributedLock_Renew_Call struct { + *mock.Call +} + +// Renew is a helper method to define mock.On call +// - ctx context.Context +// - lockTime time.Duration +func (_e *DistributedLock_Expecter) Renew(ctx interface{}, lockTime interface{}) *DistributedLock_Renew_Call { + return &DistributedLock_Renew_Call{Call: _e.mock.On("Renew", ctx, lockTime)} +} + +func (_c *DistributedLock_Renew_Call) Run(run func(ctx context.Context, lockTime time.Duration)) *DistributedLock_Renew_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(time.Duration)) + }) + return _c +} + +func (_c *DistributedLock_Renew_Call) Return(_a0 error) *DistributedLock_Renew_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DistributedLock_Renew_Call) RunAndReturn(run func(context.Context, time.Duration) error) *DistributedLock_Renew_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewDistributedLock interface { mock.TestingT Cleanup(func()) diff --git a/pkg/conc/mocks/DistributedLockProvider.go b/pkg/conc/mocks/DistributedLockProvider.go index ce8fcf5a8..25fe9763f 100644 --- a/pkg/conc/mocks/DistributedLockProvider.go +++ b/pkg/conc/mocks/DistributedLockProvider.go @@ -15,6 +15,14 @@ type DistributedLockProvider struct { mock.Mock } +type DistributedLockProvider_Expecter struct { + mock *mock.Mock +} + +func (_m *DistributedLockProvider) EXPECT() *DistributedLockProvider_Expecter { + return &DistributedLockProvider_Expecter{mock: &_m.Mock} +} + // Acquire provides a mock function with given fields: ctx, resource func (_m *DistributedLockProvider) Acquire(ctx context.Context, resource string) (conc.DistributedLock, error) { ret := _m.Called(ctx, resource) @@ -41,6 +49,35 @@ func (_m *DistributedLockProvider) Acquire(ctx context.Context, resource string) return r0, r1 } +// DistributedLockProvider_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire' +type DistributedLockProvider_Acquire_Call struct { + *mock.Call +} + +// Acquire is a helper method to define mock.On call +// - ctx context.Context +// - resource string +func (_e *DistributedLockProvider_Expecter) Acquire(ctx interface{}, resource interface{}) *DistributedLockProvider_Acquire_Call { + return &DistributedLockProvider_Acquire_Call{Call: _e.mock.On("Acquire", ctx, resource)} +} + +func (_c *DistributedLockProvider_Acquire_Call) Run(run func(ctx context.Context, resource string)) *DistributedLockProvider_Acquire_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *DistributedLockProvider_Acquire_Call) Return(_a0 conc.DistributedLock, _a1 error) *DistributedLockProvider_Acquire_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *DistributedLockProvider_Acquire_Call) RunAndReturn(run func(context.Context, string) (conc.DistributedLock, error)) *DistributedLockProvider_Acquire_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewDistributedLockProvider interface { mock.TestingT Cleanup(func()) diff --git a/pkg/conc/mocks/PoisonedLock.go b/pkg/conc/mocks/PoisonedLock.go index 805d0f52d..c0f7a2325 100644 --- a/pkg/conc/mocks/PoisonedLock.go +++ b/pkg/conc/mocks/PoisonedLock.go @@ -9,11 +9,46 @@ type PoisonedLock struct { mock.Mock } +type PoisonedLock_Expecter struct { + mock *mock.Mock +} + +func (_m *PoisonedLock) EXPECT() *PoisonedLock_Expecter { + return &PoisonedLock_Expecter{mock: &_m.Mock} +} + // MustLock provides a mock function with given fields: func (_m *PoisonedLock) MustLock() { _m.Called() } +// PoisonedLock_MustLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MustLock' +type PoisonedLock_MustLock_Call struct { + *mock.Call +} + +// MustLock is a helper method to define mock.On call +func (_e *PoisonedLock_Expecter) MustLock() *PoisonedLock_MustLock_Call { + return &PoisonedLock_MustLock_Call{Call: _e.mock.On("MustLock")} +} + +func (_c *PoisonedLock_MustLock_Call) Run(run func()) *PoisonedLock_MustLock_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PoisonedLock_MustLock_Call) Return() *PoisonedLock_MustLock_Call { + _c.Call.Return() + return _c +} + +func (_c *PoisonedLock_MustLock_Call) RunAndReturn(run func()) *PoisonedLock_MustLock_Call { + _c.Call.Return(run) + return _c +} + // Poison provides a mock function with given fields: func (_m *PoisonedLock) Poison() error { ret := _m.Called() @@ -28,6 +63,33 @@ func (_m *PoisonedLock) Poison() error { return r0 } +// PoisonedLock_Poison_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Poison' +type PoisonedLock_Poison_Call struct { + *mock.Call +} + +// Poison is a helper method to define mock.On call +func (_e *PoisonedLock_Expecter) Poison() *PoisonedLock_Poison_Call { + return &PoisonedLock_Poison_Call{Call: _e.mock.On("Poison")} +} + +func (_c *PoisonedLock_Poison_Call) Run(run func()) *PoisonedLock_Poison_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PoisonedLock_Poison_Call) Return(_a0 error) *PoisonedLock_Poison_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PoisonedLock_Poison_Call) RunAndReturn(run func() error) *PoisonedLock_Poison_Call { + _c.Call.Return(run) + return _c +} + // PoisonIf provides a mock function with given fields: _a0 func (_m *PoisonedLock) PoisonIf(_a0 func() (bool, error)) error { ret := _m.Called(_a0) @@ -42,6 +104,34 @@ func (_m *PoisonedLock) PoisonIf(_a0 func() (bool, error)) error { return r0 } +// PoisonedLock_PoisonIf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PoisonIf' +type PoisonedLock_PoisonIf_Call struct { + *mock.Call +} + +// PoisonIf is a helper method to define mock.On call +// - _a0 func()(bool , error) +func (_e *PoisonedLock_Expecter) PoisonIf(_a0 interface{}) *PoisonedLock_PoisonIf_Call { + return &PoisonedLock_PoisonIf_Call{Call: _e.mock.On("PoisonIf", _a0)} +} + +func (_c *PoisonedLock_PoisonIf_Call) Run(run func(_a0 func() (bool, error))) *PoisonedLock_PoisonIf_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func() (bool, error))) + }) + return _c +} + +func (_c *PoisonedLock_PoisonIf_Call) Return(_a0 error) *PoisonedLock_PoisonIf_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PoisonedLock_PoisonIf_Call) RunAndReturn(run func(func() (bool, error)) error) *PoisonedLock_PoisonIf_Call { + _c.Call.Return(run) + return _c +} + // TryLock provides a mock function with given fields: func (_m *PoisonedLock) TryLock() error { ret := _m.Called() @@ -56,11 +146,65 @@ func (_m *PoisonedLock) TryLock() error { return r0 } +// PoisonedLock_TryLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TryLock' +type PoisonedLock_TryLock_Call struct { + *mock.Call +} + +// TryLock is a helper method to define mock.On call +func (_e *PoisonedLock_Expecter) TryLock() *PoisonedLock_TryLock_Call { + return &PoisonedLock_TryLock_Call{Call: _e.mock.On("TryLock")} +} + +func (_c *PoisonedLock_TryLock_Call) Run(run func()) *PoisonedLock_TryLock_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PoisonedLock_TryLock_Call) Return(_a0 error) *PoisonedLock_TryLock_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PoisonedLock_TryLock_Call) RunAndReturn(run func() error) *PoisonedLock_TryLock_Call { + _c.Call.Return(run) + return _c +} + // Unlock provides a mock function with given fields: func (_m *PoisonedLock) Unlock() { _m.Called() } +// PoisonedLock_Unlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unlock' +type PoisonedLock_Unlock_Call struct { + *mock.Call +} + +// Unlock is a helper method to define mock.On call +func (_e *PoisonedLock_Expecter) Unlock() *PoisonedLock_Unlock_Call { + return &PoisonedLock_Unlock_Call{Call: _e.mock.On("Unlock")} +} + +func (_c *PoisonedLock_Unlock_Call) Run(run func()) *PoisonedLock_Unlock_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PoisonedLock_Unlock_Call) Return() *PoisonedLock_Unlock_Call { + _c.Call.Return() + return _c +} + +func (_c *PoisonedLock_Unlock_Call) RunAndReturn(run func()) *PoisonedLock_Unlock_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewPoisonedLock interface { mock.TestingT Cleanup(func()) diff --git a/pkg/conc/mocks/SignalOnce.go b/pkg/conc/mocks/SignalOnce.go index e19b288fe..1e3103fec 100644 --- a/pkg/conc/mocks/SignalOnce.go +++ b/pkg/conc/mocks/SignalOnce.go @@ -9,6 +9,14 @@ type SignalOnce struct { mock.Mock } +type SignalOnce_Expecter struct { + mock *mock.Mock +} + +func (_m *SignalOnce) EXPECT() *SignalOnce_Expecter { + return &SignalOnce_Expecter{mock: &_m.Mock} +} + // Channel provides a mock function with given fields: func (_m *SignalOnce) Channel() chan struct{} { ret := _m.Called() @@ -25,11 +33,65 @@ func (_m *SignalOnce) Channel() chan struct{} { return r0 } +// SignalOnce_Channel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Channel' +type SignalOnce_Channel_Call struct { + *mock.Call +} + +// Channel is a helper method to define mock.On call +func (_e *SignalOnce_Expecter) Channel() *SignalOnce_Channel_Call { + return &SignalOnce_Channel_Call{Call: _e.mock.On("Channel")} +} + +func (_c *SignalOnce_Channel_Call) Run(run func()) *SignalOnce_Channel_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SignalOnce_Channel_Call) Return(_a0 chan struct{}) *SignalOnce_Channel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SignalOnce_Channel_Call) RunAndReturn(run func() chan struct{}) *SignalOnce_Channel_Call { + _c.Call.Return(run) + return _c +} + // Signal provides a mock function with given fields: func (_m *SignalOnce) Signal() { _m.Called() } +// SignalOnce_Signal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Signal' +type SignalOnce_Signal_Call struct { + *mock.Call +} + +// Signal is a helper method to define mock.On call +func (_e *SignalOnce_Expecter) Signal() *SignalOnce_Signal_Call { + return &SignalOnce_Signal_Call{Call: _e.mock.On("Signal")} +} + +func (_c *SignalOnce_Signal_Call) Run(run func()) *SignalOnce_Signal_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SignalOnce_Signal_Call) Return() *SignalOnce_Signal_Call { + _c.Call.Return() + return _c +} + +func (_c *SignalOnce_Signal_Call) RunAndReturn(run func()) *SignalOnce_Signal_Call { + _c.Call.Return(run) + return _c +} + // Signaled provides a mock function with given fields: func (_m *SignalOnce) Signaled() bool { ret := _m.Called() @@ -44,6 +106,33 @@ func (_m *SignalOnce) Signaled() bool { return r0 } +// SignalOnce_Signaled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Signaled' +type SignalOnce_Signaled_Call struct { + *mock.Call +} + +// Signaled is a helper method to define mock.On call +func (_e *SignalOnce_Expecter) Signaled() *SignalOnce_Signaled_Call { + return &SignalOnce_Signaled_Call{Call: _e.mock.On("Signaled")} +} + +func (_c *SignalOnce_Signaled_Call) Run(run func()) *SignalOnce_Signaled_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SignalOnce_Signaled_Call) Return(_a0 bool) *SignalOnce_Signaled_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SignalOnce_Signaled_Call) RunAndReturn(run func() bool) *SignalOnce_Signaled_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewSignalOnce interface { mock.TestingT Cleanup(func()) diff --git a/pkg/currency/mocks/Service.go b/pkg/currency/mocks/Service.go index 59c5035ad..98eb19695 100644 --- a/pkg/currency/mocks/Service.go +++ b/pkg/currency/mocks/Service.go @@ -15,6 +15,14 @@ type Service struct { mock.Mock } +type Service_Expecter struct { + mock *mock.Mock +} + +func (_m *Service) EXPECT() *Service_Expecter { + return &Service_Expecter{mock: &_m.Mock} +} + // HasCurrency provides a mock function with given fields: ctx, _a1 func (_m *Service) HasCurrency(ctx context.Context, _a1 string) (bool, error) { ret := _m.Called(ctx, _a1) @@ -39,6 +47,35 @@ func (_m *Service) HasCurrency(ctx context.Context, _a1 string) (bool, error) { return r0, r1 } +// Service_HasCurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCurrency' +type Service_HasCurrency_Call struct { + *mock.Call +} + +// HasCurrency is a helper method to define mock.On call +// - ctx context.Context +// - _a1 string +func (_e *Service_Expecter) HasCurrency(ctx interface{}, _a1 interface{}) *Service_HasCurrency_Call { + return &Service_HasCurrency_Call{Call: _e.mock.On("HasCurrency", ctx, _a1)} +} + +func (_c *Service_HasCurrency_Call) Run(run func(ctx context.Context, _a1 string)) *Service_HasCurrency_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Service_HasCurrency_Call) Return(_a0 bool, _a1 error) *Service_HasCurrency_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_HasCurrency_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *Service_HasCurrency_Call { + _c.Call.Return(run) + return _c +} + // HasCurrencyAtDate provides a mock function with given fields: ctx, _a1, date func (_m *Service) HasCurrencyAtDate(ctx context.Context, _a1 string, date time.Time) (bool, error) { ret := _m.Called(ctx, _a1, date) @@ -63,6 +100,36 @@ func (_m *Service) HasCurrencyAtDate(ctx context.Context, _a1 string, date time. return r0, r1 } +// Service_HasCurrencyAtDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCurrencyAtDate' +type Service_HasCurrencyAtDate_Call struct { + *mock.Call +} + +// HasCurrencyAtDate is a helper method to define mock.On call +// - ctx context.Context +// - _a1 string +// - date time.Time +func (_e *Service_Expecter) HasCurrencyAtDate(ctx interface{}, _a1 interface{}, date interface{}) *Service_HasCurrencyAtDate_Call { + return &Service_HasCurrencyAtDate_Call{Call: _e.mock.On("HasCurrencyAtDate", ctx, _a1, date)} +} + +func (_c *Service_HasCurrencyAtDate_Call) Run(run func(ctx context.Context, _a1 string, date time.Time)) *Service_HasCurrencyAtDate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(time.Time)) + }) + return _c +} + +func (_c *Service_HasCurrencyAtDate_Call) Return(_a0 bool, _a1 error) *Service_HasCurrencyAtDate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_HasCurrencyAtDate_Call) RunAndReturn(run func(context.Context, string, time.Time) (bool, error)) *Service_HasCurrencyAtDate_Call { + _c.Call.Return(run) + return _c +} + // ToCurrency provides a mock function with given fields: ctx, toCurrency, value, fromCurrency func (_m *Service) ToCurrency(ctx context.Context, toCurrency string, value float64, fromCurrency string) (float64, error) { ret := _m.Called(ctx, toCurrency, value, fromCurrency) @@ -87,6 +154,37 @@ func (_m *Service) ToCurrency(ctx context.Context, toCurrency string, value floa return r0, r1 } +// Service_ToCurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToCurrency' +type Service_ToCurrency_Call struct { + *mock.Call +} + +// ToCurrency is a helper method to define mock.On call +// - ctx context.Context +// - toCurrency string +// - value float64 +// - fromCurrency string +func (_e *Service_Expecter) ToCurrency(ctx interface{}, toCurrency interface{}, value interface{}, fromCurrency interface{}) *Service_ToCurrency_Call { + return &Service_ToCurrency_Call{Call: _e.mock.On("ToCurrency", ctx, toCurrency, value, fromCurrency)} +} + +func (_c *Service_ToCurrency_Call) Run(run func(ctx context.Context, toCurrency string, value float64, fromCurrency string)) *Service_ToCurrency_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 *Service_ToCurrency_Call) Return(_a0 float64, _a1 error) *Service_ToCurrency_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_ToCurrency_Call) RunAndReturn(run func(context.Context, string, float64, string) (float64, error)) *Service_ToCurrency_Call { + _c.Call.Return(run) + return _c +} + // ToCurrencyAtDate provides a mock function with given fields: ctx, toCurrency, value, fromCurrency, date func (_m *Service) ToCurrencyAtDate(ctx context.Context, toCurrency string, value float64, fromCurrency string, date time.Time) (float64, error) { ret := _m.Called(ctx, toCurrency, value, fromCurrency, date) @@ -111,6 +209,38 @@ func (_m *Service) ToCurrencyAtDate(ctx context.Context, toCurrency string, valu return r0, r1 } +// Service_ToCurrencyAtDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToCurrencyAtDate' +type Service_ToCurrencyAtDate_Call struct { + *mock.Call +} + +// ToCurrencyAtDate is a helper method to define mock.On call +// - ctx context.Context +// - toCurrency string +// - value float64 +// - fromCurrency string +// - date time.Time +func (_e *Service_Expecter) ToCurrencyAtDate(ctx interface{}, toCurrency interface{}, value interface{}, fromCurrency interface{}, date interface{}) *Service_ToCurrencyAtDate_Call { + return &Service_ToCurrencyAtDate_Call{Call: _e.mock.On("ToCurrencyAtDate", ctx, toCurrency, value, fromCurrency, date)} +} + +func (_c *Service_ToCurrencyAtDate_Call) Run(run func(ctx context.Context, toCurrency string, value float64, fromCurrency string, date time.Time)) *Service_ToCurrencyAtDate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64), args[3].(string), args[4].(time.Time)) + }) + return _c +} + +func (_c *Service_ToCurrencyAtDate_Call) Return(_a0 float64, _a1 error) *Service_ToCurrencyAtDate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_ToCurrencyAtDate_Call) RunAndReturn(run func(context.Context, string, float64, string, time.Time) (float64, error)) *Service_ToCurrencyAtDate_Call { + _c.Call.Return(run) + return _c +} + // ToEur provides a mock function with given fields: ctx, value, fromCurrency func (_m *Service) ToEur(ctx context.Context, value float64, fromCurrency string) (float64, error) { ret := _m.Called(ctx, value, fromCurrency) @@ -135,6 +265,36 @@ func (_m *Service) ToEur(ctx context.Context, value float64, fromCurrency string return r0, r1 } +// Service_ToEur_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToEur' +type Service_ToEur_Call struct { + *mock.Call +} + +// ToEur is a helper method to define mock.On call +// - ctx context.Context +// - value float64 +// - fromCurrency string +func (_e *Service_Expecter) ToEur(ctx interface{}, value interface{}, fromCurrency interface{}) *Service_ToEur_Call { + return &Service_ToEur_Call{Call: _e.mock.On("ToEur", ctx, value, fromCurrency)} +} + +func (_c *Service_ToEur_Call) Run(run func(ctx context.Context, value float64, fromCurrency string)) *Service_ToEur_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(float64), args[2].(string)) + }) + return _c +} + +func (_c *Service_ToEur_Call) Return(_a0 float64, _a1 error) *Service_ToEur_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_ToEur_Call) RunAndReturn(run func(context.Context, float64, string) (float64, error)) *Service_ToEur_Call { + _c.Call.Return(run) + return _c +} + // ToEurAtDate provides a mock function with given fields: ctx, value, fromCurrency, date func (_m *Service) ToEurAtDate(ctx context.Context, value float64, fromCurrency string, date time.Time) (float64, error) { ret := _m.Called(ctx, value, fromCurrency, date) @@ -159,6 +319,37 @@ func (_m *Service) ToEurAtDate(ctx context.Context, value float64, fromCurrency return r0, r1 } +// Service_ToEurAtDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToEurAtDate' +type Service_ToEurAtDate_Call struct { + *mock.Call +} + +// ToEurAtDate is a helper method to define mock.On call +// - ctx context.Context +// - value float64 +// - fromCurrency string +// - date time.Time +func (_e *Service_Expecter) ToEurAtDate(ctx interface{}, value interface{}, fromCurrency interface{}, date interface{}) *Service_ToEurAtDate_Call { + return &Service_ToEurAtDate_Call{Call: _e.mock.On("ToEurAtDate", ctx, value, fromCurrency, date)} +} + +func (_c *Service_ToEurAtDate_Call) Run(run func(ctx context.Context, value float64, fromCurrency string, date time.Time)) *Service_ToEurAtDate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(float64), args[2].(string), args[3].(time.Time)) + }) + return _c +} + +func (_c *Service_ToEurAtDate_Call) Return(_a0 float64, _a1 error) *Service_ToEurAtDate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_ToEurAtDate_Call) RunAndReturn(run func(context.Context, float64, string, time.Time) (float64, error)) *Service_ToEurAtDate_Call { + _c.Call.Return(run) + return _c +} + // ToUsd provides a mock function with given fields: ctx, value, fromCurrency func (_m *Service) ToUsd(ctx context.Context, value float64, fromCurrency string) (float64, error) { ret := _m.Called(ctx, value, fromCurrency) @@ -183,6 +374,36 @@ func (_m *Service) ToUsd(ctx context.Context, value float64, fromCurrency string return r0, r1 } +// Service_ToUsd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToUsd' +type Service_ToUsd_Call struct { + *mock.Call +} + +// ToUsd is a helper method to define mock.On call +// - ctx context.Context +// - value float64 +// - fromCurrency string +func (_e *Service_Expecter) ToUsd(ctx interface{}, value interface{}, fromCurrency interface{}) *Service_ToUsd_Call { + return &Service_ToUsd_Call{Call: _e.mock.On("ToUsd", ctx, value, fromCurrency)} +} + +func (_c *Service_ToUsd_Call) Run(run func(ctx context.Context, value float64, fromCurrency string)) *Service_ToUsd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(float64), args[2].(string)) + }) + return _c +} + +func (_c *Service_ToUsd_Call) Return(_a0 float64, _a1 error) *Service_ToUsd_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_ToUsd_Call) RunAndReturn(run func(context.Context, float64, string) (float64, error)) *Service_ToUsd_Call { + _c.Call.Return(run) + return _c +} + // ToUsdAtDate provides a mock function with given fields: ctx, value, fromCurrency, date func (_m *Service) ToUsdAtDate(ctx context.Context, value float64, fromCurrency string, date time.Time) (float64, error) { ret := _m.Called(ctx, value, fromCurrency, date) @@ -207,6 +428,37 @@ func (_m *Service) ToUsdAtDate(ctx context.Context, value float64, fromCurrency return r0, r1 } +// Service_ToUsdAtDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToUsdAtDate' +type Service_ToUsdAtDate_Call struct { + *mock.Call +} + +// ToUsdAtDate is a helper method to define mock.On call +// - ctx context.Context +// - value float64 +// - fromCurrency string +// - date time.Time +func (_e *Service_Expecter) ToUsdAtDate(ctx interface{}, value interface{}, fromCurrency interface{}, date interface{}) *Service_ToUsdAtDate_Call { + return &Service_ToUsdAtDate_Call{Call: _e.mock.On("ToUsdAtDate", ctx, value, fromCurrency, date)} +} + +func (_c *Service_ToUsdAtDate_Call) Run(run func(ctx context.Context, value float64, fromCurrency string, date time.Time)) *Service_ToUsdAtDate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(float64), args[2].(string), args[3].(time.Time)) + }) + return _c +} + +func (_c *Service_ToUsdAtDate_Call) Return(_a0 float64, _a1 error) *Service_ToUsdAtDate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_ToUsdAtDate_Call) RunAndReturn(run func(context.Context, float64, string, time.Time) (float64, error)) *Service_ToUsdAtDate_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewService interface { mock.TestingT Cleanup(func()) diff --git a/pkg/currency/mocks/UpdaterService.go b/pkg/currency/mocks/UpdaterService.go index 91575ad8a..4aaf4fa60 100644 --- a/pkg/currency/mocks/UpdaterService.go +++ b/pkg/currency/mocks/UpdaterService.go @@ -13,6 +13,14 @@ type UpdaterService struct { mock.Mock } +type UpdaterService_Expecter struct { + mock *mock.Mock +} + +func (_m *UpdaterService) EXPECT() *UpdaterService_Expecter { + return &UpdaterService_Expecter{mock: &_m.Mock} +} + // EnsureHistoricalExchangeRates provides a mock function with given fields: ctx func (_m *UpdaterService) EnsureHistoricalExchangeRates(ctx context.Context) error { ret := _m.Called(ctx) @@ -27,6 +35,34 @@ func (_m *UpdaterService) EnsureHistoricalExchangeRates(ctx context.Context) err return r0 } +// UpdaterService_EnsureHistoricalExchangeRates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureHistoricalExchangeRates' +type UpdaterService_EnsureHistoricalExchangeRates_Call struct { + *mock.Call +} + +// EnsureHistoricalExchangeRates is a helper method to define mock.On call +// - ctx context.Context +func (_e *UpdaterService_Expecter) EnsureHistoricalExchangeRates(ctx interface{}) *UpdaterService_EnsureHistoricalExchangeRates_Call { + return &UpdaterService_EnsureHistoricalExchangeRates_Call{Call: _e.mock.On("EnsureHistoricalExchangeRates", ctx)} +} + +func (_c *UpdaterService_EnsureHistoricalExchangeRates_Call) Run(run func(ctx context.Context)) *UpdaterService_EnsureHistoricalExchangeRates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *UpdaterService_EnsureHistoricalExchangeRates_Call) Return(_a0 error) *UpdaterService_EnsureHistoricalExchangeRates_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdaterService_EnsureHistoricalExchangeRates_Call) RunAndReturn(run func(context.Context) error) *UpdaterService_EnsureHistoricalExchangeRates_Call { + _c.Call.Return(run) + return _c +} + // EnsureRecentExchangeRates provides a mock function with given fields: ctx func (_m *UpdaterService) EnsureRecentExchangeRates(ctx context.Context) error { ret := _m.Called(ctx) @@ -41,6 +77,34 @@ func (_m *UpdaterService) EnsureRecentExchangeRates(ctx context.Context) error { return r0 } +// UpdaterService_EnsureRecentExchangeRates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureRecentExchangeRates' +type UpdaterService_EnsureRecentExchangeRates_Call struct { + *mock.Call +} + +// EnsureRecentExchangeRates is a helper method to define mock.On call +// - ctx context.Context +func (_e *UpdaterService_Expecter) EnsureRecentExchangeRates(ctx interface{}) *UpdaterService_EnsureRecentExchangeRates_Call { + return &UpdaterService_EnsureRecentExchangeRates_Call{Call: _e.mock.On("EnsureRecentExchangeRates", ctx)} +} + +func (_c *UpdaterService_EnsureRecentExchangeRates_Call) Run(run func(ctx context.Context)) *UpdaterService_EnsureRecentExchangeRates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *UpdaterService_EnsureRecentExchangeRates_Call) Return(_a0 error) *UpdaterService_EnsureRecentExchangeRates_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdaterService_EnsureRecentExchangeRates_Call) RunAndReturn(run func(context.Context) error) *UpdaterService_EnsureRecentExchangeRates_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewUpdaterService interface { mock.TestingT Cleanup(func()) diff --git a/pkg/db-repo/mocks/ModelBased.go b/pkg/db-repo/mocks/ModelBased.go index af7bfb0ac..1fd217479 100644 --- a/pkg/db-repo/mocks/ModelBased.go +++ b/pkg/db-repo/mocks/ModelBased.go @@ -13,6 +13,14 @@ type ModelBased struct { mock.Mock } +type ModelBased_Expecter struct { + mock *mock.Mock +} + +func (_m *ModelBased) EXPECT() *ModelBased_Expecter { + return &ModelBased_Expecter{mock: &_m.Mock} +} + // GetId provides a mock function with given fields: func (_m *ModelBased) GetId() *uint { ret := _m.Called() @@ -29,16 +37,99 @@ func (_m *ModelBased) GetId() *uint { return r0 } +// ModelBased_GetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetId' +type ModelBased_GetId_Call struct { + *mock.Call +} + +// GetId is a helper method to define mock.On call +func (_e *ModelBased_Expecter) GetId() *ModelBased_GetId_Call { + return &ModelBased_GetId_Call{Call: _e.mock.On("GetId")} +} + +func (_c *ModelBased_GetId_Call) Run(run func()) *ModelBased_GetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ModelBased_GetId_Call) Return(_a0 *uint) *ModelBased_GetId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ModelBased_GetId_Call) RunAndReturn(run func() *uint) *ModelBased_GetId_Call { + _c.Call.Return(run) + return _c +} + // SetCreatedAt provides a mock function with given fields: createdAt func (_m *ModelBased) SetCreatedAt(createdAt *time.Time) { _m.Called(createdAt) } +// ModelBased_SetCreatedAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCreatedAt' +type ModelBased_SetCreatedAt_Call struct { + *mock.Call +} + +// SetCreatedAt is a helper method to define mock.On call +// - createdAt *time.Time +func (_e *ModelBased_Expecter) SetCreatedAt(createdAt interface{}) *ModelBased_SetCreatedAt_Call { + return &ModelBased_SetCreatedAt_Call{Call: _e.mock.On("SetCreatedAt", createdAt)} +} + +func (_c *ModelBased_SetCreatedAt_Call) Run(run func(createdAt *time.Time)) *ModelBased_SetCreatedAt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*time.Time)) + }) + return _c +} + +func (_c *ModelBased_SetCreatedAt_Call) Return() *ModelBased_SetCreatedAt_Call { + _c.Call.Return() + return _c +} + +func (_c *ModelBased_SetCreatedAt_Call) RunAndReturn(run func(*time.Time)) *ModelBased_SetCreatedAt_Call { + _c.Call.Return(run) + return _c +} + // SetUpdatedAt provides a mock function with given fields: updatedAt func (_m *ModelBased) SetUpdatedAt(updatedAt *time.Time) { _m.Called(updatedAt) } +// ModelBased_SetUpdatedAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUpdatedAt' +type ModelBased_SetUpdatedAt_Call struct { + *mock.Call +} + +// SetUpdatedAt is a helper method to define mock.On call +// - updatedAt *time.Time +func (_e *ModelBased_Expecter) SetUpdatedAt(updatedAt interface{}) *ModelBased_SetUpdatedAt_Call { + return &ModelBased_SetUpdatedAt_Call{Call: _e.mock.On("SetUpdatedAt", updatedAt)} +} + +func (_c *ModelBased_SetUpdatedAt_Call) Run(run func(updatedAt *time.Time)) *ModelBased_SetUpdatedAt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*time.Time)) + }) + return _c +} + +func (_c *ModelBased_SetUpdatedAt_Call) Return() *ModelBased_SetUpdatedAt_Call { + _c.Call.Return() + return _c +} + +func (_c *ModelBased_SetUpdatedAt_Call) RunAndReturn(run func(*time.Time)) *ModelBased_SetUpdatedAt_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewModelBased interface { mock.TestingT Cleanup(func()) diff --git a/pkg/db-repo/mocks/Repository.go b/pkg/db-repo/mocks/Repository.go index 2ee637c86..b39dee595 100644 --- a/pkg/db-repo/mocks/Repository.go +++ b/pkg/db-repo/mocks/Repository.go @@ -14,6 +14,14 @@ type Repository struct { mock.Mock } +type Repository_Expecter struct { + mock *mock.Mock +} + +func (_m *Repository) EXPECT() *Repository_Expecter { + return &Repository_Expecter{mock: &_m.Mock} +} + // Count provides a mock function with given fields: ctx, qb, model func (_m *Repository) Count(ctx context.Context, qb *db_repo.QueryBuilder, model db_repo.ModelBased) (int, error) { ret := _m.Called(ctx, qb, model) @@ -38,6 +46,36 @@ func (_m *Repository) Count(ctx context.Context, qb *db_repo.QueryBuilder, model return r0, r1 } +// Repository_Count_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Count' +type Repository_Count_Call struct { + *mock.Call +} + +// Count is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - model db_repo.ModelBased +func (_e *Repository_Expecter) Count(ctx interface{}, qb interface{}, model interface{}) *Repository_Count_Call { + return &Repository_Count_Call{Call: _e.mock.On("Count", ctx, qb, model)} +} + +func (_c *Repository_Count_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, model db_repo.ModelBased)) *Repository_Count_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Count_Call) Return(_a0 int, _a1 error) *Repository_Count_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_Count_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, db_repo.ModelBased) (int, error)) *Repository_Count_Call { + _c.Call.Return(run) + return _c +} + // Create provides a mock function with given fields: ctx, value func (_m *Repository) Create(ctx context.Context, value db_repo.ModelBased) error { ret := _m.Called(ctx, value) @@ -52,6 +90,35 @@ func (_m *Repository) Create(ctx context.Context, value db_repo.ModelBased) erro return r0 } +// Repository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type Repository_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - value db_repo.ModelBased +func (_e *Repository_Expecter) Create(ctx interface{}, value interface{}) *Repository_Create_Call { + return &Repository_Create_Call{Call: _e.mock.On("Create", ctx, value)} +} + +func (_c *Repository_Create_Call) Run(run func(ctx context.Context, value db_repo.ModelBased)) *Repository_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Create_Call) Return(_a0 error) *Repository_Create_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Create_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased) error) *Repository_Create_Call { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: ctx, value func (_m *Repository) Delete(ctx context.Context, value db_repo.ModelBased) error { ret := _m.Called(ctx, value) @@ -66,6 +133,35 @@ func (_m *Repository) Delete(ctx context.Context, value db_repo.ModelBased) erro return r0 } +// Repository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type Repository_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - value db_repo.ModelBased +func (_e *Repository_Expecter) Delete(ctx interface{}, value interface{}) *Repository_Delete_Call { + return &Repository_Delete_Call{Call: _e.mock.On("Delete", ctx, value)} +} + +func (_c *Repository_Delete_Call) Run(run func(ctx context.Context, value db_repo.ModelBased)) *Repository_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Delete_Call) Return(_a0 error) *Repository_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Delete_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased) error) *Repository_Delete_Call { + _c.Call.Return(run) + return _c +} + // GetMetadata provides a mock function with given fields: func (_m *Repository) GetMetadata() db_repo.Metadata { ret := _m.Called() @@ -80,6 +176,33 @@ func (_m *Repository) GetMetadata() db_repo.Metadata { return r0 } +// Repository_GetMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetadata' +type Repository_GetMetadata_Call struct { + *mock.Call +} + +// GetMetadata is a helper method to define mock.On call +func (_e *Repository_Expecter) GetMetadata() *Repository_GetMetadata_Call { + return &Repository_GetMetadata_Call{Call: _e.mock.On("GetMetadata")} +} + +func (_c *Repository_GetMetadata_Call) Run(run func()) *Repository_GetMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_GetMetadata_Call) Return(_a0 db_repo.Metadata) *Repository_GetMetadata_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_GetMetadata_Call) RunAndReturn(run func() db_repo.Metadata) *Repository_GetMetadata_Call { + _c.Call.Return(run) + return _c +} + // GetModelId provides a mock function with given fields: func (_m *Repository) GetModelId() string { ret := _m.Called() @@ -94,6 +217,33 @@ func (_m *Repository) GetModelId() string { return r0 } +// Repository_GetModelId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModelId' +type Repository_GetModelId_Call struct { + *mock.Call +} + +// GetModelId is a helper method to define mock.On call +func (_e *Repository_Expecter) GetModelId() *Repository_GetModelId_Call { + return &Repository_GetModelId_Call{Call: _e.mock.On("GetModelId")} +} + +func (_c *Repository_GetModelId_Call) Run(run func()) *Repository_GetModelId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_GetModelId_Call) Return(_a0 string) *Repository_GetModelId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_GetModelId_Call) RunAndReturn(run func() string) *Repository_GetModelId_Call { + _c.Call.Return(run) + return _c +} + // GetModelName provides a mock function with given fields: func (_m *Repository) GetModelName() string { ret := _m.Called() @@ -108,6 +258,33 @@ func (_m *Repository) GetModelName() string { return r0 } +// Repository_GetModelName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModelName' +type Repository_GetModelName_Call struct { + *mock.Call +} + +// GetModelName is a helper method to define mock.On call +func (_e *Repository_Expecter) GetModelName() *Repository_GetModelName_Call { + return &Repository_GetModelName_Call{Call: _e.mock.On("GetModelName")} +} + +func (_c *Repository_GetModelName_Call) Run(run func()) *Repository_GetModelName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_GetModelName_Call) Return(_a0 string) *Repository_GetModelName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_GetModelName_Call) RunAndReturn(run func() string) *Repository_GetModelName_Call { + _c.Call.Return(run) + return _c +} + // Query provides a mock function with given fields: ctx, qb, result func (_m *Repository) Query(ctx context.Context, qb *db_repo.QueryBuilder, result interface{}) error { ret := _m.Called(ctx, qb, result) @@ -122,6 +299,36 @@ func (_m *Repository) Query(ctx context.Context, qb *db_repo.QueryBuilder, resul return r0 } +// Repository_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' +type Repository_Query_Call struct { + *mock.Call +} + +// Query is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - result interface{} +func (_e *Repository_Expecter) Query(ctx interface{}, qb interface{}, result interface{}) *Repository_Query_Call { + return &Repository_Query_Call{Call: _e.mock.On("Query", ctx, qb, result)} +} + +func (_c *Repository_Query_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, result interface{})) *Repository_Query_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_Query_Call) Return(_a0 error) *Repository_Query_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Query_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, interface{}) error) *Repository_Query_Call { + _c.Call.Return(run) + return _c +} + // Read provides a mock function with given fields: ctx, id, out func (_m *Repository) Read(ctx context.Context, id *uint, out db_repo.ModelBased) error { ret := _m.Called(ctx, id, out) @@ -136,6 +343,36 @@ func (_m *Repository) Read(ctx context.Context, id *uint, out db_repo.ModelBased return r0 } +// Repository_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type Repository_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - ctx context.Context +// - id *uint +// - out db_repo.ModelBased +func (_e *Repository_Expecter) Read(ctx interface{}, id interface{}, out interface{}) *Repository_Read_Call { + return &Repository_Read_Call{Call: _e.mock.On("Read", ctx, id, out)} +} + +func (_c *Repository_Read_Call) Run(run func(ctx context.Context, id *uint, out db_repo.ModelBased)) *Repository_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*uint), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Read_Call) Return(_a0 error) *Repository_Read_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Read_Call) RunAndReturn(run func(context.Context, *uint, db_repo.ModelBased) error) *Repository_Read_Call { + _c.Call.Return(run) + return _c +} + // Update provides a mock function with given fields: ctx, value func (_m *Repository) Update(ctx context.Context, value db_repo.ModelBased) error { ret := _m.Called(ctx, value) @@ -150,6 +387,35 @@ func (_m *Repository) Update(ctx context.Context, value db_repo.ModelBased) erro return r0 } +// Repository_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type Repository_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - ctx context.Context +// - value db_repo.ModelBased +func (_e *Repository_Expecter) Update(ctx interface{}, value interface{}) *Repository_Update_Call { + return &Repository_Update_Call{Call: _e.mock.On("Update", ctx, value)} +} + +func (_c *Repository_Update_Call) Run(run func(ctx context.Context, value db_repo.ModelBased)) *Repository_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *Repository_Update_Call) Return(_a0 error) *Repository_Update_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_Update_Call) RunAndReturn(run func(context.Context, db_repo.ModelBased) error) *Repository_Update_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRepository interface { mock.TestingT Cleanup(func()) diff --git a/pkg/db-repo/mocks/RepositoryReadOnly.go b/pkg/db-repo/mocks/RepositoryReadOnly.go index 121a2311e..766c19620 100644 --- a/pkg/db-repo/mocks/RepositoryReadOnly.go +++ b/pkg/db-repo/mocks/RepositoryReadOnly.go @@ -14,6 +14,14 @@ type RepositoryReadOnly struct { mock.Mock } +type RepositoryReadOnly_Expecter struct { + mock *mock.Mock +} + +func (_m *RepositoryReadOnly) EXPECT() *RepositoryReadOnly_Expecter { + return &RepositoryReadOnly_Expecter{mock: &_m.Mock} +} + // Count provides a mock function with given fields: ctx, qb, model func (_m *RepositoryReadOnly) Count(ctx context.Context, qb *db_repo.QueryBuilder, model db_repo.ModelBased) (int, error) { ret := _m.Called(ctx, qb, model) @@ -38,6 +46,36 @@ func (_m *RepositoryReadOnly) Count(ctx context.Context, qb *db_repo.QueryBuilde return r0, r1 } +// RepositoryReadOnly_Count_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Count' +type RepositoryReadOnly_Count_Call struct { + *mock.Call +} + +// Count is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - model db_repo.ModelBased +func (_e *RepositoryReadOnly_Expecter) Count(ctx interface{}, qb interface{}, model interface{}) *RepositoryReadOnly_Count_Call { + return &RepositoryReadOnly_Count_Call{Call: _e.mock.On("Count", ctx, qb, model)} +} + +func (_c *RepositoryReadOnly_Count_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, model db_repo.ModelBased)) *RepositoryReadOnly_Count_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *RepositoryReadOnly_Count_Call) Return(_a0 int, _a1 error) *RepositoryReadOnly_Count_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RepositoryReadOnly_Count_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, db_repo.ModelBased) (int, error)) *RepositoryReadOnly_Count_Call { + _c.Call.Return(run) + return _c +} + // GetMetadata provides a mock function with given fields: func (_m *RepositoryReadOnly) GetMetadata() db_repo.Metadata { ret := _m.Called() @@ -52,6 +90,33 @@ func (_m *RepositoryReadOnly) GetMetadata() db_repo.Metadata { return r0 } +// RepositoryReadOnly_GetMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetadata' +type RepositoryReadOnly_GetMetadata_Call struct { + *mock.Call +} + +// GetMetadata is a helper method to define mock.On call +func (_e *RepositoryReadOnly_Expecter) GetMetadata() *RepositoryReadOnly_GetMetadata_Call { + return &RepositoryReadOnly_GetMetadata_Call{Call: _e.mock.On("GetMetadata")} +} + +func (_c *RepositoryReadOnly_GetMetadata_Call) Run(run func()) *RepositoryReadOnly_GetMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RepositoryReadOnly_GetMetadata_Call) Return(_a0 db_repo.Metadata) *RepositoryReadOnly_GetMetadata_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RepositoryReadOnly_GetMetadata_Call) RunAndReturn(run func() db_repo.Metadata) *RepositoryReadOnly_GetMetadata_Call { + _c.Call.Return(run) + return _c +} + // GetModelId provides a mock function with given fields: func (_m *RepositoryReadOnly) GetModelId() string { ret := _m.Called() @@ -66,6 +131,33 @@ func (_m *RepositoryReadOnly) GetModelId() string { return r0 } +// RepositoryReadOnly_GetModelId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModelId' +type RepositoryReadOnly_GetModelId_Call struct { + *mock.Call +} + +// GetModelId is a helper method to define mock.On call +func (_e *RepositoryReadOnly_Expecter) GetModelId() *RepositoryReadOnly_GetModelId_Call { + return &RepositoryReadOnly_GetModelId_Call{Call: _e.mock.On("GetModelId")} +} + +func (_c *RepositoryReadOnly_GetModelId_Call) Run(run func()) *RepositoryReadOnly_GetModelId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RepositoryReadOnly_GetModelId_Call) Return(_a0 string) *RepositoryReadOnly_GetModelId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RepositoryReadOnly_GetModelId_Call) RunAndReturn(run func() string) *RepositoryReadOnly_GetModelId_Call { + _c.Call.Return(run) + return _c +} + // GetModelName provides a mock function with given fields: func (_m *RepositoryReadOnly) GetModelName() string { ret := _m.Called() @@ -80,6 +172,33 @@ func (_m *RepositoryReadOnly) GetModelName() string { return r0 } +// RepositoryReadOnly_GetModelName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModelName' +type RepositoryReadOnly_GetModelName_Call struct { + *mock.Call +} + +// GetModelName is a helper method to define mock.On call +func (_e *RepositoryReadOnly_Expecter) GetModelName() *RepositoryReadOnly_GetModelName_Call { + return &RepositoryReadOnly_GetModelName_Call{Call: _e.mock.On("GetModelName")} +} + +func (_c *RepositoryReadOnly_GetModelName_Call) Run(run func()) *RepositoryReadOnly_GetModelName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RepositoryReadOnly_GetModelName_Call) Return(_a0 string) *RepositoryReadOnly_GetModelName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RepositoryReadOnly_GetModelName_Call) RunAndReturn(run func() string) *RepositoryReadOnly_GetModelName_Call { + _c.Call.Return(run) + return _c +} + // Query provides a mock function with given fields: ctx, qb, result func (_m *RepositoryReadOnly) Query(ctx context.Context, qb *db_repo.QueryBuilder, result interface{}) error { ret := _m.Called(ctx, qb, result) @@ -94,6 +213,36 @@ func (_m *RepositoryReadOnly) Query(ctx context.Context, qb *db_repo.QueryBuilde return r0 } +// RepositoryReadOnly_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' +type RepositoryReadOnly_Query_Call struct { + *mock.Call +} + +// Query is a helper method to define mock.On call +// - ctx context.Context +// - qb *db_repo.QueryBuilder +// - result interface{} +func (_e *RepositoryReadOnly_Expecter) Query(ctx interface{}, qb interface{}, result interface{}) *RepositoryReadOnly_Query_Call { + return &RepositoryReadOnly_Query_Call{Call: _e.mock.On("Query", ctx, qb, result)} +} + +func (_c *RepositoryReadOnly_Query_Call) Run(run func(ctx context.Context, qb *db_repo.QueryBuilder, result interface{})) *RepositoryReadOnly_Query_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*db_repo.QueryBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *RepositoryReadOnly_Query_Call) Return(_a0 error) *RepositoryReadOnly_Query_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RepositoryReadOnly_Query_Call) RunAndReturn(run func(context.Context, *db_repo.QueryBuilder, interface{}) error) *RepositoryReadOnly_Query_Call { + _c.Call.Return(run) + return _c +} + // Read provides a mock function with given fields: ctx, id, out func (_m *RepositoryReadOnly) Read(ctx context.Context, id *uint, out db_repo.ModelBased) error { ret := _m.Called(ctx, id, out) @@ -108,6 +257,36 @@ func (_m *RepositoryReadOnly) Read(ctx context.Context, id *uint, out db_repo.Mo return r0 } +// RepositoryReadOnly_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type RepositoryReadOnly_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - ctx context.Context +// - id *uint +// - out db_repo.ModelBased +func (_e *RepositoryReadOnly_Expecter) Read(ctx interface{}, id interface{}, out interface{}) *RepositoryReadOnly_Read_Call { + return &RepositoryReadOnly_Read_Call{Call: _e.mock.On("Read", ctx, id, out)} +} + +func (_c *RepositoryReadOnly_Read_Call) Run(run func(ctx context.Context, id *uint, out db_repo.ModelBased)) *RepositoryReadOnly_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*uint), args[2].(db_repo.ModelBased)) + }) + return _c +} + +func (_c *RepositoryReadOnly_Read_Call) Return(_a0 error) *RepositoryReadOnly_Read_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RepositoryReadOnly_Read_Call) RunAndReturn(run func(context.Context, *uint, db_repo.ModelBased) error) *RepositoryReadOnly_Read_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRepositoryReadOnly interface { mock.TestingT Cleanup(func()) diff --git a/pkg/db-repo/mocks/TimeStampable.go b/pkg/db-repo/mocks/TimeStampable.go index 348d163b1..6d3aff4a6 100644 --- a/pkg/db-repo/mocks/TimeStampable.go +++ b/pkg/db-repo/mocks/TimeStampable.go @@ -13,16 +13,80 @@ type TimeStampable struct { mock.Mock } +type TimeStampable_Expecter struct { + mock *mock.Mock +} + +func (_m *TimeStampable) EXPECT() *TimeStampable_Expecter { + return &TimeStampable_Expecter{mock: &_m.Mock} +} + // SetCreatedAt provides a mock function with given fields: createdAt func (_m *TimeStampable) SetCreatedAt(createdAt *time.Time) { _m.Called(createdAt) } +// TimeStampable_SetCreatedAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCreatedAt' +type TimeStampable_SetCreatedAt_Call struct { + *mock.Call +} + +// SetCreatedAt is a helper method to define mock.On call +// - createdAt *time.Time +func (_e *TimeStampable_Expecter) SetCreatedAt(createdAt interface{}) *TimeStampable_SetCreatedAt_Call { + return &TimeStampable_SetCreatedAt_Call{Call: _e.mock.On("SetCreatedAt", createdAt)} +} + +func (_c *TimeStampable_SetCreatedAt_Call) Run(run func(createdAt *time.Time)) *TimeStampable_SetCreatedAt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*time.Time)) + }) + return _c +} + +func (_c *TimeStampable_SetCreatedAt_Call) Return() *TimeStampable_SetCreatedAt_Call { + _c.Call.Return() + return _c +} + +func (_c *TimeStampable_SetCreatedAt_Call) RunAndReturn(run func(*time.Time)) *TimeStampable_SetCreatedAt_Call { + _c.Call.Return(run) + return _c +} + // SetUpdatedAt provides a mock function with given fields: updatedAt func (_m *TimeStampable) SetUpdatedAt(updatedAt *time.Time) { _m.Called(updatedAt) } +// TimeStampable_SetUpdatedAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUpdatedAt' +type TimeStampable_SetUpdatedAt_Call struct { + *mock.Call +} + +// SetUpdatedAt is a helper method to define mock.On call +// - updatedAt *time.Time +func (_e *TimeStampable_Expecter) SetUpdatedAt(updatedAt interface{}) *TimeStampable_SetUpdatedAt_Call { + return &TimeStampable_SetUpdatedAt_Call{Call: _e.mock.On("SetUpdatedAt", updatedAt)} +} + +func (_c *TimeStampable_SetUpdatedAt_Call) Run(run func(updatedAt *time.Time)) *TimeStampable_SetUpdatedAt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*time.Time)) + }) + return _c +} + +func (_c *TimeStampable_SetUpdatedAt_Call) Return() *TimeStampable_SetUpdatedAt_Call { + _c.Call.Return() + return _c +} + +func (_c *TimeStampable_SetUpdatedAt_Call) RunAndReturn(run func(*time.Time)) *TimeStampable_SetUpdatedAt_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTimeStampable interface { mock.TestingT Cleanup(func()) diff --git a/pkg/db/mocks/Client.go b/pkg/db/mocks/Client.go index 36b8a8d49..c28806411 100644 --- a/pkg/db/mocks/Client.go +++ b/pkg/db/mocks/Client.go @@ -18,6 +18,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // Exec provides a mock function with given fields: ctx, query, args func (_m *Client) Exec(ctx context.Context, query string, args ...interface{}) (sql.Result, error) { var _ca []interface{} @@ -47,6 +55,43 @@ func (_m *Client) Exec(ctx context.Context, query string, args ...interface{}) ( return r0, r1 } +// Client_Exec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exec' +type Client_Exec_Call struct { + *mock.Call +} + +// Exec is a helper method to define mock.On call +// - ctx context.Context +// - query string +// - args ...interface{} +func (_e *Client_Expecter) Exec(ctx interface{}, query interface{}, args ...interface{}) *Client_Exec_Call { + return &Client_Exec_Call{Call: _e.mock.On("Exec", + append([]interface{}{ctx, query}, args...)...)} +} + +func (_c *Client_Exec_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Client_Exec_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 *Client_Exec_Call) Return(_a0 sql.Result, _a1 error) *Client_Exec_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Exec_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (sql.Result, error)) *Client_Exec_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: ctx, dest, query, args func (_m *Client) Get(ctx context.Context, dest interface{}, query string, args ...interface{}) error { var _ca []interface{} @@ -64,6 +109,44 @@ func (_m *Client) Get(ctx context.Context, dest interface{}, query string, args return r0 } +// Client_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Client_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - dest interface{} +// - query string +// - args ...interface{} +func (_e *Client_Expecter) Get(ctx interface{}, dest interface{}, query interface{}, args ...interface{}) *Client_Get_Call { + return &Client_Get_Call{Call: _e.mock.On("Get", + append([]interface{}{ctx, dest, query}, args...)...)} +} + +func (_c *Client_Get_Call) Run(run func(ctx context.Context, dest interface{}, query string, args ...interface{})) *Client_Get_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].(interface{}), args[2].(string), variadicArgs...) + }) + return _c +} + +func (_c *Client_Get_Call) Return(_a0 error) *Client_Get_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_Get_Call) RunAndReturn(run func(context.Context, interface{}, string, ...interface{}) error) *Client_Get_Call { + _c.Call.Return(run) + return _c +} + // GetResult provides a mock function with given fields: ctx, query, args func (_m *Client) GetResult(ctx context.Context, query string, args ...interface{}) (*db.Result, error) { var _ca []interface{} @@ -93,6 +176,43 @@ func (_m *Client) GetResult(ctx context.Context, query string, args ...interface return r0, r1 } +// Client_GetResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResult' +type Client_GetResult_Call struct { + *mock.Call +} + +// GetResult is a helper method to define mock.On call +// - ctx context.Context +// - query string +// - args ...interface{} +func (_e *Client_Expecter) GetResult(ctx interface{}, query interface{}, args ...interface{}) *Client_GetResult_Call { + return &Client_GetResult_Call{Call: _e.mock.On("GetResult", + append([]interface{}{ctx, query}, args...)...)} +} + +func (_c *Client_GetResult_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Client_GetResult_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 *Client_GetResult_Call) Return(_a0 *db.Result, _a1 error) *Client_GetResult_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetResult_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (*db.Result, error)) *Client_GetResult_Call { + _c.Call.Return(run) + return _c +} + // GetSingleScalarValue provides a mock function with given fields: ctx, query, args func (_m *Client) GetSingleScalarValue(ctx context.Context, query string, args ...interface{}) (int, error) { var _ca []interface{} @@ -120,6 +240,43 @@ func (_m *Client) GetSingleScalarValue(ctx context.Context, query string, args . return r0, r1 } +// Client_GetSingleScalarValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSingleScalarValue' +type Client_GetSingleScalarValue_Call struct { + *mock.Call +} + +// GetSingleScalarValue is a helper method to define mock.On call +// - ctx context.Context +// - query string +// - args ...interface{} +func (_e *Client_Expecter) GetSingleScalarValue(ctx interface{}, query interface{}, args ...interface{}) *Client_GetSingleScalarValue_Call { + return &Client_GetSingleScalarValue_Call{Call: _e.mock.On("GetSingleScalarValue", + append([]interface{}{ctx, query}, args...)...)} +} + +func (_c *Client_GetSingleScalarValue_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Client_GetSingleScalarValue_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 *Client_GetSingleScalarValue_Call) Return(_a0 int, _a1 error) *Client_GetSingleScalarValue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetSingleScalarValue_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (int, error)) *Client_GetSingleScalarValue_Call { + _c.Call.Return(run) + return _c +} + // Prepare provides a mock function with given fields: ctx, query func (_m *Client) Prepare(ctx context.Context, query string) (*sql.Stmt, error) { ret := _m.Called(ctx, query) @@ -146,6 +303,35 @@ func (_m *Client) Prepare(ctx context.Context, query string) (*sql.Stmt, error) return r0, r1 } +// Client_Prepare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prepare' +type Client_Prepare_Call struct { + *mock.Call +} + +// Prepare is a helper method to define mock.On call +// - ctx context.Context +// - query string +func (_e *Client_Expecter) Prepare(ctx interface{}, query interface{}) *Client_Prepare_Call { + return &Client_Prepare_Call{Call: _e.mock.On("Prepare", ctx, query)} +} + +func (_c *Client_Prepare_Call) Run(run func(ctx context.Context, query string)) *Client_Prepare_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_Prepare_Call) Return(_a0 *sql.Stmt, _a1 error) *Client_Prepare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Prepare_Call) RunAndReturn(run func(context.Context, string) (*sql.Stmt, error)) *Client_Prepare_Call { + _c.Call.Return(run) + return _c +} + // Query provides a mock function with given fields: ctx, query, args func (_m *Client) Query(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) { var _ca []interface{} @@ -175,6 +361,43 @@ func (_m *Client) Query(ctx context.Context, query string, args ...interface{}) return r0, r1 } +// Client_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' +type Client_Query_Call struct { + *mock.Call +} + +// Query is a helper method to define mock.On call +// - ctx context.Context +// - query string +// - args ...interface{} +func (_e *Client_Expecter) Query(ctx interface{}, query interface{}, args ...interface{}) *Client_Query_Call { + return &Client_Query_Call{Call: _e.mock.On("Query", + append([]interface{}{ctx, query}, args...)...)} +} + +func (_c *Client_Query_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Client_Query_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 *Client_Query_Call) Return(_a0 *sql.Rows, _a1 error) *Client_Query_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Query_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (*sql.Rows, error)) *Client_Query_Call { + _c.Call.Return(run) + return _c +} + // QueryRow provides a mock function with given fields: ctx, query, args func (_m *Client) QueryRow(ctx context.Context, query string, args ...interface{}) *sql.Row { var _ca []interface{} @@ -194,6 +417,43 @@ func (_m *Client) QueryRow(ctx context.Context, query string, args ...interface{ return r0 } +// Client_QueryRow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryRow' +type Client_QueryRow_Call struct { + *mock.Call +} + +// QueryRow is a helper method to define mock.On call +// - ctx context.Context +// - query string +// - args ...interface{} +func (_e *Client_Expecter) QueryRow(ctx interface{}, query interface{}, args ...interface{}) *Client_QueryRow_Call { + return &Client_QueryRow_Call{Call: _e.mock.On("QueryRow", + append([]interface{}{ctx, query}, args...)...)} +} + +func (_c *Client_QueryRow_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Client_QueryRow_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 *Client_QueryRow_Call) Return(_a0 *sql.Row) *Client_QueryRow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_QueryRow_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *sql.Row) *Client_QueryRow_Call { + _c.Call.Return(run) + return _c +} + // Queryx provides a mock function with given fields: ctx, query, args func (_m *Client) Queryx(ctx context.Context, query string, args ...interface{}) (*sqlx.Rows, error) { var _ca []interface{} @@ -223,6 +483,43 @@ func (_m *Client) Queryx(ctx context.Context, query string, args ...interface{}) return r0, r1 } +// Client_Queryx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Queryx' +type Client_Queryx_Call struct { + *mock.Call +} + +// Queryx is a helper method to define mock.On call +// - ctx context.Context +// - query string +// - args ...interface{} +func (_e *Client_Expecter) Queryx(ctx interface{}, query interface{}, args ...interface{}) *Client_Queryx_Call { + return &Client_Queryx_Call{Call: _e.mock.On("Queryx", + append([]interface{}{ctx, query}, args...)...)} +} + +func (_c *Client_Queryx_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Client_Queryx_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 *Client_Queryx_Call) Return(_a0 *sqlx.Rows, _a1 error) *Client_Queryx_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Queryx_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (*sqlx.Rows, error)) *Client_Queryx_Call { + _c.Call.Return(run) + return _c +} + // Select provides a mock function with given fields: ctx, dest, query, args func (_m *Client) Select(ctx context.Context, dest interface{}, query string, args ...interface{}) error { var _ca []interface{} @@ -240,6 +537,44 @@ func (_m *Client) Select(ctx context.Context, dest interface{}, query string, ar return r0 } +// Client_Select_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Select' +type Client_Select_Call struct { + *mock.Call +} + +// Select is a helper method to define mock.On call +// - ctx context.Context +// - dest interface{} +// - query string +// - args ...interface{} +func (_e *Client_Expecter) Select(ctx interface{}, dest interface{}, query interface{}, args ...interface{}) *Client_Select_Call { + return &Client_Select_Call{Call: _e.mock.On("Select", + append([]interface{}{ctx, dest, query}, args...)...)} +} + +func (_c *Client_Select_Call) Run(run func(ctx context.Context, dest interface{}, query string, args ...interface{})) *Client_Select_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].(interface{}), args[2].(string), variadicArgs...) + }) + return _c +} + +func (_c *Client_Select_Call) Return(_a0 error) *Client_Select_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_Select_Call) RunAndReturn(run func(context.Context, interface{}, string, ...interface{}) error) *Client_Select_Call { + _c.Call.Return(run) + return _c +} + // WithTx provides a mock function with given fields: ctx, ops, do func (_m *Client) WithTx(ctx context.Context, ops *sql.TxOptions, do func(context.Context, *sql.Tx) error) error { ret := _m.Called(ctx, ops, do) @@ -254,6 +589,36 @@ func (_m *Client) WithTx(ctx context.Context, ops *sql.TxOptions, do func(contex return r0 } +// Client_WithTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithTx' +type Client_WithTx_Call struct { + *mock.Call +} + +// WithTx is a helper method to define mock.On call +// - ctx context.Context +// - ops *sql.TxOptions +// - do func(context.Context , *sql.Tx) error +func (_e *Client_Expecter) WithTx(ctx interface{}, ops interface{}, do interface{}) *Client_WithTx_Call { + return &Client_WithTx_Call{Call: _e.mock.On("WithTx", ctx, ops, do)} +} + +func (_c *Client_WithTx_Call) Run(run func(ctx context.Context, ops *sql.TxOptions, do func(context.Context, *sql.Tx) error)) *Client_WithTx_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*sql.TxOptions), args[2].(func(context.Context, *sql.Tx) error)) + }) + return _c +} + +func (_c *Client_WithTx_Call) Return(_a0 error) *Client_WithTx_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_WithTx_Call) RunAndReturn(run func(context.Context, *sql.TxOptions, func(context.Context, *sql.Tx) error) error) *Client_WithTx_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/db/mocks/QueryBuilder.go b/pkg/db/mocks/QueryBuilder.go index 6789a4db5..7de274fd6 100644 --- a/pkg/db/mocks/QueryBuilder.go +++ b/pkg/db/mocks/QueryBuilder.go @@ -12,6 +12,14 @@ type QueryBuilder struct { mock.Mock } +type QueryBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *QueryBuilder) EXPECT() *QueryBuilder_Expecter { + return &QueryBuilder_Expecter{mock: &_m.Mock} +} + // GroupBy provides a mock function with given fields: field func (_m *QueryBuilder) GroupBy(field ...string) db.QueryBuilder { _va := make([]interface{}, len(field)) @@ -34,6 +42,41 @@ func (_m *QueryBuilder) GroupBy(field ...string) db.QueryBuilder { return r0 } +// QueryBuilder_GroupBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupBy' +type QueryBuilder_GroupBy_Call struct { + *mock.Call +} + +// GroupBy is a helper method to define mock.On call +// - field ...string +func (_e *QueryBuilder_Expecter) GroupBy(field ...interface{}) *QueryBuilder_GroupBy_Call { + return &QueryBuilder_GroupBy_Call{Call: _e.mock.On("GroupBy", + append([]interface{}{}, field...)...)} +} + +func (_c *QueryBuilder_GroupBy_Call) Run(run func(field ...string)) *QueryBuilder_GroupBy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *QueryBuilder_GroupBy_Call) Return(_a0 db.QueryBuilder) *QueryBuilder_GroupBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_GroupBy_Call) RunAndReturn(run func(...string) db.QueryBuilder) *QueryBuilder_GroupBy_Call { + _c.Call.Return(run) + return _c +} + // Joins provides a mock function with given fields: joins func (_m *QueryBuilder) Joins(joins []string) db.QueryBuilder { ret := _m.Called(joins) @@ -50,6 +93,34 @@ func (_m *QueryBuilder) Joins(joins []string) db.QueryBuilder { return r0 } +// QueryBuilder_Joins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Joins' +type QueryBuilder_Joins_Call struct { + *mock.Call +} + +// Joins is a helper method to define mock.On call +// - joins []string +func (_e *QueryBuilder_Expecter) Joins(joins interface{}) *QueryBuilder_Joins_Call { + return &QueryBuilder_Joins_Call{Call: _e.mock.On("Joins", joins)} +} + +func (_c *QueryBuilder_Joins_Call) Run(run func(joins []string)) *QueryBuilder_Joins_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]string)) + }) + return _c +} + +func (_c *QueryBuilder_Joins_Call) Return(_a0 db.QueryBuilder) *QueryBuilder_Joins_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_Joins_Call) RunAndReturn(run func([]string) db.QueryBuilder) *QueryBuilder_Joins_Call { + _c.Call.Return(run) + return _c +} + // OrderBy provides a mock function with given fields: field, direction func (_m *QueryBuilder) OrderBy(field string, direction string) db.QueryBuilder { ret := _m.Called(field, direction) @@ -66,6 +137,35 @@ func (_m *QueryBuilder) OrderBy(field string, direction string) db.QueryBuilder return r0 } +// QueryBuilder_OrderBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrderBy' +type QueryBuilder_OrderBy_Call struct { + *mock.Call +} + +// OrderBy is a helper method to define mock.On call +// - field string +// - direction string +func (_e *QueryBuilder_Expecter) OrderBy(field interface{}, direction interface{}) *QueryBuilder_OrderBy_Call { + return &QueryBuilder_OrderBy_Call{Call: _e.mock.On("OrderBy", field, direction)} +} + +func (_c *QueryBuilder_OrderBy_Call) Run(run func(field string, direction string)) *QueryBuilder_OrderBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *QueryBuilder_OrderBy_Call) Return(_a0 db.QueryBuilder) *QueryBuilder_OrderBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_OrderBy_Call) RunAndReturn(run func(string, string) db.QueryBuilder) *QueryBuilder_OrderBy_Call { + _c.Call.Return(run) + return _c +} + // Page provides a mock function with given fields: offset, size func (_m *QueryBuilder) Page(offset int, size int) db.QueryBuilder { ret := _m.Called(offset, size) @@ -82,6 +182,35 @@ func (_m *QueryBuilder) Page(offset int, size int) db.QueryBuilder { return r0 } +// QueryBuilder_Page_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Page' +type QueryBuilder_Page_Call struct { + *mock.Call +} + +// Page is a helper method to define mock.On call +// - offset int +// - size int +func (_e *QueryBuilder_Expecter) Page(offset interface{}, size interface{}) *QueryBuilder_Page_Call { + return &QueryBuilder_Page_Call{Call: _e.mock.On("Page", offset, size)} +} + +func (_c *QueryBuilder_Page_Call) Run(run func(offset int, size int)) *QueryBuilder_Page_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(int)) + }) + return _c +} + +func (_c *QueryBuilder_Page_Call) Return(_a0 db.QueryBuilder) *QueryBuilder_Page_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_Page_Call) RunAndReturn(run func(int, int) db.QueryBuilder) *QueryBuilder_Page_Call { + _c.Call.Return(run) + return _c +} + // Table provides a mock function with given fields: table func (_m *QueryBuilder) Table(table string) db.QueryBuilder { ret := _m.Called(table) @@ -98,6 +227,34 @@ func (_m *QueryBuilder) Table(table string) db.QueryBuilder { return r0 } +// QueryBuilder_Table_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Table' +type QueryBuilder_Table_Call struct { + *mock.Call +} + +// Table is a helper method to define mock.On call +// - table string +func (_e *QueryBuilder_Expecter) Table(table interface{}) *QueryBuilder_Table_Call { + return &QueryBuilder_Table_Call{Call: _e.mock.On("Table", table)} +} + +func (_c *QueryBuilder_Table_Call) Run(run func(table string)) *QueryBuilder_Table_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *QueryBuilder_Table_Call) Return(_a0 db.QueryBuilder) *QueryBuilder_Table_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_Table_Call) RunAndReturn(run func(string) db.QueryBuilder) *QueryBuilder_Table_Call { + _c.Call.Return(run) + return _c +} + // Where provides a mock function with given fields: query, args func (_m *QueryBuilder) Where(query interface{}, args ...interface{}) db.QueryBuilder { var _ca []interface{} @@ -117,6 +274,42 @@ func (_m *QueryBuilder) Where(query interface{}, args ...interface{}) db.QueryBu return r0 } +// QueryBuilder_Where_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Where' +type QueryBuilder_Where_Call struct { + *mock.Call +} + +// Where is a helper method to define mock.On call +// - query interface{} +// - args ...interface{} +func (_e *QueryBuilder_Expecter) Where(query interface{}, args ...interface{}) *QueryBuilder_Where_Call { + return &QueryBuilder_Where_Call{Call: _e.mock.On("Where", + append([]interface{}{query}, args...)...)} +} + +func (_c *QueryBuilder_Where_Call) Run(run func(query interface{}, args ...interface{})) *QueryBuilder_Where_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].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *QueryBuilder_Where_Call) Return(_a0 db.QueryBuilder) *QueryBuilder_Where_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_Where_Call) RunAndReturn(run func(interface{}, ...interface{}) db.QueryBuilder) *QueryBuilder_Where_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewQueryBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/db/mocks/SqlResult.go b/pkg/db/mocks/SqlResult.go index 1f9a2f180..0fa203bb7 100644 --- a/pkg/db/mocks/SqlResult.go +++ b/pkg/db/mocks/SqlResult.go @@ -9,6 +9,14 @@ type SqlResult struct { mock.Mock } +type SqlResult_Expecter struct { + mock *mock.Mock +} + +func (_m *SqlResult) EXPECT() *SqlResult_Expecter { + return &SqlResult_Expecter{mock: &_m.Mock} +} + // LastInsertId provides a mock function with given fields: func (_m *SqlResult) LastInsertId() (int64, error) { ret := _m.Called() @@ -33,6 +41,33 @@ func (_m *SqlResult) LastInsertId() (int64, error) { return r0, r1 } +// SqlResult_LastInsertId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastInsertId' +type SqlResult_LastInsertId_Call struct { + *mock.Call +} + +// LastInsertId is a helper method to define mock.On call +func (_e *SqlResult_Expecter) LastInsertId() *SqlResult_LastInsertId_Call { + return &SqlResult_LastInsertId_Call{Call: _e.mock.On("LastInsertId")} +} + +func (_c *SqlResult_LastInsertId_Call) Run(run func()) *SqlResult_LastInsertId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SqlResult_LastInsertId_Call) Return(_a0 int64, _a1 error) *SqlResult_LastInsertId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SqlResult_LastInsertId_Call) RunAndReturn(run func() (int64, error)) *SqlResult_LastInsertId_Call { + _c.Call.Return(run) + return _c +} + // RowsAffected provides a mock function with given fields: func (_m *SqlResult) RowsAffected() (int64, error) { ret := _m.Called() @@ -57,6 +92,33 @@ func (_m *SqlResult) RowsAffected() (int64, error) { return r0, r1 } +// SqlResult_RowsAffected_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RowsAffected' +type SqlResult_RowsAffected_Call struct { + *mock.Call +} + +// RowsAffected is a helper method to define mock.On call +func (_e *SqlResult_Expecter) RowsAffected() *SqlResult_RowsAffected_Call { + return &SqlResult_RowsAffected_Call{Call: _e.mock.On("RowsAffected")} +} + +func (_c *SqlResult_RowsAffected_Call) Run(run func()) *SqlResult_RowsAffected_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SqlResult_RowsAffected_Call) Return(_a0 int64, _a1 error) *SqlResult_RowsAffected_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SqlResult_RowsAffected_Call) RunAndReturn(run func() (int64, error)) *SqlResult_RowsAffected_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewSqlResult interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/BatchGetItemsBuilder.go b/pkg/ddb/mocks/BatchGetItemsBuilder.go index cbc18df69..76386d738 100644 --- a/pkg/ddb/mocks/BatchGetItemsBuilder.go +++ b/pkg/ddb/mocks/BatchGetItemsBuilder.go @@ -14,6 +14,14 @@ type BatchGetItemsBuilder struct { mock.Mock } +type BatchGetItemsBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *BatchGetItemsBuilder) EXPECT() *BatchGetItemsBuilder_Expecter { + return &BatchGetItemsBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: result func (_m *BatchGetItemsBuilder) Build(result interface{}) (*dynamodb.BatchGetItemInput, error) { ret := _m.Called(result) @@ -40,6 +48,34 @@ func (_m *BatchGetItemsBuilder) Build(result interface{}) (*dynamodb.BatchGetIte return r0, r1 } +// BatchGetItemsBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type BatchGetItemsBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +// - result interface{} +func (_e *BatchGetItemsBuilder_Expecter) Build(result interface{}) *BatchGetItemsBuilder_Build_Call { + return &BatchGetItemsBuilder_Build_Call{Call: _e.mock.On("Build", result)} +} + +func (_c *BatchGetItemsBuilder_Build_Call) Run(run func(result interface{})) *BatchGetItemsBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *BatchGetItemsBuilder_Build_Call) Return(_a0 *dynamodb.BatchGetItemInput, _a1 error) *BatchGetItemsBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *BatchGetItemsBuilder_Build_Call) RunAndReturn(run func(interface{}) (*dynamodb.BatchGetItemInput, error)) *BatchGetItemsBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // DisableTtlFilter provides a mock function with given fields: func (_m *BatchGetItemsBuilder) DisableTtlFilter() ddb.BatchGetItemsBuilder { ret := _m.Called() @@ -56,6 +92,33 @@ func (_m *BatchGetItemsBuilder) DisableTtlFilter() ddb.BatchGetItemsBuilder { return r0 } +// BatchGetItemsBuilder_DisableTtlFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableTtlFilter' +type BatchGetItemsBuilder_DisableTtlFilter_Call struct { + *mock.Call +} + +// DisableTtlFilter is a helper method to define mock.On call +func (_e *BatchGetItemsBuilder_Expecter) DisableTtlFilter() *BatchGetItemsBuilder_DisableTtlFilter_Call { + return &BatchGetItemsBuilder_DisableTtlFilter_Call{Call: _e.mock.On("DisableTtlFilter")} +} + +func (_c *BatchGetItemsBuilder_DisableTtlFilter_Call) Run(run func()) *BatchGetItemsBuilder_DisableTtlFilter_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *BatchGetItemsBuilder_DisableTtlFilter_Call) Return(_a0 ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_DisableTtlFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BatchGetItemsBuilder_DisableTtlFilter_Call) RunAndReturn(run func() ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_DisableTtlFilter_Call { + _c.Call.Return(run) + return _c +} + // WithConsistentRead provides a mock function with given fields: consistentRead func (_m *BatchGetItemsBuilder) WithConsistentRead(consistentRead bool) ddb.BatchGetItemsBuilder { ret := _m.Called(consistentRead) @@ -72,6 +135,34 @@ func (_m *BatchGetItemsBuilder) WithConsistentRead(consistentRead bool) ddb.Batc return r0 } +// BatchGetItemsBuilder_WithConsistentRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithConsistentRead' +type BatchGetItemsBuilder_WithConsistentRead_Call struct { + *mock.Call +} + +// WithConsistentRead is a helper method to define mock.On call +// - consistentRead bool +func (_e *BatchGetItemsBuilder_Expecter) WithConsistentRead(consistentRead interface{}) *BatchGetItemsBuilder_WithConsistentRead_Call { + return &BatchGetItemsBuilder_WithConsistentRead_Call{Call: _e.mock.On("WithConsistentRead", consistentRead)} +} + +func (_c *BatchGetItemsBuilder_WithConsistentRead_Call) Run(run func(consistentRead bool)) *BatchGetItemsBuilder_WithConsistentRead_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *BatchGetItemsBuilder_WithConsistentRead_Call) Return(_a0 ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithConsistentRead_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BatchGetItemsBuilder_WithConsistentRead_Call) RunAndReturn(run func(bool) ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithConsistentRead_Call { + _c.Call.Return(run) + return _c +} + // WithHashKeys provides a mock function with given fields: hashKeys func (_m *BatchGetItemsBuilder) WithHashKeys(hashKeys interface{}) ddb.BatchGetItemsBuilder { ret := _m.Called(hashKeys) @@ -88,6 +179,34 @@ func (_m *BatchGetItemsBuilder) WithHashKeys(hashKeys interface{}) ddb.BatchGetI return r0 } +// BatchGetItemsBuilder_WithHashKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithHashKeys' +type BatchGetItemsBuilder_WithHashKeys_Call struct { + *mock.Call +} + +// WithHashKeys is a helper method to define mock.On call +// - hashKeys interface{} +func (_e *BatchGetItemsBuilder_Expecter) WithHashKeys(hashKeys interface{}) *BatchGetItemsBuilder_WithHashKeys_Call { + return &BatchGetItemsBuilder_WithHashKeys_Call{Call: _e.mock.On("WithHashKeys", hashKeys)} +} + +func (_c *BatchGetItemsBuilder_WithHashKeys_Call) Run(run func(hashKeys interface{})) *BatchGetItemsBuilder_WithHashKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *BatchGetItemsBuilder_WithHashKeys_Call) Return(_a0 ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithHashKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BatchGetItemsBuilder_WithHashKeys_Call) RunAndReturn(run func(interface{}) ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithHashKeys_Call { + _c.Call.Return(run) + return _c +} + // WithKeyPairs provides a mock function with given fields: pairs func (_m *BatchGetItemsBuilder) WithKeyPairs(pairs [][]interface{}) ddb.BatchGetItemsBuilder { ret := _m.Called(pairs) @@ -104,6 +223,34 @@ func (_m *BatchGetItemsBuilder) WithKeyPairs(pairs [][]interface{}) ddb.BatchGet return r0 } +// BatchGetItemsBuilder_WithKeyPairs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithKeyPairs' +type BatchGetItemsBuilder_WithKeyPairs_Call struct { + *mock.Call +} + +// WithKeyPairs is a helper method to define mock.On call +// - pairs [][]interface{} +func (_e *BatchGetItemsBuilder_Expecter) WithKeyPairs(pairs interface{}) *BatchGetItemsBuilder_WithKeyPairs_Call { + return &BatchGetItemsBuilder_WithKeyPairs_Call{Call: _e.mock.On("WithKeyPairs", pairs)} +} + +func (_c *BatchGetItemsBuilder_WithKeyPairs_Call) Run(run func(pairs [][]interface{})) *BatchGetItemsBuilder_WithKeyPairs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([][]interface{})) + }) + return _c +} + +func (_c *BatchGetItemsBuilder_WithKeyPairs_Call) Return(_a0 ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithKeyPairs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BatchGetItemsBuilder_WithKeyPairs_Call) RunAndReturn(run func([][]interface{}) ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithKeyPairs_Call { + _c.Call.Return(run) + return _c +} + // WithKeys provides a mock function with given fields: values func (_m *BatchGetItemsBuilder) WithKeys(values ...interface{}) ddb.BatchGetItemsBuilder { var _ca []interface{} @@ -122,6 +269,41 @@ func (_m *BatchGetItemsBuilder) WithKeys(values ...interface{}) ddb.BatchGetItem return r0 } +// BatchGetItemsBuilder_WithKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithKeys' +type BatchGetItemsBuilder_WithKeys_Call struct { + *mock.Call +} + +// WithKeys is a helper method to define mock.On call +// - values ...interface{} +func (_e *BatchGetItemsBuilder_Expecter) WithKeys(values ...interface{}) *BatchGetItemsBuilder_WithKeys_Call { + return &BatchGetItemsBuilder_WithKeys_Call{Call: _e.mock.On("WithKeys", + append([]interface{}{}, values...)...)} +} + +func (_c *BatchGetItemsBuilder_WithKeys_Call) Run(run func(values ...interface{})) *BatchGetItemsBuilder_WithKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *BatchGetItemsBuilder_WithKeys_Call) Return(_a0 ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BatchGetItemsBuilder_WithKeys_Call) RunAndReturn(run func(...interface{}) ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithKeys_Call { + _c.Call.Return(run) + return _c +} + // WithProjection provides a mock function with given fields: projection func (_m *BatchGetItemsBuilder) WithProjection(projection interface{}) ddb.BatchGetItemsBuilder { ret := _m.Called(projection) @@ -138,6 +320,34 @@ func (_m *BatchGetItemsBuilder) WithProjection(projection interface{}) ddb.Batch return r0 } +// BatchGetItemsBuilder_WithProjection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithProjection' +type BatchGetItemsBuilder_WithProjection_Call struct { + *mock.Call +} + +// WithProjection is a helper method to define mock.On call +// - projection interface{} +func (_e *BatchGetItemsBuilder_Expecter) WithProjection(projection interface{}) *BatchGetItemsBuilder_WithProjection_Call { + return &BatchGetItemsBuilder_WithProjection_Call{Call: _e.mock.On("WithProjection", projection)} +} + +func (_c *BatchGetItemsBuilder_WithProjection_Call) Run(run func(projection interface{})) *BatchGetItemsBuilder_WithProjection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *BatchGetItemsBuilder_WithProjection_Call) Return(_a0 ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithProjection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BatchGetItemsBuilder_WithProjection_Call) RunAndReturn(run func(interface{}) ddb.BatchGetItemsBuilder) *BatchGetItemsBuilder_WithProjection_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewBatchGetItemsBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/ConditionCheckBuilder.go b/pkg/ddb/mocks/ConditionCheckBuilder.go index caae80464..e41a5fa17 100644 --- a/pkg/ddb/mocks/ConditionCheckBuilder.go +++ b/pkg/ddb/mocks/ConditionCheckBuilder.go @@ -15,6 +15,14 @@ type ConditionCheckBuilder struct { mock.Mock } +type ConditionCheckBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *ConditionCheckBuilder) EXPECT() *ConditionCheckBuilder_Expecter { + return &ConditionCheckBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: result func (_m *ConditionCheckBuilder) Build(result interface{}) (*types.ConditionCheck, error) { ret := _m.Called(result) @@ -41,6 +49,34 @@ func (_m *ConditionCheckBuilder) Build(result interface{}) (*types.ConditionChec return r0, r1 } +// ConditionCheckBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type ConditionCheckBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +// - result interface{} +func (_e *ConditionCheckBuilder_Expecter) Build(result interface{}) *ConditionCheckBuilder_Build_Call { + return &ConditionCheckBuilder_Build_Call{Call: _e.mock.On("Build", result)} +} + +func (_c *ConditionCheckBuilder_Build_Call) Run(run func(result interface{})) *ConditionCheckBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *ConditionCheckBuilder_Build_Call) Return(_a0 *types.ConditionCheck, _a1 error) *ConditionCheckBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ConditionCheckBuilder_Build_Call) RunAndReturn(run func(interface{}) (*types.ConditionCheck, error)) *ConditionCheckBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // ReturnAllOld provides a mock function with given fields: func (_m *ConditionCheckBuilder) ReturnAllOld() ddb.ConditionCheckBuilder { ret := _m.Called() @@ -57,6 +93,33 @@ func (_m *ConditionCheckBuilder) ReturnAllOld() ddb.ConditionCheckBuilder { return r0 } +// ConditionCheckBuilder_ReturnAllOld_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllOld' +type ConditionCheckBuilder_ReturnAllOld_Call struct { + *mock.Call +} + +// ReturnAllOld is a helper method to define mock.On call +func (_e *ConditionCheckBuilder_Expecter) ReturnAllOld() *ConditionCheckBuilder_ReturnAllOld_Call { + return &ConditionCheckBuilder_ReturnAllOld_Call{Call: _e.mock.On("ReturnAllOld")} +} + +func (_c *ConditionCheckBuilder_ReturnAllOld_Call) Run(run func()) *ConditionCheckBuilder_ReturnAllOld_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ConditionCheckBuilder_ReturnAllOld_Call) Return(_a0 ddb.ConditionCheckBuilder) *ConditionCheckBuilder_ReturnAllOld_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ConditionCheckBuilder_ReturnAllOld_Call) RunAndReturn(run func() ddb.ConditionCheckBuilder) *ConditionCheckBuilder_ReturnAllOld_Call { + _c.Call.Return(run) + return _c +} + // ReturnNone provides a mock function with given fields: func (_m *ConditionCheckBuilder) ReturnNone() ddb.ConditionCheckBuilder { ret := _m.Called() @@ -73,6 +136,33 @@ func (_m *ConditionCheckBuilder) ReturnNone() ddb.ConditionCheckBuilder { return r0 } +// ConditionCheckBuilder_ReturnNone_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnNone' +type ConditionCheckBuilder_ReturnNone_Call struct { + *mock.Call +} + +// ReturnNone is a helper method to define mock.On call +func (_e *ConditionCheckBuilder_Expecter) ReturnNone() *ConditionCheckBuilder_ReturnNone_Call { + return &ConditionCheckBuilder_ReturnNone_Call{Call: _e.mock.On("ReturnNone")} +} + +func (_c *ConditionCheckBuilder_ReturnNone_Call) Run(run func()) *ConditionCheckBuilder_ReturnNone_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ConditionCheckBuilder_ReturnNone_Call) Return(_a0 ddb.ConditionCheckBuilder) *ConditionCheckBuilder_ReturnNone_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ConditionCheckBuilder_ReturnNone_Call) RunAndReturn(run func() ddb.ConditionCheckBuilder) *ConditionCheckBuilder_ReturnNone_Call { + _c.Call.Return(run) + return _c +} + // WithCondition provides a mock function with given fields: cond func (_m *ConditionCheckBuilder) WithCondition(cond expression.ConditionBuilder) ddb.ConditionCheckBuilder { ret := _m.Called(cond) @@ -89,6 +179,34 @@ func (_m *ConditionCheckBuilder) WithCondition(cond expression.ConditionBuilder) return r0 } +// ConditionCheckBuilder_WithCondition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithCondition' +type ConditionCheckBuilder_WithCondition_Call struct { + *mock.Call +} + +// WithCondition is a helper method to define mock.On call +// - cond expression.ConditionBuilder +func (_e *ConditionCheckBuilder_Expecter) WithCondition(cond interface{}) *ConditionCheckBuilder_WithCondition_Call { + return &ConditionCheckBuilder_WithCondition_Call{Call: _e.mock.On("WithCondition", cond)} +} + +func (_c *ConditionCheckBuilder_WithCondition_Call) Run(run func(cond expression.ConditionBuilder)) *ConditionCheckBuilder_WithCondition_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(expression.ConditionBuilder)) + }) + return _c +} + +func (_c *ConditionCheckBuilder_WithCondition_Call) Return(_a0 ddb.ConditionCheckBuilder) *ConditionCheckBuilder_WithCondition_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ConditionCheckBuilder_WithCondition_Call) RunAndReturn(run func(expression.ConditionBuilder) ddb.ConditionCheckBuilder) *ConditionCheckBuilder_WithCondition_Call { + _c.Call.Return(run) + return _c +} + // WithHash provides a mock function with given fields: hashValue func (_m *ConditionCheckBuilder) WithHash(hashValue interface{}) ddb.ConditionCheckBuilder { ret := _m.Called(hashValue) @@ -105,6 +223,34 @@ func (_m *ConditionCheckBuilder) WithHash(hashValue interface{}) ddb.ConditionCh return r0 } +// ConditionCheckBuilder_WithHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithHash' +type ConditionCheckBuilder_WithHash_Call struct { + *mock.Call +} + +// WithHash is a helper method to define mock.On call +// - hashValue interface{} +func (_e *ConditionCheckBuilder_Expecter) WithHash(hashValue interface{}) *ConditionCheckBuilder_WithHash_Call { + return &ConditionCheckBuilder_WithHash_Call{Call: _e.mock.On("WithHash", hashValue)} +} + +func (_c *ConditionCheckBuilder_WithHash_Call) Run(run func(hashValue interface{})) *ConditionCheckBuilder_WithHash_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *ConditionCheckBuilder_WithHash_Call) Return(_a0 ddb.ConditionCheckBuilder) *ConditionCheckBuilder_WithHash_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ConditionCheckBuilder_WithHash_Call) RunAndReturn(run func(interface{}) ddb.ConditionCheckBuilder) *ConditionCheckBuilder_WithHash_Call { + _c.Call.Return(run) + return _c +} + // WithKeys provides a mock function with given fields: keys func (_m *ConditionCheckBuilder) WithKeys(keys ...interface{}) ddb.ConditionCheckBuilder { var _ca []interface{} @@ -123,6 +269,41 @@ func (_m *ConditionCheckBuilder) WithKeys(keys ...interface{}) ddb.ConditionChec return r0 } +// ConditionCheckBuilder_WithKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithKeys' +type ConditionCheckBuilder_WithKeys_Call struct { + *mock.Call +} + +// WithKeys is a helper method to define mock.On call +// - keys ...interface{} +func (_e *ConditionCheckBuilder_Expecter) WithKeys(keys ...interface{}) *ConditionCheckBuilder_WithKeys_Call { + return &ConditionCheckBuilder_WithKeys_Call{Call: _e.mock.On("WithKeys", + append([]interface{}{}, keys...)...)} +} + +func (_c *ConditionCheckBuilder_WithKeys_Call) Run(run func(keys ...interface{})) *ConditionCheckBuilder_WithKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *ConditionCheckBuilder_WithKeys_Call) Return(_a0 ddb.ConditionCheckBuilder) *ConditionCheckBuilder_WithKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ConditionCheckBuilder_WithKeys_Call) RunAndReturn(run func(...interface{}) ddb.ConditionCheckBuilder) *ConditionCheckBuilder_WithKeys_Call { + _c.Call.Return(run) + return _c +} + // WithRange provides a mock function with given fields: rangeValue func (_m *ConditionCheckBuilder) WithRange(rangeValue interface{}) ddb.ConditionCheckBuilder { ret := _m.Called(rangeValue) @@ -139,6 +320,34 @@ func (_m *ConditionCheckBuilder) WithRange(rangeValue interface{}) ddb.Condition return r0 } +// ConditionCheckBuilder_WithRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRange' +type ConditionCheckBuilder_WithRange_Call struct { + *mock.Call +} + +// WithRange is a helper method to define mock.On call +// - rangeValue interface{} +func (_e *ConditionCheckBuilder_Expecter) WithRange(rangeValue interface{}) *ConditionCheckBuilder_WithRange_Call { + return &ConditionCheckBuilder_WithRange_Call{Call: _e.mock.On("WithRange", rangeValue)} +} + +func (_c *ConditionCheckBuilder_WithRange_Call) Run(run func(rangeValue interface{})) *ConditionCheckBuilder_WithRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *ConditionCheckBuilder_WithRange_Call) Return(_a0 ddb.ConditionCheckBuilder) *ConditionCheckBuilder_WithRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ConditionCheckBuilder_WithRange_Call) RunAndReturn(run func(interface{}) ddb.ConditionCheckBuilder) *ConditionCheckBuilder_WithRange_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewConditionCheckBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/DeleteItemBuilder.go b/pkg/ddb/mocks/DeleteItemBuilder.go index 6d032aca7..5ebba64b2 100644 --- a/pkg/ddb/mocks/DeleteItemBuilder.go +++ b/pkg/ddb/mocks/DeleteItemBuilder.go @@ -16,6 +16,14 @@ type DeleteItemBuilder struct { mock.Mock } +type DeleteItemBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *DeleteItemBuilder) EXPECT() *DeleteItemBuilder_Expecter { + return &DeleteItemBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: item func (_m *DeleteItemBuilder) Build(item interface{}) (*dynamodb.DeleteItemInput, error) { ret := _m.Called(item) @@ -42,6 +50,34 @@ func (_m *DeleteItemBuilder) Build(item interface{}) (*dynamodb.DeleteItemInput, return r0, r1 } +// DeleteItemBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type DeleteItemBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +// - item interface{} +func (_e *DeleteItemBuilder_Expecter) Build(item interface{}) *DeleteItemBuilder_Build_Call { + return &DeleteItemBuilder_Build_Call{Call: _e.mock.On("Build", item)} +} + +func (_c *DeleteItemBuilder_Build_Call) Run(run func(item interface{})) *DeleteItemBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *DeleteItemBuilder_Build_Call) Return(_a0 *dynamodb.DeleteItemInput, _a1 error) *DeleteItemBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *DeleteItemBuilder_Build_Call) RunAndReturn(run func(interface{}) (*dynamodb.DeleteItemInput, error)) *DeleteItemBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // ReturnAllOld provides a mock function with given fields: func (_m *DeleteItemBuilder) ReturnAllOld() ddb.DeleteItemBuilder { ret := _m.Called() @@ -58,6 +94,33 @@ func (_m *DeleteItemBuilder) ReturnAllOld() ddb.DeleteItemBuilder { return r0 } +// DeleteItemBuilder_ReturnAllOld_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllOld' +type DeleteItemBuilder_ReturnAllOld_Call struct { + *mock.Call +} + +// ReturnAllOld is a helper method to define mock.On call +func (_e *DeleteItemBuilder_Expecter) ReturnAllOld() *DeleteItemBuilder_ReturnAllOld_Call { + return &DeleteItemBuilder_ReturnAllOld_Call{Call: _e.mock.On("ReturnAllOld")} +} + +func (_c *DeleteItemBuilder_ReturnAllOld_Call) Run(run func()) *DeleteItemBuilder_ReturnAllOld_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DeleteItemBuilder_ReturnAllOld_Call) Return(_a0 ddb.DeleteItemBuilder) *DeleteItemBuilder_ReturnAllOld_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DeleteItemBuilder_ReturnAllOld_Call) RunAndReturn(run func() ddb.DeleteItemBuilder) *DeleteItemBuilder_ReturnAllOld_Call { + _c.Call.Return(run) + return _c +} + // ReturnNone provides a mock function with given fields: func (_m *DeleteItemBuilder) ReturnNone() ddb.DeleteItemBuilder { ret := _m.Called() @@ -74,6 +137,33 @@ func (_m *DeleteItemBuilder) ReturnNone() ddb.DeleteItemBuilder { return r0 } +// DeleteItemBuilder_ReturnNone_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnNone' +type DeleteItemBuilder_ReturnNone_Call struct { + *mock.Call +} + +// ReturnNone is a helper method to define mock.On call +func (_e *DeleteItemBuilder_Expecter) ReturnNone() *DeleteItemBuilder_ReturnNone_Call { + return &DeleteItemBuilder_ReturnNone_Call{Call: _e.mock.On("ReturnNone")} +} + +func (_c *DeleteItemBuilder_ReturnNone_Call) Run(run func()) *DeleteItemBuilder_ReturnNone_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DeleteItemBuilder_ReturnNone_Call) Return(_a0 ddb.DeleteItemBuilder) *DeleteItemBuilder_ReturnNone_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DeleteItemBuilder_ReturnNone_Call) RunAndReturn(run func() ddb.DeleteItemBuilder) *DeleteItemBuilder_ReturnNone_Call { + _c.Call.Return(run) + return _c +} + // WithCondition provides a mock function with given fields: cond func (_m *DeleteItemBuilder) WithCondition(cond expression.ConditionBuilder) ddb.DeleteItemBuilder { ret := _m.Called(cond) @@ -90,6 +180,34 @@ func (_m *DeleteItemBuilder) WithCondition(cond expression.ConditionBuilder) ddb return r0 } +// DeleteItemBuilder_WithCondition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithCondition' +type DeleteItemBuilder_WithCondition_Call struct { + *mock.Call +} + +// WithCondition is a helper method to define mock.On call +// - cond expression.ConditionBuilder +func (_e *DeleteItemBuilder_Expecter) WithCondition(cond interface{}) *DeleteItemBuilder_WithCondition_Call { + return &DeleteItemBuilder_WithCondition_Call{Call: _e.mock.On("WithCondition", cond)} +} + +func (_c *DeleteItemBuilder_WithCondition_Call) Run(run func(cond expression.ConditionBuilder)) *DeleteItemBuilder_WithCondition_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(expression.ConditionBuilder)) + }) + return _c +} + +func (_c *DeleteItemBuilder_WithCondition_Call) Return(_a0 ddb.DeleteItemBuilder) *DeleteItemBuilder_WithCondition_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DeleteItemBuilder_WithCondition_Call) RunAndReturn(run func(expression.ConditionBuilder) ddb.DeleteItemBuilder) *DeleteItemBuilder_WithCondition_Call { + _c.Call.Return(run) + return _c +} + // WithHash provides a mock function with given fields: hashValue func (_m *DeleteItemBuilder) WithHash(hashValue interface{}) ddb.DeleteItemBuilder { ret := _m.Called(hashValue) @@ -106,6 +224,34 @@ func (_m *DeleteItemBuilder) WithHash(hashValue interface{}) ddb.DeleteItemBuild return r0 } +// DeleteItemBuilder_WithHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithHash' +type DeleteItemBuilder_WithHash_Call struct { + *mock.Call +} + +// WithHash is a helper method to define mock.On call +// - hashValue interface{} +func (_e *DeleteItemBuilder_Expecter) WithHash(hashValue interface{}) *DeleteItemBuilder_WithHash_Call { + return &DeleteItemBuilder_WithHash_Call{Call: _e.mock.On("WithHash", hashValue)} +} + +func (_c *DeleteItemBuilder_WithHash_Call) Run(run func(hashValue interface{})) *DeleteItemBuilder_WithHash_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *DeleteItemBuilder_WithHash_Call) Return(_a0 ddb.DeleteItemBuilder) *DeleteItemBuilder_WithHash_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DeleteItemBuilder_WithHash_Call) RunAndReturn(run func(interface{}) ddb.DeleteItemBuilder) *DeleteItemBuilder_WithHash_Call { + _c.Call.Return(run) + return _c +} + // WithRange provides a mock function with given fields: rangeValue func (_m *DeleteItemBuilder) WithRange(rangeValue interface{}) ddb.DeleteItemBuilder { ret := _m.Called(rangeValue) @@ -122,6 +268,34 @@ func (_m *DeleteItemBuilder) WithRange(rangeValue interface{}) ddb.DeleteItemBui return r0 } +// DeleteItemBuilder_WithRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRange' +type DeleteItemBuilder_WithRange_Call struct { + *mock.Call +} + +// WithRange is a helper method to define mock.On call +// - rangeValue interface{} +func (_e *DeleteItemBuilder_Expecter) WithRange(rangeValue interface{}) *DeleteItemBuilder_WithRange_Call { + return &DeleteItemBuilder_WithRange_Call{Call: _e.mock.On("WithRange", rangeValue)} +} + +func (_c *DeleteItemBuilder_WithRange_Call) Run(run func(rangeValue interface{})) *DeleteItemBuilder_WithRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *DeleteItemBuilder_WithRange_Call) Return(_a0 ddb.DeleteItemBuilder) *DeleteItemBuilder_WithRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DeleteItemBuilder_WithRange_Call) RunAndReturn(run func(interface{}) ddb.DeleteItemBuilder) *DeleteItemBuilder_WithRange_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewDeleteItemBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/GetItemBuilder.go b/pkg/ddb/mocks/GetItemBuilder.go index a1e2c7c2d..f40a73e35 100644 --- a/pkg/ddb/mocks/GetItemBuilder.go +++ b/pkg/ddb/mocks/GetItemBuilder.go @@ -14,6 +14,14 @@ type GetItemBuilder struct { mock.Mock } +type GetItemBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *GetItemBuilder) EXPECT() *GetItemBuilder_Expecter { + return &GetItemBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: result func (_m *GetItemBuilder) Build(result interface{}) (*dynamodb.GetItemInput, error) { ret := _m.Called(result) @@ -40,6 +48,34 @@ func (_m *GetItemBuilder) Build(result interface{}) (*dynamodb.GetItemInput, err return r0, r1 } +// GetItemBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type GetItemBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +// - result interface{} +func (_e *GetItemBuilder_Expecter) Build(result interface{}) *GetItemBuilder_Build_Call { + return &GetItemBuilder_Build_Call{Call: _e.mock.On("Build", result)} +} + +func (_c *GetItemBuilder_Build_Call) Run(run func(result interface{})) *GetItemBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *GetItemBuilder_Build_Call) Return(_a0 *dynamodb.GetItemInput, _a1 error) *GetItemBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *GetItemBuilder_Build_Call) RunAndReturn(run func(interface{}) (*dynamodb.GetItemInput, error)) *GetItemBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // DisableTtlFilter provides a mock function with given fields: func (_m *GetItemBuilder) DisableTtlFilter() ddb.GetItemBuilder { ret := _m.Called() @@ -56,6 +92,33 @@ func (_m *GetItemBuilder) DisableTtlFilter() ddb.GetItemBuilder { return r0 } +// GetItemBuilder_DisableTtlFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableTtlFilter' +type GetItemBuilder_DisableTtlFilter_Call struct { + *mock.Call +} + +// DisableTtlFilter is a helper method to define mock.On call +func (_e *GetItemBuilder_Expecter) DisableTtlFilter() *GetItemBuilder_DisableTtlFilter_Call { + return &GetItemBuilder_DisableTtlFilter_Call{Call: _e.mock.On("DisableTtlFilter")} +} + +func (_c *GetItemBuilder_DisableTtlFilter_Call) Run(run func()) *GetItemBuilder_DisableTtlFilter_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *GetItemBuilder_DisableTtlFilter_Call) Return(_a0 ddb.GetItemBuilder) *GetItemBuilder_DisableTtlFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GetItemBuilder_DisableTtlFilter_Call) RunAndReturn(run func() ddb.GetItemBuilder) *GetItemBuilder_DisableTtlFilter_Call { + _c.Call.Return(run) + return _c +} + // WithConsistentRead provides a mock function with given fields: consistentRead func (_m *GetItemBuilder) WithConsistentRead(consistentRead bool) ddb.GetItemBuilder { ret := _m.Called(consistentRead) @@ -72,6 +135,34 @@ func (_m *GetItemBuilder) WithConsistentRead(consistentRead bool) ddb.GetItemBui return r0 } +// GetItemBuilder_WithConsistentRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithConsistentRead' +type GetItemBuilder_WithConsistentRead_Call struct { + *mock.Call +} + +// WithConsistentRead is a helper method to define mock.On call +// - consistentRead bool +func (_e *GetItemBuilder_Expecter) WithConsistentRead(consistentRead interface{}) *GetItemBuilder_WithConsistentRead_Call { + return &GetItemBuilder_WithConsistentRead_Call{Call: _e.mock.On("WithConsistentRead", consistentRead)} +} + +func (_c *GetItemBuilder_WithConsistentRead_Call) Run(run func(consistentRead bool)) *GetItemBuilder_WithConsistentRead_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *GetItemBuilder_WithConsistentRead_Call) Return(_a0 ddb.GetItemBuilder) *GetItemBuilder_WithConsistentRead_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GetItemBuilder_WithConsistentRead_Call) RunAndReturn(run func(bool) ddb.GetItemBuilder) *GetItemBuilder_WithConsistentRead_Call { + _c.Call.Return(run) + return _c +} + // WithHash provides a mock function with given fields: hashValue func (_m *GetItemBuilder) WithHash(hashValue interface{}) ddb.GetItemBuilder { ret := _m.Called(hashValue) @@ -88,6 +179,34 @@ func (_m *GetItemBuilder) WithHash(hashValue interface{}) ddb.GetItemBuilder { return r0 } +// GetItemBuilder_WithHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithHash' +type GetItemBuilder_WithHash_Call struct { + *mock.Call +} + +// WithHash is a helper method to define mock.On call +// - hashValue interface{} +func (_e *GetItemBuilder_Expecter) WithHash(hashValue interface{}) *GetItemBuilder_WithHash_Call { + return &GetItemBuilder_WithHash_Call{Call: _e.mock.On("WithHash", hashValue)} +} + +func (_c *GetItemBuilder_WithHash_Call) Run(run func(hashValue interface{})) *GetItemBuilder_WithHash_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *GetItemBuilder_WithHash_Call) Return(_a0 ddb.GetItemBuilder) *GetItemBuilder_WithHash_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GetItemBuilder_WithHash_Call) RunAndReturn(run func(interface{}) ddb.GetItemBuilder) *GetItemBuilder_WithHash_Call { + _c.Call.Return(run) + return _c +} + // WithKeys provides a mock function with given fields: keys func (_m *GetItemBuilder) WithKeys(keys ...interface{}) ddb.GetItemBuilder { var _ca []interface{} @@ -106,6 +225,41 @@ func (_m *GetItemBuilder) WithKeys(keys ...interface{}) ddb.GetItemBuilder { return r0 } +// GetItemBuilder_WithKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithKeys' +type GetItemBuilder_WithKeys_Call struct { + *mock.Call +} + +// WithKeys is a helper method to define mock.On call +// - keys ...interface{} +func (_e *GetItemBuilder_Expecter) WithKeys(keys ...interface{}) *GetItemBuilder_WithKeys_Call { + return &GetItemBuilder_WithKeys_Call{Call: _e.mock.On("WithKeys", + append([]interface{}{}, keys...)...)} +} + +func (_c *GetItemBuilder_WithKeys_Call) Run(run func(keys ...interface{})) *GetItemBuilder_WithKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *GetItemBuilder_WithKeys_Call) Return(_a0 ddb.GetItemBuilder) *GetItemBuilder_WithKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GetItemBuilder_WithKeys_Call) RunAndReturn(run func(...interface{}) ddb.GetItemBuilder) *GetItemBuilder_WithKeys_Call { + _c.Call.Return(run) + return _c +} + // WithProjection provides a mock function with given fields: rangeValue func (_m *GetItemBuilder) WithProjection(rangeValue interface{}) ddb.GetItemBuilder { ret := _m.Called(rangeValue) @@ -122,6 +276,34 @@ func (_m *GetItemBuilder) WithProjection(rangeValue interface{}) ddb.GetItemBuil return r0 } +// GetItemBuilder_WithProjection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithProjection' +type GetItemBuilder_WithProjection_Call struct { + *mock.Call +} + +// WithProjection is a helper method to define mock.On call +// - rangeValue interface{} +func (_e *GetItemBuilder_Expecter) WithProjection(rangeValue interface{}) *GetItemBuilder_WithProjection_Call { + return &GetItemBuilder_WithProjection_Call{Call: _e.mock.On("WithProjection", rangeValue)} +} + +func (_c *GetItemBuilder_WithProjection_Call) Run(run func(rangeValue interface{})) *GetItemBuilder_WithProjection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *GetItemBuilder_WithProjection_Call) Return(_a0 ddb.GetItemBuilder) *GetItemBuilder_WithProjection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GetItemBuilder_WithProjection_Call) RunAndReturn(run func(interface{}) ddb.GetItemBuilder) *GetItemBuilder_WithProjection_Call { + _c.Call.Return(run) + return _c +} + // WithRange provides a mock function with given fields: rangeValue func (_m *GetItemBuilder) WithRange(rangeValue interface{}) ddb.GetItemBuilder { ret := _m.Called(rangeValue) @@ -138,6 +320,34 @@ func (_m *GetItemBuilder) WithRange(rangeValue interface{}) ddb.GetItemBuilder { return r0 } +// GetItemBuilder_WithRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRange' +type GetItemBuilder_WithRange_Call struct { + *mock.Call +} + +// WithRange is a helper method to define mock.On call +// - rangeValue interface{} +func (_e *GetItemBuilder_Expecter) WithRange(rangeValue interface{}) *GetItemBuilder_WithRange_Call { + return &GetItemBuilder_WithRange_Call{Call: _e.mock.On("WithRange", rangeValue)} +} + +func (_c *GetItemBuilder_WithRange_Call) Run(run func(rangeValue interface{})) *GetItemBuilder_WithRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *GetItemBuilder_WithRange_Call) Return(_a0 ddb.GetItemBuilder) *GetItemBuilder_WithRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GetItemBuilder_WithRange_Call) RunAndReturn(run func(interface{}) ddb.GetItemBuilder) *GetItemBuilder_WithRange_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewGetItemBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/PutItemBuilder.go b/pkg/ddb/mocks/PutItemBuilder.go index e2b530f62..ef9062329 100644 --- a/pkg/ddb/mocks/PutItemBuilder.go +++ b/pkg/ddb/mocks/PutItemBuilder.go @@ -16,6 +16,14 @@ type PutItemBuilder struct { mock.Mock } +type PutItemBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *PutItemBuilder) EXPECT() *PutItemBuilder_Expecter { + return &PutItemBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: item func (_m *PutItemBuilder) Build(item interface{}) (*dynamodb.PutItemInput, error) { ret := _m.Called(item) @@ -42,6 +50,34 @@ func (_m *PutItemBuilder) Build(item interface{}) (*dynamodb.PutItemInput, error return r0, r1 } +// PutItemBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type PutItemBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +// - item interface{} +func (_e *PutItemBuilder_Expecter) Build(item interface{}) *PutItemBuilder_Build_Call { + return &PutItemBuilder_Build_Call{Call: _e.mock.On("Build", item)} +} + +func (_c *PutItemBuilder_Build_Call) Run(run func(item interface{})) *PutItemBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *PutItemBuilder_Build_Call) Return(_a0 *dynamodb.PutItemInput, _a1 error) *PutItemBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *PutItemBuilder_Build_Call) RunAndReturn(run func(interface{}) (*dynamodb.PutItemInput, error)) *PutItemBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // ReturnAllOld provides a mock function with given fields: func (_m *PutItemBuilder) ReturnAllOld() ddb.PutItemBuilder { ret := _m.Called() @@ -58,6 +94,33 @@ func (_m *PutItemBuilder) ReturnAllOld() ddb.PutItemBuilder { return r0 } +// PutItemBuilder_ReturnAllOld_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllOld' +type PutItemBuilder_ReturnAllOld_Call struct { + *mock.Call +} + +// ReturnAllOld is a helper method to define mock.On call +func (_e *PutItemBuilder_Expecter) ReturnAllOld() *PutItemBuilder_ReturnAllOld_Call { + return &PutItemBuilder_ReturnAllOld_Call{Call: _e.mock.On("ReturnAllOld")} +} + +func (_c *PutItemBuilder_ReturnAllOld_Call) Run(run func()) *PutItemBuilder_ReturnAllOld_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PutItemBuilder_ReturnAllOld_Call) Return(_a0 ddb.PutItemBuilder) *PutItemBuilder_ReturnAllOld_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PutItemBuilder_ReturnAllOld_Call) RunAndReturn(run func() ddb.PutItemBuilder) *PutItemBuilder_ReturnAllOld_Call { + _c.Call.Return(run) + return _c +} + // ReturnNone provides a mock function with given fields: func (_m *PutItemBuilder) ReturnNone() ddb.PutItemBuilder { ret := _m.Called() @@ -74,6 +137,33 @@ func (_m *PutItemBuilder) ReturnNone() ddb.PutItemBuilder { return r0 } +// PutItemBuilder_ReturnNone_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnNone' +type PutItemBuilder_ReturnNone_Call struct { + *mock.Call +} + +// ReturnNone is a helper method to define mock.On call +func (_e *PutItemBuilder_Expecter) ReturnNone() *PutItemBuilder_ReturnNone_Call { + return &PutItemBuilder_ReturnNone_Call{Call: _e.mock.On("ReturnNone")} +} + +func (_c *PutItemBuilder_ReturnNone_Call) Run(run func()) *PutItemBuilder_ReturnNone_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PutItemBuilder_ReturnNone_Call) Return(_a0 ddb.PutItemBuilder) *PutItemBuilder_ReturnNone_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PutItemBuilder_ReturnNone_Call) RunAndReturn(run func() ddb.PutItemBuilder) *PutItemBuilder_ReturnNone_Call { + _c.Call.Return(run) + return _c +} + // WithCondition provides a mock function with given fields: cond func (_m *PutItemBuilder) WithCondition(cond expression.ConditionBuilder) ddb.PutItemBuilder { ret := _m.Called(cond) @@ -90,6 +180,34 @@ func (_m *PutItemBuilder) WithCondition(cond expression.ConditionBuilder) ddb.Pu return r0 } +// PutItemBuilder_WithCondition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithCondition' +type PutItemBuilder_WithCondition_Call struct { + *mock.Call +} + +// WithCondition is a helper method to define mock.On call +// - cond expression.ConditionBuilder +func (_e *PutItemBuilder_Expecter) WithCondition(cond interface{}) *PutItemBuilder_WithCondition_Call { + return &PutItemBuilder_WithCondition_Call{Call: _e.mock.On("WithCondition", cond)} +} + +func (_c *PutItemBuilder_WithCondition_Call) Run(run func(cond expression.ConditionBuilder)) *PutItemBuilder_WithCondition_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(expression.ConditionBuilder)) + }) + return _c +} + +func (_c *PutItemBuilder_WithCondition_Call) Return(_a0 ddb.PutItemBuilder) *PutItemBuilder_WithCondition_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PutItemBuilder_WithCondition_Call) RunAndReturn(run func(expression.ConditionBuilder) ddb.PutItemBuilder) *PutItemBuilder_WithCondition_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewPutItemBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/QueryBuilder.go b/pkg/ddb/mocks/QueryBuilder.go index 3d8f0f476..b907ac9cc 100644 --- a/pkg/ddb/mocks/QueryBuilder.go +++ b/pkg/ddb/mocks/QueryBuilder.go @@ -13,6 +13,14 @@ type QueryBuilder struct { mock.Mock } +type QueryBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *QueryBuilder) EXPECT() *QueryBuilder_Expecter { + return &QueryBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: result func (_m *QueryBuilder) Build(result interface{}) (*ddb.QueryOperation, error) { ret := _m.Called(result) @@ -39,6 +47,34 @@ func (_m *QueryBuilder) Build(result interface{}) (*ddb.QueryOperation, error) { return r0, r1 } +// QueryBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type QueryBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +// - result interface{} +func (_e *QueryBuilder_Expecter) Build(result interface{}) *QueryBuilder_Build_Call { + return &QueryBuilder_Build_Call{Call: _e.mock.On("Build", result)} +} + +func (_c *QueryBuilder_Build_Call) Run(run func(result interface{})) *QueryBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_Build_Call) Return(_a0 *ddb.QueryOperation, _a1 error) *QueryBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueryBuilder_Build_Call) RunAndReturn(run func(interface{}) (*ddb.QueryOperation, error)) *QueryBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // DisableTtlFilter provides a mock function with given fields: func (_m *QueryBuilder) DisableTtlFilter() ddb.QueryBuilder { ret := _m.Called() @@ -55,6 +91,33 @@ func (_m *QueryBuilder) DisableTtlFilter() ddb.QueryBuilder { return r0 } +// QueryBuilder_DisableTtlFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableTtlFilter' +type QueryBuilder_DisableTtlFilter_Call struct { + *mock.Call +} + +// DisableTtlFilter is a helper method to define mock.On call +func (_e *QueryBuilder_Expecter) DisableTtlFilter() *QueryBuilder_DisableTtlFilter_Call { + return &QueryBuilder_DisableTtlFilter_Call{Call: _e.mock.On("DisableTtlFilter")} +} + +func (_c *QueryBuilder_DisableTtlFilter_Call) Run(run func()) *QueryBuilder_DisableTtlFilter_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *QueryBuilder_DisableTtlFilter_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_DisableTtlFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_DisableTtlFilter_Call) RunAndReturn(run func() ddb.QueryBuilder) *QueryBuilder_DisableTtlFilter_Call { + _c.Call.Return(run) + return _c +} + // WithConsistentRead provides a mock function with given fields: consistentRead func (_m *QueryBuilder) WithConsistentRead(consistentRead bool) ddb.QueryBuilder { ret := _m.Called(consistentRead) @@ -71,6 +134,34 @@ func (_m *QueryBuilder) WithConsistentRead(consistentRead bool) ddb.QueryBuilder return r0 } +// QueryBuilder_WithConsistentRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithConsistentRead' +type QueryBuilder_WithConsistentRead_Call struct { + *mock.Call +} + +// WithConsistentRead is a helper method to define mock.On call +// - consistentRead bool +func (_e *QueryBuilder_Expecter) WithConsistentRead(consistentRead interface{}) *QueryBuilder_WithConsistentRead_Call { + return &QueryBuilder_WithConsistentRead_Call{Call: _e.mock.On("WithConsistentRead", consistentRead)} +} + +func (_c *QueryBuilder_WithConsistentRead_Call) Run(run func(consistentRead bool)) *QueryBuilder_WithConsistentRead_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *QueryBuilder_WithConsistentRead_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithConsistentRead_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithConsistentRead_Call) RunAndReturn(run func(bool) ddb.QueryBuilder) *QueryBuilder_WithConsistentRead_Call { + _c.Call.Return(run) + return _c +} + // WithDescendingOrder provides a mock function with given fields: func (_m *QueryBuilder) WithDescendingOrder() ddb.QueryBuilder { ret := _m.Called() @@ -87,6 +178,33 @@ func (_m *QueryBuilder) WithDescendingOrder() ddb.QueryBuilder { return r0 } +// QueryBuilder_WithDescendingOrder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithDescendingOrder' +type QueryBuilder_WithDescendingOrder_Call struct { + *mock.Call +} + +// WithDescendingOrder is a helper method to define mock.On call +func (_e *QueryBuilder_Expecter) WithDescendingOrder() *QueryBuilder_WithDescendingOrder_Call { + return &QueryBuilder_WithDescendingOrder_Call{Call: _e.mock.On("WithDescendingOrder")} +} + +func (_c *QueryBuilder_WithDescendingOrder_Call) Run(run func()) *QueryBuilder_WithDescendingOrder_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *QueryBuilder_WithDescendingOrder_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithDescendingOrder_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithDescendingOrder_Call) RunAndReturn(run func() ddb.QueryBuilder) *QueryBuilder_WithDescendingOrder_Call { + _c.Call.Return(run) + return _c +} + // WithFilter provides a mock function with given fields: filter func (_m *QueryBuilder) WithFilter(filter expression.ConditionBuilder) ddb.QueryBuilder { ret := _m.Called(filter) @@ -103,6 +221,34 @@ func (_m *QueryBuilder) WithFilter(filter expression.ConditionBuilder) ddb.Query return r0 } +// QueryBuilder_WithFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithFilter' +type QueryBuilder_WithFilter_Call struct { + *mock.Call +} + +// WithFilter is a helper method to define mock.On call +// - filter expression.ConditionBuilder +func (_e *QueryBuilder_Expecter) WithFilter(filter interface{}) *QueryBuilder_WithFilter_Call { + return &QueryBuilder_WithFilter_Call{Call: _e.mock.On("WithFilter", filter)} +} + +func (_c *QueryBuilder_WithFilter_Call) Run(run func(filter expression.ConditionBuilder)) *QueryBuilder_WithFilter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(expression.ConditionBuilder)) + }) + return _c +} + +func (_c *QueryBuilder_WithFilter_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithFilter_Call) RunAndReturn(run func(expression.ConditionBuilder) ddb.QueryBuilder) *QueryBuilder_WithFilter_Call { + _c.Call.Return(run) + return _c +} + // WithHash provides a mock function with given fields: value func (_m *QueryBuilder) WithHash(value interface{}) ddb.QueryBuilder { ret := _m.Called(value) @@ -119,6 +265,34 @@ func (_m *QueryBuilder) WithHash(value interface{}) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithHash' +type QueryBuilder_WithHash_Call struct { + *mock.Call +} + +// WithHash is a helper method to define mock.On call +// - value interface{} +func (_e *QueryBuilder_Expecter) WithHash(value interface{}) *QueryBuilder_WithHash_Call { + return &QueryBuilder_WithHash_Call{Call: _e.mock.On("WithHash", value)} +} + +func (_c *QueryBuilder_WithHash_Call) Run(run func(value interface{})) *QueryBuilder_WithHash_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_WithHash_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithHash_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithHash_Call) RunAndReturn(run func(interface{}) ddb.QueryBuilder) *QueryBuilder_WithHash_Call { + _c.Call.Return(run) + return _c +} + // WithIndex provides a mock function with given fields: name func (_m *QueryBuilder) WithIndex(name string) ddb.QueryBuilder { ret := _m.Called(name) @@ -135,6 +309,34 @@ func (_m *QueryBuilder) WithIndex(name string) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithIndex' +type QueryBuilder_WithIndex_Call struct { + *mock.Call +} + +// WithIndex is a helper method to define mock.On call +// - name string +func (_e *QueryBuilder_Expecter) WithIndex(name interface{}) *QueryBuilder_WithIndex_Call { + return &QueryBuilder_WithIndex_Call{Call: _e.mock.On("WithIndex", name)} +} + +func (_c *QueryBuilder_WithIndex_Call) Run(run func(name string)) *QueryBuilder_WithIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *QueryBuilder_WithIndex_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithIndex_Call) RunAndReturn(run func(string) ddb.QueryBuilder) *QueryBuilder_WithIndex_Call { + _c.Call.Return(run) + return _c +} + // WithLimit provides a mock function with given fields: limit func (_m *QueryBuilder) WithLimit(limit int) ddb.QueryBuilder { ret := _m.Called(limit) @@ -151,6 +353,34 @@ func (_m *QueryBuilder) WithLimit(limit int) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithLimit' +type QueryBuilder_WithLimit_Call struct { + *mock.Call +} + +// WithLimit is a helper method to define mock.On call +// - limit int +func (_e *QueryBuilder_Expecter) WithLimit(limit interface{}) *QueryBuilder_WithLimit_Call { + return &QueryBuilder_WithLimit_Call{Call: _e.mock.On("WithLimit", limit)} +} + +func (_c *QueryBuilder_WithLimit_Call) Run(run func(limit int)) *QueryBuilder_WithLimit_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *QueryBuilder_WithLimit_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithLimit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithLimit_Call) RunAndReturn(run func(int) ddb.QueryBuilder) *QueryBuilder_WithLimit_Call { + _c.Call.Return(run) + return _c +} + // WithPageSize provides a mock function with given fields: size func (_m *QueryBuilder) WithPageSize(size int) ddb.QueryBuilder { ret := _m.Called(size) @@ -167,6 +397,34 @@ func (_m *QueryBuilder) WithPageSize(size int) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithPageSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithPageSize' +type QueryBuilder_WithPageSize_Call struct { + *mock.Call +} + +// WithPageSize is a helper method to define mock.On call +// - size int +func (_e *QueryBuilder_Expecter) WithPageSize(size interface{}) *QueryBuilder_WithPageSize_Call { + return &QueryBuilder_WithPageSize_Call{Call: _e.mock.On("WithPageSize", size)} +} + +func (_c *QueryBuilder_WithPageSize_Call) Run(run func(size int)) *QueryBuilder_WithPageSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *QueryBuilder_WithPageSize_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithPageSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithPageSize_Call) RunAndReturn(run func(int) ddb.QueryBuilder) *QueryBuilder_WithPageSize_Call { + _c.Call.Return(run) + return _c +} + // WithProjection provides a mock function with given fields: projection func (_m *QueryBuilder) WithProjection(projection interface{}) ddb.QueryBuilder { ret := _m.Called(projection) @@ -183,6 +441,34 @@ func (_m *QueryBuilder) WithProjection(projection interface{}) ddb.QueryBuilder return r0 } +// QueryBuilder_WithProjection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithProjection' +type QueryBuilder_WithProjection_Call struct { + *mock.Call +} + +// WithProjection is a helper method to define mock.On call +// - projection interface{} +func (_e *QueryBuilder_Expecter) WithProjection(projection interface{}) *QueryBuilder_WithProjection_Call { + return &QueryBuilder_WithProjection_Call{Call: _e.mock.On("WithProjection", projection)} +} + +func (_c *QueryBuilder_WithProjection_Call) Run(run func(projection interface{})) *QueryBuilder_WithProjection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_WithProjection_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithProjection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithProjection_Call) RunAndReturn(run func(interface{}) ddb.QueryBuilder) *QueryBuilder_WithProjection_Call { + _c.Call.Return(run) + return _c +} + // WithRangeBeginsWith provides a mock function with given fields: prefix func (_m *QueryBuilder) WithRangeBeginsWith(prefix string) ddb.QueryBuilder { ret := _m.Called(prefix) @@ -199,6 +485,34 @@ func (_m *QueryBuilder) WithRangeBeginsWith(prefix string) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithRangeBeginsWith_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRangeBeginsWith' +type QueryBuilder_WithRangeBeginsWith_Call struct { + *mock.Call +} + +// WithRangeBeginsWith is a helper method to define mock.On call +// - prefix string +func (_e *QueryBuilder_Expecter) WithRangeBeginsWith(prefix interface{}) *QueryBuilder_WithRangeBeginsWith_Call { + return &QueryBuilder_WithRangeBeginsWith_Call{Call: _e.mock.On("WithRangeBeginsWith", prefix)} +} + +func (_c *QueryBuilder_WithRangeBeginsWith_Call) Run(run func(prefix string)) *QueryBuilder_WithRangeBeginsWith_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *QueryBuilder_WithRangeBeginsWith_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithRangeBeginsWith_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithRangeBeginsWith_Call) RunAndReturn(run func(string) ddb.QueryBuilder) *QueryBuilder_WithRangeBeginsWith_Call { + _c.Call.Return(run) + return _c +} + // WithRangeBetween provides a mock function with given fields: lower, upper func (_m *QueryBuilder) WithRangeBetween(lower interface{}, upper interface{}) ddb.QueryBuilder { ret := _m.Called(lower, upper) @@ -215,6 +529,35 @@ func (_m *QueryBuilder) WithRangeBetween(lower interface{}, upper interface{}) d return r0 } +// QueryBuilder_WithRangeBetween_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRangeBetween' +type QueryBuilder_WithRangeBetween_Call struct { + *mock.Call +} + +// WithRangeBetween is a helper method to define mock.On call +// - lower interface{} +// - upper interface{} +func (_e *QueryBuilder_Expecter) WithRangeBetween(lower interface{}, upper interface{}) *QueryBuilder_WithRangeBetween_Call { + return &QueryBuilder_WithRangeBetween_Call{Call: _e.mock.On("WithRangeBetween", lower, upper)} +} + +func (_c *QueryBuilder_WithRangeBetween_Call) Run(run func(lower interface{}, upper interface{})) *QueryBuilder_WithRangeBetween_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{}), args[1].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_WithRangeBetween_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithRangeBetween_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithRangeBetween_Call) RunAndReturn(run func(interface{}, interface{}) ddb.QueryBuilder) *QueryBuilder_WithRangeBetween_Call { + _c.Call.Return(run) + return _c +} + // WithRangeEq provides a mock function with given fields: value func (_m *QueryBuilder) WithRangeEq(value interface{}) ddb.QueryBuilder { ret := _m.Called(value) @@ -231,6 +574,34 @@ func (_m *QueryBuilder) WithRangeEq(value interface{}) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithRangeEq_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRangeEq' +type QueryBuilder_WithRangeEq_Call struct { + *mock.Call +} + +// WithRangeEq is a helper method to define mock.On call +// - value interface{} +func (_e *QueryBuilder_Expecter) WithRangeEq(value interface{}) *QueryBuilder_WithRangeEq_Call { + return &QueryBuilder_WithRangeEq_Call{Call: _e.mock.On("WithRangeEq", value)} +} + +func (_c *QueryBuilder_WithRangeEq_Call) Run(run func(value interface{})) *QueryBuilder_WithRangeEq_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_WithRangeEq_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithRangeEq_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithRangeEq_Call) RunAndReturn(run func(interface{}) ddb.QueryBuilder) *QueryBuilder_WithRangeEq_Call { + _c.Call.Return(run) + return _c +} + // WithRangeGt provides a mock function with given fields: value func (_m *QueryBuilder) WithRangeGt(value interface{}) ddb.QueryBuilder { ret := _m.Called(value) @@ -247,6 +618,34 @@ func (_m *QueryBuilder) WithRangeGt(value interface{}) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithRangeGt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRangeGt' +type QueryBuilder_WithRangeGt_Call struct { + *mock.Call +} + +// WithRangeGt is a helper method to define mock.On call +// - value interface{} +func (_e *QueryBuilder_Expecter) WithRangeGt(value interface{}) *QueryBuilder_WithRangeGt_Call { + return &QueryBuilder_WithRangeGt_Call{Call: _e.mock.On("WithRangeGt", value)} +} + +func (_c *QueryBuilder_WithRangeGt_Call) Run(run func(value interface{})) *QueryBuilder_WithRangeGt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_WithRangeGt_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithRangeGt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithRangeGt_Call) RunAndReturn(run func(interface{}) ddb.QueryBuilder) *QueryBuilder_WithRangeGt_Call { + _c.Call.Return(run) + return _c +} + // WithRangeGte provides a mock function with given fields: value func (_m *QueryBuilder) WithRangeGte(value interface{}) ddb.QueryBuilder { ret := _m.Called(value) @@ -263,6 +662,34 @@ func (_m *QueryBuilder) WithRangeGte(value interface{}) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithRangeGte_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRangeGte' +type QueryBuilder_WithRangeGte_Call struct { + *mock.Call +} + +// WithRangeGte is a helper method to define mock.On call +// - value interface{} +func (_e *QueryBuilder_Expecter) WithRangeGte(value interface{}) *QueryBuilder_WithRangeGte_Call { + return &QueryBuilder_WithRangeGte_Call{Call: _e.mock.On("WithRangeGte", value)} +} + +func (_c *QueryBuilder_WithRangeGte_Call) Run(run func(value interface{})) *QueryBuilder_WithRangeGte_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_WithRangeGte_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithRangeGte_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithRangeGte_Call) RunAndReturn(run func(interface{}) ddb.QueryBuilder) *QueryBuilder_WithRangeGte_Call { + _c.Call.Return(run) + return _c +} + // WithRangeLt provides a mock function with given fields: value func (_m *QueryBuilder) WithRangeLt(value interface{}) ddb.QueryBuilder { ret := _m.Called(value) @@ -279,6 +706,34 @@ func (_m *QueryBuilder) WithRangeLt(value interface{}) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithRangeLt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRangeLt' +type QueryBuilder_WithRangeLt_Call struct { + *mock.Call +} + +// WithRangeLt is a helper method to define mock.On call +// - value interface{} +func (_e *QueryBuilder_Expecter) WithRangeLt(value interface{}) *QueryBuilder_WithRangeLt_Call { + return &QueryBuilder_WithRangeLt_Call{Call: _e.mock.On("WithRangeLt", value)} +} + +func (_c *QueryBuilder_WithRangeLt_Call) Run(run func(value interface{})) *QueryBuilder_WithRangeLt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_WithRangeLt_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithRangeLt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithRangeLt_Call) RunAndReturn(run func(interface{}) ddb.QueryBuilder) *QueryBuilder_WithRangeLt_Call { + _c.Call.Return(run) + return _c +} + // WithRangeLte provides a mock function with given fields: value func (_m *QueryBuilder) WithRangeLte(value interface{}) ddb.QueryBuilder { ret := _m.Called(value) @@ -295,6 +750,34 @@ func (_m *QueryBuilder) WithRangeLte(value interface{}) ddb.QueryBuilder { return r0 } +// QueryBuilder_WithRangeLte_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRangeLte' +type QueryBuilder_WithRangeLte_Call struct { + *mock.Call +} + +// WithRangeLte is a helper method to define mock.On call +// - value interface{} +func (_e *QueryBuilder_Expecter) WithRangeLte(value interface{}) *QueryBuilder_WithRangeLte_Call { + return &QueryBuilder_WithRangeLte_Call{Call: _e.mock.On("WithRangeLte", value)} +} + +func (_c *QueryBuilder_WithRangeLte_Call) Run(run func(value interface{})) *QueryBuilder_WithRangeLte_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *QueryBuilder_WithRangeLte_Call) Return(_a0 ddb.QueryBuilder) *QueryBuilder_WithRangeLte_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueryBuilder_WithRangeLte_Call) RunAndReturn(run func(interface{}) ddb.QueryBuilder) *QueryBuilder_WithRangeLte_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewQueryBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/Repository.go b/pkg/ddb/mocks/Repository.go index bd9f929f7..d4e09bab7 100644 --- a/pkg/ddb/mocks/Repository.go +++ b/pkg/ddb/mocks/Repository.go @@ -16,6 +16,14 @@ type Repository struct { mock.Mock } +type Repository_Expecter struct { + mock *mock.Mock +} + +func (_m *Repository) EXPECT() *Repository_Expecter { + return &Repository_Expecter{mock: &_m.Mock} +} + // BatchDeleteItems provides a mock function with given fields: ctx, value func (_m *Repository) BatchDeleteItems(ctx context.Context, value interface{}) (*ddb.OperationResult, error) { ret := _m.Called(ctx, value) @@ -42,6 +50,35 @@ func (_m *Repository) BatchDeleteItems(ctx context.Context, value interface{}) ( return r0, r1 } +// Repository_BatchDeleteItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchDeleteItems' +type Repository_BatchDeleteItems_Call struct { + *mock.Call +} + +// BatchDeleteItems is a helper method to define mock.On call +// - ctx context.Context +// - value interface{} +func (_e *Repository_Expecter) BatchDeleteItems(ctx interface{}, value interface{}) *Repository_BatchDeleteItems_Call { + return &Repository_BatchDeleteItems_Call{Call: _e.mock.On("BatchDeleteItems", ctx, value)} +} + +func (_c *Repository_BatchDeleteItems_Call) Run(run func(ctx context.Context, value interface{})) *Repository_BatchDeleteItems_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *Repository_BatchDeleteItems_Call) Return(_a0 *ddb.OperationResult, _a1 error) *Repository_BatchDeleteItems_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_BatchDeleteItems_Call) RunAndReturn(run func(context.Context, interface{}) (*ddb.OperationResult, error)) *Repository_BatchDeleteItems_Call { + _c.Call.Return(run) + return _c +} + // BatchGetItems provides a mock function with given fields: ctx, qb, result func (_m *Repository) BatchGetItems(ctx context.Context, qb ddb.BatchGetItemsBuilder, result interface{}) (*ddb.OperationResult, error) { ret := _m.Called(ctx, qb, result) @@ -68,6 +105,36 @@ func (_m *Repository) BatchGetItems(ctx context.Context, qb ddb.BatchGetItemsBui return r0, r1 } +// Repository_BatchGetItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchGetItems' +type Repository_BatchGetItems_Call struct { + *mock.Call +} + +// BatchGetItems is a helper method to define mock.On call +// - ctx context.Context +// - qb ddb.BatchGetItemsBuilder +// - result interface{} +func (_e *Repository_Expecter) BatchGetItems(ctx interface{}, qb interface{}, result interface{}) *Repository_BatchGetItems_Call { + return &Repository_BatchGetItems_Call{Call: _e.mock.On("BatchGetItems", ctx, qb, result)} +} + +func (_c *Repository_BatchGetItems_Call) Run(run func(ctx context.Context, qb ddb.BatchGetItemsBuilder, result interface{})) *Repository_BatchGetItems_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(ddb.BatchGetItemsBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_BatchGetItems_Call) Return(_a0 *ddb.OperationResult, _a1 error) *Repository_BatchGetItems_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_BatchGetItems_Call) RunAndReturn(run func(context.Context, ddb.BatchGetItemsBuilder, interface{}) (*ddb.OperationResult, error)) *Repository_BatchGetItems_Call { + _c.Call.Return(run) + return _c +} + // BatchGetItemsBuilder provides a mock function with given fields: func (_m *Repository) BatchGetItemsBuilder() ddb.BatchGetItemsBuilder { ret := _m.Called() @@ -84,6 +151,33 @@ func (_m *Repository) BatchGetItemsBuilder() ddb.BatchGetItemsBuilder { return r0 } +// Repository_BatchGetItemsBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchGetItemsBuilder' +type Repository_BatchGetItemsBuilder_Call struct { + *mock.Call +} + +// BatchGetItemsBuilder is a helper method to define mock.On call +func (_e *Repository_Expecter) BatchGetItemsBuilder() *Repository_BatchGetItemsBuilder_Call { + return &Repository_BatchGetItemsBuilder_Call{Call: _e.mock.On("BatchGetItemsBuilder")} +} + +func (_c *Repository_BatchGetItemsBuilder_Call) Run(run func()) *Repository_BatchGetItemsBuilder_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_BatchGetItemsBuilder_Call) Return(_a0 ddb.BatchGetItemsBuilder) *Repository_BatchGetItemsBuilder_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_BatchGetItemsBuilder_Call) RunAndReturn(run func() ddb.BatchGetItemsBuilder) *Repository_BatchGetItemsBuilder_Call { + _c.Call.Return(run) + return _c +} + // BatchPutItems provides a mock function with given fields: ctx, items func (_m *Repository) BatchPutItems(ctx context.Context, items interface{}) (*ddb.OperationResult, error) { ret := _m.Called(ctx, items) @@ -110,6 +204,35 @@ func (_m *Repository) BatchPutItems(ctx context.Context, items interface{}) (*dd return r0, r1 } +// Repository_BatchPutItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchPutItems' +type Repository_BatchPutItems_Call struct { + *mock.Call +} + +// BatchPutItems is a helper method to define mock.On call +// - ctx context.Context +// - items interface{} +func (_e *Repository_Expecter) BatchPutItems(ctx interface{}, items interface{}) *Repository_BatchPutItems_Call { + return &Repository_BatchPutItems_Call{Call: _e.mock.On("BatchPutItems", ctx, items)} +} + +func (_c *Repository_BatchPutItems_Call) Run(run func(ctx context.Context, items interface{})) *Repository_BatchPutItems_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *Repository_BatchPutItems_Call) Return(_a0 *ddb.OperationResult, _a1 error) *Repository_BatchPutItems_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_BatchPutItems_Call) RunAndReturn(run func(context.Context, interface{}) (*ddb.OperationResult, error)) *Repository_BatchPutItems_Call { + _c.Call.Return(run) + return _c +} + // DeleteItem provides a mock function with given fields: ctx, db, item func (_m *Repository) DeleteItem(ctx context.Context, db ddb.DeleteItemBuilder, item interface{}) (*ddb.DeleteItemResult, error) { ret := _m.Called(ctx, db, item) @@ -136,6 +259,36 @@ func (_m *Repository) DeleteItem(ctx context.Context, db ddb.DeleteItemBuilder, return r0, r1 } +// Repository_DeleteItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteItem' +type Repository_DeleteItem_Call struct { + *mock.Call +} + +// DeleteItem is a helper method to define mock.On call +// - ctx context.Context +// - db ddb.DeleteItemBuilder +// - item interface{} +func (_e *Repository_Expecter) DeleteItem(ctx interface{}, db interface{}, item interface{}) *Repository_DeleteItem_Call { + return &Repository_DeleteItem_Call{Call: _e.mock.On("DeleteItem", ctx, db, item)} +} + +func (_c *Repository_DeleteItem_Call) Run(run func(ctx context.Context, db ddb.DeleteItemBuilder, item interface{})) *Repository_DeleteItem_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(ddb.DeleteItemBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_DeleteItem_Call) Return(_a0 *ddb.DeleteItemResult, _a1 error) *Repository_DeleteItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_DeleteItem_Call) RunAndReturn(run func(context.Context, ddb.DeleteItemBuilder, interface{}) (*ddb.DeleteItemResult, error)) *Repository_DeleteItem_Call { + _c.Call.Return(run) + return _c +} + // DeleteItemBuilder provides a mock function with given fields: func (_m *Repository) DeleteItemBuilder() ddb.DeleteItemBuilder { ret := _m.Called() @@ -152,6 +305,33 @@ func (_m *Repository) DeleteItemBuilder() ddb.DeleteItemBuilder { return r0 } +// Repository_DeleteItemBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteItemBuilder' +type Repository_DeleteItemBuilder_Call struct { + *mock.Call +} + +// DeleteItemBuilder is a helper method to define mock.On call +func (_e *Repository_Expecter) DeleteItemBuilder() *Repository_DeleteItemBuilder_Call { + return &Repository_DeleteItemBuilder_Call{Call: _e.mock.On("DeleteItemBuilder")} +} + +func (_c *Repository_DeleteItemBuilder_Call) Run(run func()) *Repository_DeleteItemBuilder_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_DeleteItemBuilder_Call) Return(_a0 ddb.DeleteItemBuilder) *Repository_DeleteItemBuilder_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_DeleteItemBuilder_Call) RunAndReturn(run func() ddb.DeleteItemBuilder) *Repository_DeleteItemBuilder_Call { + _c.Call.Return(run) + return _c +} + // GetItem provides a mock function with given fields: ctx, qb, result func (_m *Repository) GetItem(ctx context.Context, qb ddb.GetItemBuilder, result interface{}) (*ddb.GetItemResult, error) { ret := _m.Called(ctx, qb, result) @@ -178,6 +358,36 @@ func (_m *Repository) GetItem(ctx context.Context, qb ddb.GetItemBuilder, result return r0, r1 } +// Repository_GetItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItem' +type Repository_GetItem_Call struct { + *mock.Call +} + +// GetItem is a helper method to define mock.On call +// - ctx context.Context +// - qb ddb.GetItemBuilder +// - result interface{} +func (_e *Repository_Expecter) GetItem(ctx interface{}, qb interface{}, result interface{}) *Repository_GetItem_Call { + return &Repository_GetItem_Call{Call: _e.mock.On("GetItem", ctx, qb, result)} +} + +func (_c *Repository_GetItem_Call) Run(run func(ctx context.Context, qb ddb.GetItemBuilder, result interface{})) *Repository_GetItem_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(ddb.GetItemBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_GetItem_Call) Return(_a0 *ddb.GetItemResult, _a1 error) *Repository_GetItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_GetItem_Call) RunAndReturn(run func(context.Context, ddb.GetItemBuilder, interface{}) (*ddb.GetItemResult, error)) *Repository_GetItem_Call { + _c.Call.Return(run) + return _c +} + // GetItemBuilder provides a mock function with given fields: func (_m *Repository) GetItemBuilder() ddb.GetItemBuilder { ret := _m.Called() @@ -194,6 +404,33 @@ func (_m *Repository) GetItemBuilder() ddb.GetItemBuilder { return r0 } +// Repository_GetItemBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItemBuilder' +type Repository_GetItemBuilder_Call struct { + *mock.Call +} + +// GetItemBuilder is a helper method to define mock.On call +func (_e *Repository_Expecter) GetItemBuilder() *Repository_GetItemBuilder_Call { + return &Repository_GetItemBuilder_Call{Call: _e.mock.On("GetItemBuilder")} +} + +func (_c *Repository_GetItemBuilder_Call) Run(run func()) *Repository_GetItemBuilder_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_GetItemBuilder_Call) Return(_a0 ddb.GetItemBuilder) *Repository_GetItemBuilder_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_GetItemBuilder_Call) RunAndReturn(run func() ddb.GetItemBuilder) *Repository_GetItemBuilder_Call { + _c.Call.Return(run) + return _c +} + // GetModelId provides a mock function with given fields: func (_m *Repository) GetModelId() mdl.ModelId { ret := _m.Called() @@ -208,6 +445,33 @@ func (_m *Repository) GetModelId() mdl.ModelId { return r0 } +// Repository_GetModelId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModelId' +type Repository_GetModelId_Call struct { + *mock.Call +} + +// GetModelId is a helper method to define mock.On call +func (_e *Repository_Expecter) GetModelId() *Repository_GetModelId_Call { + return &Repository_GetModelId_Call{Call: _e.mock.On("GetModelId")} +} + +func (_c *Repository_GetModelId_Call) Run(run func()) *Repository_GetModelId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_GetModelId_Call) Return(_a0 mdl.ModelId) *Repository_GetModelId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_GetModelId_Call) RunAndReturn(run func() mdl.ModelId) *Repository_GetModelId_Call { + _c.Call.Return(run) + return _c +} + // PutItem provides a mock function with given fields: ctx, qb, item func (_m *Repository) PutItem(ctx context.Context, qb ddb.PutItemBuilder, item interface{}) (*ddb.PutItemResult, error) { ret := _m.Called(ctx, qb, item) @@ -234,6 +498,36 @@ func (_m *Repository) PutItem(ctx context.Context, qb ddb.PutItemBuilder, item i return r0, r1 } +// Repository_PutItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutItem' +type Repository_PutItem_Call struct { + *mock.Call +} + +// PutItem is a helper method to define mock.On call +// - ctx context.Context +// - qb ddb.PutItemBuilder +// - item interface{} +func (_e *Repository_Expecter) PutItem(ctx interface{}, qb interface{}, item interface{}) *Repository_PutItem_Call { + return &Repository_PutItem_Call{Call: _e.mock.On("PutItem", ctx, qb, item)} +} + +func (_c *Repository_PutItem_Call) Run(run func(ctx context.Context, qb ddb.PutItemBuilder, item interface{})) *Repository_PutItem_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(ddb.PutItemBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_PutItem_Call) Return(_a0 *ddb.PutItemResult, _a1 error) *Repository_PutItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_PutItem_Call) RunAndReturn(run func(context.Context, ddb.PutItemBuilder, interface{}) (*ddb.PutItemResult, error)) *Repository_PutItem_Call { + _c.Call.Return(run) + return _c +} + // PutItemBuilder provides a mock function with given fields: func (_m *Repository) PutItemBuilder() ddb.PutItemBuilder { ret := _m.Called() @@ -250,6 +544,33 @@ func (_m *Repository) PutItemBuilder() ddb.PutItemBuilder { return r0 } +// Repository_PutItemBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutItemBuilder' +type Repository_PutItemBuilder_Call struct { + *mock.Call +} + +// PutItemBuilder is a helper method to define mock.On call +func (_e *Repository_Expecter) PutItemBuilder() *Repository_PutItemBuilder_Call { + return &Repository_PutItemBuilder_Call{Call: _e.mock.On("PutItemBuilder")} +} + +func (_c *Repository_PutItemBuilder_Call) Run(run func()) *Repository_PutItemBuilder_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_PutItemBuilder_Call) Return(_a0 ddb.PutItemBuilder) *Repository_PutItemBuilder_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_PutItemBuilder_Call) RunAndReturn(run func() ddb.PutItemBuilder) *Repository_PutItemBuilder_Call { + _c.Call.Return(run) + return _c +} + // Query provides a mock function with given fields: ctx, qb, result func (_m *Repository) Query(ctx context.Context, qb ddb.QueryBuilder, result interface{}) (*ddb.QueryResult, error) { ret := _m.Called(ctx, qb, result) @@ -276,6 +597,36 @@ func (_m *Repository) Query(ctx context.Context, qb ddb.QueryBuilder, result int return r0, r1 } +// Repository_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' +type Repository_Query_Call struct { + *mock.Call +} + +// Query is a helper method to define mock.On call +// - ctx context.Context +// - qb ddb.QueryBuilder +// - result interface{} +func (_e *Repository_Expecter) Query(ctx interface{}, qb interface{}, result interface{}) *Repository_Query_Call { + return &Repository_Query_Call{Call: _e.mock.On("Query", ctx, qb, result)} +} + +func (_c *Repository_Query_Call) Run(run func(ctx context.Context, qb ddb.QueryBuilder, result interface{})) *Repository_Query_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(ddb.QueryBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_Query_Call) Return(_a0 *ddb.QueryResult, _a1 error) *Repository_Query_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_Query_Call) RunAndReturn(run func(context.Context, ddb.QueryBuilder, interface{}) (*ddb.QueryResult, error)) *Repository_Query_Call { + _c.Call.Return(run) + return _c +} + // QueryBuilder provides a mock function with given fields: func (_m *Repository) QueryBuilder() ddb.QueryBuilder { ret := _m.Called() @@ -292,6 +643,33 @@ func (_m *Repository) QueryBuilder() ddb.QueryBuilder { return r0 } +// Repository_QueryBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryBuilder' +type Repository_QueryBuilder_Call struct { + *mock.Call +} + +// QueryBuilder is a helper method to define mock.On call +func (_e *Repository_Expecter) QueryBuilder() *Repository_QueryBuilder_Call { + return &Repository_QueryBuilder_Call{Call: _e.mock.On("QueryBuilder")} +} + +func (_c *Repository_QueryBuilder_Call) Run(run func()) *Repository_QueryBuilder_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_QueryBuilder_Call) Return(_a0 ddb.QueryBuilder) *Repository_QueryBuilder_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_QueryBuilder_Call) RunAndReturn(run func() ddb.QueryBuilder) *Repository_QueryBuilder_Call { + _c.Call.Return(run) + return _c +} + // Scan provides a mock function with given fields: ctx, sb, result func (_m *Repository) Scan(ctx context.Context, sb ddb.ScanBuilder, result interface{}) (*ddb.ScanResult, error) { ret := _m.Called(ctx, sb, result) @@ -318,6 +696,36 @@ func (_m *Repository) Scan(ctx context.Context, sb ddb.ScanBuilder, result inter return r0, r1 } +// Repository_Scan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Scan' +type Repository_Scan_Call struct { + *mock.Call +} + +// Scan is a helper method to define mock.On call +// - ctx context.Context +// - sb ddb.ScanBuilder +// - result interface{} +func (_e *Repository_Expecter) Scan(ctx interface{}, sb interface{}, result interface{}) *Repository_Scan_Call { + return &Repository_Scan_Call{Call: _e.mock.On("Scan", ctx, sb, result)} +} + +func (_c *Repository_Scan_Call) Run(run func(ctx context.Context, sb ddb.ScanBuilder, result interface{})) *Repository_Scan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(ddb.ScanBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_Scan_Call) Return(_a0 *ddb.ScanResult, _a1 error) *Repository_Scan_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_Scan_Call) RunAndReturn(run func(context.Context, ddb.ScanBuilder, interface{}) (*ddb.ScanResult, error)) *Repository_Scan_Call { + _c.Call.Return(run) + return _c +} + // ScanBuilder provides a mock function with given fields: func (_m *Repository) ScanBuilder() ddb.ScanBuilder { ret := _m.Called() @@ -334,6 +742,33 @@ func (_m *Repository) ScanBuilder() ddb.ScanBuilder { return r0 } +// Repository_ScanBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanBuilder' +type Repository_ScanBuilder_Call struct { + *mock.Call +} + +// ScanBuilder is a helper method to define mock.On call +func (_e *Repository_Expecter) ScanBuilder() *Repository_ScanBuilder_Call { + return &Repository_ScanBuilder_Call{Call: _e.mock.On("ScanBuilder")} +} + +func (_c *Repository_ScanBuilder_Call) Run(run func()) *Repository_ScanBuilder_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_ScanBuilder_Call) Return(_a0 ddb.ScanBuilder) *Repository_ScanBuilder_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_ScanBuilder_Call) RunAndReturn(run func() ddb.ScanBuilder) *Repository_ScanBuilder_Call { + _c.Call.Return(run) + return _c +} + // UpdateItem provides a mock function with given fields: ctx, ub, item func (_m *Repository) UpdateItem(ctx context.Context, ub ddb.UpdateItemBuilder, item interface{}) (*ddb.UpdateItemResult, error) { ret := _m.Called(ctx, ub, item) @@ -360,6 +795,36 @@ func (_m *Repository) UpdateItem(ctx context.Context, ub ddb.UpdateItemBuilder, return r0, r1 } +// Repository_UpdateItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateItem' +type Repository_UpdateItem_Call struct { + *mock.Call +} + +// UpdateItem is a helper method to define mock.On call +// - ctx context.Context +// - ub ddb.UpdateItemBuilder +// - item interface{} +func (_e *Repository_Expecter) UpdateItem(ctx interface{}, ub interface{}, item interface{}) *Repository_UpdateItem_Call { + return &Repository_UpdateItem_Call{Call: _e.mock.On("UpdateItem", ctx, ub, item)} +} + +func (_c *Repository_UpdateItem_Call) Run(run func(ctx context.Context, ub ddb.UpdateItemBuilder, item interface{})) *Repository_UpdateItem_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(ddb.UpdateItemBuilder), args[2].(interface{})) + }) + return _c +} + +func (_c *Repository_UpdateItem_Call) Return(_a0 *ddb.UpdateItemResult, _a1 error) *Repository_UpdateItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Repository_UpdateItem_Call) RunAndReturn(run func(context.Context, ddb.UpdateItemBuilder, interface{}) (*ddb.UpdateItemResult, error)) *Repository_UpdateItem_Call { + _c.Call.Return(run) + return _c +} + // UpdateItemBuilder provides a mock function with given fields: func (_m *Repository) UpdateItemBuilder() ddb.UpdateItemBuilder { ret := _m.Called() @@ -376,6 +841,33 @@ func (_m *Repository) UpdateItemBuilder() ddb.UpdateItemBuilder { return r0 } +// Repository_UpdateItemBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateItemBuilder' +type Repository_UpdateItemBuilder_Call struct { + *mock.Call +} + +// UpdateItemBuilder is a helper method to define mock.On call +func (_e *Repository_Expecter) UpdateItemBuilder() *Repository_UpdateItemBuilder_Call { + return &Repository_UpdateItemBuilder_Call{Call: _e.mock.On("UpdateItemBuilder")} +} + +func (_c *Repository_UpdateItemBuilder_Call) Run(run func()) *Repository_UpdateItemBuilder_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_UpdateItemBuilder_Call) Return(_a0 ddb.UpdateItemBuilder) *Repository_UpdateItemBuilder_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_UpdateItemBuilder_Call) RunAndReturn(run func() ddb.UpdateItemBuilder) *Repository_UpdateItemBuilder_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRepository interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/ScanBuilder.go b/pkg/ddb/mocks/ScanBuilder.go index d89c4e3a3..d1b372e6f 100644 --- a/pkg/ddb/mocks/ScanBuilder.go +++ b/pkg/ddb/mocks/ScanBuilder.go @@ -13,6 +13,14 @@ type ScanBuilder struct { mock.Mock } +type ScanBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *ScanBuilder) EXPECT() *ScanBuilder_Expecter { + return &ScanBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: result func (_m *ScanBuilder) Build(result interface{}) (*ddb.ScanOperation, error) { ret := _m.Called(result) @@ -39,6 +47,34 @@ func (_m *ScanBuilder) Build(result interface{}) (*ddb.ScanOperation, error) { return r0, r1 } +// ScanBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type ScanBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +// - result interface{} +func (_e *ScanBuilder_Expecter) Build(result interface{}) *ScanBuilder_Build_Call { + return &ScanBuilder_Build_Call{Call: _e.mock.On("Build", result)} +} + +func (_c *ScanBuilder_Build_Call) Run(run func(result interface{})) *ScanBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *ScanBuilder_Build_Call) Return(_a0 *ddb.ScanOperation, _a1 error) *ScanBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ScanBuilder_Build_Call) RunAndReturn(run func(interface{}) (*ddb.ScanOperation, error)) *ScanBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // DisableTtlFilter provides a mock function with given fields: func (_m *ScanBuilder) DisableTtlFilter() ddb.ScanBuilder { ret := _m.Called() @@ -55,6 +91,33 @@ func (_m *ScanBuilder) DisableTtlFilter() ddb.ScanBuilder { return r0 } +// ScanBuilder_DisableTtlFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableTtlFilter' +type ScanBuilder_DisableTtlFilter_Call struct { + *mock.Call +} + +// DisableTtlFilter is a helper method to define mock.On call +func (_e *ScanBuilder_Expecter) DisableTtlFilter() *ScanBuilder_DisableTtlFilter_Call { + return &ScanBuilder_DisableTtlFilter_Call{Call: _e.mock.On("DisableTtlFilter")} +} + +func (_c *ScanBuilder_DisableTtlFilter_Call) Run(run func()) *ScanBuilder_DisableTtlFilter_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ScanBuilder_DisableTtlFilter_Call) Return(_a0 ddb.ScanBuilder) *ScanBuilder_DisableTtlFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ScanBuilder_DisableTtlFilter_Call) RunAndReturn(run func() ddb.ScanBuilder) *ScanBuilder_DisableTtlFilter_Call { + _c.Call.Return(run) + return _c +} + // WithConsistentRead provides a mock function with given fields: consistentRead func (_m *ScanBuilder) WithConsistentRead(consistentRead bool) ddb.ScanBuilder { ret := _m.Called(consistentRead) @@ -71,6 +134,34 @@ func (_m *ScanBuilder) WithConsistentRead(consistentRead bool) ddb.ScanBuilder { return r0 } +// ScanBuilder_WithConsistentRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithConsistentRead' +type ScanBuilder_WithConsistentRead_Call struct { + *mock.Call +} + +// WithConsistentRead is a helper method to define mock.On call +// - consistentRead bool +func (_e *ScanBuilder_Expecter) WithConsistentRead(consistentRead interface{}) *ScanBuilder_WithConsistentRead_Call { + return &ScanBuilder_WithConsistentRead_Call{Call: _e.mock.On("WithConsistentRead", consistentRead)} +} + +func (_c *ScanBuilder_WithConsistentRead_Call) Run(run func(consistentRead bool)) *ScanBuilder_WithConsistentRead_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *ScanBuilder_WithConsistentRead_Call) Return(_a0 ddb.ScanBuilder) *ScanBuilder_WithConsistentRead_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ScanBuilder_WithConsistentRead_Call) RunAndReturn(run func(bool) ddb.ScanBuilder) *ScanBuilder_WithConsistentRead_Call { + _c.Call.Return(run) + return _c +} + // WithFilter provides a mock function with given fields: filter func (_m *ScanBuilder) WithFilter(filter expression.ConditionBuilder) ddb.ScanBuilder { ret := _m.Called(filter) @@ -87,6 +178,34 @@ func (_m *ScanBuilder) WithFilter(filter expression.ConditionBuilder) ddb.ScanBu return r0 } +// ScanBuilder_WithFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithFilter' +type ScanBuilder_WithFilter_Call struct { + *mock.Call +} + +// WithFilter is a helper method to define mock.On call +// - filter expression.ConditionBuilder +func (_e *ScanBuilder_Expecter) WithFilter(filter interface{}) *ScanBuilder_WithFilter_Call { + return &ScanBuilder_WithFilter_Call{Call: _e.mock.On("WithFilter", filter)} +} + +func (_c *ScanBuilder_WithFilter_Call) Run(run func(filter expression.ConditionBuilder)) *ScanBuilder_WithFilter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(expression.ConditionBuilder)) + }) + return _c +} + +func (_c *ScanBuilder_WithFilter_Call) Return(_a0 ddb.ScanBuilder) *ScanBuilder_WithFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ScanBuilder_WithFilter_Call) RunAndReturn(run func(expression.ConditionBuilder) ddb.ScanBuilder) *ScanBuilder_WithFilter_Call { + _c.Call.Return(run) + return _c +} + // WithIndex provides a mock function with given fields: name func (_m *ScanBuilder) WithIndex(name string) ddb.ScanBuilder { ret := _m.Called(name) @@ -103,6 +222,34 @@ func (_m *ScanBuilder) WithIndex(name string) ddb.ScanBuilder { return r0 } +// ScanBuilder_WithIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithIndex' +type ScanBuilder_WithIndex_Call struct { + *mock.Call +} + +// WithIndex is a helper method to define mock.On call +// - name string +func (_e *ScanBuilder_Expecter) WithIndex(name interface{}) *ScanBuilder_WithIndex_Call { + return &ScanBuilder_WithIndex_Call{Call: _e.mock.On("WithIndex", name)} +} + +func (_c *ScanBuilder_WithIndex_Call) Run(run func(name string)) *ScanBuilder_WithIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *ScanBuilder_WithIndex_Call) Return(_a0 ddb.ScanBuilder) *ScanBuilder_WithIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ScanBuilder_WithIndex_Call) RunAndReturn(run func(string) ddb.ScanBuilder) *ScanBuilder_WithIndex_Call { + _c.Call.Return(run) + return _c +} + // WithLimit provides a mock function with given fields: limit func (_m *ScanBuilder) WithLimit(limit int) ddb.ScanBuilder { ret := _m.Called(limit) @@ -119,6 +266,34 @@ func (_m *ScanBuilder) WithLimit(limit int) ddb.ScanBuilder { return r0 } +// ScanBuilder_WithLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithLimit' +type ScanBuilder_WithLimit_Call struct { + *mock.Call +} + +// WithLimit is a helper method to define mock.On call +// - limit int +func (_e *ScanBuilder_Expecter) WithLimit(limit interface{}) *ScanBuilder_WithLimit_Call { + return &ScanBuilder_WithLimit_Call{Call: _e.mock.On("WithLimit", limit)} +} + +func (_c *ScanBuilder_WithLimit_Call) Run(run func(limit int)) *ScanBuilder_WithLimit_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *ScanBuilder_WithLimit_Call) Return(_a0 ddb.ScanBuilder) *ScanBuilder_WithLimit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ScanBuilder_WithLimit_Call) RunAndReturn(run func(int) ddb.ScanBuilder) *ScanBuilder_WithLimit_Call { + _c.Call.Return(run) + return _c +} + // WithPageSize provides a mock function with given fields: size func (_m *ScanBuilder) WithPageSize(size int) ddb.ScanBuilder { ret := _m.Called(size) @@ -135,6 +310,34 @@ func (_m *ScanBuilder) WithPageSize(size int) ddb.ScanBuilder { return r0 } +// ScanBuilder_WithPageSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithPageSize' +type ScanBuilder_WithPageSize_Call struct { + *mock.Call +} + +// WithPageSize is a helper method to define mock.On call +// - size int +func (_e *ScanBuilder_Expecter) WithPageSize(size interface{}) *ScanBuilder_WithPageSize_Call { + return &ScanBuilder_WithPageSize_Call{Call: _e.mock.On("WithPageSize", size)} +} + +func (_c *ScanBuilder_WithPageSize_Call) Run(run func(size int)) *ScanBuilder_WithPageSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *ScanBuilder_WithPageSize_Call) Return(_a0 ddb.ScanBuilder) *ScanBuilder_WithPageSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ScanBuilder_WithPageSize_Call) RunAndReturn(run func(int) ddb.ScanBuilder) *ScanBuilder_WithPageSize_Call { + _c.Call.Return(run) + return _c +} + // WithProjection provides a mock function with given fields: projection func (_m *ScanBuilder) WithProjection(projection interface{}) ddb.ScanBuilder { ret := _m.Called(projection) @@ -151,6 +354,34 @@ func (_m *ScanBuilder) WithProjection(projection interface{}) ddb.ScanBuilder { return r0 } +// ScanBuilder_WithProjection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithProjection' +type ScanBuilder_WithProjection_Call struct { + *mock.Call +} + +// WithProjection is a helper method to define mock.On call +// - projection interface{} +func (_e *ScanBuilder_Expecter) WithProjection(projection interface{}) *ScanBuilder_WithProjection_Call { + return &ScanBuilder_WithProjection_Call{Call: _e.mock.On("WithProjection", projection)} +} + +func (_c *ScanBuilder_WithProjection_Call) Run(run func(projection interface{})) *ScanBuilder_WithProjection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *ScanBuilder_WithProjection_Call) Return(_a0 ddb.ScanBuilder) *ScanBuilder_WithProjection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ScanBuilder_WithProjection_Call) RunAndReturn(run func(interface{}) ddb.ScanBuilder) *ScanBuilder_WithProjection_Call { + _c.Call.Return(run) + return _c +} + // WithSegment provides a mock function with given fields: segment, total func (_m *ScanBuilder) WithSegment(segment int, total int) ddb.ScanBuilder { ret := _m.Called(segment, total) @@ -167,6 +398,35 @@ func (_m *ScanBuilder) WithSegment(segment int, total int) ddb.ScanBuilder { return r0 } +// ScanBuilder_WithSegment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithSegment' +type ScanBuilder_WithSegment_Call struct { + *mock.Call +} + +// WithSegment is a helper method to define mock.On call +// - segment int +// - total int +func (_e *ScanBuilder_Expecter) WithSegment(segment interface{}, total interface{}) *ScanBuilder_WithSegment_Call { + return &ScanBuilder_WithSegment_Call{Call: _e.mock.On("WithSegment", segment, total)} +} + +func (_c *ScanBuilder_WithSegment_Call) Run(run func(segment int, total int)) *ScanBuilder_WithSegment_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(int)) + }) + return _c +} + +func (_c *ScanBuilder_WithSegment_Call) Return(_a0 ddb.ScanBuilder) *ScanBuilder_WithSegment_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ScanBuilder_WithSegment_Call) RunAndReturn(run func(int, int) ddb.ScanBuilder) *ScanBuilder_WithSegment_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewScanBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/TransactGetItemBuilder.go b/pkg/ddb/mocks/TransactGetItemBuilder.go index 3e2a926b4..8ee9e7505 100644 --- a/pkg/ddb/mocks/TransactGetItemBuilder.go +++ b/pkg/ddb/mocks/TransactGetItemBuilder.go @@ -12,6 +12,14 @@ type TransactGetItemBuilder struct { mock.Mock } +type TransactGetItemBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *TransactGetItemBuilder) EXPECT() *TransactGetItemBuilder_Expecter { + return &TransactGetItemBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: func (_m *TransactGetItemBuilder) Build() (types.TransactGetItem, error) { ret := _m.Called() @@ -36,6 +44,33 @@ func (_m *TransactGetItemBuilder) Build() (types.TransactGetItem, error) { return r0, r1 } +// TransactGetItemBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type TransactGetItemBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +func (_e *TransactGetItemBuilder_Expecter) Build() *TransactGetItemBuilder_Build_Call { + return &TransactGetItemBuilder_Build_Call{Call: _e.mock.On("Build")} +} + +func (_c *TransactGetItemBuilder_Build_Call) Run(run func()) *TransactGetItemBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TransactGetItemBuilder_Build_Call) Return(_a0 types.TransactGetItem, _a1 error) *TransactGetItemBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TransactGetItemBuilder_Build_Call) RunAndReturn(run func() (types.TransactGetItem, error)) *TransactGetItemBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // GetItem provides a mock function with given fields: func (_m *TransactGetItemBuilder) GetItem() interface{} { ret := _m.Called() @@ -52,6 +87,33 @@ func (_m *TransactGetItemBuilder) GetItem() interface{} { return r0 } +// TransactGetItemBuilder_GetItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItem' +type TransactGetItemBuilder_GetItem_Call struct { + *mock.Call +} + +// GetItem is a helper method to define mock.On call +func (_e *TransactGetItemBuilder_Expecter) GetItem() *TransactGetItemBuilder_GetItem_Call { + return &TransactGetItemBuilder_GetItem_Call{Call: _e.mock.On("GetItem")} +} + +func (_c *TransactGetItemBuilder_GetItem_Call) Run(run func()) *TransactGetItemBuilder_GetItem_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TransactGetItemBuilder_GetItem_Call) Return(_a0 interface{}) *TransactGetItemBuilder_GetItem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TransactGetItemBuilder_GetItem_Call) RunAndReturn(run func() interface{}) *TransactGetItemBuilder_GetItem_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTransactGetItemBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/TransactWriteItemBuilder.go b/pkg/ddb/mocks/TransactWriteItemBuilder.go index 04536b9b0..b64cadca5 100644 --- a/pkg/ddb/mocks/TransactWriteItemBuilder.go +++ b/pkg/ddb/mocks/TransactWriteItemBuilder.go @@ -12,6 +12,14 @@ type TransactWriteItemBuilder struct { mock.Mock } +type TransactWriteItemBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *TransactWriteItemBuilder) EXPECT() *TransactWriteItemBuilder_Expecter { + return &TransactWriteItemBuilder_Expecter{mock: &_m.Mock} +} + // Build provides a mock function with given fields: func (_m *TransactWriteItemBuilder) Build() (*types.TransactWriteItem, error) { ret := _m.Called() @@ -38,6 +46,33 @@ func (_m *TransactWriteItemBuilder) Build() (*types.TransactWriteItem, error) { return r0, r1 } +// TransactWriteItemBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type TransactWriteItemBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +func (_e *TransactWriteItemBuilder_Expecter) Build() *TransactWriteItemBuilder_Build_Call { + return &TransactWriteItemBuilder_Build_Call{Call: _e.mock.On("Build")} +} + +func (_c *TransactWriteItemBuilder_Build_Call) Run(run func()) *TransactWriteItemBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TransactWriteItemBuilder_Build_Call) Return(_a0 *types.TransactWriteItem, _a1 error) *TransactWriteItemBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TransactWriteItemBuilder_Build_Call) RunAndReturn(run func() (*types.TransactWriteItem, error)) *TransactWriteItemBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // GetItem provides a mock function with given fields: func (_m *TransactWriteItemBuilder) GetItem() interface{} { ret := _m.Called() @@ -54,6 +89,33 @@ func (_m *TransactWriteItemBuilder) GetItem() interface{} { return r0 } +// TransactWriteItemBuilder_GetItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItem' +type TransactWriteItemBuilder_GetItem_Call struct { + *mock.Call +} + +// GetItem is a helper method to define mock.On call +func (_e *TransactWriteItemBuilder_Expecter) GetItem() *TransactWriteItemBuilder_GetItem_Call { + return &TransactWriteItemBuilder_GetItem_Call{Call: _e.mock.On("GetItem")} +} + +func (_c *TransactWriteItemBuilder_GetItem_Call) Run(run func()) *TransactWriteItemBuilder_GetItem_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TransactWriteItemBuilder_GetItem_Call) Return(_a0 interface{}) *TransactWriteItemBuilder_GetItem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TransactWriteItemBuilder_GetItem_Call) RunAndReturn(run func() interface{}) *TransactWriteItemBuilder_GetItem_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTransactWriteItemBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/TransactionRepository.go b/pkg/ddb/mocks/TransactionRepository.go index 0e5293484..0cb716d23 100644 --- a/pkg/ddb/mocks/TransactionRepository.go +++ b/pkg/ddb/mocks/TransactionRepository.go @@ -14,6 +14,14 @@ type TransactionRepository struct { mock.Mock } +type TransactionRepository_Expecter struct { + mock *mock.Mock +} + +func (_m *TransactionRepository) EXPECT() *TransactionRepository_Expecter { + return &TransactionRepository_Expecter{mock: &_m.Mock} +} + // TransactGetItems provides a mock function with given fields: ctx, items func (_m *TransactionRepository) TransactGetItems(ctx context.Context, items []ddb.TransactGetItemBuilder) (*ddb.OperationResult, error) { ret := _m.Called(ctx, items) @@ -40,6 +48,35 @@ func (_m *TransactionRepository) TransactGetItems(ctx context.Context, items []d return r0, r1 } +// TransactionRepository_TransactGetItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactGetItems' +type TransactionRepository_TransactGetItems_Call struct { + *mock.Call +} + +// TransactGetItems is a helper method to define mock.On call +// - ctx context.Context +// - items []ddb.TransactGetItemBuilder +func (_e *TransactionRepository_Expecter) TransactGetItems(ctx interface{}, items interface{}) *TransactionRepository_TransactGetItems_Call { + return &TransactionRepository_TransactGetItems_Call{Call: _e.mock.On("TransactGetItems", ctx, items)} +} + +func (_c *TransactionRepository_TransactGetItems_Call) Run(run func(ctx context.Context, items []ddb.TransactGetItemBuilder)) *TransactionRepository_TransactGetItems_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]ddb.TransactGetItemBuilder)) + }) + return _c +} + +func (_c *TransactionRepository_TransactGetItems_Call) Return(_a0 *ddb.OperationResult, _a1 error) *TransactionRepository_TransactGetItems_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TransactionRepository_TransactGetItems_Call) RunAndReturn(run func(context.Context, []ddb.TransactGetItemBuilder) (*ddb.OperationResult, error)) *TransactionRepository_TransactGetItems_Call { + _c.Call.Return(run) + return _c +} + // TransactWriteItems provides a mock function with given fields: ctx, items func (_m *TransactionRepository) TransactWriteItems(ctx context.Context, items []ddb.TransactWriteItemBuilder) (*ddb.OperationResult, error) { ret := _m.Called(ctx, items) @@ -66,6 +103,35 @@ func (_m *TransactionRepository) TransactWriteItems(ctx context.Context, items [ return r0, r1 } +// TransactionRepository_TransactWriteItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactWriteItems' +type TransactionRepository_TransactWriteItems_Call struct { + *mock.Call +} + +// TransactWriteItems is a helper method to define mock.On call +// - ctx context.Context +// - items []ddb.TransactWriteItemBuilder +func (_e *TransactionRepository_Expecter) TransactWriteItems(ctx interface{}, items interface{}) *TransactionRepository_TransactWriteItems_Call { + return &TransactionRepository_TransactWriteItems_Call{Call: _e.mock.On("TransactWriteItems", ctx, items)} +} + +func (_c *TransactionRepository_TransactWriteItems_Call) Run(run func(ctx context.Context, items []ddb.TransactWriteItemBuilder)) *TransactionRepository_TransactWriteItems_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]ddb.TransactWriteItemBuilder)) + }) + return _c +} + +func (_c *TransactionRepository_TransactWriteItems_Call) Return(_a0 *ddb.OperationResult, _a1 error) *TransactionRepository_TransactWriteItems_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TransactionRepository_TransactWriteItems_Call) RunAndReturn(run func(context.Context, []ddb.TransactWriteItemBuilder) (*ddb.OperationResult, error)) *TransactionRepository_TransactWriteItems_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTransactionRepository interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ddb/mocks/UpdateItemBuilder.go b/pkg/ddb/mocks/UpdateItemBuilder.go index 54aa334ef..7b5c99827 100644 --- a/pkg/ddb/mocks/UpdateItemBuilder.go +++ b/pkg/ddb/mocks/UpdateItemBuilder.go @@ -16,6 +16,14 @@ type UpdateItemBuilder struct { mock.Mock } +type UpdateItemBuilder_Expecter struct { + mock *mock.Mock +} + +func (_m *UpdateItemBuilder) EXPECT() *UpdateItemBuilder_Expecter { + return &UpdateItemBuilder_Expecter{mock: &_m.Mock} +} + // Add provides a mock function with given fields: path, value func (_m *UpdateItemBuilder) Add(path string, value interface{}) ddb.UpdateItemBuilder { ret := _m.Called(path, value) @@ -32,6 +40,35 @@ func (_m *UpdateItemBuilder) Add(path string, value interface{}) ddb.UpdateItemB return r0 } +// UpdateItemBuilder_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add' +type UpdateItemBuilder_Add_Call struct { + *mock.Call +} + +// Add is a helper method to define mock.On call +// - path string +// - value interface{} +func (_e *UpdateItemBuilder_Expecter) Add(path interface{}, value interface{}) *UpdateItemBuilder_Add_Call { + return &UpdateItemBuilder_Add_Call{Call: _e.mock.On("Add", path, value)} +} + +func (_c *UpdateItemBuilder_Add_Call) Run(run func(path string, value interface{})) *UpdateItemBuilder_Add_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(interface{})) + }) + return _c +} + +func (_c *UpdateItemBuilder_Add_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_Add_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_Add_Call) RunAndReturn(run func(string, interface{}) ddb.UpdateItemBuilder) *UpdateItemBuilder_Add_Call { + _c.Call.Return(run) + return _c +} + // Build provides a mock function with given fields: item func (_m *UpdateItemBuilder) Build(item interface{}) (*dynamodb.UpdateItemInput, error) { ret := _m.Called(item) @@ -58,6 +95,34 @@ func (_m *UpdateItemBuilder) Build(item interface{}) (*dynamodb.UpdateItemInput, return r0, r1 } +// UpdateItemBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type UpdateItemBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +// - item interface{} +func (_e *UpdateItemBuilder_Expecter) Build(item interface{}) *UpdateItemBuilder_Build_Call { + return &UpdateItemBuilder_Build_Call{Call: _e.mock.On("Build", item)} +} + +func (_c *UpdateItemBuilder_Build_Call) Run(run func(item interface{})) *UpdateItemBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *UpdateItemBuilder_Build_Call) Return(_a0 *dynamodb.UpdateItemInput, _a1 error) *UpdateItemBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *UpdateItemBuilder_Build_Call) RunAndReturn(run func(interface{}) (*dynamodb.UpdateItemInput, error)) *UpdateItemBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: path, value func (_m *UpdateItemBuilder) Delete(path string, value interface{}) ddb.UpdateItemBuilder { ret := _m.Called(path, value) @@ -74,6 +139,35 @@ func (_m *UpdateItemBuilder) Delete(path string, value interface{}) ddb.UpdateIt return r0 } +// UpdateItemBuilder_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type UpdateItemBuilder_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - path string +// - value interface{} +func (_e *UpdateItemBuilder_Expecter) Delete(path interface{}, value interface{}) *UpdateItemBuilder_Delete_Call { + return &UpdateItemBuilder_Delete_Call{Call: _e.mock.On("Delete", path, value)} +} + +func (_c *UpdateItemBuilder_Delete_Call) Run(run func(path string, value interface{})) *UpdateItemBuilder_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(interface{})) + }) + return _c +} + +func (_c *UpdateItemBuilder_Delete_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_Delete_Call) RunAndReturn(run func(string, interface{}) ddb.UpdateItemBuilder) *UpdateItemBuilder_Delete_Call { + _c.Call.Return(run) + return _c +} + // Remove provides a mock function with given fields: path func (_m *UpdateItemBuilder) Remove(path string) ddb.UpdateItemBuilder { ret := _m.Called(path) @@ -90,6 +184,34 @@ func (_m *UpdateItemBuilder) Remove(path string) ddb.UpdateItemBuilder { return r0 } +// UpdateItemBuilder_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove' +type UpdateItemBuilder_Remove_Call struct { + *mock.Call +} + +// Remove is a helper method to define mock.On call +// - path string +func (_e *UpdateItemBuilder_Expecter) Remove(path interface{}) *UpdateItemBuilder_Remove_Call { + return &UpdateItemBuilder_Remove_Call{Call: _e.mock.On("Remove", path)} +} + +func (_c *UpdateItemBuilder_Remove_Call) Run(run func(path string)) *UpdateItemBuilder_Remove_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *UpdateItemBuilder_Remove_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_Remove_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_Remove_Call) RunAndReturn(run func(string) ddb.UpdateItemBuilder) *UpdateItemBuilder_Remove_Call { + _c.Call.Return(run) + return _c +} + // RemoveMultiple provides a mock function with given fields: paths func (_m *UpdateItemBuilder) RemoveMultiple(paths ...string) ddb.UpdateItemBuilder { _va := make([]interface{}, len(paths)) @@ -112,6 +234,41 @@ func (_m *UpdateItemBuilder) RemoveMultiple(paths ...string) ddb.UpdateItemBuild return r0 } +// UpdateItemBuilder_RemoveMultiple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMultiple' +type UpdateItemBuilder_RemoveMultiple_Call struct { + *mock.Call +} + +// RemoveMultiple is a helper method to define mock.On call +// - paths ...string +func (_e *UpdateItemBuilder_Expecter) RemoveMultiple(paths ...interface{}) *UpdateItemBuilder_RemoveMultiple_Call { + return &UpdateItemBuilder_RemoveMultiple_Call{Call: _e.mock.On("RemoveMultiple", + append([]interface{}{}, paths...)...)} +} + +func (_c *UpdateItemBuilder_RemoveMultiple_Call) Run(run func(paths ...string)) *UpdateItemBuilder_RemoveMultiple_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *UpdateItemBuilder_RemoveMultiple_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_RemoveMultiple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_RemoveMultiple_Call) RunAndReturn(run func(...string) ddb.UpdateItemBuilder) *UpdateItemBuilder_RemoveMultiple_Call { + _c.Call.Return(run) + return _c +} + // ReturnAllNew provides a mock function with given fields: func (_m *UpdateItemBuilder) ReturnAllNew() ddb.UpdateItemBuilder { ret := _m.Called() @@ -128,6 +285,33 @@ func (_m *UpdateItemBuilder) ReturnAllNew() ddb.UpdateItemBuilder { return r0 } +// UpdateItemBuilder_ReturnAllNew_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllNew' +type UpdateItemBuilder_ReturnAllNew_Call struct { + *mock.Call +} + +// ReturnAllNew is a helper method to define mock.On call +func (_e *UpdateItemBuilder_Expecter) ReturnAllNew() *UpdateItemBuilder_ReturnAllNew_Call { + return &UpdateItemBuilder_ReturnAllNew_Call{Call: _e.mock.On("ReturnAllNew")} +} + +func (_c *UpdateItemBuilder_ReturnAllNew_Call) Run(run func()) *UpdateItemBuilder_ReturnAllNew_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateItemBuilder_ReturnAllNew_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnAllNew_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_ReturnAllNew_Call) RunAndReturn(run func() ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnAllNew_Call { + _c.Call.Return(run) + return _c +} + // ReturnAllOld provides a mock function with given fields: func (_m *UpdateItemBuilder) ReturnAllOld() ddb.UpdateItemBuilder { ret := _m.Called() @@ -144,6 +328,33 @@ func (_m *UpdateItemBuilder) ReturnAllOld() ddb.UpdateItemBuilder { return r0 } +// UpdateItemBuilder_ReturnAllOld_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllOld' +type UpdateItemBuilder_ReturnAllOld_Call struct { + *mock.Call +} + +// ReturnAllOld is a helper method to define mock.On call +func (_e *UpdateItemBuilder_Expecter) ReturnAllOld() *UpdateItemBuilder_ReturnAllOld_Call { + return &UpdateItemBuilder_ReturnAllOld_Call{Call: _e.mock.On("ReturnAllOld")} +} + +func (_c *UpdateItemBuilder_ReturnAllOld_Call) Run(run func()) *UpdateItemBuilder_ReturnAllOld_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateItemBuilder_ReturnAllOld_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnAllOld_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_ReturnAllOld_Call) RunAndReturn(run func() ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnAllOld_Call { + _c.Call.Return(run) + return _c +} + // ReturnNone provides a mock function with given fields: func (_m *UpdateItemBuilder) ReturnNone() ddb.UpdateItemBuilder { ret := _m.Called() @@ -160,6 +371,33 @@ func (_m *UpdateItemBuilder) ReturnNone() ddb.UpdateItemBuilder { return r0 } +// UpdateItemBuilder_ReturnNone_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnNone' +type UpdateItemBuilder_ReturnNone_Call struct { + *mock.Call +} + +// ReturnNone is a helper method to define mock.On call +func (_e *UpdateItemBuilder_Expecter) ReturnNone() *UpdateItemBuilder_ReturnNone_Call { + return &UpdateItemBuilder_ReturnNone_Call{Call: _e.mock.On("ReturnNone")} +} + +func (_c *UpdateItemBuilder_ReturnNone_Call) Run(run func()) *UpdateItemBuilder_ReturnNone_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateItemBuilder_ReturnNone_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnNone_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_ReturnNone_Call) RunAndReturn(run func() ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnNone_Call { + _c.Call.Return(run) + return _c +} + // ReturnUpdatedNew provides a mock function with given fields: func (_m *UpdateItemBuilder) ReturnUpdatedNew() ddb.UpdateItemBuilder { ret := _m.Called() @@ -176,6 +414,33 @@ func (_m *UpdateItemBuilder) ReturnUpdatedNew() ddb.UpdateItemBuilder { return r0 } +// UpdateItemBuilder_ReturnUpdatedNew_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnUpdatedNew' +type UpdateItemBuilder_ReturnUpdatedNew_Call struct { + *mock.Call +} + +// ReturnUpdatedNew is a helper method to define mock.On call +func (_e *UpdateItemBuilder_Expecter) ReturnUpdatedNew() *UpdateItemBuilder_ReturnUpdatedNew_Call { + return &UpdateItemBuilder_ReturnUpdatedNew_Call{Call: _e.mock.On("ReturnUpdatedNew")} +} + +func (_c *UpdateItemBuilder_ReturnUpdatedNew_Call) Run(run func()) *UpdateItemBuilder_ReturnUpdatedNew_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateItemBuilder_ReturnUpdatedNew_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnUpdatedNew_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_ReturnUpdatedNew_Call) RunAndReturn(run func() ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnUpdatedNew_Call { + _c.Call.Return(run) + return _c +} + // ReturnUpdatedOld provides a mock function with given fields: func (_m *UpdateItemBuilder) ReturnUpdatedOld() ddb.UpdateItemBuilder { ret := _m.Called() @@ -192,6 +457,33 @@ func (_m *UpdateItemBuilder) ReturnUpdatedOld() ddb.UpdateItemBuilder { return r0 } +// UpdateItemBuilder_ReturnUpdatedOld_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnUpdatedOld' +type UpdateItemBuilder_ReturnUpdatedOld_Call struct { + *mock.Call +} + +// ReturnUpdatedOld is a helper method to define mock.On call +func (_e *UpdateItemBuilder_Expecter) ReturnUpdatedOld() *UpdateItemBuilder_ReturnUpdatedOld_Call { + return &UpdateItemBuilder_ReturnUpdatedOld_Call{Call: _e.mock.On("ReturnUpdatedOld")} +} + +func (_c *UpdateItemBuilder_ReturnUpdatedOld_Call) Run(run func()) *UpdateItemBuilder_ReturnUpdatedOld_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateItemBuilder_ReturnUpdatedOld_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnUpdatedOld_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_ReturnUpdatedOld_Call) RunAndReturn(run func() ddb.UpdateItemBuilder) *UpdateItemBuilder_ReturnUpdatedOld_Call { + _c.Call.Return(run) + return _c +} + // Set provides a mock function with given fields: path, value func (_m *UpdateItemBuilder) Set(path string, value interface{}) ddb.UpdateItemBuilder { ret := _m.Called(path, value) @@ -208,6 +500,35 @@ func (_m *UpdateItemBuilder) Set(path string, value interface{}) ddb.UpdateItemB return r0 } +// UpdateItemBuilder_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set' +type UpdateItemBuilder_Set_Call struct { + *mock.Call +} + +// Set is a helper method to define mock.On call +// - path string +// - value interface{} +func (_e *UpdateItemBuilder_Expecter) Set(path interface{}, value interface{}) *UpdateItemBuilder_Set_Call { + return &UpdateItemBuilder_Set_Call{Call: _e.mock.On("Set", path, value)} +} + +func (_c *UpdateItemBuilder_Set_Call) Run(run func(path string, value interface{})) *UpdateItemBuilder_Set_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(interface{})) + }) + return _c +} + +func (_c *UpdateItemBuilder_Set_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_Set_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_Set_Call) RunAndReturn(run func(string, interface{}) ddb.UpdateItemBuilder) *UpdateItemBuilder_Set_Call { + _c.Call.Return(run) + return _c +} + // SetIfNotExist provides a mock function with given fields: path, value func (_m *UpdateItemBuilder) SetIfNotExist(path string, value interface{}) ddb.UpdateItemBuilder { ret := _m.Called(path, value) @@ -224,6 +545,35 @@ func (_m *UpdateItemBuilder) SetIfNotExist(path string, value interface{}) ddb.U return r0 } +// UpdateItemBuilder_SetIfNotExist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetIfNotExist' +type UpdateItemBuilder_SetIfNotExist_Call struct { + *mock.Call +} + +// SetIfNotExist is a helper method to define mock.On call +// - path string +// - value interface{} +func (_e *UpdateItemBuilder_Expecter) SetIfNotExist(path interface{}, value interface{}) *UpdateItemBuilder_SetIfNotExist_Call { + return &UpdateItemBuilder_SetIfNotExist_Call{Call: _e.mock.On("SetIfNotExist", path, value)} +} + +func (_c *UpdateItemBuilder_SetIfNotExist_Call) Run(run func(path string, value interface{})) *UpdateItemBuilder_SetIfNotExist_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(interface{})) + }) + return _c +} + +func (_c *UpdateItemBuilder_SetIfNotExist_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_SetIfNotExist_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_SetIfNotExist_Call) RunAndReturn(run func(string, interface{}) ddb.UpdateItemBuilder) *UpdateItemBuilder_SetIfNotExist_Call { + _c.Call.Return(run) + return _c +} + // SetMap provides a mock function with given fields: values func (_m *UpdateItemBuilder) SetMap(values map[string]interface{}) ddb.UpdateItemBuilder { ret := _m.Called(values) @@ -240,6 +590,34 @@ func (_m *UpdateItemBuilder) SetMap(values map[string]interface{}) ddb.UpdateIte return r0 } +// UpdateItemBuilder_SetMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMap' +type UpdateItemBuilder_SetMap_Call struct { + *mock.Call +} + +// SetMap is a helper method to define mock.On call +// - values map[string]interface{} +func (_e *UpdateItemBuilder_Expecter) SetMap(values interface{}) *UpdateItemBuilder_SetMap_Call { + return &UpdateItemBuilder_SetMap_Call{Call: _e.mock.On("SetMap", values)} +} + +func (_c *UpdateItemBuilder_SetMap_Call) Run(run func(values map[string]interface{})) *UpdateItemBuilder_SetMap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]interface{})) + }) + return _c +} + +func (_c *UpdateItemBuilder_SetMap_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_SetMap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_SetMap_Call) RunAndReturn(run func(map[string]interface{}) ddb.UpdateItemBuilder) *UpdateItemBuilder_SetMap_Call { + _c.Call.Return(run) + return _c +} + // WithCondition provides a mock function with given fields: cond func (_m *UpdateItemBuilder) WithCondition(cond expression.ConditionBuilder) ddb.UpdateItemBuilder { ret := _m.Called(cond) @@ -256,6 +634,34 @@ func (_m *UpdateItemBuilder) WithCondition(cond expression.ConditionBuilder) ddb return r0 } +// UpdateItemBuilder_WithCondition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithCondition' +type UpdateItemBuilder_WithCondition_Call struct { + *mock.Call +} + +// WithCondition is a helper method to define mock.On call +// - cond expression.ConditionBuilder +func (_e *UpdateItemBuilder_Expecter) WithCondition(cond interface{}) *UpdateItemBuilder_WithCondition_Call { + return &UpdateItemBuilder_WithCondition_Call{Call: _e.mock.On("WithCondition", cond)} +} + +func (_c *UpdateItemBuilder_WithCondition_Call) Run(run func(cond expression.ConditionBuilder)) *UpdateItemBuilder_WithCondition_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(expression.ConditionBuilder)) + }) + return _c +} + +func (_c *UpdateItemBuilder_WithCondition_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_WithCondition_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_WithCondition_Call) RunAndReturn(run func(expression.ConditionBuilder) ddb.UpdateItemBuilder) *UpdateItemBuilder_WithCondition_Call { + _c.Call.Return(run) + return _c +} + // WithHash provides a mock function with given fields: hashValue func (_m *UpdateItemBuilder) WithHash(hashValue interface{}) ddb.UpdateItemBuilder { ret := _m.Called(hashValue) @@ -272,6 +678,34 @@ func (_m *UpdateItemBuilder) WithHash(hashValue interface{}) ddb.UpdateItemBuild return r0 } +// UpdateItemBuilder_WithHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithHash' +type UpdateItemBuilder_WithHash_Call struct { + *mock.Call +} + +// WithHash is a helper method to define mock.On call +// - hashValue interface{} +func (_e *UpdateItemBuilder_Expecter) WithHash(hashValue interface{}) *UpdateItemBuilder_WithHash_Call { + return &UpdateItemBuilder_WithHash_Call{Call: _e.mock.On("WithHash", hashValue)} +} + +func (_c *UpdateItemBuilder_WithHash_Call) Run(run func(hashValue interface{})) *UpdateItemBuilder_WithHash_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *UpdateItemBuilder_WithHash_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_WithHash_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_WithHash_Call) RunAndReturn(run func(interface{}) ddb.UpdateItemBuilder) *UpdateItemBuilder_WithHash_Call { + _c.Call.Return(run) + return _c +} + // WithRange provides a mock function with given fields: rangeValue func (_m *UpdateItemBuilder) WithRange(rangeValue interface{}) ddb.UpdateItemBuilder { ret := _m.Called(rangeValue) @@ -288,6 +722,34 @@ func (_m *UpdateItemBuilder) WithRange(rangeValue interface{}) ddb.UpdateItemBui return r0 } +// UpdateItemBuilder_WithRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRange' +type UpdateItemBuilder_WithRange_Call struct { + *mock.Call +} + +// WithRange is a helper method to define mock.On call +// - rangeValue interface{} +func (_e *UpdateItemBuilder_Expecter) WithRange(rangeValue interface{}) *UpdateItemBuilder_WithRange_Call { + return &UpdateItemBuilder_WithRange_Call{Call: _e.mock.On("WithRange", rangeValue)} +} + +func (_c *UpdateItemBuilder_WithRange_Call) Run(run func(rangeValue interface{})) *UpdateItemBuilder_WithRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *UpdateItemBuilder_WithRange_Call) Return(_a0 ddb.UpdateItemBuilder) *UpdateItemBuilder_WithRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateItemBuilder_WithRange_Call) RunAndReturn(run func(interface{}) ddb.UpdateItemBuilder) *UpdateItemBuilder_WithRange_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewUpdateItemBuilder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/guard/mocks/Guard.go b/pkg/guard/mocks/Guard.go index 5e9704fab..7685899b7 100644 --- a/pkg/guard/mocks/Guard.go +++ b/pkg/guard/mocks/Guard.go @@ -12,6 +12,14 @@ type Guard struct { mock.Mock } +type Guard_Expecter struct { + mock *mock.Mock +} + +func (_m *Guard) EXPECT() *Guard_Expecter { + return &Guard_Expecter{mock: &_m.Mock} +} + // CreatePolicy provides a mock function with given fields: pol func (_m *Guard) CreatePolicy(pol ladon.Policy) error { ret := _m.Called(pol) @@ -26,6 +34,34 @@ func (_m *Guard) CreatePolicy(pol ladon.Policy) error { return r0 } +// Guard_CreatePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePolicy' +type Guard_CreatePolicy_Call struct { + *mock.Call +} + +// CreatePolicy is a helper method to define mock.On call +// - pol ladon.Policy +func (_e *Guard_Expecter) CreatePolicy(pol interface{}) *Guard_CreatePolicy_Call { + return &Guard_CreatePolicy_Call{Call: _e.mock.On("CreatePolicy", pol)} +} + +func (_c *Guard_CreatePolicy_Call) Run(run func(pol ladon.Policy)) *Guard_CreatePolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(ladon.Policy)) + }) + return _c +} + +func (_c *Guard_CreatePolicy_Call) Return(_a0 error) *Guard_CreatePolicy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Guard_CreatePolicy_Call) RunAndReturn(run func(ladon.Policy) error) *Guard_CreatePolicy_Call { + _c.Call.Return(run) + return _c +} + // DeletePolicy provides a mock function with given fields: pol func (_m *Guard) DeletePolicy(pol ladon.Policy) error { ret := _m.Called(pol) @@ -40,6 +76,34 @@ func (_m *Guard) DeletePolicy(pol ladon.Policy) error { return r0 } +// Guard_DeletePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePolicy' +type Guard_DeletePolicy_Call struct { + *mock.Call +} + +// DeletePolicy is a helper method to define mock.On call +// - pol ladon.Policy +func (_e *Guard_Expecter) DeletePolicy(pol interface{}) *Guard_DeletePolicy_Call { + return &Guard_DeletePolicy_Call{Call: _e.mock.On("DeletePolicy", pol)} +} + +func (_c *Guard_DeletePolicy_Call) Run(run func(pol ladon.Policy)) *Guard_DeletePolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(ladon.Policy)) + }) + return _c +} + +func (_c *Guard_DeletePolicy_Call) Return(_a0 error) *Guard_DeletePolicy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Guard_DeletePolicy_Call) RunAndReturn(run func(ladon.Policy) error) *Guard_DeletePolicy_Call { + _c.Call.Return(run) + return _c +} + // GetPolicies provides a mock function with given fields: func (_m *Guard) GetPolicies() (ladon.Policies, error) { ret := _m.Called() @@ -66,6 +130,33 @@ func (_m *Guard) GetPolicies() (ladon.Policies, error) { return r0, r1 } +// Guard_GetPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicies' +type Guard_GetPolicies_Call struct { + *mock.Call +} + +// GetPolicies is a helper method to define mock.On call +func (_e *Guard_Expecter) GetPolicies() *Guard_GetPolicies_Call { + return &Guard_GetPolicies_Call{Call: _e.mock.On("GetPolicies")} +} + +func (_c *Guard_GetPolicies_Call) Run(run func()) *Guard_GetPolicies_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Guard_GetPolicies_Call) Return(_a0 ladon.Policies, _a1 error) *Guard_GetPolicies_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Guard_GetPolicies_Call) RunAndReturn(run func() (ladon.Policies, error)) *Guard_GetPolicies_Call { + _c.Call.Return(run) + return _c +} + // GetPoliciesBySubject provides a mock function with given fields: subject func (_m *Guard) GetPoliciesBySubject(subject string) (ladon.Policies, error) { ret := _m.Called(subject) @@ -92,6 +183,34 @@ func (_m *Guard) GetPoliciesBySubject(subject string) (ladon.Policies, error) { return r0, r1 } +// Guard_GetPoliciesBySubject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPoliciesBySubject' +type Guard_GetPoliciesBySubject_Call struct { + *mock.Call +} + +// GetPoliciesBySubject is a helper method to define mock.On call +// - subject string +func (_e *Guard_Expecter) GetPoliciesBySubject(subject interface{}) *Guard_GetPoliciesBySubject_Call { + return &Guard_GetPoliciesBySubject_Call{Call: _e.mock.On("GetPoliciesBySubject", subject)} +} + +func (_c *Guard_GetPoliciesBySubject_Call) Run(run func(subject string)) *Guard_GetPoliciesBySubject_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Guard_GetPoliciesBySubject_Call) Return(_a0 ladon.Policies, _a1 error) *Guard_GetPoliciesBySubject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Guard_GetPoliciesBySubject_Call) RunAndReturn(run func(string) (ladon.Policies, error)) *Guard_GetPoliciesBySubject_Call { + _c.Call.Return(run) + return _c +} + // GetPolicy provides a mock function with given fields: id func (_m *Guard) GetPolicy(id string) (ladon.Policy, error) { ret := _m.Called(id) @@ -118,6 +237,34 @@ func (_m *Guard) GetPolicy(id string) (ladon.Policy, error) { return r0, r1 } +// Guard_GetPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPolicy' +type Guard_GetPolicy_Call struct { + *mock.Call +} + +// GetPolicy is a helper method to define mock.On call +// - id string +func (_e *Guard_Expecter) GetPolicy(id interface{}) *Guard_GetPolicy_Call { + return &Guard_GetPolicy_Call{Call: _e.mock.On("GetPolicy", id)} +} + +func (_c *Guard_GetPolicy_Call) Run(run func(id string)) *Guard_GetPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Guard_GetPolicy_Call) Return(_a0 ladon.Policy, _a1 error) *Guard_GetPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Guard_GetPolicy_Call) RunAndReturn(run func(string) (ladon.Policy, error)) *Guard_GetPolicy_Call { + _c.Call.Return(run) + return _c +} + // IsAllowed provides a mock function with given fields: request func (_m *Guard) IsAllowed(request *ladon.Request) error { ret := _m.Called(request) @@ -132,6 +279,34 @@ func (_m *Guard) IsAllowed(request *ladon.Request) error { return r0 } +// Guard_IsAllowed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAllowed' +type Guard_IsAllowed_Call struct { + *mock.Call +} + +// IsAllowed is a helper method to define mock.On call +// - request *ladon.Request +func (_e *Guard_Expecter) IsAllowed(request interface{}) *Guard_IsAllowed_Call { + return &Guard_IsAllowed_Call{Call: _e.mock.On("IsAllowed", request)} +} + +func (_c *Guard_IsAllowed_Call) Run(run func(request *ladon.Request)) *Guard_IsAllowed_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*ladon.Request)) + }) + return _c +} + +func (_c *Guard_IsAllowed_Call) Return(_a0 error) *Guard_IsAllowed_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Guard_IsAllowed_Call) RunAndReturn(run func(*ladon.Request) error) *Guard_IsAllowed_Call { + _c.Call.Return(run) + return _c +} + // UpdatePolicy provides a mock function with given fields: pol func (_m *Guard) UpdatePolicy(pol ladon.Policy) error { ret := _m.Called(pol) @@ -146,6 +321,34 @@ func (_m *Guard) UpdatePolicy(pol ladon.Policy) error { return r0 } +// Guard_UpdatePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePolicy' +type Guard_UpdatePolicy_Call struct { + *mock.Call +} + +// UpdatePolicy is a helper method to define mock.On call +// - pol ladon.Policy +func (_e *Guard_Expecter) UpdatePolicy(pol interface{}) *Guard_UpdatePolicy_Call { + return &Guard_UpdatePolicy_Call{Call: _e.mock.On("UpdatePolicy", pol)} +} + +func (_c *Guard_UpdatePolicy_Call) Run(run func(pol ladon.Policy)) *Guard_UpdatePolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(ladon.Policy)) + }) + return _c +} + +func (_c *Guard_UpdatePolicy_Call) Return(_a0 error) *Guard_UpdatePolicy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Guard_UpdatePolicy_Call) RunAndReturn(run func(ladon.Policy) error) *Guard_UpdatePolicy_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewGuard interface { mock.TestingT Cleanup(func()) diff --git a/pkg/guard/mocks/Manager.go b/pkg/guard/mocks/Manager.go index a882b045c..b4d68c31a 100644 --- a/pkg/guard/mocks/Manager.go +++ b/pkg/guard/mocks/Manager.go @@ -12,6 +12,14 @@ type Manager struct { mock.Mock } +type Manager_Expecter struct { + mock *mock.Mock +} + +func (_m *Manager) EXPECT() *Manager_Expecter { + return &Manager_Expecter{mock: &_m.Mock} +} + // Create provides a mock function with given fields: policy func (_m *Manager) Create(policy ladon.Policy) error { ret := _m.Called(policy) @@ -26,6 +34,34 @@ func (_m *Manager) Create(policy ladon.Policy) error { return r0 } +// Manager_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type Manager_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - policy ladon.Policy +func (_e *Manager_Expecter) Create(policy interface{}) *Manager_Create_Call { + return &Manager_Create_Call{Call: _e.mock.On("Create", policy)} +} + +func (_c *Manager_Create_Call) Run(run func(policy ladon.Policy)) *Manager_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(ladon.Policy)) + }) + return _c +} + +func (_c *Manager_Create_Call) Return(_a0 error) *Manager_Create_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Manager_Create_Call) RunAndReturn(run func(ladon.Policy) error) *Manager_Create_Call { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: id func (_m *Manager) Delete(id string) error { ret := _m.Called(id) @@ -40,6 +76,34 @@ func (_m *Manager) Delete(id string) error { return r0 } +// Manager_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type Manager_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - id string +func (_e *Manager_Expecter) Delete(id interface{}) *Manager_Delete_Call { + return &Manager_Delete_Call{Call: _e.mock.On("Delete", id)} +} + +func (_c *Manager_Delete_Call) Run(run func(id string)) *Manager_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Manager_Delete_Call) Return(_a0 error) *Manager_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Manager_Delete_Call) RunAndReturn(run func(string) error) *Manager_Delete_Call { + _c.Call.Return(run) + return _c +} + // FindPoliciesForResource provides a mock function with given fields: resource func (_m *Manager) FindPoliciesForResource(resource string) (ladon.Policies, error) { ret := _m.Called(resource) @@ -66,6 +130,34 @@ func (_m *Manager) FindPoliciesForResource(resource string) (ladon.Policies, err return r0, r1 } +// Manager_FindPoliciesForResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindPoliciesForResource' +type Manager_FindPoliciesForResource_Call struct { + *mock.Call +} + +// FindPoliciesForResource is a helper method to define mock.On call +// - resource string +func (_e *Manager_Expecter) FindPoliciesForResource(resource interface{}) *Manager_FindPoliciesForResource_Call { + return &Manager_FindPoliciesForResource_Call{Call: _e.mock.On("FindPoliciesForResource", resource)} +} + +func (_c *Manager_FindPoliciesForResource_Call) Run(run func(resource string)) *Manager_FindPoliciesForResource_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Manager_FindPoliciesForResource_Call) Return(_a0 ladon.Policies, _a1 error) *Manager_FindPoliciesForResource_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Manager_FindPoliciesForResource_Call) RunAndReturn(run func(string) (ladon.Policies, error)) *Manager_FindPoliciesForResource_Call { + _c.Call.Return(run) + return _c +} + // FindPoliciesForSubject provides a mock function with given fields: subject func (_m *Manager) FindPoliciesForSubject(subject string) (ladon.Policies, error) { ret := _m.Called(subject) @@ -92,6 +184,34 @@ func (_m *Manager) FindPoliciesForSubject(subject string) (ladon.Policies, error return r0, r1 } +// Manager_FindPoliciesForSubject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindPoliciesForSubject' +type Manager_FindPoliciesForSubject_Call struct { + *mock.Call +} + +// FindPoliciesForSubject is a helper method to define mock.On call +// - subject string +func (_e *Manager_Expecter) FindPoliciesForSubject(subject interface{}) *Manager_FindPoliciesForSubject_Call { + return &Manager_FindPoliciesForSubject_Call{Call: _e.mock.On("FindPoliciesForSubject", subject)} +} + +func (_c *Manager_FindPoliciesForSubject_Call) Run(run func(subject string)) *Manager_FindPoliciesForSubject_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Manager_FindPoliciesForSubject_Call) Return(_a0 ladon.Policies, _a1 error) *Manager_FindPoliciesForSubject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Manager_FindPoliciesForSubject_Call) RunAndReturn(run func(string) (ladon.Policies, error)) *Manager_FindPoliciesForSubject_Call { + _c.Call.Return(run) + return _c +} + // FindRequestCandidates provides a mock function with given fields: r func (_m *Manager) FindRequestCandidates(r *ladon.Request) (ladon.Policies, error) { ret := _m.Called(r) @@ -118,6 +238,34 @@ func (_m *Manager) FindRequestCandidates(r *ladon.Request) (ladon.Policies, erro return r0, r1 } +// Manager_FindRequestCandidates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindRequestCandidates' +type Manager_FindRequestCandidates_Call struct { + *mock.Call +} + +// FindRequestCandidates is a helper method to define mock.On call +// - r *ladon.Request +func (_e *Manager_Expecter) FindRequestCandidates(r interface{}) *Manager_FindRequestCandidates_Call { + return &Manager_FindRequestCandidates_Call{Call: _e.mock.On("FindRequestCandidates", r)} +} + +func (_c *Manager_FindRequestCandidates_Call) Run(run func(r *ladon.Request)) *Manager_FindRequestCandidates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*ladon.Request)) + }) + return _c +} + +func (_c *Manager_FindRequestCandidates_Call) Return(_a0 ladon.Policies, _a1 error) *Manager_FindRequestCandidates_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Manager_FindRequestCandidates_Call) RunAndReturn(run func(*ladon.Request) (ladon.Policies, error)) *Manager_FindRequestCandidates_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: id func (_m *Manager) Get(id string) (ladon.Policy, error) { ret := _m.Called(id) @@ -144,6 +292,34 @@ func (_m *Manager) Get(id string) (ladon.Policy, error) { return r0, r1 } +// Manager_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Manager_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - id string +func (_e *Manager_Expecter) Get(id interface{}) *Manager_Get_Call { + return &Manager_Get_Call{Call: _e.mock.On("Get", id)} +} + +func (_c *Manager_Get_Call) Run(run func(id string)) *Manager_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Manager_Get_Call) Return(_a0 ladon.Policy, _a1 error) *Manager_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Manager_Get_Call) RunAndReturn(run func(string) (ladon.Policy, error)) *Manager_Get_Call { + _c.Call.Return(run) + return _c +} + // GetAll provides a mock function with given fields: limit, offset func (_m *Manager) GetAll(limit int64, offset int64) (ladon.Policies, error) { ret := _m.Called(limit, offset) @@ -170,6 +346,35 @@ func (_m *Manager) GetAll(limit int64, offset int64) (ladon.Policies, error) { return r0, r1 } +// Manager_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll' +type Manager_GetAll_Call struct { + *mock.Call +} + +// GetAll is a helper method to define mock.On call +// - limit int64 +// - offset int64 +func (_e *Manager_Expecter) GetAll(limit interface{}, offset interface{}) *Manager_GetAll_Call { + return &Manager_GetAll_Call{Call: _e.mock.On("GetAll", limit, offset)} +} + +func (_c *Manager_GetAll_Call) Run(run func(limit int64, offset int64)) *Manager_GetAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int64), args[1].(int64)) + }) + return _c +} + +func (_c *Manager_GetAll_Call) Return(_a0 ladon.Policies, _a1 error) *Manager_GetAll_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Manager_GetAll_Call) RunAndReturn(run func(int64, int64) (ladon.Policies, error)) *Manager_GetAll_Call { + _c.Call.Return(run) + return _c +} + // Update provides a mock function with given fields: policy func (_m *Manager) Update(policy ladon.Policy) error { ret := _m.Called(policy) @@ -184,6 +389,34 @@ func (_m *Manager) Update(policy ladon.Policy) error { return r0 } +// Manager_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type Manager_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - policy ladon.Policy +func (_e *Manager_Expecter) Update(policy interface{}) *Manager_Update_Call { + return &Manager_Update_Call{Call: _e.mock.On("Update", policy)} +} + +func (_c *Manager_Update_Call) Run(run func(policy ladon.Policy)) *Manager_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(ladon.Policy)) + }) + return _c +} + +func (_c *Manager_Update_Call) Return(_a0 error) *Manager_Update_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Manager_Update_Call) RunAndReturn(run func(ladon.Policy) error) *Manager_Update_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) diff --git a/pkg/http/mocks/Client.go b/pkg/http/mocks/Client.go index a1dce5d46..51a6d626f 100644 --- a/pkg/http/mocks/Client.go +++ b/pkg/http/mocks/Client.go @@ -18,11 +18,47 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // AddRetryCondition provides a mock function with given fields: f func (_m *Client) AddRetryCondition(f http.RetryConditionFunc) { _m.Called(f) } +// Client_AddRetryCondition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRetryCondition' +type Client_AddRetryCondition_Call struct { + *mock.Call +} + +// AddRetryCondition is a helper method to define mock.On call +// - f http.RetryConditionFunc +func (_e *Client_Expecter) AddRetryCondition(f interface{}) *Client_AddRetryCondition_Call { + return &Client_AddRetryCondition_Call{Call: _e.mock.On("AddRetryCondition", f)} +} + +func (_c *Client_AddRetryCondition_Call) Run(run func(f http.RetryConditionFunc)) *Client_AddRetryCondition_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(http.RetryConditionFunc)) + }) + return _c +} + +func (_c *Client_AddRetryCondition_Call) Return() *Client_AddRetryCondition_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_AddRetryCondition_Call) RunAndReturn(run func(http.RetryConditionFunc)) *Client_AddRetryCondition_Call { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: ctx, request func (_m *Client) Delete(ctx context.Context, request *http.Request) (*http.Response, error) { ret := _m.Called(ctx, request) @@ -49,6 +85,35 @@ func (_m *Client) Delete(ctx context.Context, request *http.Request) (*http.Resp return r0, r1 } +// Client_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type Client_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - request *http.Request +func (_e *Client_Expecter) Delete(ctx interface{}, request interface{}) *Client_Delete_Call { + return &Client_Delete_Call{Call: _e.mock.On("Delete", ctx, request)} +} + +func (_c *Client_Delete_Call) Run(run func(ctx context.Context, request *http.Request)) *Client_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*http.Request)) + }) + return _c +} + +func (_c *Client_Delete_Call) Return(_a0 *http.Response, _a1 error) *Client_Delete_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Delete_Call) RunAndReturn(run func(context.Context, *http.Request) (*http.Response, error)) *Client_Delete_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: ctx, request func (_m *Client) Get(ctx context.Context, request *http.Request) (*http.Response, error) { ret := _m.Called(ctx, request) @@ -75,6 +140,35 @@ func (_m *Client) Get(ctx context.Context, request *http.Request) (*http.Respons return r0, r1 } +// Client_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Client_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - request *http.Request +func (_e *Client_Expecter) Get(ctx interface{}, request interface{}) *Client_Get_Call { + return &Client_Get_Call{Call: _e.mock.On("Get", ctx, request)} +} + +func (_c *Client_Get_Call) Run(run func(ctx context.Context, request *http.Request)) *Client_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*http.Request)) + }) + return _c +} + +func (_c *Client_Get_Call) Return(_a0 *http.Response, _a1 error) *Client_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Get_Call) RunAndReturn(run func(context.Context, *http.Request) (*http.Response, error)) *Client_Get_Call { + _c.Call.Return(run) + return _c +} + // NewJsonRequest provides a mock function with given fields: func (_m *Client) NewJsonRequest() *http.Request { ret := _m.Called() @@ -91,6 +185,33 @@ func (_m *Client) NewJsonRequest() *http.Request { return r0 } +// Client_NewJsonRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewJsonRequest' +type Client_NewJsonRequest_Call struct { + *mock.Call +} + +// NewJsonRequest is a helper method to define mock.On call +func (_e *Client_Expecter) NewJsonRequest() *Client_NewJsonRequest_Call { + return &Client_NewJsonRequest_Call{Call: _e.mock.On("NewJsonRequest")} +} + +func (_c *Client_NewJsonRequest_Call) Run(run func()) *Client_NewJsonRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Client_NewJsonRequest_Call) Return(_a0 *http.Request) *Client_NewJsonRequest_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_NewJsonRequest_Call) RunAndReturn(run func() *http.Request) *Client_NewJsonRequest_Call { + _c.Call.Return(run) + return _c +} + // NewRequest provides a mock function with given fields: func (_m *Client) NewRequest() *http.Request { ret := _m.Called() @@ -107,6 +228,33 @@ func (_m *Client) NewRequest() *http.Request { return r0 } +// Client_NewRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewRequest' +type Client_NewRequest_Call struct { + *mock.Call +} + +// NewRequest is a helper method to define mock.On call +func (_e *Client_Expecter) NewRequest() *Client_NewRequest_Call { + return &Client_NewRequest_Call{Call: _e.mock.On("NewRequest")} +} + +func (_c *Client_NewRequest_Call) Run(run func()) *Client_NewRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Client_NewRequest_Call) Return(_a0 *http.Request) *Client_NewRequest_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_NewRequest_Call) RunAndReturn(run func() *http.Request) *Client_NewRequest_Call { + _c.Call.Return(run) + return _c +} + // NewXmlRequest provides a mock function with given fields: func (_m *Client) NewXmlRequest() *http.Request { ret := _m.Called() @@ -123,6 +271,33 @@ func (_m *Client) NewXmlRequest() *http.Request { return r0 } +// Client_NewXmlRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewXmlRequest' +type Client_NewXmlRequest_Call struct { + *mock.Call +} + +// NewXmlRequest is a helper method to define mock.On call +func (_e *Client_Expecter) NewXmlRequest() *Client_NewXmlRequest_Call { + return &Client_NewXmlRequest_Call{Call: _e.mock.On("NewXmlRequest")} +} + +func (_c *Client_NewXmlRequest_Call) Run(run func()) *Client_NewXmlRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Client_NewXmlRequest_Call) Return(_a0 *http.Request) *Client_NewXmlRequest_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_NewXmlRequest_Call) RunAndReturn(run func() *http.Request) *Client_NewXmlRequest_Call { + _c.Call.Return(run) + return _c +} + // Patch provides a mock function with given fields: ctx, request func (_m *Client) Patch(ctx context.Context, request *http.Request) (*http.Response, error) { ret := _m.Called(ctx, request) @@ -149,6 +324,35 @@ func (_m *Client) Patch(ctx context.Context, request *http.Request) (*http.Respo return r0, r1 } +// Client_Patch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Patch' +type Client_Patch_Call struct { + *mock.Call +} + +// Patch is a helper method to define mock.On call +// - ctx context.Context +// - request *http.Request +func (_e *Client_Expecter) Patch(ctx interface{}, request interface{}) *Client_Patch_Call { + return &Client_Patch_Call{Call: _e.mock.On("Patch", ctx, request)} +} + +func (_c *Client_Patch_Call) Run(run func(ctx context.Context, request *http.Request)) *Client_Patch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*http.Request)) + }) + return _c +} + +func (_c *Client_Patch_Call) Return(_a0 *http.Response, _a1 error) *Client_Patch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Patch_Call) RunAndReturn(run func(context.Context, *http.Request) (*http.Response, error)) *Client_Patch_Call { + _c.Call.Return(run) + return _c +} + // Post provides a mock function with given fields: ctx, request func (_m *Client) Post(ctx context.Context, request *http.Request) (*http.Response, error) { ret := _m.Called(ctx, request) @@ -175,6 +379,35 @@ func (_m *Client) Post(ctx context.Context, request *http.Request) (*http.Respon return r0, r1 } +// Client_Post_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Post' +type Client_Post_Call struct { + *mock.Call +} + +// Post is a helper method to define mock.On call +// - ctx context.Context +// - request *http.Request +func (_e *Client_Expecter) Post(ctx interface{}, request interface{}) *Client_Post_Call { + return &Client_Post_Call{Call: _e.mock.On("Post", ctx, request)} +} + +func (_c *Client_Post_Call) Run(run func(ctx context.Context, request *http.Request)) *Client_Post_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*http.Request)) + }) + return _c +} + +func (_c *Client_Post_Call) Return(_a0 *http.Response, _a1 error) *Client_Post_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Post_Call) RunAndReturn(run func(context.Context, *http.Request) (*http.Response, error)) *Client_Post_Call { + _c.Call.Return(run) + return _c +} + // Put provides a mock function with given fields: ctx, request func (_m *Client) Put(ctx context.Context, request *http.Request) (*http.Response, error) { ret := _m.Called(ctx, request) @@ -201,36 +434,233 @@ func (_m *Client) Put(ctx context.Context, request *http.Request) (*http.Respons return r0, r1 } +// Client_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type Client_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - ctx context.Context +// - request *http.Request +func (_e *Client_Expecter) Put(ctx interface{}, request interface{}) *Client_Put_Call { + return &Client_Put_Call{Call: _e.mock.On("Put", ctx, request)} +} + +func (_c *Client_Put_Call) Run(run func(ctx context.Context, request *http.Request)) *Client_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*http.Request)) + }) + return _c +} + +func (_c *Client_Put_Call) Return(_a0 *http.Response, _a1 error) *Client_Put_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Put_Call) RunAndReturn(run func(context.Context, *http.Request) (*http.Response, error)) *Client_Put_Call { + _c.Call.Return(run) + return _c +} + // SetCookie provides a mock function with given fields: c func (_m *Client) SetCookie(c *nethttp.Cookie) { _m.Called(c) } +// Client_SetCookie_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCookie' +type Client_SetCookie_Call struct { + *mock.Call +} + +// SetCookie is a helper method to define mock.On call +// - c *nethttp.Cookie +func (_e *Client_Expecter) SetCookie(c interface{}) *Client_SetCookie_Call { + return &Client_SetCookie_Call{Call: _e.mock.On("SetCookie", c)} +} + +func (_c *Client_SetCookie_Call) Run(run func(c *nethttp.Cookie)) *Client_SetCookie_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*nethttp.Cookie)) + }) + return _c +} + +func (_c *Client_SetCookie_Call) Return() *Client_SetCookie_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_SetCookie_Call) RunAndReturn(run func(*nethttp.Cookie)) *Client_SetCookie_Call { + _c.Call.Return(run) + return _c +} + // SetCookies provides a mock function with given fields: cs func (_m *Client) SetCookies(cs []*nethttp.Cookie) { _m.Called(cs) } +// Client_SetCookies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCookies' +type Client_SetCookies_Call struct { + *mock.Call +} + +// SetCookies is a helper method to define mock.On call +// - cs []*nethttp.Cookie +func (_e *Client_Expecter) SetCookies(cs interface{}) *Client_SetCookies_Call { + return &Client_SetCookies_Call{Call: _e.mock.On("SetCookies", cs)} +} + +func (_c *Client_SetCookies_Call) Run(run func(cs []*nethttp.Cookie)) *Client_SetCookies_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]*nethttp.Cookie)) + }) + return _c +} + +func (_c *Client_SetCookies_Call) Return() *Client_SetCookies_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_SetCookies_Call) RunAndReturn(run func([]*nethttp.Cookie)) *Client_SetCookies_Call { + _c.Call.Return(run) + return _c +} + // SetProxyUrl provides a mock function with given fields: p func (_m *Client) SetProxyUrl(p string) { _m.Called(p) } +// Client_SetProxyUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProxyUrl' +type Client_SetProxyUrl_Call struct { + *mock.Call +} + +// SetProxyUrl is a helper method to define mock.On call +// - p string +func (_e *Client_Expecter) SetProxyUrl(p interface{}) *Client_SetProxyUrl_Call { + return &Client_SetProxyUrl_Call{Call: _e.mock.On("SetProxyUrl", p)} +} + +func (_c *Client_SetProxyUrl_Call) Run(run func(p string)) *Client_SetProxyUrl_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Client_SetProxyUrl_Call) Return() *Client_SetProxyUrl_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_SetProxyUrl_Call) RunAndReturn(run func(string)) *Client_SetProxyUrl_Call { + _c.Call.Return(run) + return _c +} + // SetRedirectValidator provides a mock function with given fields: allowRequest func (_m *Client) SetRedirectValidator(allowRequest func(*nethttp.Request) bool) { _m.Called(allowRequest) } +// Client_SetRedirectValidator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetRedirectValidator' +type Client_SetRedirectValidator_Call struct { + *mock.Call +} + +// SetRedirectValidator is a helper method to define mock.On call +// - allowRequest func(*nethttp.Request) bool +func (_e *Client_Expecter) SetRedirectValidator(allowRequest interface{}) *Client_SetRedirectValidator_Call { + return &Client_SetRedirectValidator_Call{Call: _e.mock.On("SetRedirectValidator", allowRequest)} +} + +func (_c *Client_SetRedirectValidator_Call) Run(run func(allowRequest func(*nethttp.Request) bool)) *Client_SetRedirectValidator_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(*nethttp.Request) bool)) + }) + return _c +} + +func (_c *Client_SetRedirectValidator_Call) Return() *Client_SetRedirectValidator_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_SetRedirectValidator_Call) RunAndReturn(run func(func(*nethttp.Request) bool)) *Client_SetRedirectValidator_Call { + _c.Call.Return(run) + return _c +} + // SetTimeout provides a mock function with given fields: timeout func (_m *Client) SetTimeout(timeout time.Duration) { _m.Called(timeout) } +// Client_SetTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTimeout' +type Client_SetTimeout_Call struct { + *mock.Call +} + +// SetTimeout is a helper method to define mock.On call +// - timeout time.Duration +func (_e *Client_Expecter) SetTimeout(timeout interface{}) *Client_SetTimeout_Call { + return &Client_SetTimeout_Call{Call: _e.mock.On("SetTimeout", timeout)} +} + +func (_c *Client_SetTimeout_Call) Run(run func(timeout time.Duration)) *Client_SetTimeout_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *Client_SetTimeout_Call) Return() *Client_SetTimeout_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_SetTimeout_Call) RunAndReturn(run func(time.Duration)) *Client_SetTimeout_Call { + _c.Call.Return(run) + return _c +} + // SetUserAgent provides a mock function with given fields: ua func (_m *Client) SetUserAgent(ua string) { _m.Called(ua) } +// Client_SetUserAgent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserAgent' +type Client_SetUserAgent_Call struct { + *mock.Call +} + +// SetUserAgent is a helper method to define mock.On call +// - ua string +func (_e *Client_Expecter) SetUserAgent(ua interface{}) *Client_SetUserAgent_Call { + return &Client_SetUserAgent_Call{Call: _e.mock.On("SetUserAgent", ua)} +} + +func (_c *Client_SetUserAgent_Call) Run(run func(ua string)) *Client_SetUserAgent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Client_SetUserAgent_Call) Return() *Client_SetUserAgent_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_SetUserAgent_Call) RunAndReturn(run func(string)) *Client_SetUserAgent_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/ipread/mocks/Reader.go b/pkg/ipread/mocks/Reader.go index d264c2614..7e076e92c 100644 --- a/pkg/ipread/mocks/Reader.go +++ b/pkg/ipread/mocks/Reader.go @@ -12,6 +12,14 @@ type Reader struct { mock.Mock } +type Reader_Expecter struct { + mock *mock.Mock +} + +func (_m *Reader) EXPECT() *Reader_Expecter { + return &Reader_Expecter{mock: &_m.Mock} +} + // City provides a mock function with given fields: ipString func (_m *Reader) City(ipString string) (*ipread.GeoCity, error) { ret := _m.Called(ipString) @@ -38,6 +46,34 @@ func (_m *Reader) City(ipString string) (*ipread.GeoCity, error) { return r0, r1 } +// Reader_City_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'City' +type Reader_City_Call struct { + *mock.Call +} + +// City is a helper method to define mock.On call +// - ipString string +func (_e *Reader_Expecter) City(ipString interface{}) *Reader_City_Call { + return &Reader_City_Call{Call: _e.mock.On("City", ipString)} +} + +func (_c *Reader_City_Call) Run(run func(ipString string)) *Reader_City_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Reader_City_Call) Return(_a0 *ipread.GeoCity, _a1 error) *Reader_City_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Reader_City_Call) RunAndReturn(run func(string) (*ipread.GeoCity, error)) *Reader_City_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewReader interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kafka/consumer/consumer_offset_manager.go b/pkg/kafka/consumer/consumer_offset_manager.go index f0485b91a..07515bb94 100644 --- a/pkg/kafka/consumer/consumer_offset_manager.go +++ b/pkg/kafka/consumer/consumer_offset_manager.go @@ -2,9 +2,8 @@ package consumer import ( "context" - "time" - "sync" + "time" "github.com/justtrackio/gosoline/pkg/log" "github.com/segmentio/kafka-go" diff --git a/pkg/kafka/consumer/mocks/Batcher.go b/pkg/kafka/consumer/mocks/Batcher.go index 2a6f11b2f..afee7bd80 100644 --- a/pkg/kafka/consumer/mocks/Batcher.go +++ b/pkg/kafka/consumer/mocks/Batcher.go @@ -14,6 +14,14 @@ type Batcher struct { mock.Mock } +type Batcher_Expecter struct { + mock *mock.Mock +} + +func (_m *Batcher) EXPECT() *Batcher_Expecter { + return &Batcher_Expecter{mock: &_m.Mock} +} + // Get provides a mock function with given fields: ctx func (_m *Batcher) Get(ctx context.Context) []kafka.Message { ret := _m.Called(ctx) @@ -30,6 +38,34 @@ func (_m *Batcher) Get(ctx context.Context) []kafka.Message { return r0 } +// Batcher_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Batcher_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +func (_e *Batcher_Expecter) Get(ctx interface{}) *Batcher_Get_Call { + return &Batcher_Get_Call{Call: _e.mock.On("Get", ctx)} +} + +func (_c *Batcher_Get_Call) Run(run func(ctx context.Context)) *Batcher_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Batcher_Get_Call) Return(_a0 []kafka.Message) *Batcher_Get_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Batcher_Get_Call) RunAndReturn(run func(context.Context) []kafka.Message) *Batcher_Get_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewBatcher interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kafka/consumer/mocks/OffsetManager.go b/pkg/kafka/consumer/mocks/OffsetManager.go index e7cd93c8c..c1e40b983 100644 --- a/pkg/kafka/consumer/mocks/OffsetManager.go +++ b/pkg/kafka/consumer/mocks/OffsetManager.go @@ -14,6 +14,14 @@ type OffsetManager struct { mock.Mock } +type OffsetManager_Expecter struct { + mock *mock.Mock +} + +func (_m *OffsetManager) EXPECT() *OffsetManager_Expecter { + return &OffsetManager_Expecter{mock: &_m.Mock} +} + // Batch provides a mock function with given fields: ctx func (_m *OffsetManager) Batch(ctx context.Context) []kafka.Message { ret := _m.Called(ctx) @@ -30,6 +38,34 @@ func (_m *OffsetManager) Batch(ctx context.Context) []kafka.Message { return r0 } +// OffsetManager_Batch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Batch' +type OffsetManager_Batch_Call struct { + *mock.Call +} + +// Batch is a helper method to define mock.On call +// - ctx context.Context +func (_e *OffsetManager_Expecter) Batch(ctx interface{}) *OffsetManager_Batch_Call { + return &OffsetManager_Batch_Call{Call: _e.mock.On("Batch", ctx)} +} + +func (_c *OffsetManager_Batch_Call) Run(run func(ctx context.Context)) *OffsetManager_Batch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OffsetManager_Batch_Call) Return(_a0 []kafka.Message) *OffsetManager_Batch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OffsetManager_Batch_Call) RunAndReturn(run func(context.Context) []kafka.Message) *OffsetManager_Batch_Call { + _c.Call.Return(run) + return _c +} + // Commit provides a mock function with given fields: ctx, msgs func (_m *OffsetManager) Commit(ctx context.Context, msgs ...kafka.Message) error { _va := make([]interface{}, len(msgs)) @@ -51,6 +87,42 @@ func (_m *OffsetManager) Commit(ctx context.Context, msgs ...kafka.Message) erro return r0 } +// OffsetManager_Commit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Commit' +type OffsetManager_Commit_Call struct { + *mock.Call +} + +// Commit is a helper method to define mock.On call +// - ctx context.Context +// - msgs ...kafka.Message +func (_e *OffsetManager_Expecter) Commit(ctx interface{}, msgs ...interface{}) *OffsetManager_Commit_Call { + return &OffsetManager_Commit_Call{Call: _e.mock.On("Commit", + append([]interface{}{ctx}, msgs...)...)} +} + +func (_c *OffsetManager_Commit_Call) Run(run func(ctx context.Context, msgs ...kafka.Message)) *OffsetManager_Commit_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]kafka.Message, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(kafka.Message) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *OffsetManager_Commit_Call) Return(_a0 error) *OffsetManager_Commit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OffsetManager_Commit_Call) RunAndReturn(run func(context.Context, ...kafka.Message) error) *OffsetManager_Commit_Call { + _c.Call.Return(run) + return _c +} + // Flush provides a mock function with given fields: func (_m *OffsetManager) Flush() error { ret := _m.Called() @@ -65,6 +137,33 @@ func (_m *OffsetManager) Flush() error { return r0 } +// OffsetManager_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush' +type OffsetManager_Flush_Call struct { + *mock.Call +} + +// Flush is a helper method to define mock.On call +func (_e *OffsetManager_Expecter) Flush() *OffsetManager_Flush_Call { + return &OffsetManager_Flush_Call{Call: _e.mock.On("Flush")} +} + +func (_c *OffsetManager_Flush_Call) Run(run func()) *OffsetManager_Flush_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OffsetManager_Flush_Call) Return(_a0 error) *OffsetManager_Flush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OffsetManager_Flush_Call) RunAndReturn(run func() error) *OffsetManager_Flush_Call { + _c.Call.Return(run) + return _c +} + // Start provides a mock function with given fields: ctx func (_m *OffsetManager) Start(ctx context.Context) error { ret := _m.Called(ctx) @@ -79,6 +178,34 @@ func (_m *OffsetManager) Start(ctx context.Context) error { return r0 } +// OffsetManager_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type OffsetManager_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - ctx context.Context +func (_e *OffsetManager_Expecter) Start(ctx interface{}) *OffsetManager_Start_Call { + return &OffsetManager_Start_Call{Call: _e.mock.On("Start", ctx)} +} + +func (_c *OffsetManager_Start_Call) Run(run func(ctx context.Context)) *OffsetManager_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OffsetManager_Start_Call) Return(_a0 error) *OffsetManager_Start_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OffsetManager_Start_Call) RunAndReturn(run func(context.Context) error) *OffsetManager_Start_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewOffsetManager interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kafka/consumer/mocks/Reader.go b/pkg/kafka/consumer/mocks/Reader.go index 9473924f3..c09d7a424 100644 --- a/pkg/kafka/consumer/mocks/Reader.go +++ b/pkg/kafka/consumer/mocks/Reader.go @@ -14,6 +14,14 @@ type Reader struct { mock.Mock } +type Reader_Expecter struct { + mock *mock.Mock +} + +func (_m *Reader) EXPECT() *Reader_Expecter { + return &Reader_Expecter{mock: &_m.Mock} +} + // Close provides a mock function with given fields: func (_m *Reader) Close() error { ret := _m.Called() @@ -28,6 +36,33 @@ func (_m *Reader) Close() error { return r0 } +// Reader_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type Reader_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *Reader_Expecter) Close() *Reader_Close_Call { + return &Reader_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *Reader_Close_Call) Run(run func()) *Reader_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Reader_Close_Call) Return(_a0 error) *Reader_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Reader_Close_Call) RunAndReturn(run func() error) *Reader_Close_Call { + _c.Call.Return(run) + return _c +} + // CommitMessages provides a mock function with given fields: _a0, _a1 func (_m *Reader) CommitMessages(_a0 context.Context, _a1 ...kafka.Message) error { _va := make([]interface{}, len(_a1)) @@ -49,6 +84,42 @@ func (_m *Reader) CommitMessages(_a0 context.Context, _a1 ...kafka.Message) erro return r0 } +// Reader_CommitMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommitMessages' +type Reader_CommitMessages_Call struct { + *mock.Call +} + +// CommitMessages is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 ...kafka.Message +func (_e *Reader_Expecter) CommitMessages(_a0 interface{}, _a1 ...interface{}) *Reader_CommitMessages_Call { + return &Reader_CommitMessages_Call{Call: _e.mock.On("CommitMessages", + append([]interface{}{_a0}, _a1...)...)} +} + +func (_c *Reader_CommitMessages_Call) Run(run func(_a0 context.Context, _a1 ...kafka.Message)) *Reader_CommitMessages_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]kafka.Message, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(kafka.Message) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *Reader_CommitMessages_Call) Return(_a0 error) *Reader_CommitMessages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Reader_CommitMessages_Call) RunAndReturn(run func(context.Context, ...kafka.Message) error) *Reader_CommitMessages_Call { + _c.Call.Return(run) + return _c +} + // FetchMessage provides a mock function with given fields: _a0 func (_m *Reader) FetchMessage(_a0 context.Context) (kafka.Message, error) { ret := _m.Called(_a0) @@ -73,6 +144,34 @@ func (_m *Reader) FetchMessage(_a0 context.Context) (kafka.Message, error) { return r0, r1 } +// Reader_FetchMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchMessage' +type Reader_FetchMessage_Call struct { + *mock.Call +} + +// FetchMessage is a helper method to define mock.On call +// - _a0 context.Context +func (_e *Reader_Expecter) FetchMessage(_a0 interface{}) *Reader_FetchMessage_Call { + return &Reader_FetchMessage_Call{Call: _e.mock.On("FetchMessage", _a0)} +} + +func (_c *Reader_FetchMessage_Call) Run(run func(_a0 context.Context)) *Reader_FetchMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Reader_FetchMessage_Call) Return(_a0 kafka.Message, _a1 error) *Reader_FetchMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Reader_FetchMessage_Call) RunAndReturn(run func(context.Context) (kafka.Message, error)) *Reader_FetchMessage_Call { + _c.Call.Return(run) + return _c +} + // ReadMessage provides a mock function with given fields: _a0 func (_m *Reader) ReadMessage(_a0 context.Context) (kafka.Message, error) { ret := _m.Called(_a0) @@ -97,6 +196,34 @@ func (_m *Reader) ReadMessage(_a0 context.Context) (kafka.Message, error) { return r0, r1 } +// Reader_ReadMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadMessage' +type Reader_ReadMessage_Call struct { + *mock.Call +} + +// ReadMessage is a helper method to define mock.On call +// - _a0 context.Context +func (_e *Reader_Expecter) ReadMessage(_a0 interface{}) *Reader_ReadMessage_Call { + return &Reader_ReadMessage_Call{Call: _e.mock.On("ReadMessage", _a0)} +} + +func (_c *Reader_ReadMessage_Call) Run(run func(_a0 context.Context)) *Reader_ReadMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Reader_ReadMessage_Call) Return(_a0 kafka.Message, _a1 error) *Reader_ReadMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Reader_ReadMessage_Call) RunAndReturn(run func(context.Context) (kafka.Message, error)) *Reader_ReadMessage_Call { + _c.Call.Return(run) + return _c +} + // Stats provides a mock function with given fields: func (_m *Reader) Stats() kafka.ReaderStats { ret := _m.Called() @@ -111,6 +238,33 @@ func (_m *Reader) Stats() kafka.ReaderStats { return r0 } +// Reader_Stats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stats' +type Reader_Stats_Call struct { + *mock.Call +} + +// Stats is a helper method to define mock.On call +func (_e *Reader_Expecter) Stats() *Reader_Stats_Call { + return &Reader_Stats_Call{Call: _e.mock.On("Stats")} +} + +func (_c *Reader_Stats_Call) Run(run func()) *Reader_Stats_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Reader_Stats_Call) Return(_a0 kafka.ReaderStats) *Reader_Stats_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Reader_Stats_Call) RunAndReturn(run func() kafka.ReaderStats) *Reader_Stats_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewReader interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kafka/producer/writer.go b/pkg/kafka/producer/writer.go index 2190b1f3e..c964f0cca 100644 --- a/pkg/kafka/producer/writer.go +++ b/pkg/kafka/producer/writer.go @@ -31,7 +31,7 @@ const ( DefaultIdleTimeout = 30 * time.Second ) -//go:generate mockery --name Writer --unroll-variadic=False +//go:generate mockery --name Writer --unroll-variadic=False --with-expecter=False type Writer interface { WriteMessages(ctx context.Context, msgs ...kafka.Message) error Stats() kafka.WriterStats diff --git a/pkg/kernel/mocks/FullModule.go b/pkg/kernel/mocks/FullModule.go index 5ad464150..9fa1ee5a1 100644 --- a/pkg/kernel/mocks/FullModule.go +++ b/pkg/kernel/mocks/FullModule.go @@ -13,6 +13,14 @@ type FullModule struct { mock.Mock } +type FullModule_Expecter struct { + mock *mock.Mock +} + +func (_m *FullModule) EXPECT() *FullModule_Expecter { + return &FullModule_Expecter{mock: &_m.Mock} +} + // GetStage provides a mock function with given fields: func (_m *FullModule) GetStage() int { ret := _m.Called() @@ -27,6 +35,33 @@ func (_m *FullModule) GetStage() int { return r0 } +// FullModule_GetStage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStage' +type FullModule_GetStage_Call struct { + *mock.Call +} + +// GetStage is a helper method to define mock.On call +func (_e *FullModule_Expecter) GetStage() *FullModule_GetStage_Call { + return &FullModule_GetStage_Call{Call: _e.mock.On("GetStage")} +} + +func (_c *FullModule_GetStage_Call) Run(run func()) *FullModule_GetStage_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *FullModule_GetStage_Call) Return(_a0 int) *FullModule_GetStage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FullModule_GetStage_Call) RunAndReturn(run func() int) *FullModule_GetStage_Call { + _c.Call.Return(run) + return _c +} + // IsBackground provides a mock function with given fields: func (_m *FullModule) IsBackground() bool { ret := _m.Called() @@ -41,6 +76,33 @@ func (_m *FullModule) IsBackground() bool { return r0 } +// FullModule_IsBackground_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsBackground' +type FullModule_IsBackground_Call struct { + *mock.Call +} + +// IsBackground is a helper method to define mock.On call +func (_e *FullModule_Expecter) IsBackground() *FullModule_IsBackground_Call { + return &FullModule_IsBackground_Call{Call: _e.mock.On("IsBackground")} +} + +func (_c *FullModule_IsBackground_Call) Run(run func()) *FullModule_IsBackground_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *FullModule_IsBackground_Call) Return(_a0 bool) *FullModule_IsBackground_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FullModule_IsBackground_Call) RunAndReturn(run func() bool) *FullModule_IsBackground_Call { + _c.Call.Return(run) + return _c +} + // IsEssential provides a mock function with given fields: func (_m *FullModule) IsEssential() bool { ret := _m.Called() @@ -55,6 +117,33 @@ func (_m *FullModule) IsEssential() bool { return r0 } +// FullModule_IsEssential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsEssential' +type FullModule_IsEssential_Call struct { + *mock.Call +} + +// IsEssential is a helper method to define mock.On call +func (_e *FullModule_Expecter) IsEssential() *FullModule_IsEssential_Call { + return &FullModule_IsEssential_Call{Call: _e.mock.On("IsEssential")} +} + +func (_c *FullModule_IsEssential_Call) Run(run func()) *FullModule_IsEssential_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *FullModule_IsEssential_Call) Return(_a0 bool) *FullModule_IsEssential_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FullModule_IsEssential_Call) RunAndReturn(run func() bool) *FullModule_IsEssential_Call { + _c.Call.Return(run) + return _c +} + // Run provides a mock function with given fields: ctx func (_m *FullModule) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -69,6 +158,34 @@ func (_m *FullModule) Run(ctx context.Context) error { return r0 } +// FullModule_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type FullModule_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *FullModule_Expecter) Run(ctx interface{}) *FullModule_Run_Call { + return &FullModule_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *FullModule_Run_Call) Run(run func(ctx context.Context)) *FullModule_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *FullModule_Run_Call) Return(_a0 error) *FullModule_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FullModule_Run_Call) RunAndReturn(run func(context.Context) error) *FullModule_Run_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewFullModule interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kernel/mocks/Kernel.go b/pkg/kernel/mocks/Kernel.go index b1a5120db..7b3c141e2 100644 --- a/pkg/kernel/mocks/Kernel.go +++ b/pkg/kernel/mocks/Kernel.go @@ -9,11 +9,46 @@ type Kernel struct { mock.Mock } +type Kernel_Expecter struct { + mock *mock.Mock +} + +func (_m *Kernel) EXPECT() *Kernel_Expecter { + return &Kernel_Expecter{mock: &_m.Mock} +} + // Run provides a mock function with given fields: func (_m *Kernel) Run() { _m.Called() } +// Kernel_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type Kernel_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +func (_e *Kernel_Expecter) Run() *Kernel_Run_Call { + return &Kernel_Run_Call{Call: _e.mock.On("Run")} +} + +func (_c *Kernel_Run_Call) Run(run func()) *Kernel_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Kernel_Run_Call) Return() *Kernel_Run_Call { + _c.Call.Return() + return _c +} + +func (_c *Kernel_Run_Call) RunAndReturn(run func()) *Kernel_Run_Call { + _c.Call.Return(run) + return _c +} + // Running provides a mock function with given fields: func (_m *Kernel) Running() <-chan struct{} { ret := _m.Called() @@ -30,11 +65,66 @@ func (_m *Kernel) Running() <-chan struct{} { return r0 } +// Kernel_Running_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Running' +type Kernel_Running_Call struct { + *mock.Call +} + +// Running is a helper method to define mock.On call +func (_e *Kernel_Expecter) Running() *Kernel_Running_Call { + return &Kernel_Running_Call{Call: _e.mock.On("Running")} +} + +func (_c *Kernel_Running_Call) Run(run func()) *Kernel_Running_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Kernel_Running_Call) Return(_a0 <-chan struct{}) *Kernel_Running_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Kernel_Running_Call) RunAndReturn(run func() <-chan struct{}) *Kernel_Running_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: reason func (_m *Kernel) Stop(reason string) { _m.Called(reason) } +// Kernel_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type Kernel_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +// - reason string +func (_e *Kernel_Expecter) Stop(reason interface{}) *Kernel_Stop_Call { + return &Kernel_Stop_Call{Call: _e.mock.On("Stop", reason)} +} + +func (_c *Kernel_Stop_Call) Run(run func(reason string)) *Kernel_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Kernel_Stop_Call) Return() *Kernel_Stop_Call { + _c.Call.Return() + return _c +} + +func (_c *Kernel_Stop_Call) RunAndReturn(run func(string)) *Kernel_Stop_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewKernel interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kernel/mocks/Module.go b/pkg/kernel/mocks/Module.go index ea5051efc..594e5745c 100644 --- a/pkg/kernel/mocks/Module.go +++ b/pkg/kernel/mocks/Module.go @@ -13,6 +13,14 @@ type Module struct { mock.Mock } +type Module_Expecter struct { + mock *mock.Mock +} + +func (_m *Module) EXPECT() *Module_Expecter { + return &Module_Expecter{mock: &_m.Mock} +} + // Run provides a mock function with given fields: ctx func (_m *Module) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -27,6 +35,34 @@ func (_m *Module) Run(ctx context.Context) error { return r0 } +// Module_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type Module_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *Module_Expecter) Run(ctx interface{}) *Module_Run_Call { + return &Module_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *Module_Run_Call) Run(run func(ctx context.Context)) *Module_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Module_Run_Call) Return(_a0 error) *Module_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Module_Run_Call) RunAndReturn(run func(context.Context) error) *Module_Run_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewModule interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kernel/mocks/StagedModule.go b/pkg/kernel/mocks/StagedModule.go index 624934f62..853fab6b0 100644 --- a/pkg/kernel/mocks/StagedModule.go +++ b/pkg/kernel/mocks/StagedModule.go @@ -9,6 +9,14 @@ type StagedModule struct { mock.Mock } +type StagedModule_Expecter struct { + mock *mock.Mock +} + +func (_m *StagedModule) EXPECT() *StagedModule_Expecter { + return &StagedModule_Expecter{mock: &_m.Mock} +} + // GetStage provides a mock function with given fields: func (_m *StagedModule) GetStage() int { ret := _m.Called() @@ -23,6 +31,33 @@ func (_m *StagedModule) GetStage() int { return r0 } +// StagedModule_GetStage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStage' +type StagedModule_GetStage_Call struct { + *mock.Call +} + +// GetStage is a helper method to define mock.On call +func (_e *StagedModule_Expecter) GetStage() *StagedModule_GetStage_Call { + return &StagedModule_GetStage_Call{Call: _e.mock.On("GetStage")} +} + +func (_c *StagedModule_GetStage_Call) Run(run func()) *StagedModule_GetStage_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StagedModule_GetStage_Call) Return(_a0 int) *StagedModule_GetStage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StagedModule_GetStage_Call) RunAndReturn(run func() int) *StagedModule_GetStage_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewStagedModule interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kernel/mocks/TypedModule.go b/pkg/kernel/mocks/TypedModule.go index dc2cb02d4..497167923 100644 --- a/pkg/kernel/mocks/TypedModule.go +++ b/pkg/kernel/mocks/TypedModule.go @@ -9,6 +9,14 @@ type TypedModule struct { mock.Mock } +type TypedModule_Expecter struct { + mock *mock.Mock +} + +func (_m *TypedModule) EXPECT() *TypedModule_Expecter { + return &TypedModule_Expecter{mock: &_m.Mock} +} + // IsBackground provides a mock function with given fields: func (_m *TypedModule) IsBackground() bool { ret := _m.Called() @@ -23,6 +31,33 @@ func (_m *TypedModule) IsBackground() bool { return r0 } +// TypedModule_IsBackground_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsBackground' +type TypedModule_IsBackground_Call struct { + *mock.Call +} + +// IsBackground is a helper method to define mock.On call +func (_e *TypedModule_Expecter) IsBackground() *TypedModule_IsBackground_Call { + return &TypedModule_IsBackground_Call{Call: _e.mock.On("IsBackground")} +} + +func (_c *TypedModule_IsBackground_Call) Run(run func()) *TypedModule_IsBackground_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TypedModule_IsBackground_Call) Return(_a0 bool) *TypedModule_IsBackground_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TypedModule_IsBackground_Call) RunAndReturn(run func() bool) *TypedModule_IsBackground_Call { + _c.Call.Return(run) + return _c +} + // IsEssential provides a mock function with given fields: func (_m *TypedModule) IsEssential() bool { ret := _m.Called() @@ -37,6 +72,33 @@ func (_m *TypedModule) IsEssential() bool { return r0 } +// TypedModule_IsEssential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsEssential' +type TypedModule_IsEssential_Call struct { + *mock.Call +} + +// IsEssential is a helper method to define mock.On call +func (_e *TypedModule_Expecter) IsEssential() *TypedModule_IsEssential_Call { + return &TypedModule_IsEssential_Call{Call: _e.mock.On("IsEssential")} +} + +func (_c *TypedModule_IsEssential_Call) Run(run func()) *TypedModule_IsEssential_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TypedModule_IsEssential_Call) Return(_a0 bool) *TypedModule_IsEssential_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TypedModule_IsEssential_Call) RunAndReturn(run func() bool) *TypedModule_IsEssential_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTypedModule interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kvstore/mocks/KvStore.go b/pkg/kvstore/mocks/KvStore.go index 65bf0dacc..c0b931b19 100644 --- a/pkg/kvstore/mocks/KvStore.go +++ b/pkg/kvstore/mocks/KvStore.go @@ -13,6 +13,14 @@ type KvStore[T interface{}] struct { mock.Mock } +type KvStore_Expecter[T interface{}] struct { + mock *mock.Mock +} + +func (_m *KvStore[T]) EXPECT() *KvStore_Expecter[T] { + return &KvStore_Expecter[T]{mock: &_m.Mock} +} + // Contains provides a mock function with given fields: ctx, key func (_m *KvStore[T]) Contains(ctx context.Context, key interface{}) (bool, error) { ret := _m.Called(ctx, key) @@ -37,6 +45,35 @@ func (_m *KvStore[T]) Contains(ctx context.Context, key interface{}) (bool, erro return r0, r1 } +// KvStore_Contains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Contains' +type KvStore_Contains_Call[T interface{}] struct { + *mock.Call +} + +// Contains is a helper method to define mock.On call +// - ctx context.Context +// - key interface{} +func (_e *KvStore_Expecter[T]) Contains(ctx interface{}, key interface{}) *KvStore_Contains_Call[T] { + return &KvStore_Contains_Call[T]{Call: _e.mock.On("Contains", ctx, key)} +} + +func (_c *KvStore_Contains_Call[T]) Run(run func(ctx context.Context, key interface{})) *KvStore_Contains_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *KvStore_Contains_Call[T]) Return(_a0 bool, _a1 error) *KvStore_Contains_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *KvStore_Contains_Call[T]) RunAndReturn(run func(context.Context, interface{}) (bool, error)) *KvStore_Contains_Call[T] { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: ctx, key func (_m *KvStore[T]) Delete(ctx context.Context, key interface{}) error { ret := _m.Called(ctx, key) @@ -51,6 +88,35 @@ func (_m *KvStore[T]) Delete(ctx context.Context, key interface{}) error { return r0 } +// KvStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type KvStore_Delete_Call[T interface{}] struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - key interface{} +func (_e *KvStore_Expecter[T]) Delete(ctx interface{}, key interface{}) *KvStore_Delete_Call[T] { + return &KvStore_Delete_Call[T]{Call: _e.mock.On("Delete", ctx, key)} +} + +func (_c *KvStore_Delete_Call[T]) Run(run func(ctx context.Context, key interface{})) *KvStore_Delete_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *KvStore_Delete_Call[T]) Return(_a0 error) *KvStore_Delete_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *KvStore_Delete_Call[T]) RunAndReturn(run func(context.Context, interface{}) error) *KvStore_Delete_Call[T] { + _c.Call.Return(run) + return _c +} + // DeleteBatch provides a mock function with given fields: ctx, keys func (_m *KvStore[T]) DeleteBatch(ctx context.Context, keys interface{}) error { ret := _m.Called(ctx, keys) @@ -65,6 +131,35 @@ func (_m *KvStore[T]) DeleteBatch(ctx context.Context, keys interface{}) error { return r0 } +// KvStore_DeleteBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBatch' +type KvStore_DeleteBatch_Call[T interface{}] struct { + *mock.Call +} + +// DeleteBatch is a helper method to define mock.On call +// - ctx context.Context +// - keys interface{} +func (_e *KvStore_Expecter[T]) DeleteBatch(ctx interface{}, keys interface{}) *KvStore_DeleteBatch_Call[T] { + return &KvStore_DeleteBatch_Call[T]{Call: _e.mock.On("DeleteBatch", ctx, keys)} +} + +func (_c *KvStore_DeleteBatch_Call[T]) Run(run func(ctx context.Context, keys interface{})) *KvStore_DeleteBatch_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *KvStore_DeleteBatch_Call[T]) Return(_a0 error) *KvStore_DeleteBatch_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *KvStore_DeleteBatch_Call[T]) RunAndReturn(run func(context.Context, interface{}) error) *KvStore_DeleteBatch_Call[T] { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: ctx, key, value func (_m *KvStore[T]) Get(ctx context.Context, key interface{}, value *T) (bool, error) { ret := _m.Called(ctx, key, value) @@ -89,6 +184,36 @@ func (_m *KvStore[T]) Get(ctx context.Context, key interface{}, value *T) (bool, return r0, r1 } +// KvStore_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type KvStore_Get_Call[T interface{}] struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key interface{} +// - value *T +func (_e *KvStore_Expecter[T]) Get(ctx interface{}, key interface{}, value interface{}) *KvStore_Get_Call[T] { + return &KvStore_Get_Call[T]{Call: _e.mock.On("Get", ctx, key, value)} +} + +func (_c *KvStore_Get_Call[T]) Run(run func(ctx context.Context, key interface{}, value *T)) *KvStore_Get_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(*T)) + }) + return _c +} + +func (_c *KvStore_Get_Call[T]) Return(_a0 bool, _a1 error) *KvStore_Get_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *KvStore_Get_Call[T]) RunAndReturn(run func(context.Context, interface{}, *T) (bool, error)) *KvStore_Get_Call[T] { + _c.Call.Return(run) + return _c +} + // GetBatch provides a mock function with given fields: ctx, keys, values func (_m *KvStore[T]) GetBatch(ctx context.Context, keys interface{}, values interface{}) ([]interface{}, error) { ret := _m.Called(ctx, keys, values) @@ -115,6 +240,36 @@ func (_m *KvStore[T]) GetBatch(ctx context.Context, keys interface{}, values int return r0, r1 } +// KvStore_GetBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBatch' +type KvStore_GetBatch_Call[T interface{}] struct { + *mock.Call +} + +// GetBatch is a helper method to define mock.On call +// - ctx context.Context +// - keys interface{} +// - values interface{} +func (_e *KvStore_Expecter[T]) GetBatch(ctx interface{}, keys interface{}, values interface{}) *KvStore_GetBatch_Call[T] { + return &KvStore_GetBatch_Call[T]{Call: _e.mock.On("GetBatch", ctx, keys, values)} +} + +func (_c *KvStore_GetBatch_Call[T]) Run(run func(ctx context.Context, keys interface{}, values interface{})) *KvStore_GetBatch_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(interface{})) + }) + return _c +} + +func (_c *KvStore_GetBatch_Call[T]) Return(_a0 []interface{}, _a1 error) *KvStore_GetBatch_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *KvStore_GetBatch_Call[T]) RunAndReturn(run func(context.Context, interface{}, interface{}) ([]interface{}, error)) *KvStore_GetBatch_Call[T] { + _c.Call.Return(run) + return _c +} + // Put provides a mock function with given fields: ctx, key, value func (_m *KvStore[T]) Put(ctx context.Context, key interface{}, value T) error { ret := _m.Called(ctx, key, value) @@ -129,6 +284,36 @@ func (_m *KvStore[T]) Put(ctx context.Context, key interface{}, value T) error { return r0 } +// KvStore_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type KvStore_Put_Call[T interface{}] struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - ctx context.Context +// - key interface{} +// - value T +func (_e *KvStore_Expecter[T]) Put(ctx interface{}, key interface{}, value interface{}) *KvStore_Put_Call[T] { + return &KvStore_Put_Call[T]{Call: _e.mock.On("Put", ctx, key, value)} +} + +func (_c *KvStore_Put_Call[T]) Run(run func(ctx context.Context, key interface{}, value T)) *KvStore_Put_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(T)) + }) + return _c +} + +func (_c *KvStore_Put_Call[T]) Return(_a0 error) *KvStore_Put_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *KvStore_Put_Call[T]) RunAndReturn(run func(context.Context, interface{}, T) error) *KvStore_Put_Call[T] { + _c.Call.Return(run) + return _c +} + // PutBatch provides a mock function with given fields: ctx, values func (_m *KvStore[T]) PutBatch(ctx context.Context, values interface{}) error { ret := _m.Called(ctx, values) @@ -143,6 +328,35 @@ func (_m *KvStore[T]) PutBatch(ctx context.Context, values interface{}) error { return r0 } +// KvStore_PutBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBatch' +type KvStore_PutBatch_Call[T interface{}] struct { + *mock.Call +} + +// PutBatch is a helper method to define mock.On call +// - ctx context.Context +// - values interface{} +func (_e *KvStore_Expecter[T]) PutBatch(ctx interface{}, values interface{}) *KvStore_PutBatch_Call[T] { + return &KvStore_PutBatch_Call[T]{Call: _e.mock.On("PutBatch", ctx, values)} +} + +func (_c *KvStore_PutBatch_Call[T]) Run(run func(ctx context.Context, values interface{})) *KvStore_PutBatch_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *KvStore_PutBatch_Call[T]) Return(_a0 error) *KvStore_PutBatch_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *KvStore_PutBatch_Call[T]) RunAndReturn(run func(context.Context, interface{}) error) *KvStore_PutBatch_Call[T] { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewKvStore interface { mock.TestingT Cleanup(func()) diff --git a/pkg/kvstore/mocks/SizedStore.go b/pkg/kvstore/mocks/SizedStore.go index 776681f50..6f6895f59 100644 --- a/pkg/kvstore/mocks/SizedStore.go +++ b/pkg/kvstore/mocks/SizedStore.go @@ -13,6 +13,14 @@ type SizedStore[T interface{}] struct { mock.Mock } +type SizedStore_Expecter[T interface{}] struct { + mock *mock.Mock +} + +func (_m *SizedStore[T]) EXPECT() *SizedStore_Expecter[T] { + return &SizedStore_Expecter[T]{mock: &_m.Mock} +} + // Contains provides a mock function with given fields: ctx, key func (_m *SizedStore[T]) Contains(ctx context.Context, key interface{}) (bool, error) { ret := _m.Called(ctx, key) @@ -37,6 +45,35 @@ func (_m *SizedStore[T]) Contains(ctx context.Context, key interface{}) (bool, e return r0, r1 } +// SizedStore_Contains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Contains' +type SizedStore_Contains_Call[T interface{}] struct { + *mock.Call +} + +// Contains is a helper method to define mock.On call +// - ctx context.Context +// - key interface{} +func (_e *SizedStore_Expecter[T]) Contains(ctx interface{}, key interface{}) *SizedStore_Contains_Call[T] { + return &SizedStore_Contains_Call[T]{Call: _e.mock.On("Contains", ctx, key)} +} + +func (_c *SizedStore_Contains_Call[T]) Run(run func(ctx context.Context, key interface{})) *SizedStore_Contains_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *SizedStore_Contains_Call[T]) Return(_a0 bool, _a1 error) *SizedStore_Contains_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SizedStore_Contains_Call[T]) RunAndReturn(run func(context.Context, interface{}) (bool, error)) *SizedStore_Contains_Call[T] { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: ctx, key func (_m *SizedStore[T]) Delete(ctx context.Context, key interface{}) error { ret := _m.Called(ctx, key) @@ -51,6 +88,35 @@ func (_m *SizedStore[T]) Delete(ctx context.Context, key interface{}) error { return r0 } +// SizedStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type SizedStore_Delete_Call[T interface{}] struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - key interface{} +func (_e *SizedStore_Expecter[T]) Delete(ctx interface{}, key interface{}) *SizedStore_Delete_Call[T] { + return &SizedStore_Delete_Call[T]{Call: _e.mock.On("Delete", ctx, key)} +} + +func (_c *SizedStore_Delete_Call[T]) Run(run func(ctx context.Context, key interface{})) *SizedStore_Delete_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *SizedStore_Delete_Call[T]) Return(_a0 error) *SizedStore_Delete_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizedStore_Delete_Call[T]) RunAndReturn(run func(context.Context, interface{}) error) *SizedStore_Delete_Call[T] { + _c.Call.Return(run) + return _c +} + // DeleteBatch provides a mock function with given fields: ctx, keys func (_m *SizedStore[T]) DeleteBatch(ctx context.Context, keys interface{}) error { ret := _m.Called(ctx, keys) @@ -65,6 +131,35 @@ func (_m *SizedStore[T]) DeleteBatch(ctx context.Context, keys interface{}) erro return r0 } +// SizedStore_DeleteBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBatch' +type SizedStore_DeleteBatch_Call[T interface{}] struct { + *mock.Call +} + +// DeleteBatch is a helper method to define mock.On call +// - ctx context.Context +// - keys interface{} +func (_e *SizedStore_Expecter[T]) DeleteBatch(ctx interface{}, keys interface{}) *SizedStore_DeleteBatch_Call[T] { + return &SizedStore_DeleteBatch_Call[T]{Call: _e.mock.On("DeleteBatch", ctx, keys)} +} + +func (_c *SizedStore_DeleteBatch_Call[T]) Run(run func(ctx context.Context, keys interface{})) *SizedStore_DeleteBatch_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *SizedStore_DeleteBatch_Call[T]) Return(_a0 error) *SizedStore_DeleteBatch_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizedStore_DeleteBatch_Call[T]) RunAndReturn(run func(context.Context, interface{}) error) *SizedStore_DeleteBatch_Call[T] { + _c.Call.Return(run) + return _c +} + // EstimateSize provides a mock function with given fields: func (_m *SizedStore[T]) EstimateSize() *int64 { ret := _m.Called() @@ -81,6 +176,33 @@ func (_m *SizedStore[T]) EstimateSize() *int64 { return r0 } +// SizedStore_EstimateSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimateSize' +type SizedStore_EstimateSize_Call[T interface{}] struct { + *mock.Call +} + +// EstimateSize is a helper method to define mock.On call +func (_e *SizedStore_Expecter[T]) EstimateSize() *SizedStore_EstimateSize_Call[T] { + return &SizedStore_EstimateSize_Call[T]{Call: _e.mock.On("EstimateSize")} +} + +func (_c *SizedStore_EstimateSize_Call[T]) Run(run func()) *SizedStore_EstimateSize_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SizedStore_EstimateSize_Call[T]) Return(_a0 *int64) *SizedStore_EstimateSize_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizedStore_EstimateSize_Call[T]) RunAndReturn(run func() *int64) *SizedStore_EstimateSize_Call[T] { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: ctx, key, value func (_m *SizedStore[T]) Get(ctx context.Context, key interface{}, value *T) (bool, error) { ret := _m.Called(ctx, key, value) @@ -105,6 +227,36 @@ func (_m *SizedStore[T]) Get(ctx context.Context, key interface{}, value *T) (bo return r0, r1 } +// SizedStore_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type SizedStore_Get_Call[T interface{}] struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key interface{} +// - value *T +func (_e *SizedStore_Expecter[T]) Get(ctx interface{}, key interface{}, value interface{}) *SizedStore_Get_Call[T] { + return &SizedStore_Get_Call[T]{Call: _e.mock.On("Get", ctx, key, value)} +} + +func (_c *SizedStore_Get_Call[T]) Run(run func(ctx context.Context, key interface{}, value *T)) *SizedStore_Get_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(*T)) + }) + return _c +} + +func (_c *SizedStore_Get_Call[T]) Return(_a0 bool, _a1 error) *SizedStore_Get_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SizedStore_Get_Call[T]) RunAndReturn(run func(context.Context, interface{}, *T) (bool, error)) *SizedStore_Get_Call[T] { + _c.Call.Return(run) + return _c +} + // GetBatch provides a mock function with given fields: ctx, keys, values func (_m *SizedStore[T]) GetBatch(ctx context.Context, keys interface{}, values interface{}) ([]interface{}, error) { ret := _m.Called(ctx, keys, values) @@ -131,6 +283,36 @@ func (_m *SizedStore[T]) GetBatch(ctx context.Context, keys interface{}, values return r0, r1 } +// SizedStore_GetBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBatch' +type SizedStore_GetBatch_Call[T interface{}] struct { + *mock.Call +} + +// GetBatch is a helper method to define mock.On call +// - ctx context.Context +// - keys interface{} +// - values interface{} +func (_e *SizedStore_Expecter[T]) GetBatch(ctx interface{}, keys interface{}, values interface{}) *SizedStore_GetBatch_Call[T] { + return &SizedStore_GetBatch_Call[T]{Call: _e.mock.On("GetBatch", ctx, keys, values)} +} + +func (_c *SizedStore_GetBatch_Call[T]) Run(run func(ctx context.Context, keys interface{}, values interface{})) *SizedStore_GetBatch_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(interface{})) + }) + return _c +} + +func (_c *SizedStore_GetBatch_Call[T]) Return(_a0 []interface{}, _a1 error) *SizedStore_GetBatch_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SizedStore_GetBatch_Call[T]) RunAndReturn(run func(context.Context, interface{}, interface{}) ([]interface{}, error)) *SizedStore_GetBatch_Call[T] { + _c.Call.Return(run) + return _c +} + // Put provides a mock function with given fields: ctx, key, value func (_m *SizedStore[T]) Put(ctx context.Context, key interface{}, value T) error { ret := _m.Called(ctx, key, value) @@ -145,6 +327,36 @@ func (_m *SizedStore[T]) Put(ctx context.Context, key interface{}, value T) erro return r0 } +// SizedStore_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type SizedStore_Put_Call[T interface{}] struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - ctx context.Context +// - key interface{} +// - value T +func (_e *SizedStore_Expecter[T]) Put(ctx interface{}, key interface{}, value interface{}) *SizedStore_Put_Call[T] { + return &SizedStore_Put_Call[T]{Call: _e.mock.On("Put", ctx, key, value)} +} + +func (_c *SizedStore_Put_Call[T]) Run(run func(ctx context.Context, key interface{}, value T)) *SizedStore_Put_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(T)) + }) + return _c +} + +func (_c *SizedStore_Put_Call[T]) Return(_a0 error) *SizedStore_Put_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizedStore_Put_Call[T]) RunAndReturn(run func(context.Context, interface{}, T) error) *SizedStore_Put_Call[T] { + _c.Call.Return(run) + return _c +} + // PutBatch provides a mock function with given fields: ctx, values func (_m *SizedStore[T]) PutBatch(ctx context.Context, values interface{}) error { ret := _m.Called(ctx, values) @@ -159,6 +371,35 @@ func (_m *SizedStore[T]) PutBatch(ctx context.Context, values interface{}) error return r0 } +// SizedStore_PutBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBatch' +type SizedStore_PutBatch_Call[T interface{}] struct { + *mock.Call +} + +// PutBatch is a helper method to define mock.On call +// - ctx context.Context +// - values interface{} +func (_e *SizedStore_Expecter[T]) PutBatch(ctx interface{}, values interface{}) *SizedStore_PutBatch_Call[T] { + return &SizedStore_PutBatch_Call[T]{Call: _e.mock.On("PutBatch", ctx, values)} +} + +func (_c *SizedStore_PutBatch_Call[T]) Run(run func(ctx context.Context, values interface{})) *SizedStore_PutBatch_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *SizedStore_PutBatch_Call[T]) Return(_a0 error) *SizedStore_PutBatch_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizedStore_PutBatch_Call[T]) RunAndReturn(run func(context.Context, interface{}) error) *SizedStore_PutBatch_Call[T] { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewSizedStore interface { mock.TestingT Cleanup(func()) diff --git a/pkg/log/mocks/Logger.go b/pkg/log/mocks/Logger.go index ce95ebf80..5a37f67c3 100644 --- a/pkg/log/mocks/Logger.go +++ b/pkg/log/mocks/Logger.go @@ -14,6 +14,14 @@ type Logger struct { mock.Mock } +type Logger_Expecter struct { + mock *mock.Mock +} + +func (_m *Logger) EXPECT() *Logger_Expecter { + return &Logger_Expecter{mock: &_m.Mock} +} + // Debug provides a mock function with given fields: format, args func (_m *Logger) Debug(format string, args ...interface{}) { var _ca []interface{} @@ -22,6 +30,42 @@ func (_m *Logger) Debug(format string, args ...interface{}) { _m.Called(_ca...) } +// Logger_Debug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Debug' +type Logger_Debug_Call struct { + *mock.Call +} + +// Debug is a helper method to define mock.On call +// - format string +// - args ...interface{} +func (_e *Logger_Expecter) Debug(format interface{}, args ...interface{}) *Logger_Debug_Call { + return &Logger_Debug_Call{Call: _e.mock.On("Debug", + append([]interface{}{format}, args...)...)} +} + +func (_c *Logger_Debug_Call) Run(run func(format string, args ...interface{})) *Logger_Debug_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Logger_Debug_Call) Return() *Logger_Debug_Call { + _c.Call.Return() + return _c +} + +func (_c *Logger_Debug_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Debug_Call { + _c.Call.Return(run) + return _c +} + // Error provides a mock function with given fields: format, args func (_m *Logger) Error(format string, args ...interface{}) { var _ca []interface{} @@ -30,6 +74,42 @@ func (_m *Logger) Error(format string, args ...interface{}) { _m.Called(_ca...) } +// Logger_Error_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Error' +type Logger_Error_Call struct { + *mock.Call +} + +// Error is a helper method to define mock.On call +// - format string +// - args ...interface{} +func (_e *Logger_Expecter) Error(format interface{}, args ...interface{}) *Logger_Error_Call { + return &Logger_Error_Call{Call: _e.mock.On("Error", + append([]interface{}{format}, args...)...)} +} + +func (_c *Logger_Error_Call) Run(run func(format string, args ...interface{})) *Logger_Error_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Logger_Error_Call) Return() *Logger_Error_Call { + _c.Call.Return() + return _c +} + +func (_c *Logger_Error_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Error_Call { + _c.Call.Return(run) + return _c +} + // Info provides a mock function with given fields: format, args func (_m *Logger) Info(format string, args ...interface{}) { var _ca []interface{} @@ -38,6 +118,42 @@ func (_m *Logger) Info(format string, args ...interface{}) { _m.Called(_ca...) } +// Logger_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info' +type Logger_Info_Call struct { + *mock.Call +} + +// Info is a helper method to define mock.On call +// - format string +// - args ...interface{} +func (_e *Logger_Expecter) Info(format interface{}, args ...interface{}) *Logger_Info_Call { + return &Logger_Info_Call{Call: _e.mock.On("Info", + append([]interface{}{format}, args...)...)} +} + +func (_c *Logger_Info_Call) Run(run func(format string, args ...interface{})) *Logger_Info_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Logger_Info_Call) Return() *Logger_Info_Call { + _c.Call.Return() + return _c +} + +func (_c *Logger_Info_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Info_Call { + _c.Call.Return(run) + return _c +} + // Warn provides a mock function with given fields: format, args func (_m *Logger) Warn(format string, args ...interface{}) { var _ca []interface{} @@ -46,6 +162,42 @@ func (_m *Logger) Warn(format string, args ...interface{}) { _m.Called(_ca...) } +// Logger_Warn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warn' +type Logger_Warn_Call struct { + *mock.Call +} + +// Warn is a helper method to define mock.On call +// - format string +// - args ...interface{} +func (_e *Logger_Expecter) Warn(format interface{}, args ...interface{}) *Logger_Warn_Call { + return &Logger_Warn_Call{Call: _e.mock.On("Warn", + append([]interface{}{format}, args...)...)} +} + +func (_c *Logger_Warn_Call) Run(run func(format string, args ...interface{})) *Logger_Warn_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].(string), variadicArgs...) + }) + return _c +} + +func (_c *Logger_Warn_Call) Return() *Logger_Warn_Call { + _c.Call.Return() + return _c +} + +func (_c *Logger_Warn_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Warn_Call { + _c.Call.Return(run) + return _c +} + // WithChannel provides a mock function with given fields: channel func (_m *Logger) WithChannel(channel string) log.Logger { ret := _m.Called(channel) @@ -62,6 +214,34 @@ func (_m *Logger) WithChannel(channel string) log.Logger { return r0 } +// Logger_WithChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithChannel' +type Logger_WithChannel_Call struct { + *mock.Call +} + +// WithChannel is a helper method to define mock.On call +// - channel string +func (_e *Logger_Expecter) WithChannel(channel interface{}) *Logger_WithChannel_Call { + return &Logger_WithChannel_Call{Call: _e.mock.On("WithChannel", channel)} +} + +func (_c *Logger_WithChannel_Call) Run(run func(channel string)) *Logger_WithChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Logger_WithChannel_Call) Return(_a0 log.Logger) *Logger_WithChannel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Logger_WithChannel_Call) RunAndReturn(run func(string) log.Logger) *Logger_WithChannel_Call { + _c.Call.Return(run) + return _c +} + // WithContext provides a mock function with given fields: ctx func (_m *Logger) WithContext(ctx context.Context) log.Logger { ret := _m.Called(ctx) @@ -78,6 +258,34 @@ func (_m *Logger) WithContext(ctx context.Context) log.Logger { return r0 } +// Logger_WithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithContext' +type Logger_WithContext_Call struct { + *mock.Call +} + +// WithContext is a helper method to define mock.On call +// - ctx context.Context +func (_e *Logger_Expecter) WithContext(ctx interface{}) *Logger_WithContext_Call { + return &Logger_WithContext_Call{Call: _e.mock.On("WithContext", ctx)} +} + +func (_c *Logger_WithContext_Call) Run(run func(ctx context.Context)) *Logger_WithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Logger_WithContext_Call) Return(_a0 log.Logger) *Logger_WithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Logger_WithContext_Call) RunAndReturn(run func(context.Context) log.Logger) *Logger_WithContext_Call { + _c.Call.Return(run) + return _c +} + // WithFields provides a mock function with given fields: _a0 func (_m *Logger) WithFields(_a0 log.Fields) log.Logger { ret := _m.Called(_a0) @@ -94,6 +302,34 @@ func (_m *Logger) WithFields(_a0 log.Fields) log.Logger { return r0 } +// Logger_WithFields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithFields' +type Logger_WithFields_Call struct { + *mock.Call +} + +// WithFields is a helper method to define mock.On call +// - _a0 log.Fields +func (_e *Logger_Expecter) WithFields(_a0 interface{}) *Logger_WithFields_Call { + return &Logger_WithFields_Call{Call: _e.mock.On("WithFields", _a0)} +} + +func (_c *Logger_WithFields_Call) Run(run func(_a0 log.Fields)) *Logger_WithFields_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(log.Fields)) + }) + return _c +} + +func (_c *Logger_WithFields_Call) Return(_a0 log.Logger) *Logger_WithFields_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Logger_WithFields_Call) RunAndReturn(run func(log.Fields) log.Logger) *Logger_WithFields_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewLogger interface { mock.TestingT Cleanup(func()) diff --git a/pkg/log/mocks/SentryHub.go b/pkg/log/mocks/SentryHub.go index 64cfca351..42ebcd5f0 100644 --- a/pkg/log/mocks/SentryHub.go +++ b/pkg/log/mocks/SentryHub.go @@ -14,6 +14,14 @@ type SentryHub struct { mock.Mock } +type SentryHub_Expecter struct { + mock *mock.Mock +} + +func (_m *SentryHub) EXPECT() *SentryHub_Expecter { + return &SentryHub_Expecter{mock: &_m.Mock} +} + // CaptureException provides a mock function with given fields: exception func (_m *SentryHub) CaptureException(exception error) *sentry.EventID { ret := _m.Called(exception) @@ -30,11 +38,67 @@ func (_m *SentryHub) CaptureException(exception error) *sentry.EventID { return r0 } +// SentryHub_CaptureException_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CaptureException' +type SentryHub_CaptureException_Call struct { + *mock.Call +} + +// CaptureException is a helper method to define mock.On call +// - exception error +func (_e *SentryHub_Expecter) CaptureException(exception interface{}) *SentryHub_CaptureException_Call { + return &SentryHub_CaptureException_Call{Call: _e.mock.On("CaptureException", exception)} +} + +func (_c *SentryHub_CaptureException_Call) Run(run func(exception error)) *SentryHub_CaptureException_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(error)) + }) + return _c +} + +func (_c *SentryHub_CaptureException_Call) Return(_a0 *sentry.EventID) *SentryHub_CaptureException_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SentryHub_CaptureException_Call) RunAndReturn(run func(error) *sentry.EventID) *SentryHub_CaptureException_Call { + _c.Call.Return(run) + return _c +} + // ConfigureScope provides a mock function with given fields: f func (_m *SentryHub) ConfigureScope(f func(*sentry.Scope)) { _m.Called(f) } +// SentryHub_ConfigureScope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigureScope' +type SentryHub_ConfigureScope_Call struct { + *mock.Call +} + +// ConfigureScope is a helper method to define mock.On call +// - f func(*sentry.Scope) +func (_e *SentryHub_Expecter) ConfigureScope(f interface{}) *SentryHub_ConfigureScope_Call { + return &SentryHub_ConfigureScope_Call{Call: _e.mock.On("ConfigureScope", f)} +} + +func (_c *SentryHub_ConfigureScope_Call) Run(run func(f func(*sentry.Scope))) *SentryHub_ConfigureScope_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(*sentry.Scope))) + }) + return _c +} + +func (_c *SentryHub_ConfigureScope_Call) Return() *SentryHub_ConfigureScope_Call { + _c.Call.Return() + return _c +} + +func (_c *SentryHub_ConfigureScope_Call) RunAndReturn(run func(func(*sentry.Scope))) *SentryHub_ConfigureScope_Call { + _c.Call.Return(run) + return _c +} + // Flush provides a mock function with given fields: timeout func (_m *SentryHub) Flush(timeout time.Duration) bool { ret := _m.Called(timeout) @@ -49,11 +113,67 @@ func (_m *SentryHub) Flush(timeout time.Duration) bool { return r0 } +// SentryHub_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush' +type SentryHub_Flush_Call struct { + *mock.Call +} + +// Flush is a helper method to define mock.On call +// - timeout time.Duration +func (_e *SentryHub_Expecter) Flush(timeout interface{}) *SentryHub_Flush_Call { + return &SentryHub_Flush_Call{Call: _e.mock.On("Flush", timeout)} +} + +func (_c *SentryHub_Flush_Call) Run(run func(timeout time.Duration)) *SentryHub_Flush_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Duration)) + }) + return _c +} + +func (_c *SentryHub_Flush_Call) Return(_a0 bool) *SentryHub_Flush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SentryHub_Flush_Call) RunAndReturn(run func(time.Duration) bool) *SentryHub_Flush_Call { + _c.Call.Return(run) + return _c +} + // WithScope provides a mock function with given fields: f func (_m *SentryHub) WithScope(f func(*sentry.Scope)) { _m.Called(f) } +// SentryHub_WithScope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithScope' +type SentryHub_WithScope_Call struct { + *mock.Call +} + +// WithScope is a helper method to define mock.On call +// - f func(*sentry.Scope) +func (_e *SentryHub_Expecter) WithScope(f interface{}) *SentryHub_WithScope_Call { + return &SentryHub_WithScope_Call{Call: _e.mock.On("WithScope", f)} +} + +func (_c *SentryHub_WithScope_Call) Run(run func(f func(*sentry.Scope))) *SentryHub_WithScope_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(*sentry.Scope))) + }) + return _c +} + +func (_c *SentryHub_WithScope_Call) Return() *SentryHub_WithScope_Call { + _c.Call.Return() + return _c +} + +func (_c *SentryHub_WithScope_Call) RunAndReturn(run func(func(*sentry.Scope))) *SentryHub_WithScope_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewSentryHub interface { mock.TestingT Cleanup(func()) diff --git a/pkg/log/status/mocks/Manager.go b/pkg/log/status/mocks/Manager.go index 9a792d9a7..59a04719c 100644 --- a/pkg/log/status/mocks/Manager.go +++ b/pkg/log/status/mocks/Manager.go @@ -16,6 +16,14 @@ type Manager struct { mock.Mock } +type Manager_Expecter struct { + mock *mock.Mock +} + +func (_m *Manager) EXPECT() *Manager_Expecter { + return &Manager_Expecter{mock: &_m.Mock} +} + // Monitor provides a mock function with given fields: key, f func (_m *Manager) Monitor(key string, f func() error) func() error { ret := _m.Called(key, f) @@ -32,6 +40,35 @@ func (_m *Manager) Monitor(key string, f func() error) func() error { return r0 } +// Manager_Monitor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Monitor' +type Manager_Monitor_Call struct { + *mock.Call +} + +// Monitor is a helper method to define mock.On call +// - key string +// - f func() error +func (_e *Manager_Expecter) Monitor(key interface{}, f interface{}) *Manager_Monitor_Call { + return &Manager_Monitor_Call{Call: _e.mock.On("Monitor", key, f)} +} + +func (_c *Manager_Monitor_Call) Run(run func(key string, f func() error)) *Manager_Monitor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func() error)) + }) + return _c +} + +func (_c *Manager_Monitor_Call) Return(_a0 func() error) *Manager_Monitor_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Manager_Monitor_Call) RunAndReturn(run func(string, func() error) func() error) *Manager_Monitor_Call { + _c.Call.Return(run) + return _c +} + // MonitorWithContext provides a mock function with given fields: key, f func (_m *Manager) MonitorWithContext(key string, f func(context.Context) error) func(context.Context) error { ret := _m.Called(key, f) @@ -48,11 +85,68 @@ func (_m *Manager) MonitorWithContext(key string, f func(context.Context) error) return r0 } +// Manager_MonitorWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MonitorWithContext' +type Manager_MonitorWithContext_Call struct { + *mock.Call +} + +// MonitorWithContext is a helper method to define mock.On call +// - key string +// - f func(context.Context) error +func (_e *Manager_Expecter) MonitorWithContext(key interface{}, f interface{}) *Manager_MonitorWithContext_Call { + return &Manager_MonitorWithContext_Call{Call: _e.mock.On("MonitorWithContext", key, f)} +} + +func (_c *Manager_MonitorWithContext_Call) Run(run func(key string, f func(context.Context) error)) *Manager_MonitorWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func(context.Context) error)) + }) + return _c +} + +func (_c *Manager_MonitorWithContext_Call) Return(_a0 func(context.Context) error) *Manager_MonitorWithContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Manager_MonitorWithContext_Call) RunAndReturn(run func(string, func(context.Context) error) func(context.Context) error) *Manager_MonitorWithContext_Call { + _c.Call.Return(run) + return _c +} + // PrintReport provides a mock function with given fields: logger func (_m *Manager) PrintReport(logger log.Logger) { _m.Called(logger) } +// Manager_PrintReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrintReport' +type Manager_PrintReport_Call struct { + *mock.Call +} + +// PrintReport is a helper method to define mock.On call +// - logger log.Logger +func (_e *Manager_Expecter) PrintReport(logger interface{}) *Manager_PrintReport_Call { + return &Manager_PrintReport_Call{Call: _e.mock.On("PrintReport", logger)} +} + +func (_c *Manager_PrintReport_Call) Run(run func(logger log.Logger)) *Manager_PrintReport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(log.Logger)) + }) + return _c +} + +func (_c *Manager_PrintReport_Call) Return() *Manager_PrintReport_Call { + _c.Call.Return() + return _c +} + +func (_c *Manager_PrintReport_Call) RunAndReturn(run func(log.Logger)) *Manager_PrintReport_Call { + _c.Call.Return(run) + return _c +} + // StartWork provides a mock function with given fields: key, steps func (_m *Manager) StartWork(key string, steps int) status.WorkItem { ret := _m.Called(key, steps) @@ -69,6 +163,35 @@ func (_m *Manager) StartWork(key string, steps int) status.WorkItem { return r0 } +// Manager_StartWork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartWork' +type Manager_StartWork_Call struct { + *mock.Call +} + +// StartWork is a helper method to define mock.On call +// - key string +// - steps int +func (_e *Manager_Expecter) StartWork(key interface{}, steps interface{}) *Manager_StartWork_Call { + return &Manager_StartWork_Call{Call: _e.mock.On("StartWork", key, steps)} +} + +func (_c *Manager_StartWork_Call) Run(run func(key string, steps int)) *Manager_StartWork_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(int)) + }) + return _c +} + +func (_c *Manager_StartWork_Call) Return(_a0 status.WorkItem) *Manager_StartWork_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Manager_StartWork_Call) RunAndReturn(run func(string, int) status.WorkItem) *Manager_StartWork_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewManager interface { mock.TestingT Cleanup(func()) diff --git a/pkg/log/status/mocks/WorkItem.go b/pkg/log/status/mocks/WorkItem.go index 792c35202..ee9f9e9ef 100644 --- a/pkg/log/status/mocks/WorkItem.go +++ b/pkg/log/status/mocks/WorkItem.go @@ -9,6 +9,14 @@ type WorkItem struct { mock.Mock } +type WorkItem_Expecter struct { + mock *mock.Mock +} + +func (_m *WorkItem) EXPECT() *WorkItem_Expecter { + return &WorkItem_Expecter{mock: &_m.Mock} +} + // Monitor provides a mock function with given fields: f func (_m *WorkItem) Monitor(f func() error) func() error { ret := _m.Called(f) @@ -25,21 +33,133 @@ func (_m *WorkItem) Monitor(f func() error) func() error { return r0 } +// WorkItem_Monitor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Monitor' +type WorkItem_Monitor_Call struct { + *mock.Call +} + +// Monitor is a helper method to define mock.On call +// - f func() error +func (_e *WorkItem_Expecter) Monitor(f interface{}) *WorkItem_Monitor_Call { + return &WorkItem_Monitor_Call{Call: _e.mock.On("Monitor", f)} +} + +func (_c *WorkItem_Monitor_Call) Run(run func(f func() error)) *WorkItem_Monitor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func() error)) + }) + return _c +} + +func (_c *WorkItem_Monitor_Call) Return(_a0 func() error) *WorkItem_Monitor_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *WorkItem_Monitor_Call) RunAndReturn(run func(func() error) func() error) *WorkItem_Monitor_Call { + _c.Call.Return(run) + return _c +} + // ReportDone provides a mock function with given fields: func (_m *WorkItem) ReportDone() { _m.Called() } +// WorkItem_ReportDone_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportDone' +type WorkItem_ReportDone_Call struct { + *mock.Call +} + +// ReportDone is a helper method to define mock.On call +func (_e *WorkItem_Expecter) ReportDone() *WorkItem_ReportDone_Call { + return &WorkItem_ReportDone_Call{Call: _e.mock.On("ReportDone")} +} + +func (_c *WorkItem_ReportDone_Call) Run(run func()) *WorkItem_ReportDone_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WorkItem_ReportDone_Call) Return() *WorkItem_ReportDone_Call { + _c.Call.Return() + return _c +} + +func (_c *WorkItem_ReportDone_Call) RunAndReturn(run func()) *WorkItem_ReportDone_Call { + _c.Call.Return(run) + return _c +} + // ReportError provides a mock function with given fields: err func (_m *WorkItem) ReportError(err error) { _m.Called(err) } +// WorkItem_ReportError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportError' +type WorkItem_ReportError_Call struct { + *mock.Call +} + +// ReportError is a helper method to define mock.On call +// - err error +func (_e *WorkItem_Expecter) ReportError(err interface{}) *WorkItem_ReportError_Call { + return &WorkItem_ReportError_Call{Call: _e.mock.On("ReportError", err)} +} + +func (_c *WorkItem_ReportError_Call) Run(run func(err error)) *WorkItem_ReportError_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(error)) + }) + return _c +} + +func (_c *WorkItem_ReportError_Call) Return() *WorkItem_ReportError_Call { + _c.Call.Return() + return _c +} + +func (_c *WorkItem_ReportError_Call) RunAndReturn(run func(error)) *WorkItem_ReportError_Call { + _c.Call.Return(run) + return _c +} + // ReportProgress provides a mock function with given fields: step, progress func (_m *WorkItem) ReportProgress(step int, progress float64) { _m.Called(step, progress) } +// WorkItem_ReportProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportProgress' +type WorkItem_ReportProgress_Call struct { + *mock.Call +} + +// ReportProgress is a helper method to define mock.On call +// - step int +// - progress float64 +func (_e *WorkItem_Expecter) ReportProgress(step interface{}, progress interface{}) *WorkItem_ReportProgress_Call { + return &WorkItem_ReportProgress_Call{Call: _e.mock.On("ReportProgress", step, progress)} +} + +func (_c *WorkItem_ReportProgress_Call) Run(run func(step int, progress float64)) *WorkItem_ReportProgress_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(float64)) + }) + return _c +} + +func (_c *WorkItem_ReportProgress_Call) Return() *WorkItem_ReportProgress_Call { + _c.Call.Return() + return _c +} + +func (_c *WorkItem_ReportProgress_Call) RunAndReturn(run func(int, float64)) *WorkItem_ReportProgress_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewWorkItem interface { mock.TestingT Cleanup(func()) diff --git a/pkg/mdlsub/mocks/ModelTransformer.go b/pkg/mdlsub/mocks/ModelTransformer.go index 7032e9851..6f5731ba5 100644 --- a/pkg/mdlsub/mocks/ModelTransformer.go +++ b/pkg/mdlsub/mocks/ModelTransformer.go @@ -14,6 +14,14 @@ type ModelTransformer struct { mock.Mock } +type ModelTransformer_Expecter struct { + mock *mock.Mock +} + +func (_m *ModelTransformer) EXPECT() *ModelTransformer_Expecter { + return &ModelTransformer_Expecter{mock: &_m.Mock} +} + // GetInput provides a mock function with given fields: func (_m *ModelTransformer) GetInput() interface{} { ret := _m.Called() @@ -30,6 +38,33 @@ func (_m *ModelTransformer) GetInput() interface{} { return r0 } +// ModelTransformer_GetInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInput' +type ModelTransformer_GetInput_Call struct { + *mock.Call +} + +// GetInput is a helper method to define mock.On call +func (_e *ModelTransformer_Expecter) GetInput() *ModelTransformer_GetInput_Call { + return &ModelTransformer_GetInput_Call{Call: _e.mock.On("GetInput")} +} + +func (_c *ModelTransformer_GetInput_Call) Run(run func()) *ModelTransformer_GetInput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ModelTransformer_GetInput_Call) Return(_a0 interface{}) *ModelTransformer_GetInput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ModelTransformer_GetInput_Call) RunAndReturn(run func() interface{}) *ModelTransformer_GetInput_Call { + _c.Call.Return(run) + return _c +} + // Transform provides a mock function with given fields: ctx, inp func (_m *ModelTransformer) Transform(ctx context.Context, inp interface{}) (mdlsub.Model, error) { ret := _m.Called(ctx, inp) @@ -56,6 +91,35 @@ func (_m *ModelTransformer) Transform(ctx context.Context, inp interface{}) (mdl return r0, r1 } +// ModelTransformer_Transform_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Transform' +type ModelTransformer_Transform_Call struct { + *mock.Call +} + +// Transform is a helper method to define mock.On call +// - ctx context.Context +// - inp interface{} +func (_e *ModelTransformer_Expecter) Transform(ctx interface{}, inp interface{}) *ModelTransformer_Transform_Call { + return &ModelTransformer_Transform_Call{Call: _e.mock.On("Transform", ctx, inp)} +} + +func (_c *ModelTransformer_Transform_Call) Run(run func(ctx context.Context, inp interface{})) *ModelTransformer_Transform_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *ModelTransformer_Transform_Call) Return(out mdlsub.Model, err error) *ModelTransformer_Transform_Call { + _c.Call.Return(out, err) + return _c +} + +func (_c *ModelTransformer_Transform_Call) RunAndReturn(run func(context.Context, interface{}) (mdlsub.Model, error)) *ModelTransformer_Transform_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewModelTransformer interface { mock.TestingT Cleanup(func()) diff --git a/pkg/mdlsub/mocks/Publisher.go b/pkg/mdlsub/mocks/Publisher.go index a2957c26e..605be349c 100644 --- a/pkg/mdlsub/mocks/Publisher.go +++ b/pkg/mdlsub/mocks/Publisher.go @@ -13,6 +13,14 @@ type Publisher struct { mock.Mock } +type Publisher_Expecter struct { + mock *mock.Mock +} + +func (_m *Publisher) EXPECT() *Publisher_Expecter { + return &Publisher_Expecter{mock: &_m.Mock} +} + // Publish provides a mock function with given fields: ctx, typ, version, value, customAttributes func (_m *Publisher) Publish(ctx context.Context, typ string, version int, value interface{}, customAttributes ...map[string]interface{}) error { _va := make([]interface{}, len(customAttributes)) @@ -34,6 +42,45 @@ func (_m *Publisher) Publish(ctx context.Context, typ string, version int, value return r0 } +// Publisher_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish' +type Publisher_Publish_Call struct { + *mock.Call +} + +// Publish is a helper method to define mock.On call +// - ctx context.Context +// - typ string +// - version int +// - value interface{} +// - customAttributes ...map[string]interface{} +func (_e *Publisher_Expecter) Publish(ctx interface{}, typ interface{}, version interface{}, value interface{}, customAttributes ...interface{}) *Publisher_Publish_Call { + return &Publisher_Publish_Call{Call: _e.mock.On("Publish", + append([]interface{}{ctx, typ, version, value}, customAttributes...)...)} +} + +func (_c *Publisher_Publish_Call) Run(run func(ctx context.Context, typ string, version int, value interface{}, customAttributes ...map[string]interface{})) *Publisher_Publish_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *Publisher_Publish_Call) Return(_a0 error) *Publisher_Publish_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Publisher_Publish_Call) RunAndReturn(run func(context.Context, string, int, interface{}, ...map[string]interface{}) error) *Publisher_Publish_Call { + _c.Call.Return(run) + return _c +} + // PublishBatch provides a mock function with given fields: ctx, typ, version, values, customAttributes func (_m *Publisher) PublishBatch(ctx context.Context, typ string, version int, values []interface{}, customAttributes ...map[string]interface{}) error { _va := make([]interface{}, len(customAttributes)) @@ -55,6 +102,45 @@ func (_m *Publisher) PublishBatch(ctx context.Context, typ string, version int, return r0 } +// Publisher_PublishBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishBatch' +type Publisher_PublishBatch_Call struct { + *mock.Call +} + +// PublishBatch is a helper method to define mock.On call +// - ctx context.Context +// - typ string +// - version int +// - values []interface{} +// - customAttributes ...map[string]interface{} +func (_e *Publisher_Expecter) PublishBatch(ctx interface{}, typ interface{}, version interface{}, values interface{}, customAttributes ...interface{}) *Publisher_PublishBatch_Call { + return &Publisher_PublishBatch_Call{Call: _e.mock.On("PublishBatch", + append([]interface{}{ctx, typ, version, values}, customAttributes...)...)} +} + +func (_c *Publisher_PublishBatch_Call) Run(run func(ctx context.Context, typ string, version int, values []interface{}, customAttributes ...map[string]interface{})) *Publisher_PublishBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].([]interface{}), variadicArgs...) + }) + return _c +} + +func (_c *Publisher_PublishBatch_Call) Return(_a0 error) *Publisher_PublishBatch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Publisher_PublishBatch_Call) RunAndReturn(run func(context.Context, string, int, []interface{}, ...map[string]interface{}) error) *Publisher_PublishBatch_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewPublisher interface { mock.TestingT Cleanup(func()) diff --git a/pkg/metric/mocks/Writer.go b/pkg/metric/mocks/Writer.go index 15b3d13d6..ea40baa2c 100644 --- a/pkg/metric/mocks/Writer.go +++ b/pkg/metric/mocks/Writer.go @@ -12,6 +12,14 @@ type Writer struct { mock.Mock } +type Writer_Expecter struct { + mock *mock.Mock +} + +func (_m *Writer) EXPECT() *Writer_Expecter { + return &Writer_Expecter{mock: &_m.Mock} +} + // GetPriority provides a mock function with given fields: func (_m *Writer) GetPriority() int { ret := _m.Called() @@ -26,16 +34,99 @@ func (_m *Writer) GetPriority() int { return r0 } +// Writer_GetPriority_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPriority' +type Writer_GetPriority_Call struct { + *mock.Call +} + +// GetPriority is a helper method to define mock.On call +func (_e *Writer_Expecter) GetPriority() *Writer_GetPriority_Call { + return &Writer_GetPriority_Call{Call: _e.mock.On("GetPriority")} +} + +func (_c *Writer_GetPriority_Call) Run(run func()) *Writer_GetPriority_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Writer_GetPriority_Call) Return(_a0 int) *Writer_GetPriority_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Writer_GetPriority_Call) RunAndReturn(run func() int) *Writer_GetPriority_Call { + _c.Call.Return(run) + return _c +} + // Write provides a mock function with given fields: batch func (_m *Writer) Write(batch metric.Data) { _m.Called(batch) } +// Writer_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type Writer_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - batch metric.Data +func (_e *Writer_Expecter) Write(batch interface{}) *Writer_Write_Call { + return &Writer_Write_Call{Call: _e.mock.On("Write", batch)} +} + +func (_c *Writer_Write_Call) Run(run func(batch metric.Data)) *Writer_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metric.Data)) + }) + return _c +} + +func (_c *Writer_Write_Call) Return() *Writer_Write_Call { + _c.Call.Return() + return _c +} + +func (_c *Writer_Write_Call) RunAndReturn(run func(metric.Data)) *Writer_Write_Call { + _c.Call.Return(run) + return _c +} + // WriteOne provides a mock function with given fields: data func (_m *Writer) WriteOne(data *metric.Datum) { _m.Called(data) } +// Writer_WriteOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOne' +type Writer_WriteOne_Call struct { + *mock.Call +} + +// WriteOne is a helper method to define mock.On call +// - data *metric.Datum +func (_e *Writer_Expecter) WriteOne(data interface{}) *Writer_WriteOne_Call { + return &Writer_WriteOne_Call{Call: _e.mock.On("WriteOne", data)} +} + +func (_c *Writer_WriteOne_Call) Run(run func(data *metric.Datum)) *Writer_WriteOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*metric.Datum)) + }) + return _c +} + +func (_c *Writer_WriteOne_Call) Return() *Writer_WriteOne_Call { + _c.Call.Return() + return _c +} + +func (_c *Writer_WriteOne_Call) RunAndReturn(run func(*metric.Datum)) *Writer_WriteOne_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewWriter interface { mock.TestingT Cleanup(func()) diff --git a/pkg/oauth2/mocks/Service.go b/pkg/oauth2/mocks/Service.go index e7bd09473..9f2758aed 100644 --- a/pkg/oauth2/mocks/Service.go +++ b/pkg/oauth2/mocks/Service.go @@ -14,6 +14,14 @@ type Service struct { mock.Mock } +type Service_Expecter struct { + mock *mock.Mock +} + +func (_m *Service) EXPECT() *Service_Expecter { + return &Service_Expecter{mock: &_m.Mock} +} + // GetAuthRefresh provides a mock function with given fields: ctx, authRequest func (_m *Service) GetAuthRefresh(ctx context.Context, authRequest *oauth2.GoogleAuthRequest) (*oauth2.GoogleAuthResponse, error) { ret := _m.Called(ctx, authRequest) @@ -40,6 +48,35 @@ func (_m *Service) GetAuthRefresh(ctx context.Context, authRequest *oauth2.Googl return r0, r1 } +// Service_GetAuthRefresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuthRefresh' +type Service_GetAuthRefresh_Call struct { + *mock.Call +} + +// GetAuthRefresh is a helper method to define mock.On call +// - ctx context.Context +// - authRequest *oauth2.GoogleAuthRequest +func (_e *Service_Expecter) GetAuthRefresh(ctx interface{}, authRequest interface{}) *Service_GetAuthRefresh_Call { + return &Service_GetAuthRefresh_Call{Call: _e.mock.On("GetAuthRefresh", ctx, authRequest)} +} + +func (_c *Service_GetAuthRefresh_Call) Run(run func(ctx context.Context, authRequest *oauth2.GoogleAuthRequest)) *Service_GetAuthRefresh_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*oauth2.GoogleAuthRequest)) + }) + return _c +} + +func (_c *Service_GetAuthRefresh_Call) Return(_a0 *oauth2.GoogleAuthResponse, _a1 error) *Service_GetAuthRefresh_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_GetAuthRefresh_Call) RunAndReturn(run func(context.Context, *oauth2.GoogleAuthRequest) (*oauth2.GoogleAuthResponse, error)) *Service_GetAuthRefresh_Call { + _c.Call.Return(run) + return _c +} + // TokenInfo provides a mock function with given fields: ctx, accessToken func (_m *Service) TokenInfo(ctx context.Context, accessToken string) (*oauth2.GoogleTokenInfoResponse, error) { ret := _m.Called(ctx, accessToken) @@ -66,6 +103,35 @@ func (_m *Service) TokenInfo(ctx context.Context, accessToken string) (*oauth2.G return r0, r1 } +// Service_TokenInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TokenInfo' +type Service_TokenInfo_Call struct { + *mock.Call +} + +// TokenInfo is a helper method to define mock.On call +// - ctx context.Context +// - accessToken string +func (_e *Service_Expecter) TokenInfo(ctx interface{}, accessToken interface{}) *Service_TokenInfo_Call { + return &Service_TokenInfo_Call{Call: _e.mock.On("TokenInfo", ctx, accessToken)} +} + +func (_c *Service_TokenInfo_Call) Run(run func(ctx context.Context, accessToken string)) *Service_TokenInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Service_TokenInfo_Call) Return(_a0 *oauth2.GoogleTokenInfoResponse, _a1 error) *Service_TokenInfo_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Service_TokenInfo_Call) RunAndReturn(run func(context.Context, string) (*oauth2.GoogleTokenInfoResponse, error)) *Service_TokenInfo_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewService interface { mock.TestingT Cleanup(func()) diff --git a/pkg/parquet/mocks/FileRecorder.go b/pkg/parquet/mocks/FileRecorder.go index 3f95a090a..e4e10572c 100644 --- a/pkg/parquet/mocks/FileRecorder.go +++ b/pkg/parquet/mocks/FileRecorder.go @@ -14,6 +14,14 @@ type FileRecorder struct { mock.Mock } +type FileRecorder_Expecter struct { + mock *mock.Mock +} + +func (_m *FileRecorder) EXPECT() *FileRecorder_Expecter { + return &FileRecorder_Expecter{mock: &_m.Mock} +} + // DeleteRecordedFiles provides a mock function with given fields: ctx func (_m *FileRecorder) DeleteRecordedFiles(ctx context.Context) error { ret := _m.Called(ctx) @@ -28,6 +36,34 @@ func (_m *FileRecorder) DeleteRecordedFiles(ctx context.Context) error { return r0 } +// FileRecorder_DeleteRecordedFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRecordedFiles' +type FileRecorder_DeleteRecordedFiles_Call struct { + *mock.Call +} + +// DeleteRecordedFiles is a helper method to define mock.On call +// - ctx context.Context +func (_e *FileRecorder_Expecter) DeleteRecordedFiles(ctx interface{}) *FileRecorder_DeleteRecordedFiles_Call { + return &FileRecorder_DeleteRecordedFiles_Call{Call: _e.mock.On("DeleteRecordedFiles", ctx)} +} + +func (_c *FileRecorder_DeleteRecordedFiles_Call) Run(run func(ctx context.Context)) *FileRecorder_DeleteRecordedFiles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *FileRecorder_DeleteRecordedFiles_Call) Return(_a0 error) *FileRecorder_DeleteRecordedFiles_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FileRecorder_DeleteRecordedFiles_Call) RunAndReturn(run func(context.Context) error) *FileRecorder_DeleteRecordedFiles_Call { + _c.Call.Return(run) + return _c +} + // Files provides a mock function with given fields: func (_m *FileRecorder) Files() []parquet.File { ret := _m.Called() @@ -44,11 +80,67 @@ func (_m *FileRecorder) Files() []parquet.File { return r0 } +// FileRecorder_Files_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Files' +type FileRecorder_Files_Call struct { + *mock.Call +} + +// Files is a helper method to define mock.On call +func (_e *FileRecorder_Expecter) Files() *FileRecorder_Files_Call { + return &FileRecorder_Files_Call{Call: _e.mock.On("Files")} +} + +func (_c *FileRecorder_Files_Call) Run(run func()) *FileRecorder_Files_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *FileRecorder_Files_Call) Return(_a0 []parquet.File) *FileRecorder_Files_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FileRecorder_Files_Call) RunAndReturn(run func() []parquet.File) *FileRecorder_Files_Call { + _c.Call.Return(run) + return _c +} + // RecordFile provides a mock function with given fields: bucket, key func (_m *FileRecorder) RecordFile(bucket string, key string) { _m.Called(bucket, key) } +// FileRecorder_RecordFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordFile' +type FileRecorder_RecordFile_Call struct { + *mock.Call +} + +// RecordFile is a helper method to define mock.On call +// - bucket string +// - key string +func (_e *FileRecorder_Expecter) RecordFile(bucket interface{}, key interface{}) *FileRecorder_RecordFile_Call { + return &FileRecorder_RecordFile_Call{Call: _e.mock.On("RecordFile", bucket, key)} +} + +func (_c *FileRecorder_RecordFile_Call) Run(run func(bucket string, key string)) *FileRecorder_RecordFile_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *FileRecorder_RecordFile_Call) Return() *FileRecorder_RecordFile_Call { + _c.Call.Return() + return _c +} + +func (_c *FileRecorder_RecordFile_Call) RunAndReturn(run func(string, string)) *FileRecorder_RecordFile_Call { + _c.Call.Return(run) + return _c +} + // RenameRecordedFiles provides a mock function with given fields: ctx, newPrefix func (_m *FileRecorder) RenameRecordedFiles(ctx context.Context, newPrefix string) error { ret := _m.Called(ctx, newPrefix) @@ -63,6 +155,35 @@ func (_m *FileRecorder) RenameRecordedFiles(ctx context.Context, newPrefix strin return r0 } +// FileRecorder_RenameRecordedFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameRecordedFiles' +type FileRecorder_RenameRecordedFiles_Call struct { + *mock.Call +} + +// RenameRecordedFiles is a helper method to define mock.On call +// - ctx context.Context +// - newPrefix string +func (_e *FileRecorder_Expecter) RenameRecordedFiles(ctx interface{}, newPrefix interface{}) *FileRecorder_RenameRecordedFiles_Call { + return &FileRecorder_RenameRecordedFiles_Call{Call: _e.mock.On("RenameRecordedFiles", ctx, newPrefix)} +} + +func (_c *FileRecorder_RenameRecordedFiles_Call) Run(run func(ctx context.Context, newPrefix string)) *FileRecorder_RenameRecordedFiles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *FileRecorder_RenameRecordedFiles_Call) Return(_a0 error) *FileRecorder_RenameRecordedFiles_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FileRecorder_RenameRecordedFiles_Call) RunAndReturn(run func(context.Context, string) error) *FileRecorder_RenameRecordedFiles_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewFileRecorder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/parquet/mocks/Partitioner.go b/pkg/parquet/mocks/Partitioner.go index 00badbbeb..3fc2fcd82 100644 --- a/pkg/parquet/mocks/Partitioner.go +++ b/pkg/parquet/mocks/Partitioner.go @@ -12,16 +12,79 @@ type Partitioner struct { mock.Mock } +type Partitioner_Expecter struct { + mock *mock.Mock +} + +func (_m *Partitioner) EXPECT() *Partitioner_Expecter { + return &Partitioner_Expecter{mock: &_m.Mock} +} + // Flush provides a mock function with given fields: func (_m *Partitioner) Flush() { _m.Called() } +// Partitioner_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush' +type Partitioner_Flush_Call struct { + *mock.Call +} + +// Flush is a helper method to define mock.On call +func (_e *Partitioner_Expecter) Flush() *Partitioner_Flush_Call { + return &Partitioner_Flush_Call{Call: _e.mock.On("Flush")} +} + +func (_c *Partitioner_Flush_Call) Run(run func()) *Partitioner_Flush_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Partitioner_Flush_Call) Return() *Partitioner_Flush_Call { + _c.Call.Return() + return _c +} + +func (_c *Partitioner_Flush_Call) RunAndReturn(run func()) *Partitioner_Flush_Call { + _c.Call.Return(run) + return _c +} + // Ingest provides a mock function with given fields: data func (_m *Partitioner) Ingest(data parquet.Partitionable) { _m.Called(data) } +// Partitioner_Ingest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ingest' +type Partitioner_Ingest_Call struct { + *mock.Call +} + +// Ingest is a helper method to define mock.On call +// - data parquet.Partitionable +func (_e *Partitioner_Expecter) Ingest(data interface{}) *Partitioner_Ingest_Call { + return &Partitioner_Ingest_Call{Call: _e.mock.On("Ingest", data)} +} + +func (_c *Partitioner_Ingest_Call) Run(run func(data parquet.Partitionable)) *Partitioner_Ingest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(parquet.Partitionable)) + }) + return _c +} + +func (_c *Partitioner_Ingest_Call) Return() *Partitioner_Ingest_Call { + _c.Call.Return() + return _c +} + +func (_c *Partitioner_Ingest_Call) RunAndReturn(run func(parquet.Partitionable)) *Partitioner_Ingest_Call { + _c.Call.Return(run) + return _c +} + // Out provides a mock function with given fields: func (_m *Partitioner) Out() <-chan *parquet.Partition { ret := _m.Called() @@ -38,6 +101,33 @@ func (_m *Partitioner) Out() <-chan *parquet.Partition { return r0 } +// Partitioner_Out_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Out' +type Partitioner_Out_Call struct { + *mock.Call +} + +// Out is a helper method to define mock.On call +func (_e *Partitioner_Expecter) Out() *Partitioner_Out_Call { + return &Partitioner_Out_Call{Call: _e.mock.On("Out")} +} + +func (_c *Partitioner_Out_Call) Run(run func()) *Partitioner_Out_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Partitioner_Out_Call) Return(_a0 <-chan *parquet.Partition) *Partitioner_Out_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Partitioner_Out_Call) RunAndReturn(run func() <-chan *parquet.Partition) *Partitioner_Out_Call { + _c.Call.Return(run) + return _c +} + // Size provides a mock function with given fields: func (_m *Partitioner) Size() int { ret := _m.Called() @@ -52,21 +142,130 @@ func (_m *Partitioner) Size() int { return r0 } +// Partitioner_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size' +type Partitioner_Size_Call struct { + *mock.Call +} + +// Size is a helper method to define mock.On call +func (_e *Partitioner_Expecter) Size() *Partitioner_Size_Call { + return &Partitioner_Size_Call{Call: _e.mock.On("Size")} +} + +func (_c *Partitioner_Size_Call) Run(run func()) *Partitioner_Size_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Partitioner_Size_Call) Return(_a0 int) *Partitioner_Size_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Partitioner_Size_Call) RunAndReturn(run func() int) *Partitioner_Size_Call { + _c.Call.Return(run) + return _c +} + // Start provides a mock function with given fields: func (_m *Partitioner) Start() { _m.Called() } +// Partitioner_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type Partitioner_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +func (_e *Partitioner_Expecter) Start() *Partitioner_Start_Call { + return &Partitioner_Start_Call{Call: _e.mock.On("Start")} +} + +func (_c *Partitioner_Start_Call) Run(run func()) *Partitioner_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Partitioner_Start_Call) Return() *Partitioner_Start_Call { + _c.Call.Return() + return _c +} + +func (_c *Partitioner_Start_Call) RunAndReturn(run func()) *Partitioner_Start_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *Partitioner) Stop() { _m.Called() } +// Partitioner_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type Partitioner_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *Partitioner_Expecter) Stop() *Partitioner_Stop_Call { + return &Partitioner_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *Partitioner_Stop_Call) Run(run func()) *Partitioner_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Partitioner_Stop_Call) Return() *Partitioner_Stop_Call { + _c.Call.Return() + return _c +} + +func (_c *Partitioner_Stop_Call) RunAndReturn(run func()) *Partitioner_Stop_Call { + _c.Call.Return(run) + return _c +} + // Trim provides a mock function with given fields: size func (_m *Partitioner) Trim(size int) { _m.Called(size) } +// Partitioner_Trim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trim' +type Partitioner_Trim_Call struct { + *mock.Call +} + +// Trim is a helper method to define mock.On call +// - size int +func (_e *Partitioner_Expecter) Trim(size interface{}) *Partitioner_Trim_Call { + return &Partitioner_Trim_Call{Call: _e.mock.On("Trim", size)} +} + +func (_c *Partitioner_Trim_Call) Run(run func(size int)) *Partitioner_Trim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *Partitioner_Trim_Call) Return() *Partitioner_Trim_Call { + _c.Call.Return() + return _c +} + +func (_c *Partitioner_Trim_Call) RunAndReturn(run func(int)) *Partitioner_Trim_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewPartitioner interface { mock.TestingT Cleanup(func()) diff --git a/pkg/parquet/mocks/Reader.go b/pkg/parquet/mocks/Reader.go index bf23a6fb1..a337933f9 100644 --- a/pkg/parquet/mocks/Reader.go +++ b/pkg/parquet/mocks/Reader.go @@ -16,6 +16,14 @@ type Reader struct { mock.Mock } +type Reader_Expecter struct { + mock *mock.Mock +} + +func (_m *Reader) EXPECT() *Reader_Expecter { + return &Reader_Expecter{mock: &_m.Mock} +} + // ReadDate provides a mock function with given fields: ctx, datetime, target func (_m *Reader) ReadDate(ctx context.Context, datetime time.Time, target interface{}) error { ret := _m.Called(ctx, datetime, target) @@ -30,6 +38,36 @@ func (_m *Reader) ReadDate(ctx context.Context, datetime time.Time, target inter return r0 } +// Reader_ReadDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadDate' +type Reader_ReadDate_Call struct { + *mock.Call +} + +// ReadDate is a helper method to define mock.On call +// - ctx context.Context +// - datetime time.Time +// - target interface{} +func (_e *Reader_Expecter) ReadDate(ctx interface{}, datetime interface{}, target interface{}) *Reader_ReadDate_Call { + return &Reader_ReadDate_Call{Call: _e.mock.On("ReadDate", ctx, datetime, target)} +} + +func (_c *Reader_ReadDate_Call) Run(run func(ctx context.Context, datetime time.Time, target interface{})) *Reader_ReadDate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(time.Time), args[2].(interface{})) + }) + return _c +} + +func (_c *Reader_ReadDate_Call) Return(_a0 error) *Reader_ReadDate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Reader_ReadDate_Call) RunAndReturn(run func(context.Context, time.Time, interface{}) error) *Reader_ReadDate_Call { + _c.Call.Return(run) + return _c +} + // ReadDateAsync provides a mock function with given fields: ctx, datetime, target, callback func (_m *Reader) ReadDateAsync(ctx context.Context, datetime time.Time, target interface{}, callback parquet.ResultCallback) error { ret := _m.Called(ctx, datetime, target, callback) @@ -44,6 +82,37 @@ func (_m *Reader) ReadDateAsync(ctx context.Context, datetime time.Time, target return r0 } +// Reader_ReadDateAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadDateAsync' +type Reader_ReadDateAsync_Call struct { + *mock.Call +} + +// ReadDateAsync is a helper method to define mock.On call +// - ctx context.Context +// - datetime time.Time +// - target interface{} +// - callback parquet.ResultCallback +func (_e *Reader_Expecter) ReadDateAsync(ctx interface{}, datetime interface{}, target interface{}, callback interface{}) *Reader_ReadDateAsync_Call { + return &Reader_ReadDateAsync_Call{Call: _e.mock.On("ReadDateAsync", ctx, datetime, target, callback)} +} + +func (_c *Reader_ReadDateAsync_Call) Run(run func(ctx context.Context, datetime time.Time, target interface{}, callback parquet.ResultCallback)) *Reader_ReadDateAsync_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(time.Time), args[2].(interface{}), args[3].(parquet.ResultCallback)) + }) + return _c +} + +func (_c *Reader_ReadDateAsync_Call) Return(_a0 error) *Reader_ReadDateAsync_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Reader_ReadDateAsync_Call) RunAndReturn(run func(context.Context, time.Time, interface{}, parquet.ResultCallback) error) *Reader_ReadDateAsync_Call { + _c.Call.Return(run) + return _c +} + // ReadFileIntoTarget provides a mock function with given fields: ctx, file, target, batchSize, offset func (_m *Reader) ReadFileIntoTarget(ctx context.Context, file string, target interface{}, batchSize int, offset int64) error { ret := _m.Called(ctx, file, target, batchSize, offset) @@ -58,6 +127,38 @@ func (_m *Reader) ReadFileIntoTarget(ctx context.Context, file string, target in return r0 } +// Reader_ReadFileIntoTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadFileIntoTarget' +type Reader_ReadFileIntoTarget_Call struct { + *mock.Call +} + +// ReadFileIntoTarget is a helper method to define mock.On call +// - ctx context.Context +// - file string +// - target interface{} +// - batchSize int +// - offset int64 +func (_e *Reader_Expecter) ReadFileIntoTarget(ctx interface{}, file interface{}, target interface{}, batchSize interface{}, offset interface{}) *Reader_ReadFileIntoTarget_Call { + return &Reader_ReadFileIntoTarget_Call{Call: _e.mock.On("ReadFileIntoTarget", ctx, file, target, batchSize, offset)} +} + +func (_c *Reader_ReadFileIntoTarget_Call) Run(run func(ctx context.Context, file string, target interface{}, batchSize int, offset int64)) *Reader_ReadFileIntoTarget_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{}), args[3].(int), args[4].(int64)) + }) + return _c +} + +func (_c *Reader_ReadFileIntoTarget_Call) Return(_a0 error) *Reader_ReadFileIntoTarget_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Reader_ReadFileIntoTarget_Call) RunAndReturn(run func(context.Context, string, interface{}, int, int64) error) *Reader_ReadFileIntoTarget_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewReader interface { mock.TestingT Cleanup(func()) diff --git a/pkg/parquet/mocks/Writer.go b/pkg/parquet/mocks/Writer.go index 204f5f1ad..55bf9767d 100644 --- a/pkg/parquet/mocks/Writer.go +++ b/pkg/parquet/mocks/Writer.go @@ -15,6 +15,14 @@ type Writer struct { mock.Mock } +type Writer_Expecter struct { + mock *mock.Mock +} + +func (_m *Writer) EXPECT() *Writer_Expecter { + return &Writer_Expecter{mock: &_m.Mock} +} + // Write provides a mock function with given fields: ctx, datetime, items func (_m *Writer) Write(ctx context.Context, datetime time.Time, items interface{}) error { ret := _m.Called(ctx, datetime, items) @@ -29,6 +37,36 @@ func (_m *Writer) Write(ctx context.Context, datetime time.Time, items interface return r0 } +// Writer_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type Writer_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - ctx context.Context +// - datetime time.Time +// - items interface{} +func (_e *Writer_Expecter) Write(ctx interface{}, datetime interface{}, items interface{}) *Writer_Write_Call { + return &Writer_Write_Call{Call: _e.mock.On("Write", ctx, datetime, items)} +} + +func (_c *Writer_Write_Call) Run(run func(ctx context.Context, datetime time.Time, items interface{})) *Writer_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(time.Time), args[2].(interface{})) + }) + return _c +} + +func (_c *Writer_Write_Call) Return(_a0 error) *Writer_Write_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Writer_Write_Call) RunAndReturn(run func(context.Context, time.Time, interface{}) error) *Writer_Write_Call { + _c.Call.Return(run) + return _c +} + // WriteToKey provides a mock function with given fields: ctx, key, items func (_m *Writer) WriteToKey(ctx context.Context, key string, items interface{}) error { ret := _m.Called(ctx, key, items) @@ -43,6 +81,36 @@ func (_m *Writer) WriteToKey(ctx context.Context, key string, items interface{}) return r0 } +// Writer_WriteToKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteToKey' +type Writer_WriteToKey_Call struct { + *mock.Call +} + +// WriteToKey is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - items interface{} +func (_e *Writer_Expecter) WriteToKey(ctx interface{}, key interface{}, items interface{}) *Writer_WriteToKey_Call { + return &Writer_WriteToKey_Call{Call: _e.mock.On("WriteToKey", ctx, key, items)} +} + +func (_c *Writer_WriteToKey_Call) Run(run func(ctx context.Context, key string, items interface{})) *Writer_WriteToKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *Writer_WriteToKey_Call) Return(_a0 error) *Writer_WriteToKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Writer_WriteToKey_Call) RunAndReturn(run func(context.Context, string, interface{}) error) *Writer_WriteToKey_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewWriter interface { mock.TestingT Cleanup(func()) diff --git a/pkg/redis/mocks/Client.go b/pkg/redis/mocks/Client.go index 69d4f9d05..b87e2300a 100644 --- a/pkg/redis/mocks/Client.go +++ b/pkg/redis/mocks/Client.go @@ -16,6 +16,14 @@ type Client struct { mock.Mock } +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + // BLPop provides a mock function with given fields: ctx, timeout, keys func (_m *Client) BLPop(ctx context.Context, timeout time.Duration, keys ...string) ([]string, error) { _va := make([]interface{}, len(keys)) @@ -49,6 +57,43 @@ func (_m *Client) BLPop(ctx context.Context, timeout time.Duration, keys ...stri return r0, r1 } +// Client_BLPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BLPop' +type Client_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 *Client_Expecter) BLPop(ctx interface{}, timeout interface{}, keys ...interface{}) *Client_BLPop_Call { + return &Client_BLPop_Call{Call: _e.mock.On("BLPop", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *Client_BLPop_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Client_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 *Client_BLPop_Call) Return(_a0 []string, _a1 error) *Client_BLPop_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_BLPop_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) ([]string, error)) *Client_BLPop_Call { + _c.Call.Return(run) + return _c +} + // DBSize provides a mock function with given fields: ctx func (_m *Client) DBSize(ctx context.Context) (int64, error) { ret := _m.Called(ctx) @@ -73,6 +118,34 @@ func (_m *Client) DBSize(ctx context.Context) (int64, error) { return r0, r1 } +// Client_DBSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DBSize' +type Client_DBSize_Call struct { + *mock.Call +} + +// DBSize is a helper method to define mock.On call +// - ctx context.Context +func (_e *Client_Expecter) DBSize(ctx interface{}) *Client_DBSize_Call { + return &Client_DBSize_Call{Call: _e.mock.On("DBSize", ctx)} +} + +func (_c *Client_DBSize_Call) Run(run func(ctx context.Context)) *Client_DBSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Client_DBSize_Call) Return(_a0 int64, _a1 error) *Client_DBSize_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DBSize_Call) RunAndReturn(run func(context.Context) (int64, error)) *Client_DBSize_Call { + _c.Call.Return(run) + return _c +} + // Decr provides a mock function with given fields: ctx, key func (_m *Client) Decr(ctx context.Context, key string) (int64, error) { ret := _m.Called(ctx, key) @@ -97,6 +170,35 @@ func (_m *Client) Decr(ctx context.Context, key string) (int64, error) { return r0, r1 } +// Client_Decr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Decr' +type Client_Decr_Call struct { + *mock.Call +} + +// Decr is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) Decr(ctx interface{}, key interface{}) *Client_Decr_Call { + return &Client_Decr_Call{Call: _e.mock.On("Decr", ctx, key)} +} + +func (_c *Client_Decr_Call) Run(run func(ctx context.Context, key string)) *Client_Decr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_Decr_Call) Return(_a0 int64, _a1 error) *Client_Decr_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Decr_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *Client_Decr_Call { + _c.Call.Return(run) + return _c +} + // DecrBy provides a mock function with given fields: ctx, key, amount func (_m *Client) DecrBy(ctx context.Context, key string, amount int64) (int64, error) { ret := _m.Called(ctx, key, amount) @@ -121,6 +223,36 @@ func (_m *Client) DecrBy(ctx context.Context, key string, amount int64) (int64, return r0, r1 } +// Client_DecrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DecrBy' +type Client_DecrBy_Call struct { + *mock.Call +} + +// DecrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - amount int64 +func (_e *Client_Expecter) DecrBy(ctx interface{}, key interface{}, amount interface{}) *Client_DecrBy_Call { + return &Client_DecrBy_Call{Call: _e.mock.On("DecrBy", ctx, key, amount)} +} + +func (_c *Client_DecrBy_Call) Run(run func(ctx context.Context, key string, amount int64)) *Client_DecrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Client_DecrBy_Call) Return(_a0 int64, _a1 error) *Client_DecrBy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_DecrBy_Call) RunAndReturn(run func(context.Context, string, int64) (int64, error)) *Client_DecrBy_Call { + _c.Call.Return(run) + return _c +} + // Del provides a mock function with given fields: ctx, keys func (_m *Client) Del(ctx context.Context, keys ...string) (int64, error) { _va := make([]interface{}, len(keys)) @@ -152,6 +284,42 @@ func (_m *Client) Del(ctx context.Context, keys ...string) (int64, error) { return r0, r1 } +// Client_Del_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Del' +type Client_Del_Call struct { + *mock.Call +} + +// Del is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Client_Expecter) Del(ctx interface{}, keys ...interface{}) *Client_Del_Call { + return &Client_Del_Call{Call: _e.mock.On("Del", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Client_Del_Call) Run(run func(ctx context.Context, keys ...string)) *Client_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 *Client_Del_Call) Return(_a0 int64, _a1 error) *Client_Del_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Del_Call) RunAndReturn(run func(context.Context, ...string) (int64, error)) *Client_Del_Call { + _c.Call.Return(run) + return _c +} + // Exists provides a mock function with given fields: ctx, keys func (_m *Client) Exists(ctx context.Context, keys ...string) (int64, error) { _va := make([]interface{}, len(keys)) @@ -183,6 +351,42 @@ func (_m *Client) Exists(ctx context.Context, keys ...string) (int64, error) { return r0, r1 } +// Client_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists' +type Client_Exists_Call struct { + *mock.Call +} + +// Exists is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Client_Expecter) Exists(ctx interface{}, keys ...interface{}) *Client_Exists_Call { + return &Client_Exists_Call{Call: _e.mock.On("Exists", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Client_Exists_Call) Run(run func(ctx context.Context, keys ...string)) *Client_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 *Client_Exists_Call) Return(_a0 int64, _a1 error) *Client_Exists_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Exists_Call) RunAndReturn(run func(context.Context, ...string) (int64, error)) *Client_Exists_Call { + _c.Call.Return(run) + return _c +} + // Expire provides a mock function with given fields: ctx, key, ttl func (_m *Client) Expire(ctx context.Context, key string, ttl time.Duration) (bool, error) { ret := _m.Called(ctx, key, ttl) @@ -207,6 +411,36 @@ func (_m *Client) Expire(ctx context.Context, key string, ttl time.Duration) (bo return r0, r1 } +// Client_Expire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expire' +type Client_Expire_Call struct { + *mock.Call +} + +// Expire is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - ttl time.Duration +func (_e *Client_Expecter) Expire(ctx interface{}, key interface{}, ttl interface{}) *Client_Expire_Call { + return &Client_Expire_Call{Call: _e.mock.On("Expire", ctx, key, ttl)} +} + +func (_c *Client_Expire_Call) Run(run func(ctx context.Context, key string, ttl time.Duration)) *Client_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 *Client_Expire_Call) Return(_a0 bool, _a1 error) *Client_Expire_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Expire_Call) RunAndReturn(run func(context.Context, string, time.Duration) (bool, error)) *Client_Expire_Call { + _c.Call.Return(run) + return _c +} + // FlushDB provides a mock function with given fields: ctx func (_m *Client) FlushDB(ctx context.Context) (string, error) { ret := _m.Called(ctx) @@ -231,6 +465,34 @@ func (_m *Client) FlushDB(ctx context.Context) (string, error) { return r0, r1 } +// Client_FlushDB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushDB' +type Client_FlushDB_Call struct { + *mock.Call +} + +// FlushDB is a helper method to define mock.On call +// - ctx context.Context +func (_e *Client_Expecter) FlushDB(ctx interface{}) *Client_FlushDB_Call { + return &Client_FlushDB_Call{Call: _e.mock.On("FlushDB", ctx)} +} + +func (_c *Client_FlushDB_Call) Run(run func(ctx context.Context)) *Client_FlushDB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Client_FlushDB_Call) Return(_a0 string, _a1 error) *Client_FlushDB_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_FlushDB_Call) RunAndReturn(run func(context.Context) (string, error)) *Client_FlushDB_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: ctx, key func (_m *Client) Get(ctx context.Context, key string) (string, error) { ret := _m.Called(ctx, key) @@ -255,6 +517,35 @@ func (_m *Client) Get(ctx context.Context, key string) (string, error) { return r0, r1 } +// Client_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Client_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) Get(ctx interface{}, key interface{}) *Client_Get_Call { + return &Client_Get_Call{Call: _e.mock.On("Get", ctx, key)} +} + +func (_c *Client_Get_Call) Run(run func(ctx context.Context, key string)) *Client_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_Get_Call) Return(_a0 string, _a1 error) *Client_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Get_Call) RunAndReturn(run func(context.Context, string) (string, error)) *Client_Get_Call { + _c.Call.Return(run) + return _c +} + // GetDel provides a mock function with given fields: ctx, key func (_m *Client) GetDel(ctx context.Context, key string) (interface{}, error) { ret := _m.Called(ctx, key) @@ -281,6 +572,35 @@ func (_m *Client) GetDel(ctx context.Context, key string) (interface{}, error) { return r0, r1 } +// Client_GetDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDel' +type Client_GetDel_Call struct { + *mock.Call +} + +// GetDel is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) GetDel(ctx interface{}, key interface{}) *Client_GetDel_Call { + return &Client_GetDel_Call{Call: _e.mock.On("GetDel", ctx, key)} +} + +func (_c *Client_GetDel_Call) Run(run func(ctx context.Context, key string)) *Client_GetDel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_GetDel_Call) Return(_a0 interface{}, _a1 error) *Client_GetDel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetDel_Call) RunAndReturn(run func(context.Context, string) (interface{}, error)) *Client_GetDel_Call { + _c.Call.Return(run) + return _c +} + // HDel provides a mock function with given fields: ctx, key, fields func (_m *Client) HDel(ctx context.Context, key string, fields ...string) (int64, error) { _va := make([]interface{}, len(fields)) @@ -312,6 +632,43 @@ func (_m *Client) HDel(ctx context.Context, key string, fields ...string) (int64 return r0, r1 } +// Client_HDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HDel' +type Client_HDel_Call struct { + *mock.Call +} + +// HDel is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *Client_Expecter) HDel(ctx interface{}, key interface{}, fields ...interface{}) *Client_HDel_Call { + return &Client_HDel_Call{Call: _e.mock.On("HDel", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *Client_HDel_Call) Run(run func(ctx context.Context, key string, fields ...string)) *Client_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 *Client_HDel_Call) Return(_a0 int64, _a1 error) *Client_HDel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_HDel_Call) RunAndReturn(run func(context.Context, string, ...string) (int64, error)) *Client_HDel_Call { + _c.Call.Return(run) + return _c +} + // HExists provides a mock function with given fields: ctx, key, field func (_m *Client) HExists(ctx context.Context, key string, field string) (bool, error) { ret := _m.Called(ctx, key, field) @@ -336,6 +693,36 @@ func (_m *Client) HExists(ctx context.Context, key string, field string) (bool, return r0, r1 } +// Client_HExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HExists' +type Client_HExists_Call struct { + *mock.Call +} + +// HExists is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +func (_e *Client_Expecter) HExists(ctx interface{}, key interface{}, field interface{}) *Client_HExists_Call { + return &Client_HExists_Call{Call: _e.mock.On("HExists", ctx, key, field)} +} + +func (_c *Client_HExists_Call) Run(run func(ctx context.Context, key string, field string)) *Client_HExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Client_HExists_Call) Return(_a0 bool, _a1 error) *Client_HExists_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_HExists_Call) RunAndReturn(run func(context.Context, string, string) (bool, error)) *Client_HExists_Call { + _c.Call.Return(run) + return _c +} + // HGet provides a mock function with given fields: ctx, key, field func (_m *Client) HGet(ctx context.Context, key string, field string) (string, error) { ret := _m.Called(ctx, key, field) @@ -360,6 +747,36 @@ func (_m *Client) HGet(ctx context.Context, key string, field string) (string, e return r0, r1 } +// Client_HGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HGet' +type Client_HGet_Call struct { + *mock.Call +} + +// HGet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +func (_e *Client_Expecter) HGet(ctx interface{}, key interface{}, field interface{}) *Client_HGet_Call { + return &Client_HGet_Call{Call: _e.mock.On("HGet", ctx, key, field)} +} + +func (_c *Client_HGet_Call) Run(run func(ctx context.Context, key string, field string)) *Client_HGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Client_HGet_Call) Return(_a0 string, _a1 error) *Client_HGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_HGet_Call) RunAndReturn(run func(context.Context, string, string) (string, error)) *Client_HGet_Call { + _c.Call.Return(run) + return _c +} + // HGetAll provides a mock function with given fields: ctx, key func (_m *Client) HGetAll(ctx context.Context, key string) (map[string]string, error) { ret := _m.Called(ctx, key) @@ -386,6 +803,35 @@ func (_m *Client) HGetAll(ctx context.Context, key string) (map[string]string, e return r0, r1 } +// Client_HGetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HGetAll' +type Client_HGetAll_Call struct { + *mock.Call +} + +// HGetAll is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) HGetAll(ctx interface{}, key interface{}) *Client_HGetAll_Call { + return &Client_HGetAll_Call{Call: _e.mock.On("HGetAll", ctx, key)} +} + +func (_c *Client_HGetAll_Call) Run(run func(ctx context.Context, key string)) *Client_HGetAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_HGetAll_Call) Return(_a0 map[string]string, _a1 error) *Client_HGetAll_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_HGetAll_Call) RunAndReturn(run func(context.Context, string) (map[string]string, error)) *Client_HGetAll_Call { + _c.Call.Return(run) + return _c +} + // HKeys provides a mock function with given fields: ctx, key func (_m *Client) HKeys(ctx context.Context, key string) ([]string, error) { ret := _m.Called(ctx, key) @@ -412,6 +858,35 @@ func (_m *Client) HKeys(ctx context.Context, key string) ([]string, error) { return r0, r1 } +// Client_HKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HKeys' +type Client_HKeys_Call struct { + *mock.Call +} + +// HKeys is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) HKeys(ctx interface{}, key interface{}) *Client_HKeys_Call { + return &Client_HKeys_Call{Call: _e.mock.On("HKeys", ctx, key)} +} + +func (_c *Client_HKeys_Call) Run(run func(ctx context.Context, key string)) *Client_HKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_HKeys_Call) Return(_a0 []string, _a1 error) *Client_HKeys_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_HKeys_Call) RunAndReturn(run func(context.Context, string) ([]string, error)) *Client_HKeys_Call { + _c.Call.Return(run) + return _c +} + // HMGet provides a mock function with given fields: ctx, key, fields func (_m *Client) HMGet(ctx context.Context, key string, fields ...string) ([]interface{}, error) { _va := make([]interface{}, len(fields)) @@ -445,6 +920,43 @@ func (_m *Client) HMGet(ctx context.Context, key string, fields ...string) ([]in return r0, r1 } +// Client_HMGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HMGet' +type Client_HMGet_Call struct { + *mock.Call +} + +// HMGet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *Client_Expecter) HMGet(ctx interface{}, key interface{}, fields ...interface{}) *Client_HMGet_Call { + return &Client_HMGet_Call{Call: _e.mock.On("HMGet", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *Client_HMGet_Call) Run(run func(ctx context.Context, key string, fields ...string)) *Client_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 *Client_HMGet_Call) Return(_a0 []interface{}, _a1 error) *Client_HMGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_HMGet_Call) RunAndReturn(run func(context.Context, string, ...string) ([]interface{}, error)) *Client_HMGet_Call { + _c.Call.Return(run) + return _c +} + // HMSet provides a mock function with given fields: ctx, key, pairs func (_m *Client) HMSet(ctx context.Context, key string, pairs map[string]interface{}) error { ret := _m.Called(ctx, key, pairs) @@ -459,6 +971,36 @@ func (_m *Client) HMSet(ctx context.Context, key string, pairs map[string]interf return r0 } +// Client_HMSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HMSet' +type Client_HMSet_Call struct { + *mock.Call +} + +// HMSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - pairs map[string]interface{} +func (_e *Client_Expecter) HMSet(ctx interface{}, key interface{}, pairs interface{}) *Client_HMSet_Call { + return &Client_HMSet_Call{Call: _e.mock.On("HMSet", ctx, key, pairs)} +} + +func (_c *Client_HMSet_Call) Run(run func(ctx context.Context, key string, pairs map[string]interface{})) *Client_HMSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(map[string]interface{})) + }) + return _c +} + +func (_c *Client_HMSet_Call) Return(_a0 error) *Client_HMSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_HMSet_Call) RunAndReturn(run func(context.Context, string, map[string]interface{}) error) *Client_HMSet_Call { + _c.Call.Return(run) + return _c +} + // HSet provides a mock function with given fields: ctx, key, field, value func (_m *Client) HSet(ctx context.Context, key string, field string, value interface{}) error { ret := _m.Called(ctx, key, field, value) @@ -473,6 +1015,37 @@ func (_m *Client) HSet(ctx context.Context, key string, field string, value inte return r0 } +// Client_HSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HSet' +type Client_HSet_Call struct { + *mock.Call +} + +// HSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +// - value interface{} +func (_e *Client_Expecter) HSet(ctx interface{}, key interface{}, field interface{}, value interface{}) *Client_HSet_Call { + return &Client_HSet_Call{Call: _e.mock.On("HSet", ctx, key, field, value)} +} + +func (_c *Client_HSet_Call) Run(run func(ctx context.Context, key string, field string, value interface{})) *Client_HSet_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 *Client_HSet_Call) Return(_a0 error) *Client_HSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_HSet_Call) RunAndReturn(run func(context.Context, string, string, interface{}) error) *Client_HSet_Call { + _c.Call.Return(run) + return _c +} + // HSetNX provides a mock function with given fields: ctx, key, field, value func (_m *Client) HSetNX(ctx context.Context, key string, field string, value interface{}) (bool, error) { ret := _m.Called(ctx, key, field, value) @@ -497,6 +1070,37 @@ func (_m *Client) HSetNX(ctx context.Context, key string, field string, value in return r0, r1 } +// Client_HSetNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HSetNX' +type Client_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 *Client_Expecter) HSetNX(ctx interface{}, key interface{}, field interface{}, value interface{}) *Client_HSetNX_Call { + return &Client_HSetNX_Call{Call: _e.mock.On("HSetNX", ctx, key, field, value)} +} + +func (_c *Client_HSetNX_Call) Run(run func(ctx context.Context, key string, field string, value interface{})) *Client_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 *Client_HSetNX_Call) Return(_a0 bool, _a1 error) *Client_HSetNX_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_HSetNX_Call) RunAndReturn(run func(context.Context, string, string, interface{}) (bool, error)) *Client_HSetNX_Call { + _c.Call.Return(run) + return _c +} + // Incr provides a mock function with given fields: ctx, key func (_m *Client) Incr(ctx context.Context, key string) (int64, error) { ret := _m.Called(ctx, key) @@ -521,6 +1125,35 @@ func (_m *Client) Incr(ctx context.Context, key string) (int64, error) { return r0, r1 } +// Client_Incr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Incr' +type Client_Incr_Call struct { + *mock.Call +} + +// Incr is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) Incr(ctx interface{}, key interface{}) *Client_Incr_Call { + return &Client_Incr_Call{Call: _e.mock.On("Incr", ctx, key)} +} + +func (_c *Client_Incr_Call) Run(run func(ctx context.Context, key string)) *Client_Incr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_Incr_Call) Return(_a0 int64, _a1 error) *Client_Incr_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Incr_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *Client_Incr_Call { + _c.Call.Return(run) + return _c +} + // IncrBy provides a mock function with given fields: ctx, key, amount func (_m *Client) IncrBy(ctx context.Context, key string, amount int64) (int64, error) { ret := _m.Called(ctx, key, amount) @@ -545,6 +1178,36 @@ func (_m *Client) IncrBy(ctx context.Context, key string, amount int64) (int64, return r0, r1 } +// Client_IncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrBy' +type Client_IncrBy_Call struct { + *mock.Call +} + +// IncrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - amount int64 +func (_e *Client_Expecter) IncrBy(ctx interface{}, key interface{}, amount interface{}) *Client_IncrBy_Call { + return &Client_IncrBy_Call{Call: _e.mock.On("IncrBy", ctx, key, amount)} +} + +func (_c *Client_IncrBy_Call) Run(run func(ctx context.Context, key string, amount int64)) *Client_IncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Client_IncrBy_Call) Return(_a0 int64, _a1 error) *Client_IncrBy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_IncrBy_Call) RunAndReturn(run func(context.Context, string, int64) (int64, error)) *Client_IncrBy_Call { + _c.Call.Return(run) + return _c +} + // IsAlive provides a mock function with given fields: ctx func (_m *Client) IsAlive(ctx context.Context) bool { ret := _m.Called(ctx) @@ -559,6 +1222,34 @@ func (_m *Client) IsAlive(ctx context.Context) bool { return r0 } +// Client_IsAlive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAlive' +type Client_IsAlive_Call struct { + *mock.Call +} + +// IsAlive is a helper method to define mock.On call +// - ctx context.Context +func (_e *Client_Expecter) IsAlive(ctx interface{}) *Client_IsAlive_Call { + return &Client_IsAlive_Call{Call: _e.mock.On("IsAlive", ctx)} +} + +func (_c *Client_IsAlive_Call) Run(run func(ctx context.Context)) *Client_IsAlive_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Client_IsAlive_Call) Return(_a0 bool) *Client_IsAlive_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_IsAlive_Call) RunAndReturn(run func(context.Context) bool) *Client_IsAlive_Call { + _c.Call.Return(run) + return _c +} + // LLen provides a mock function with given fields: ctx, key func (_m *Client) LLen(ctx context.Context, key string) (int64, error) { ret := _m.Called(ctx, key) @@ -583,6 +1274,35 @@ func (_m *Client) LLen(ctx context.Context, key string) (int64, error) { return r0, r1 } +// Client_LLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LLen' +type Client_LLen_Call struct { + *mock.Call +} + +// LLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) LLen(ctx interface{}, key interface{}) *Client_LLen_Call { + return &Client_LLen_Call{Call: _e.mock.On("LLen", ctx, key)} +} + +func (_c *Client_LLen_Call) Run(run func(ctx context.Context, key string)) *Client_LLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_LLen_Call) Return(_a0 int64, _a1 error) *Client_LLen_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_LLen_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *Client_LLen_Call { + _c.Call.Return(run) + return _c +} + // LPop provides a mock function with given fields: ctx, key func (_m *Client) LPop(ctx context.Context, key string) (string, error) { ret := _m.Called(ctx, key) @@ -607,6 +1327,35 @@ func (_m *Client) LPop(ctx context.Context, key string) (string, error) { return r0, r1 } +// Client_LPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPop' +type Client_LPop_Call struct { + *mock.Call +} + +// LPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) LPop(ctx interface{}, key interface{}) *Client_LPop_Call { + return &Client_LPop_Call{Call: _e.mock.On("LPop", ctx, key)} +} + +func (_c *Client_LPop_Call) Run(run func(ctx context.Context, key string)) *Client_LPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_LPop_Call) Return(_a0 string, _a1 error) *Client_LPop_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_LPop_Call) RunAndReturn(run func(context.Context, string) (string, error)) *Client_LPop_Call { + _c.Call.Return(run) + return _c +} + // LPush provides a mock function with given fields: ctx, key, values func (_m *Client) LPush(ctx context.Context, key string, values ...interface{}) (int64, error) { var _ca []interface{} @@ -634,6 +1383,43 @@ func (_m *Client) LPush(ctx context.Context, key string, values ...interface{}) return r0, r1 } +// Client_LPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPush' +type Client_LPush_Call struct { + *mock.Call +} + +// LPush is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Client_Expecter) LPush(ctx interface{}, key interface{}, values ...interface{}) *Client_LPush_Call { + return &Client_LPush_Call{Call: _e.mock.On("LPush", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Client_LPush_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Client_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 *Client_LPush_Call) Return(_a0 int64, _a1 error) *Client_LPush_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_LPush_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (int64, error)) *Client_LPush_Call { + _c.Call.Return(run) + return _c +} + // LRem provides a mock function with given fields: ctx, key, count, value func (_m *Client) LRem(ctx context.Context, key string, count int64, value interface{}) (int64, error) { ret := _m.Called(ctx, key, count, value) @@ -658,6 +1444,37 @@ func (_m *Client) LRem(ctx context.Context, key string, count int64, value inter return r0, r1 } +// Client_LRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LRem' +type Client_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 *Client_Expecter) LRem(ctx interface{}, key interface{}, count interface{}, value interface{}) *Client_LRem_Call { + return &Client_LRem_Call{Call: _e.mock.On("LRem", ctx, key, count, value)} +} + +func (_c *Client_LRem_Call) Run(run func(ctx context.Context, key string, count int64, value interface{})) *Client_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 *Client_LRem_Call) Return(_a0 int64, _a1 error) *Client_LRem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_LRem_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) (int64, error)) *Client_LRem_Call { + _c.Call.Return(run) + return _c +} + // MGet provides a mock function with given fields: ctx, keys func (_m *Client) MGet(ctx context.Context, keys ...string) ([]interface{}, error) { _va := make([]interface{}, len(keys)) @@ -691,6 +1508,42 @@ func (_m *Client) MGet(ctx context.Context, keys ...string) ([]interface{}, erro return r0, r1 } +// Client_MGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MGet' +type Client_MGet_Call struct { + *mock.Call +} + +// MGet is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Client_Expecter) MGet(ctx interface{}, keys ...interface{}) *Client_MGet_Call { + return &Client_MGet_Call{Call: _e.mock.On("MGet", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Client_MGet_Call) Run(run func(ctx context.Context, keys ...string)) *Client_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 *Client_MGet_Call) Return(_a0 []interface{}, _a1 error) *Client_MGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_MGet_Call) RunAndReturn(run func(context.Context, ...string) ([]interface{}, error)) *Client_MGet_Call { + _c.Call.Return(run) + return _c +} + // MSet provides a mock function with given fields: ctx, pairs func (_m *Client) MSet(ctx context.Context, pairs ...interface{}) error { var _ca []interface{} @@ -708,6 +1561,42 @@ func (_m *Client) MSet(ctx context.Context, pairs ...interface{}) error { return r0 } +// Client_MSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MSet' +type Client_MSet_Call struct { + *mock.Call +} + +// MSet is a helper method to define mock.On call +// - ctx context.Context +// - pairs ...interface{} +func (_e *Client_Expecter) MSet(ctx interface{}, pairs ...interface{}) *Client_MSet_Call { + return &Client_MSet_Call{Call: _e.mock.On("MSet", + append([]interface{}{ctx}, pairs...)...)} +} + +func (_c *Client_MSet_Call) Run(run func(ctx context.Context, pairs ...interface{})) *Client_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 *Client_MSet_Call) Return(_a0 error) *Client_MSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_MSet_Call) RunAndReturn(run func(context.Context, ...interface{}) error) *Client_MSet_Call { + _c.Call.Return(run) + return _c +} + // PFAdd provides a mock function with given fields: ctx, key, els func (_m *Client) PFAdd(ctx context.Context, key string, els ...interface{}) (int64, error) { var _ca []interface{} @@ -735,6 +1624,43 @@ func (_m *Client) PFAdd(ctx context.Context, key string, els ...interface{}) (in return r0, r1 } +// Client_PFAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFAdd' +type Client_PFAdd_Call struct { + *mock.Call +} + +// PFAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - els ...interface{} +func (_e *Client_Expecter) PFAdd(ctx interface{}, key interface{}, els ...interface{}) *Client_PFAdd_Call { + return &Client_PFAdd_Call{Call: _e.mock.On("PFAdd", + append([]interface{}{ctx, key}, els...)...)} +} + +func (_c *Client_PFAdd_Call) Run(run func(ctx context.Context, key string, els ...interface{})) *Client_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 *Client_PFAdd_Call) Return(_a0 int64, _a1 error) *Client_PFAdd_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PFAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (int64, error)) *Client_PFAdd_Call { + _c.Call.Return(run) + return _c +} + // PFCount provides a mock function with given fields: ctx, keys func (_m *Client) PFCount(ctx context.Context, keys ...string) (int64, error) { _va := make([]interface{}, len(keys)) @@ -766,6 +1692,42 @@ func (_m *Client) PFCount(ctx context.Context, keys ...string) (int64, error) { return r0, r1 } +// Client_PFCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFCount' +type Client_PFCount_Call struct { + *mock.Call +} + +// PFCount is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Client_Expecter) PFCount(ctx interface{}, keys ...interface{}) *Client_PFCount_Call { + return &Client_PFCount_Call{Call: _e.mock.On("PFCount", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Client_PFCount_Call) Run(run func(ctx context.Context, keys ...string)) *Client_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 *Client_PFCount_Call) Return(_a0 int64, _a1 error) *Client_PFCount_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PFCount_Call) RunAndReturn(run func(context.Context, ...string) (int64, error)) *Client_PFCount_Call { + _c.Call.Return(run) + return _c +} + // PFMerge provides a mock function with given fields: ctx, dest, keys func (_m *Client) PFMerge(ctx context.Context, dest string, keys ...string) (string, error) { _va := make([]interface{}, len(keys)) @@ -797,6 +1759,43 @@ func (_m *Client) PFMerge(ctx context.Context, dest string, keys ...string) (str return r0, r1 } +// Client_PFMerge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFMerge' +type Client_PFMerge_Call struct { + *mock.Call +} + +// PFMerge is a helper method to define mock.On call +// - ctx context.Context +// - dest string +// - keys ...string +func (_e *Client_Expecter) PFMerge(ctx interface{}, dest interface{}, keys ...interface{}) *Client_PFMerge_Call { + return &Client_PFMerge_Call{Call: _e.mock.On("PFMerge", + append([]interface{}{ctx, dest}, keys...)...)} +} + +func (_c *Client_PFMerge_Call) Run(run func(ctx context.Context, dest string, keys ...string)) *Client_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 *Client_PFMerge_Call) Return(_a0 string, _a1 error) *Client_PFMerge_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_PFMerge_Call) RunAndReturn(run func(context.Context, string, ...string) (string, error)) *Client_PFMerge_Call { + _c.Call.Return(run) + return _c +} + // Pipeline provides a mock function with given fields: func (_m *Client) Pipeline() redis.Pipeliner { ret := _m.Called() @@ -813,6 +1812,33 @@ func (_m *Client) Pipeline() redis.Pipeliner { return r0 } +// Client_Pipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pipeline' +type Client_Pipeline_Call struct { + *mock.Call +} + +// Pipeline is a helper method to define mock.On call +func (_e *Client_Expecter) Pipeline() *Client_Pipeline_Call { + return &Client_Pipeline_Call{Call: _e.mock.On("Pipeline")} +} + +func (_c *Client_Pipeline_Call) Run(run func()) *Client_Pipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Client_Pipeline_Call) Return(_a0 redis.Pipeliner) *Client_Pipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_Pipeline_Call) RunAndReturn(run func() redis.Pipeliner) *Client_Pipeline_Call { + _c.Call.Return(run) + return _c +} + // RPop provides a mock function with given fields: ctx, key func (_m *Client) RPop(ctx context.Context, key string) (string, error) { ret := _m.Called(ctx, key) @@ -837,6 +1863,35 @@ func (_m *Client) RPop(ctx context.Context, key string) (string, error) { return r0, r1 } +// Client_RPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPop' +type Client_RPop_Call struct { + *mock.Call +} + +// RPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) RPop(ctx interface{}, key interface{}) *Client_RPop_Call { + return &Client_RPop_Call{Call: _e.mock.On("RPop", ctx, key)} +} + +func (_c *Client_RPop_Call) Run(run func(ctx context.Context, key string)) *Client_RPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_RPop_Call) Return(_a0 string, _a1 error) *Client_RPop_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_RPop_Call) RunAndReturn(run func(context.Context, string) (string, error)) *Client_RPop_Call { + _c.Call.Return(run) + return _c +} + // RPush provides a mock function with given fields: ctx, key, values func (_m *Client) RPush(ctx context.Context, key string, values ...interface{}) (int64, error) { var _ca []interface{} @@ -864,6 +1919,43 @@ func (_m *Client) RPush(ctx context.Context, key string, values ...interface{}) return r0, r1 } +// Client_RPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPush' +type Client_RPush_Call struct { + *mock.Call +} + +// RPush is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Client_Expecter) RPush(ctx interface{}, key interface{}, values ...interface{}) *Client_RPush_Call { + return &Client_RPush_Call{Call: _e.mock.On("RPush", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Client_RPush_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Client_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 *Client_RPush_Call) Return(_a0 int64, _a1 error) *Client_RPush_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_RPush_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (int64, error)) *Client_RPush_Call { + _c.Call.Return(run) + return _c +} + // SAdd provides a mock function with given fields: ctx, key, values func (_m *Client) SAdd(ctx context.Context, key string, values ...interface{}) (int64, error) { var _ca []interface{} @@ -891,6 +1983,43 @@ func (_m *Client) SAdd(ctx context.Context, key string, values ...interface{}) ( return r0, r1 } +// Client_SAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SAdd' +type Client_SAdd_Call struct { + *mock.Call +} + +// SAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Client_Expecter) SAdd(ctx interface{}, key interface{}, values ...interface{}) *Client_SAdd_Call { + return &Client_SAdd_Call{Call: _e.mock.On("SAdd", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Client_SAdd_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Client_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 *Client_SAdd_Call) Return(_a0 int64, _a1 error) *Client_SAdd_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (int64, error)) *Client_SAdd_Call { + _c.Call.Return(run) + return _c +} + // SCard provides a mock function with given fields: ctx, key func (_m *Client) SCard(ctx context.Context, key string) (int64, error) { ret := _m.Called(ctx, key) @@ -915,6 +2044,35 @@ func (_m *Client) SCard(ctx context.Context, key string) (int64, error) { return r0, r1 } +// Client_SCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SCard' +type Client_SCard_Call struct { + *mock.Call +} + +// SCard is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) SCard(ctx interface{}, key interface{}) *Client_SCard_Call { + return &Client_SCard_Call{Call: _e.mock.On("SCard", ctx, key)} +} + +func (_c *Client_SCard_Call) Run(run func(ctx context.Context, key string)) *Client_SCard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_SCard_Call) Return(_a0 int64, _a1 error) *Client_SCard_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SCard_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *Client_SCard_Call { + _c.Call.Return(run) + return _c +} + // SDiff provides a mock function with given fields: ctx, keys func (_m *Client) SDiff(ctx context.Context, keys ...string) ([]string, error) { _va := make([]interface{}, len(keys)) @@ -948,6 +2106,42 @@ func (_m *Client) SDiff(ctx context.Context, keys ...string) ([]string, error) { return r0, r1 } +// Client_SDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SDiff' +type Client_SDiff_Call struct { + *mock.Call +} + +// SDiff is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Client_Expecter) SDiff(ctx interface{}, keys ...interface{}) *Client_SDiff_Call { + return &Client_SDiff_Call{Call: _e.mock.On("SDiff", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Client_SDiff_Call) Run(run func(ctx context.Context, keys ...string)) *Client_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 *Client_SDiff_Call) Return(_a0 []string, _a1 error) *Client_SDiff_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SDiff_Call) RunAndReturn(run func(context.Context, ...string) ([]string, error)) *Client_SDiff_Call { + _c.Call.Return(run) + return _c +} + // SDiffStore provides a mock function with given fields: ctx, destination, keys func (_m *Client) SDiffStore(ctx context.Context, destination string, keys ...string) (int64, error) { _va := make([]interface{}, len(keys)) @@ -979,6 +2173,43 @@ func (_m *Client) SDiffStore(ctx context.Context, destination string, keys ...st return r0, r1 } +// Client_SDiffStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SDiffStore' +type Client_SDiffStore_Call struct { + *mock.Call +} + +// SDiffStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *Client_Expecter) SDiffStore(ctx interface{}, destination interface{}, keys ...interface{}) *Client_SDiffStore_Call { + return &Client_SDiffStore_Call{Call: _e.mock.On("SDiffStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *Client_SDiffStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Client_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 *Client_SDiffStore_Call) Return(_a0 int64, _a1 error) *Client_SDiffStore_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SDiffStore_Call) RunAndReturn(run func(context.Context, string, ...string) (int64, error)) *Client_SDiffStore_Call { + _c.Call.Return(run) + return _c +} + // SInter provides a mock function with given fields: ctx, keys func (_m *Client) SInter(ctx context.Context, keys ...string) ([]string, error) { _va := make([]interface{}, len(keys)) @@ -1012,6 +2243,42 @@ func (_m *Client) SInter(ctx context.Context, keys ...string) ([]string, error) return r0, r1 } +// Client_SInter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SInter' +type Client_SInter_Call struct { + *mock.Call +} + +// SInter is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Client_Expecter) SInter(ctx interface{}, keys ...interface{}) *Client_SInter_Call { + return &Client_SInter_Call{Call: _e.mock.On("SInter", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Client_SInter_Call) Run(run func(ctx context.Context, keys ...string)) *Client_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 *Client_SInter_Call) Return(_a0 []string, _a1 error) *Client_SInter_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SInter_Call) RunAndReturn(run func(context.Context, ...string) ([]string, error)) *Client_SInter_Call { + _c.Call.Return(run) + return _c +} + // SInterStore provides a mock function with given fields: ctx, destination, keys func (_m *Client) SInterStore(ctx context.Context, destination string, keys ...string) (int64, error) { _va := make([]interface{}, len(keys)) @@ -1040,7 +2307,44 @@ func (_m *Client) SInterStore(ctx context.Context, destination string, keys ...s r1 = ret.Error(1) } - return r0, r1 + return r0, r1 +} + +// Client_SInterStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SInterStore' +type Client_SInterStore_Call struct { + *mock.Call +} + +// SInterStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *Client_Expecter) SInterStore(ctx interface{}, destination interface{}, keys ...interface{}) *Client_SInterStore_Call { + return &Client_SInterStore_Call{Call: _e.mock.On("SInterStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *Client_SInterStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Client_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 *Client_SInterStore_Call) Return(_a0 int64, _a1 error) *Client_SInterStore_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SInterStore_Call) RunAndReturn(run func(context.Context, string, ...string) (int64, error)) *Client_SInterStore_Call { + _c.Call.Return(run) + return _c } // SIsMember provides a mock function with given fields: ctx, key, value @@ -1067,6 +2371,36 @@ func (_m *Client) SIsMember(ctx context.Context, key string, value interface{}) return r0, r1 } +// Client_SIsMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SIsMember' +type Client_SIsMember_Call struct { + *mock.Call +} + +// SIsMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +func (_e *Client_Expecter) SIsMember(ctx interface{}, key interface{}, value interface{}) *Client_SIsMember_Call { + return &Client_SIsMember_Call{Call: _e.mock.On("SIsMember", ctx, key, value)} +} + +func (_c *Client_SIsMember_Call) Run(run func(ctx context.Context, key string, value interface{})) *Client_SIsMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *Client_SIsMember_Call) Return(_a0 bool, _a1 error) *Client_SIsMember_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SIsMember_Call) RunAndReturn(run func(context.Context, string, interface{}) (bool, error)) *Client_SIsMember_Call { + _c.Call.Return(run) + return _c +} + // SMembers provides a mock function with given fields: ctx, key func (_m *Client) SMembers(ctx context.Context, key string) ([]string, error) { ret := _m.Called(ctx, key) @@ -1093,6 +2427,35 @@ func (_m *Client) SMembers(ctx context.Context, key string) ([]string, error) { return r0, r1 } +// Client_SMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMembers' +type Client_SMembers_Call struct { + *mock.Call +} + +// SMembers is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) SMembers(ctx interface{}, key interface{}) *Client_SMembers_Call { + return &Client_SMembers_Call{Call: _e.mock.On("SMembers", ctx, key)} +} + +func (_c *Client_SMembers_Call) Run(run func(ctx context.Context, key string)) *Client_SMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_SMembers_Call) Return(_a0 []string, _a1 error) *Client_SMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SMembers_Call) RunAndReturn(run func(context.Context, string) ([]string, error)) *Client_SMembers_Call { + _c.Call.Return(run) + return _c +} + // SMove provides a mock function with given fields: ctx, sourceKey, destKey, member func (_m *Client) SMove(ctx context.Context, sourceKey string, destKey string, member interface{}) (bool, error) { ret := _m.Called(ctx, sourceKey, destKey, member) @@ -1117,6 +2480,37 @@ func (_m *Client) SMove(ctx context.Context, sourceKey string, destKey string, m return r0, r1 } +// Client_SMove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMove' +type Client_SMove_Call struct { + *mock.Call +} + +// SMove is a helper method to define mock.On call +// - ctx context.Context +// - sourceKey string +// - destKey string +// - member interface{} +func (_e *Client_Expecter) SMove(ctx interface{}, sourceKey interface{}, destKey interface{}, member interface{}) *Client_SMove_Call { + return &Client_SMove_Call{Call: _e.mock.On("SMove", ctx, sourceKey, destKey, member)} +} + +func (_c *Client_SMove_Call) Run(run func(ctx context.Context, sourceKey string, destKey string, member interface{})) *Client_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 *Client_SMove_Call) Return(_a0 bool, _a1 error) *Client_SMove_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SMove_Call) RunAndReturn(run func(context.Context, string, string, interface{}) (bool, error)) *Client_SMove_Call { + _c.Call.Return(run) + return _c +} + // SPop provides a mock function with given fields: ctx, key func (_m *Client) SPop(ctx context.Context, key string) (string, error) { ret := _m.Called(ctx, key) @@ -1141,6 +2535,35 @@ func (_m *Client) SPop(ctx context.Context, key string) (string, error) { return r0, r1 } +// Client_SPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SPop' +type Client_SPop_Call struct { + *mock.Call +} + +// SPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) SPop(ctx interface{}, key interface{}) *Client_SPop_Call { + return &Client_SPop_Call{Call: _e.mock.On("SPop", ctx, key)} +} + +func (_c *Client_SPop_Call) Run(run func(ctx context.Context, key string)) *Client_SPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_SPop_Call) Return(_a0 string, _a1 error) *Client_SPop_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SPop_Call) RunAndReturn(run func(context.Context, string) (string, error)) *Client_SPop_Call { + _c.Call.Return(run) + return _c +} + // SRandMember provides a mock function with given fields: ctx, key func (_m *Client) SRandMember(ctx context.Context, key string) (string, error) { ret := _m.Called(ctx, key) @@ -1165,6 +2588,35 @@ func (_m *Client) SRandMember(ctx context.Context, key string) (string, error) { return r0, r1 } +// Client_SRandMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SRandMember' +type Client_SRandMember_Call struct { + *mock.Call +} + +// SRandMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) SRandMember(ctx interface{}, key interface{}) *Client_SRandMember_Call { + return &Client_SRandMember_Call{Call: _e.mock.On("SRandMember", ctx, key)} +} + +func (_c *Client_SRandMember_Call) Run(run func(ctx context.Context, key string)) *Client_SRandMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_SRandMember_Call) Return(_a0 string, _a1 error) *Client_SRandMember_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SRandMember_Call) RunAndReturn(run func(context.Context, string) (string, error)) *Client_SRandMember_Call { + _c.Call.Return(run) + return _c +} + // SRem provides a mock function with given fields: ctx, key, values func (_m *Client) SRem(ctx context.Context, key string, values ...interface{}) (int64, error) { var _ca []interface{} @@ -1192,6 +2644,43 @@ func (_m *Client) SRem(ctx context.Context, key string, values ...interface{}) ( return r0, r1 } +// Client_SRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SRem' +type Client_SRem_Call struct { + *mock.Call +} + +// SRem is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Client_Expecter) SRem(ctx interface{}, key interface{}, values ...interface{}) *Client_SRem_Call { + return &Client_SRem_Call{Call: _e.mock.On("SRem", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Client_SRem_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Client_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 *Client_SRem_Call) Return(_a0 int64, _a1 error) *Client_SRem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SRem_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (int64, error)) *Client_SRem_Call { + _c.Call.Return(run) + return _c +} + // SUnion provides a mock function with given fields: ctx, keys func (_m *Client) SUnion(ctx context.Context, keys ...string) ([]string, error) { _va := make([]interface{}, len(keys)) @@ -1225,6 +2714,42 @@ func (_m *Client) SUnion(ctx context.Context, keys ...string) ([]string, error) return r0, r1 } +// Client_SUnion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SUnion' +type Client_SUnion_Call struct { + *mock.Call +} + +// SUnion is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Client_Expecter) SUnion(ctx interface{}, keys ...interface{}) *Client_SUnion_Call { + return &Client_SUnion_Call{Call: _e.mock.On("SUnion", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Client_SUnion_Call) Run(run func(ctx context.Context, keys ...string)) *Client_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 *Client_SUnion_Call) Return(_a0 []string, _a1 error) *Client_SUnion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SUnion_Call) RunAndReturn(run func(context.Context, ...string) ([]string, error)) *Client_SUnion_Call { + _c.Call.Return(run) + return _c +} + // SUnionStore provides a mock function with given fields: ctx, destination, keys func (_m *Client) SUnionStore(ctx context.Context, destination string, keys ...string) (int64, error) { _va := make([]interface{}, len(keys)) @@ -1256,6 +2781,43 @@ func (_m *Client) SUnionStore(ctx context.Context, destination string, keys ...s return r0, r1 } +// Client_SUnionStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SUnionStore' +type Client_SUnionStore_Call struct { + *mock.Call +} + +// SUnionStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *Client_Expecter) SUnionStore(ctx interface{}, destination interface{}, keys ...interface{}) *Client_SUnionStore_Call { + return &Client_SUnionStore_Call{Call: _e.mock.On("SUnionStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *Client_SUnionStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Client_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 *Client_SUnionStore_Call) Return(_a0 int64, _a1 error) *Client_SUnionStore_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SUnionStore_Call) RunAndReturn(run func(context.Context, string, ...string) (int64, error)) *Client_SUnionStore_Call { + _c.Call.Return(run) + return _c +} + // Set provides a mock function with given fields: ctx, key, value, ttl func (_m *Client) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error { ret := _m.Called(ctx, key, value, ttl) @@ -1270,6 +2832,37 @@ func (_m *Client) Set(ctx context.Context, key string, value interface{}, ttl ti return r0 } +// Client_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set' +type Client_Set_Call struct { + *mock.Call +} + +// Set is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +// - ttl time.Duration +func (_e *Client_Expecter) Set(ctx interface{}, key interface{}, value interface{}, ttl interface{}) *Client_Set_Call { + return &Client_Set_Call{Call: _e.mock.On("Set", ctx, key, value, ttl)} +} + +func (_c *Client_Set_Call) Run(run func(ctx context.Context, key string, value interface{}, ttl time.Duration)) *Client_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 *Client_Set_Call) Return(_a0 error) *Client_Set_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_Set_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) error) *Client_Set_Call { + _c.Call.Return(run) + return _c +} + // SetNX provides a mock function with given fields: ctx, key, value, ttl func (_m *Client) SetNX(ctx context.Context, key string, value interface{}, ttl time.Duration) (bool, error) { ret := _m.Called(ctx, key, value, ttl) @@ -1294,6 +2887,37 @@ func (_m *Client) SetNX(ctx context.Context, key string, value interface{}, ttl return r0, r1 } +// Client_SetNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNX' +type Client_SetNX_Call struct { + *mock.Call +} + +// SetNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +// - ttl time.Duration +func (_e *Client_Expecter) SetNX(ctx interface{}, key interface{}, value interface{}, ttl interface{}) *Client_SetNX_Call { + return &Client_SetNX_Call{Call: _e.mock.On("SetNX", ctx, key, value, ttl)} +} + +func (_c *Client_SetNX_Call) Run(run func(ctx context.Context, key string, value interface{}, ttl time.Duration)) *Client_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 *Client_SetNX_Call) Return(_a0 bool, _a1 error) *Client_SetNX_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_SetNX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) (bool, error)) *Client_SetNX_Call { + _c.Call.Return(run) + return _c +} + // ZAdd provides a mock function with given fields: ctx, key, score, member func (_m *Client) ZAdd(ctx context.Context, key string, score float64, member string) (int64, error) { ret := _m.Called(ctx, key, score, member) @@ -1318,6 +2942,37 @@ func (_m *Client) ZAdd(ctx context.Context, key string, score float64, member st return r0, r1 } +// Client_ZAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAdd' +type Client_ZAdd_Call struct { + *mock.Call +} + +// ZAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - score float64 +// - member string +func (_e *Client_Expecter) ZAdd(ctx interface{}, key interface{}, score interface{}, member interface{}) *Client_ZAdd_Call { + return &Client_ZAdd_Call{Call: _e.mock.On("ZAdd", ctx, key, score, member)} +} + +func (_c *Client_ZAdd_Call) Run(run func(ctx context.Context, key string, score float64, member string)) *Client_ZAdd_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 *Client_ZAdd_Call) Return(_a0 int64, _a1 error) *Client_ZAdd_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZAdd_Call) RunAndReturn(run func(context.Context, string, float64, string) (int64, error)) *Client_ZAdd_Call { + _c.Call.Return(run) + return _c +} + // ZAddArgs provides a mock function with given fields: ctx, args func (_m *Client) ZAddArgs(ctx context.Context, args redis.ZAddArgs) (int64, error) { ret := _m.Called(ctx, args) @@ -1342,6 +2997,35 @@ func (_m *Client) ZAddArgs(ctx context.Context, args redis.ZAddArgs) (int64, err return r0, r1 } +// Client_ZAddArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddArgs' +type Client_ZAddArgs_Call struct { + *mock.Call +} + +// ZAddArgs is a helper method to define mock.On call +// - ctx context.Context +// - args redis.ZAddArgs +func (_e *Client_Expecter) ZAddArgs(ctx interface{}, args interface{}) *Client_ZAddArgs_Call { + return &Client_ZAddArgs_Call{Call: _e.mock.On("ZAddArgs", ctx, args)} +} + +func (_c *Client_ZAddArgs_Call) Run(run func(ctx context.Context, args redis.ZAddArgs)) *Client_ZAddArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZAddArgs)) + }) + return _c +} + +func (_c *Client_ZAddArgs_Call) Return(_a0 int64, _a1 error) *Client_ZAddArgs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZAddArgs_Call) RunAndReturn(run func(context.Context, redis.ZAddArgs) (int64, error)) *Client_ZAddArgs_Call { + _c.Call.Return(run) + return _c +} + // ZAddArgsIncr provides a mock function with given fields: ctx, args func (_m *Client) ZAddArgsIncr(ctx context.Context, args redis.ZAddArgs) (float64, error) { ret := _m.Called(ctx, args) @@ -1366,6 +3050,35 @@ func (_m *Client) ZAddArgsIncr(ctx context.Context, args redis.ZAddArgs) (float6 return r0, r1 } +// Client_ZAddArgsIncr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddArgsIncr' +type Client_ZAddArgsIncr_Call struct { + *mock.Call +} + +// ZAddArgsIncr is a helper method to define mock.On call +// - ctx context.Context +// - args redis.ZAddArgs +func (_e *Client_Expecter) ZAddArgsIncr(ctx interface{}, args interface{}) *Client_ZAddArgsIncr_Call { + return &Client_ZAddArgsIncr_Call{Call: _e.mock.On("ZAddArgsIncr", ctx, args)} +} + +func (_c *Client_ZAddArgsIncr_Call) Run(run func(ctx context.Context, args redis.ZAddArgs)) *Client_ZAddArgsIncr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZAddArgs)) + }) + return _c +} + +func (_c *Client_ZAddArgsIncr_Call) Return(_a0 float64, _a1 error) *Client_ZAddArgsIncr_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZAddArgsIncr_Call) RunAndReturn(run func(context.Context, redis.ZAddArgs) (float64, error)) *Client_ZAddArgsIncr_Call { + _c.Call.Return(run) + return _c +} + // ZCard provides a mock function with given fields: ctx, key func (_m *Client) ZCard(ctx context.Context, key string) (int64, error) { ret := _m.Called(ctx, key) @@ -1390,6 +3103,35 @@ func (_m *Client) ZCard(ctx context.Context, key string) (int64, error) { return r0, r1 } +// Client_ZCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZCard' +type Client_ZCard_Call struct { + *mock.Call +} + +// ZCard is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Client_Expecter) ZCard(ctx interface{}, key interface{}) *Client_ZCard_Call { + return &Client_ZCard_Call{Call: _e.mock.On("ZCard", ctx, key)} +} + +func (_c *Client_ZCard_Call) Run(run func(ctx context.Context, key string)) *Client_ZCard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Client_ZCard_Call) Return(_a0 int64, _a1 error) *Client_ZCard_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZCard_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *Client_ZCard_Call { + _c.Call.Return(run) + return _c +} + // ZCount provides a mock function with given fields: ctx, key, min, max func (_m *Client) ZCount(ctx context.Context, key string, min string, max string) (int64, error) { ret := _m.Called(ctx, key, min, max) @@ -1414,6 +3156,37 @@ func (_m *Client) ZCount(ctx context.Context, key string, min string, max string return r0, r1 } +// Client_ZCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZCount' +type Client_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 *Client_Expecter) ZCount(ctx interface{}, key interface{}, min interface{}, max interface{}) *Client_ZCount_Call { + return &Client_ZCount_Call{Call: _e.mock.On("ZCount", ctx, key, min, max)} +} + +func (_c *Client_ZCount_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Client_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 *Client_ZCount_Call) Return(_a0 int64, _a1 error) *Client_ZCount_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZCount_Call) RunAndReturn(run func(context.Context, string, string, string) (int64, error)) *Client_ZCount_Call { + _c.Call.Return(run) + return _c +} + // ZIncrBy provides a mock function with given fields: ctx, key, increment, member func (_m *Client) ZIncrBy(ctx context.Context, key string, increment float64, member string) (float64, error) { ret := _m.Called(ctx, key, increment, member) @@ -1438,6 +3211,37 @@ func (_m *Client) ZIncrBy(ctx context.Context, key string, increment float64, me return r0, r1 } +// Client_ZIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZIncrBy' +type Client_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 *Client_Expecter) ZIncrBy(ctx interface{}, key interface{}, increment interface{}, member interface{}) *Client_ZIncrBy_Call { + return &Client_ZIncrBy_Call{Call: _e.mock.On("ZIncrBy", ctx, key, increment, member)} +} + +func (_c *Client_ZIncrBy_Call) Run(run func(ctx context.Context, key string, increment float64, member string)) *Client_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 *Client_ZIncrBy_Call) Return(_a0 float64, _a1 error) *Client_ZIncrBy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZIncrBy_Call) RunAndReturn(run func(context.Context, string, float64, string) (float64, error)) *Client_ZIncrBy_Call { + _c.Call.Return(run) + return _c +} + // ZMScore provides a mock function with given fields: ctx, key, members func (_m *Client) ZMScore(ctx context.Context, key string, members ...string) ([]float64, error) { _va := make([]interface{}, len(members)) @@ -1471,6 +3275,43 @@ func (_m *Client) ZMScore(ctx context.Context, key string, members ...string) ([ return r0, r1 } +// Client_ZMScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZMScore' +type Client_ZMScore_Call struct { + *mock.Call +} + +// ZMScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...string +func (_e *Client_Expecter) ZMScore(ctx interface{}, key interface{}, members ...interface{}) *Client_ZMScore_Call { + return &Client_ZMScore_Call{Call: _e.mock.On("ZMScore", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Client_ZMScore_Call) Run(run func(ctx context.Context, key string, members ...string)) *Client_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 *Client_ZMScore_Call) Return(_a0 []float64, _a1 error) *Client_ZMScore_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZMScore_Call) RunAndReturn(run func(context.Context, string, ...string) ([]float64, error)) *Client_ZMScore_Call { + _c.Call.Return(run) + return _c +} + // ZRandMember provides a mock function with given fields: ctx, key, count func (_m *Client) ZRandMember(ctx context.Context, key string, count int) ([]string, error) { ret := _m.Called(ctx, key, count) @@ -1497,6 +3338,36 @@ func (_m *Client) ZRandMember(ctx context.Context, key string, count int) ([]str return r0, r1 } +// Client_ZRandMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRandMember' +type Client_ZRandMember_Call struct { + *mock.Call +} + +// ZRandMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *Client_Expecter) ZRandMember(ctx interface{}, key interface{}, count interface{}) *Client_ZRandMember_Call { + return &Client_ZRandMember_Call{Call: _e.mock.On("ZRandMember", ctx, key, count)} +} + +func (_c *Client_ZRandMember_Call) Run(run func(ctx context.Context, key string, count int)) *Client_ZRandMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *Client_ZRandMember_Call) Return(_a0 []string, _a1 error) *Client_ZRandMember_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZRandMember_Call) RunAndReturn(run func(context.Context, string, int) ([]string, error)) *Client_ZRandMember_Call { + _c.Call.Return(run) + return _c +} + // ZRange provides a mock function with given fields: ctx, key, start, stop func (_m *Client) ZRange(ctx context.Context, key string, start int64, stop int64) ([]string, error) { ret := _m.Called(ctx, key, start, stop) @@ -1523,6 +3394,37 @@ func (_m *Client) ZRange(ctx context.Context, key string, start int64, stop int6 return r0, r1 } +// Client_ZRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRange' +type Client_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 *Client_Expecter) ZRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Client_ZRange_Call { + return &Client_ZRange_Call{Call: _e.mock.On("ZRange", ctx, key, start, stop)} +} + +func (_c *Client_ZRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Client_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 *Client_ZRange_Call) Return(_a0 []string, _a1 error) *Client_ZRange_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) ([]string, error)) *Client_ZRange_Call { + _c.Call.Return(run) + return _c +} + // ZRangeArgs provides a mock function with given fields: ctx, args func (_m *Client) ZRangeArgs(ctx context.Context, args redis.ZRangeArgs) ([]string, error) { ret := _m.Called(ctx, args) @@ -1549,6 +3451,35 @@ func (_m *Client) ZRangeArgs(ctx context.Context, args redis.ZRangeArgs) ([]stri return r0, r1 } +// Client_ZRangeArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeArgs' +type Client_ZRangeArgs_Call struct { + *mock.Call +} + +// ZRangeArgs is a helper method to define mock.On call +// - ctx context.Context +// - args redis.ZRangeArgs +func (_e *Client_Expecter) ZRangeArgs(ctx interface{}, args interface{}) *Client_ZRangeArgs_Call { + return &Client_ZRangeArgs_Call{Call: _e.mock.On("ZRangeArgs", ctx, args)} +} + +func (_c *Client_ZRangeArgs_Call) Run(run func(ctx context.Context, args redis.ZRangeArgs)) *Client_ZRangeArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZRangeArgs)) + }) + return _c +} + +func (_c *Client_ZRangeArgs_Call) Return(_a0 []string, _a1 error) *Client_ZRangeArgs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZRangeArgs_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) ([]string, error)) *Client_ZRangeArgs_Call { + _c.Call.Return(run) + return _c +} + // ZRangeArgsWithScore provides a mock function with given fields: ctx, args func (_m *Client) ZRangeArgsWithScore(ctx context.Context, args redis.ZRangeArgs) ([]redis.Z, error) { ret := _m.Called(ctx, args) @@ -1575,6 +3506,35 @@ func (_m *Client) ZRangeArgsWithScore(ctx context.Context, args redis.ZRangeArgs return r0, r1 } +// Client_ZRangeArgsWithScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeArgsWithScore' +type Client_ZRangeArgsWithScore_Call struct { + *mock.Call +} + +// ZRangeArgsWithScore is a helper method to define mock.On call +// - ctx context.Context +// - args redis.ZRangeArgs +func (_e *Client_Expecter) ZRangeArgsWithScore(ctx interface{}, args interface{}) *Client_ZRangeArgsWithScore_Call { + return &Client_ZRangeArgsWithScore_Call{Call: _e.mock.On("ZRangeArgsWithScore", ctx, args)} +} + +func (_c *Client_ZRangeArgsWithScore_Call) Run(run func(ctx context.Context, args redis.ZRangeArgs)) *Client_ZRangeArgsWithScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZRangeArgs)) + }) + return _c +} + +func (_c *Client_ZRangeArgsWithScore_Call) Return(_a0 []redis.Z, _a1 error) *Client_ZRangeArgsWithScore_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZRangeArgsWithScore_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) ([]redis.Z, error)) *Client_ZRangeArgsWithScore_Call { + _c.Call.Return(run) + return _c +} + // ZRank provides a mock function with given fields: ctx, key, member func (_m *Client) ZRank(ctx context.Context, key string, member string) (int64, error) { ret := _m.Called(ctx, key, member) @@ -1599,6 +3559,36 @@ func (_m *Client) ZRank(ctx context.Context, key string, member string) (int64, return r0, r1 } +// Client_ZRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRank' +type Client_ZRank_Call struct { + *mock.Call +} + +// ZRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *Client_Expecter) ZRank(ctx interface{}, key interface{}, member interface{}) *Client_ZRank_Call { + return &Client_ZRank_Call{Call: _e.mock.On("ZRank", ctx, key, member)} +} + +func (_c *Client_ZRank_Call) Run(run func(ctx context.Context, key string, member string)) *Client_ZRank_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Client_ZRank_Call) Return(_a0 int64, _a1 error) *Client_ZRank_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZRank_Call) RunAndReturn(run func(context.Context, string, string) (int64, error)) *Client_ZRank_Call { + _c.Call.Return(run) + return _c +} + // ZRem provides a mock function with given fields: ctx, key, members func (_m *Client) ZRem(ctx context.Context, key string, members ...string) (int64, error) { _va := make([]interface{}, len(members)) @@ -1630,6 +3620,43 @@ func (_m *Client) ZRem(ctx context.Context, key string, members ...string) (int6 return r0, r1 } +// Client_ZRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRem' +type Client_ZRem_Call struct { + *mock.Call +} + +// ZRem is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...string +func (_e *Client_Expecter) ZRem(ctx interface{}, key interface{}, members ...interface{}) *Client_ZRem_Call { + return &Client_ZRem_Call{Call: _e.mock.On("ZRem", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Client_ZRem_Call) Run(run func(ctx context.Context, key string, members ...string)) *Client_ZRem_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 *Client_ZRem_Call) Return(_a0 int64, _a1 error) *Client_ZRem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZRem_Call) RunAndReturn(run func(context.Context, string, ...string) (int64, error)) *Client_ZRem_Call { + _c.Call.Return(run) + return _c +} + // ZRevRank provides a mock function with given fields: ctx, key, member func (_m *Client) ZRevRank(ctx context.Context, key string, member string) (int64, error) { ret := _m.Called(ctx, key, member) @@ -1654,6 +3681,36 @@ func (_m *Client) ZRevRank(ctx context.Context, key string, member string) (int6 return r0, r1 } +// Client_ZRevRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRank' +type Client_ZRevRank_Call struct { + *mock.Call +} + +// ZRevRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *Client_Expecter) ZRevRank(ctx interface{}, key interface{}, member interface{}) *Client_ZRevRank_Call { + return &Client_ZRevRank_Call{Call: _e.mock.On("ZRevRank", ctx, key, member)} +} + +func (_c *Client_ZRevRank_Call) Run(run func(ctx context.Context, key string, member string)) *Client_ZRevRank_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Client_ZRevRank_Call) Return(_a0 int64, _a1 error) *Client_ZRevRank_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZRevRank_Call) RunAndReturn(run func(context.Context, string, string) (int64, error)) *Client_ZRevRank_Call { + _c.Call.Return(run) + return _c +} + // ZScore provides a mock function with given fields: ctx, key, member func (_m *Client) ZScore(ctx context.Context, key string, member string) (float64, error) { ret := _m.Called(ctx, key, member) @@ -1678,6 +3735,36 @@ func (_m *Client) ZScore(ctx context.Context, key string, member string) (float6 return r0, r1 } +// Client_ZScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZScore' +type Client_ZScore_Call struct { + *mock.Call +} + +// ZScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *Client_Expecter) ZScore(ctx interface{}, key interface{}, member interface{}) *Client_ZScore_Call { + return &Client_ZScore_Call{Call: _e.mock.On("ZScore", ctx, key, member)} +} + +func (_c *Client_ZScore_Call) Run(run func(ctx context.Context, key string, member string)) *Client_ZScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Client_ZScore_Call) Return(_a0 float64, _a1 error) *Client_ZScore_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_ZScore_Call) RunAndReturn(run func(context.Context, string, string) (float64, error)) *Client_ZScore_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewClient interface { mock.TestingT Cleanup(func()) diff --git a/pkg/redis/mocks/Pipeliner.go b/pkg/redis/mocks/Pipeliner.go index 64f667ace..5c141e17d 100644 --- a/pkg/redis/mocks/Pipeliner.go +++ b/pkg/redis/mocks/Pipeliner.go @@ -17,6 +17,14 @@ type Pipeliner struct { mock.Mock } +type Pipeliner_Expecter struct { + mock *mock.Mock +} + +func (_m *Pipeliner) EXPECT() *Pipeliner_Expecter { + return &Pipeliner_Expecter{mock: &_m.Mock} +} + // Append provides a mock function with given fields: ctx, key, value func (_m *Pipeliner) Append(ctx context.Context, key string, value string) *redis.IntCmd { ret := _m.Called(ctx, key, value) @@ -33,6 +41,36 @@ func (_m *Pipeliner) Append(ctx context.Context, key string, value string) *redi return r0 } +// Pipeliner_Append_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Append' +type Pipeliner_Append_Call struct { + *mock.Call +} + +// Append is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value string +func (_e *Pipeliner_Expecter) Append(ctx interface{}, key interface{}, value interface{}) *Pipeliner_Append_Call { + return &Pipeliner_Append_Call{Call: _e.mock.On("Append", ctx, key, value)} +} + +func (_c *Pipeliner_Append_Call) Run(run func(ctx context.Context, key string, value string)) *Pipeliner_Append_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_Append_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Append_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Append_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_Append_Call { + _c.Call.Return(run) + return _c +} + // Auth provides a mock function with given fields: ctx, password func (_m *Pipeliner) Auth(ctx context.Context, password string) *redis.StatusCmd { ret := _m.Called(ctx, password) @@ -49,6 +87,35 @@ func (_m *Pipeliner) Auth(ctx context.Context, password string) *redis.StatusCmd return r0 } +// Pipeliner_Auth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Auth' +type Pipeliner_Auth_Call struct { + *mock.Call +} + +// Auth is a helper method to define mock.On call +// - ctx context.Context +// - password string +func (_e *Pipeliner_Expecter) Auth(ctx interface{}, password interface{}) *Pipeliner_Auth_Call { + return &Pipeliner_Auth_Call{Call: _e.mock.On("Auth", ctx, password)} +} + +func (_c *Pipeliner_Auth_Call) Run(run func(ctx context.Context, password string)) *Pipeliner_Auth_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_Auth_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Auth_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Auth_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_Auth_Call { + _c.Call.Return(run) + return _c +} + // AuthACL provides a mock function with given fields: ctx, username, password func (_m *Pipeliner) AuthACL(ctx context.Context, username string, password string) *redis.StatusCmd { ret := _m.Called(ctx, username, password) @@ -65,6 +132,36 @@ func (_m *Pipeliner) AuthACL(ctx context.Context, username string, password stri return r0 } +// Pipeliner_AuthACL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthACL' +type Pipeliner_AuthACL_Call struct { + *mock.Call +} + +// AuthACL is a helper method to define mock.On call +// - ctx context.Context +// - username string +// - password string +func (_e *Pipeliner_Expecter) AuthACL(ctx interface{}, username interface{}, password interface{}) *Pipeliner_AuthACL_Call { + return &Pipeliner_AuthACL_Call{Call: _e.mock.On("AuthACL", ctx, username, password)} +} + +func (_c *Pipeliner_AuthACL_Call) Run(run func(ctx context.Context, username string, password string)) *Pipeliner_AuthACL_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_AuthACL_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_AuthACL_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_AuthACL_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_AuthACL_Call { + _c.Call.Return(run) + return _c +} + // BLMove provides a mock function with given fields: ctx, source, destination, srcpos, destpos, timeout func (_m *Pipeliner) 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) @@ -81,6 +178,39 @@ func (_m *Pipeliner) BLMove(ctx context.Context, source string, destination stri return r0 } +// Pipeliner_BLMove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BLMove' +type Pipeliner_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 *Pipeliner_Expecter) BLMove(ctx interface{}, source interface{}, destination interface{}, srcpos interface{}, destpos interface{}, timeout interface{}) *Pipeliner_BLMove_Call { + return &Pipeliner_BLMove_Call{Call: _e.mock.On("BLMove", ctx, source, destination, srcpos, destpos, timeout)} +} + +func (_c *Pipeliner_BLMove_Call) Run(run func(ctx context.Context, source string, destination string, srcpos string, destpos string, timeout time.Duration)) *Pipeliner_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 *Pipeliner_BLMove_Call) Return(_a0 *redis.StringCmd) *Pipeliner_BLMove_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BLMove_Call) RunAndReturn(run func(context.Context, string, string, string, string, time.Duration) *redis.StringCmd) *Pipeliner_BLMove_Call { + _c.Call.Return(run) + return _c +} + // BLPop provides a mock function with given fields: ctx, timeout, keys func (_m *Pipeliner) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { _va := make([]interface{}, len(keys)) @@ -104,6 +234,43 @@ func (_m *Pipeliner) BLPop(ctx context.Context, timeout time.Duration, keys ...s return r0 } +// Pipeliner_BLPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BLPop' +type Pipeliner_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 *Pipeliner_Expecter) BLPop(ctx interface{}, timeout interface{}, keys ...interface{}) *Pipeliner_BLPop_Call { + return &Pipeliner_BLPop_Call{Call: _e.mock.On("BLPop", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *Pipeliner_BLPop_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Pipeliner_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 *Pipeliner_BLPop_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_BLPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BLPop_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.StringSliceCmd) *Pipeliner_BLPop_Call { + _c.Call.Return(run) + return _c +} + // BRPop provides a mock function with given fields: ctx, timeout, keys func (_m *Pipeliner) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { _va := make([]interface{}, len(keys)) @@ -127,6 +294,43 @@ func (_m *Pipeliner) BRPop(ctx context.Context, timeout time.Duration, keys ...s return r0 } +// Pipeliner_BRPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BRPop' +type Pipeliner_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 *Pipeliner_Expecter) BRPop(ctx interface{}, timeout interface{}, keys ...interface{}) *Pipeliner_BRPop_Call { + return &Pipeliner_BRPop_Call{Call: _e.mock.On("BRPop", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *Pipeliner_BRPop_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Pipeliner_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 *Pipeliner_BRPop_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_BRPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BRPop_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.StringSliceCmd) *Pipeliner_BRPop_Call { + _c.Call.Return(run) + return _c +} + // BRPopLPush provides a mock function with given fields: ctx, source, destination, timeout func (_m *Pipeliner) BRPopLPush(ctx context.Context, source string, destination string, timeout time.Duration) *redis.StringCmd { ret := _m.Called(ctx, source, destination, timeout) @@ -143,6 +347,37 @@ func (_m *Pipeliner) BRPopLPush(ctx context.Context, source string, destination return r0 } +// Pipeliner_BRPopLPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BRPopLPush' +type Pipeliner_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 *Pipeliner_Expecter) BRPopLPush(ctx interface{}, source interface{}, destination interface{}, timeout interface{}) *Pipeliner_BRPopLPush_Call { + return &Pipeliner_BRPopLPush_Call{Call: _e.mock.On("BRPopLPush", ctx, source, destination, timeout)} +} + +func (_c *Pipeliner_BRPopLPush_Call) Run(run func(ctx context.Context, source string, destination string, timeout time.Duration)) *Pipeliner_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 *Pipeliner_BRPopLPush_Call) Return(_a0 *redis.StringCmd) *Pipeliner_BRPopLPush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BRPopLPush_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) *redis.StringCmd) *Pipeliner_BRPopLPush_Call { + _c.Call.Return(run) + return _c +} + // BZPopMax provides a mock function with given fields: ctx, timeout, keys func (_m *Pipeliner) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { _va := make([]interface{}, len(keys)) @@ -166,6 +401,43 @@ func (_m *Pipeliner) BZPopMax(ctx context.Context, timeout time.Duration, keys . return r0 } +// Pipeliner_BZPopMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BZPopMax' +type Pipeliner_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 *Pipeliner_Expecter) BZPopMax(ctx interface{}, timeout interface{}, keys ...interface{}) *Pipeliner_BZPopMax_Call { + return &Pipeliner_BZPopMax_Call{Call: _e.mock.On("BZPopMax", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *Pipeliner_BZPopMax_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Pipeliner_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 *Pipeliner_BZPopMax_Call) Return(_a0 *redis.ZWithKeyCmd) *Pipeliner_BZPopMax_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BZPopMax_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.ZWithKeyCmd) *Pipeliner_BZPopMax_Call { + _c.Call.Return(run) + return _c +} + // BZPopMin provides a mock function with given fields: ctx, timeout, keys func (_m *Pipeliner) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { _va := make([]interface{}, len(keys)) @@ -189,6 +461,43 @@ func (_m *Pipeliner) BZPopMin(ctx context.Context, timeout time.Duration, keys . return r0 } +// Pipeliner_BZPopMin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BZPopMin' +type Pipeliner_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 *Pipeliner_Expecter) BZPopMin(ctx interface{}, timeout interface{}, keys ...interface{}) *Pipeliner_BZPopMin_Call { + return &Pipeliner_BZPopMin_Call{Call: _e.mock.On("BZPopMin", + append([]interface{}{ctx, timeout}, keys...)...)} +} + +func (_c *Pipeliner_BZPopMin_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Pipeliner_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 *Pipeliner_BZPopMin_Call) Return(_a0 *redis.ZWithKeyCmd) *Pipeliner_BZPopMin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BZPopMin_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.ZWithKeyCmd) *Pipeliner_BZPopMin_Call { + _c.Call.Return(run) + return _c +} + // BgRewriteAOF provides a mock function with given fields: ctx func (_m *Pipeliner) BgRewriteAOF(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -205,6 +514,34 @@ func (_m *Pipeliner) BgRewriteAOF(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_BgRewriteAOF_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BgRewriteAOF' +type Pipeliner_BgRewriteAOF_Call struct { + *mock.Call +} + +// BgRewriteAOF is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) BgRewriteAOF(ctx interface{}) *Pipeliner_BgRewriteAOF_Call { + return &Pipeliner_BgRewriteAOF_Call{Call: _e.mock.On("BgRewriteAOF", ctx)} +} + +func (_c *Pipeliner_BgRewriteAOF_Call) Run(run func(ctx context.Context)) *Pipeliner_BgRewriteAOF_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_BgRewriteAOF_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_BgRewriteAOF_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BgRewriteAOF_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_BgRewriteAOF_Call { + _c.Call.Return(run) + return _c +} + // BgSave provides a mock function with given fields: ctx func (_m *Pipeliner) BgSave(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -221,6 +558,34 @@ func (_m *Pipeliner) BgSave(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_BgSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BgSave' +type Pipeliner_BgSave_Call struct { + *mock.Call +} + +// BgSave is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) BgSave(ctx interface{}) *Pipeliner_BgSave_Call { + return &Pipeliner_BgSave_Call{Call: _e.mock.On("BgSave", ctx)} +} + +func (_c *Pipeliner_BgSave_Call) Run(run func(ctx context.Context)) *Pipeliner_BgSave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_BgSave_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_BgSave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BgSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_BgSave_Call { + _c.Call.Return(run) + return _c +} + // BitCount provides a mock function with given fields: ctx, key, bitCount func (_m *Pipeliner) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd { ret := _m.Called(ctx, key, bitCount) @@ -237,6 +602,36 @@ func (_m *Pipeliner) BitCount(ctx context.Context, key string, bitCount *redis.B return r0 } +// Pipeliner_BitCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitCount' +type Pipeliner_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 *Pipeliner_Expecter) BitCount(ctx interface{}, key interface{}, bitCount interface{}) *Pipeliner_BitCount_Call { + return &Pipeliner_BitCount_Call{Call: _e.mock.On("BitCount", ctx, key, bitCount)} +} + +func (_c *Pipeliner_BitCount_Call) Run(run func(ctx context.Context, key string, bitCount *redis.BitCount)) *Pipeliner_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 *Pipeliner_BitCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BitCount_Call) RunAndReturn(run func(context.Context, string, *redis.BitCount) *redis.IntCmd) *Pipeliner_BitCount_Call { + _c.Call.Return(run) + return _c +} + // BitField provides a mock function with given fields: ctx, key, args func (_m *Pipeliner) BitField(ctx context.Context, key string, args ...interface{}) *redis.IntSliceCmd { var _ca []interface{} @@ -256,6 +651,43 @@ func (_m *Pipeliner) BitField(ctx context.Context, key string, args ...interface return r0 } +// Pipeliner_BitField_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitField' +type Pipeliner_BitField_Call struct { + *mock.Call +} + +// BitField is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - args ...interface{} +func (_e *Pipeliner_Expecter) BitField(ctx interface{}, key interface{}, args ...interface{}) *Pipeliner_BitField_Call { + return &Pipeliner_BitField_Call{Call: _e.mock.On("BitField", + append([]interface{}{ctx, key}, args...)...)} +} + +func (_c *Pipeliner_BitField_Call) Run(run func(ctx context.Context, key string, args ...interface{})) *Pipeliner_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 *Pipeliner_BitField_Call) Return(_a0 *redis.IntSliceCmd) *Pipeliner_BitField_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BitField_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntSliceCmd) *Pipeliner_BitField_Call { + _c.Call.Return(run) + return _c +} + // BitOpAnd provides a mock function with given fields: ctx, destKey, keys func (_m *Pipeliner) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -279,6 +711,43 @@ func (_m *Pipeliner) BitOpAnd(ctx context.Context, destKey string, keys ...strin return r0 } +// Pipeliner_BitOpAnd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitOpAnd' +type Pipeliner_BitOpAnd_Call struct { + *mock.Call +} + +// BitOpAnd is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - keys ...string +func (_e *Pipeliner_Expecter) BitOpAnd(ctx interface{}, destKey interface{}, keys ...interface{}) *Pipeliner_BitOpAnd_Call { + return &Pipeliner_BitOpAnd_Call{Call: _e.mock.On("BitOpAnd", + append([]interface{}{ctx, destKey}, keys...)...)} +} + +func (_c *Pipeliner_BitOpAnd_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *Pipeliner_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 *Pipeliner_BitOpAnd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitOpAnd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BitOpAnd_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_BitOpAnd_Call { + _c.Call.Return(run) + return _c +} + // BitOpNot provides a mock function with given fields: ctx, destKey, key func (_m *Pipeliner) BitOpNot(ctx context.Context, destKey string, key string) *redis.IntCmd { ret := _m.Called(ctx, destKey, key) @@ -295,6 +764,36 @@ func (_m *Pipeliner) BitOpNot(ctx context.Context, destKey string, key string) * return r0 } +// Pipeliner_BitOpNot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitOpNot' +type Pipeliner_BitOpNot_Call struct { + *mock.Call +} + +// BitOpNot is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - key string +func (_e *Pipeliner_Expecter) BitOpNot(ctx interface{}, destKey interface{}, key interface{}) *Pipeliner_BitOpNot_Call { + return &Pipeliner_BitOpNot_Call{Call: _e.mock.On("BitOpNot", ctx, destKey, key)} +} + +func (_c *Pipeliner_BitOpNot_Call) Run(run func(ctx context.Context, destKey string, key string)) *Pipeliner_BitOpNot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_BitOpNot_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitOpNot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BitOpNot_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_BitOpNot_Call { + _c.Call.Return(run) + return _c +} + // BitOpOr provides a mock function with given fields: ctx, destKey, keys func (_m *Pipeliner) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -318,6 +817,43 @@ func (_m *Pipeliner) BitOpOr(ctx context.Context, destKey string, keys ...string return r0 } +// Pipeliner_BitOpOr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitOpOr' +type Pipeliner_BitOpOr_Call struct { + *mock.Call +} + +// BitOpOr is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - keys ...string +func (_e *Pipeliner_Expecter) BitOpOr(ctx interface{}, destKey interface{}, keys ...interface{}) *Pipeliner_BitOpOr_Call { + return &Pipeliner_BitOpOr_Call{Call: _e.mock.On("BitOpOr", + append([]interface{}{ctx, destKey}, keys...)...)} +} + +func (_c *Pipeliner_BitOpOr_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *Pipeliner_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 *Pipeliner_BitOpOr_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitOpOr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BitOpOr_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_BitOpOr_Call { + _c.Call.Return(run) + return _c +} + // BitOpXor provides a mock function with given fields: ctx, destKey, keys func (_m *Pipeliner) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -341,6 +877,43 @@ func (_m *Pipeliner) BitOpXor(ctx context.Context, destKey string, keys ...strin return r0 } +// Pipeliner_BitOpXor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitOpXor' +type Pipeliner_BitOpXor_Call struct { + *mock.Call +} + +// BitOpXor is a helper method to define mock.On call +// - ctx context.Context +// - destKey string +// - keys ...string +func (_e *Pipeliner_Expecter) BitOpXor(ctx interface{}, destKey interface{}, keys ...interface{}) *Pipeliner_BitOpXor_Call { + return &Pipeliner_BitOpXor_Call{Call: _e.mock.On("BitOpXor", + append([]interface{}{ctx, destKey}, keys...)...)} +} + +func (_c *Pipeliner_BitOpXor_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *Pipeliner_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 *Pipeliner_BitOpXor_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitOpXor_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BitOpXor_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_BitOpXor_Call { + _c.Call.Return(run) + return _c +} + // BitPos provides a mock function with given fields: ctx, key, bit, pos func (_m *Pipeliner) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd { _va := make([]interface{}, len(pos)) @@ -364,6 +937,44 @@ func (_m *Pipeliner) BitPos(ctx context.Context, key string, bit int64, pos ...i return r0 } +// Pipeliner_BitPos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BitPos' +type Pipeliner_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 *Pipeliner_Expecter) BitPos(ctx interface{}, key interface{}, bit interface{}, pos ...interface{}) *Pipeliner_BitPos_Call { + return &Pipeliner_BitPos_Call{Call: _e.mock.On("BitPos", + append([]interface{}{ctx, key, bit}, pos...)...)} +} + +func (_c *Pipeliner_BitPos_Call) Run(run func(ctx context.Context, key string, bit int64, pos ...int64)) *Pipeliner_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 *Pipeliner_BitPos_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitPos_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_BitPos_Call) RunAndReturn(run func(context.Context, string, int64, ...int64) *redis.IntCmd) *Pipeliner_BitPos_Call { + _c.Call.Return(run) + return _c +} + // ClientGetName provides a mock function with given fields: ctx func (_m *Pipeliner) ClientGetName(ctx context.Context) *redis.StringCmd { ret := _m.Called(ctx) @@ -380,6 +991,34 @@ func (_m *Pipeliner) ClientGetName(ctx context.Context) *redis.StringCmd { return r0 } +// Pipeliner_ClientGetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientGetName' +type Pipeliner_ClientGetName_Call struct { + *mock.Call +} + +// ClientGetName is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClientGetName(ctx interface{}) *Pipeliner_ClientGetName_Call { + return &Pipeliner_ClientGetName_Call{Call: _e.mock.On("ClientGetName", ctx)} +} + +func (_c *Pipeliner_ClientGetName_Call) Run(run func(ctx context.Context)) *Pipeliner_ClientGetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClientGetName_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ClientGetName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClientGetName_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_ClientGetName_Call { + _c.Call.Return(run) + return _c +} + // ClientID provides a mock function with given fields: ctx func (_m *Pipeliner) ClientID(ctx context.Context) *redis.IntCmd { ret := _m.Called(ctx) @@ -396,6 +1035,34 @@ func (_m *Pipeliner) ClientID(ctx context.Context) *redis.IntCmd { return r0 } +// Pipeliner_ClientID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientID' +type Pipeliner_ClientID_Call struct { + *mock.Call +} + +// ClientID is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClientID(ctx interface{}) *Pipeliner_ClientID_Call { + return &Pipeliner_ClientID_Call{Call: _e.mock.On("ClientID", ctx)} +} + +func (_c *Pipeliner_ClientID_Call) Run(run func(ctx context.Context)) *Pipeliner_ClientID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClientID_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClientID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClientID_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *Pipeliner_ClientID_Call { + _c.Call.Return(run) + return _c +} + // ClientKill provides a mock function with given fields: ctx, ipPort func (_m *Pipeliner) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd { ret := _m.Called(ctx, ipPort) @@ -412,6 +1079,35 @@ func (_m *Pipeliner) ClientKill(ctx context.Context, ipPort string) *redis.Statu return r0 } +// Pipeliner_ClientKill_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientKill' +type Pipeliner_ClientKill_Call struct { + *mock.Call +} + +// ClientKill is a helper method to define mock.On call +// - ctx context.Context +// - ipPort string +func (_e *Pipeliner_Expecter) ClientKill(ctx interface{}, ipPort interface{}) *Pipeliner_ClientKill_Call { + return &Pipeliner_ClientKill_Call{Call: _e.mock.On("ClientKill", ctx, ipPort)} +} + +func (_c *Pipeliner_ClientKill_Call) Run(run func(ctx context.Context, ipPort string)) *Pipeliner_ClientKill_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ClientKill_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClientKill_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClientKill_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_ClientKill_Call { + _c.Call.Return(run) + return _c +} + // ClientKillByFilter provides a mock function with given fields: ctx, keys func (_m *Pipeliner) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -435,6 +1131,42 @@ func (_m *Pipeliner) ClientKillByFilter(ctx context.Context, keys ...string) *re return r0 } +// Pipeliner_ClientKillByFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientKillByFilter' +type Pipeliner_ClientKillByFilter_Call struct { + *mock.Call +} + +// ClientKillByFilter is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) ClientKillByFilter(ctx interface{}, keys ...interface{}) *Pipeliner_ClientKillByFilter_Call { + return &Pipeliner_ClientKillByFilter_Call{Call: _e.mock.On("ClientKillByFilter", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_ClientKillByFilter_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_ClientKillByFilter_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClientKillByFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClientKillByFilter_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_ClientKillByFilter_Call { + _c.Call.Return(run) + return _c +} + // ClientList provides a mock function with given fields: ctx func (_m *Pipeliner) ClientList(ctx context.Context) *redis.StringCmd { ret := _m.Called(ctx) @@ -451,6 +1183,34 @@ func (_m *Pipeliner) ClientList(ctx context.Context) *redis.StringCmd { return r0 } +// Pipeliner_ClientList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientList' +type Pipeliner_ClientList_Call struct { + *mock.Call +} + +// ClientList is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClientList(ctx interface{}) *Pipeliner_ClientList_Call { + return &Pipeliner_ClientList_Call{Call: _e.mock.On("ClientList", ctx)} +} + +func (_c *Pipeliner_ClientList_Call) Run(run func(ctx context.Context)) *Pipeliner_ClientList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClientList_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ClientList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClientList_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_ClientList_Call { + _c.Call.Return(run) + return _c +} + // ClientPause provides a mock function with given fields: ctx, dur func (_m *Pipeliner) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd { ret := _m.Called(ctx, dur) @@ -467,6 +1227,35 @@ func (_m *Pipeliner) ClientPause(ctx context.Context, dur time.Duration) *redis. return r0 } +// Pipeliner_ClientPause_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientPause' +type Pipeliner_ClientPause_Call struct { + *mock.Call +} + +// ClientPause is a helper method to define mock.On call +// - ctx context.Context +// - dur time.Duration +func (_e *Pipeliner_Expecter) ClientPause(ctx interface{}, dur interface{}) *Pipeliner_ClientPause_Call { + return &Pipeliner_ClientPause_Call{Call: _e.mock.On("ClientPause", ctx, dur)} +} + +func (_c *Pipeliner_ClientPause_Call) Run(run func(ctx context.Context, dur time.Duration)) *Pipeliner_ClientPause_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(time.Duration)) + }) + return _c +} + +func (_c *Pipeliner_ClientPause_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ClientPause_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClientPause_Call) RunAndReturn(run func(context.Context, time.Duration) *redis.BoolCmd) *Pipeliner_ClientPause_Call { + _c.Call.Return(run) + return _c +} + // ClientSetName provides a mock function with given fields: ctx, name func (_m *Pipeliner) ClientSetName(ctx context.Context, name string) *redis.BoolCmd { ret := _m.Called(ctx, name) @@ -483,8 +1272,37 @@ func (_m *Pipeliner) ClientSetName(ctx context.Context, name string) *redis.Bool return r0 } -// Close provides a mock function with given fields: -func (_m *Pipeliner) Close() error { +// Pipeliner_ClientSetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientSetName' +type Pipeliner_ClientSetName_Call struct { + *mock.Call +} + +// ClientSetName is a helper method to define mock.On call +// - ctx context.Context +// - name string +func (_e *Pipeliner_Expecter) ClientSetName(ctx interface{}, name interface{}) *Pipeliner_ClientSetName_Call { + return &Pipeliner_ClientSetName_Call{Call: _e.mock.On("ClientSetName", ctx, name)} +} + +func (_c *Pipeliner_ClientSetName_Call) Run(run func(ctx context.Context, name string)) *Pipeliner_ClientSetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ClientSetName_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ClientSetName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClientSetName_Call) RunAndReturn(run func(context.Context, string) *redis.BoolCmd) *Pipeliner_ClientSetName_Call { + _c.Call.Return(run) + return _c +} + +// Close provides a mock function with given fields: +func (_m *Pipeliner) Close() error { ret := _m.Called() var r0 error @@ -497,6 +1315,33 @@ func (_m *Pipeliner) Close() error { return r0 } +// Pipeliner_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type Pipeliner_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *Pipeliner_Expecter) Close() *Pipeliner_Close_Call { + return &Pipeliner_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *Pipeliner_Close_Call) Run(run func()) *Pipeliner_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Pipeliner_Close_Call) Return(_a0 error) *Pipeliner_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Close_Call) RunAndReturn(run func() error) *Pipeliner_Close_Call { + _c.Call.Return(run) + return _c +} + // ClusterAddSlots provides a mock function with given fields: ctx, slots func (_m *Pipeliner) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd { _va := make([]interface{}, len(slots)) @@ -520,6 +1365,42 @@ func (_m *Pipeliner) ClusterAddSlots(ctx context.Context, slots ...int) *redis.S return r0 } +// Pipeliner_ClusterAddSlots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterAddSlots' +type Pipeliner_ClusterAddSlots_Call struct { + *mock.Call +} + +// ClusterAddSlots is a helper method to define mock.On call +// - ctx context.Context +// - slots ...int +func (_e *Pipeliner_Expecter) ClusterAddSlots(ctx interface{}, slots ...interface{}) *Pipeliner_ClusterAddSlots_Call { + return &Pipeliner_ClusterAddSlots_Call{Call: _e.mock.On("ClusterAddSlots", + append([]interface{}{ctx}, slots...)...)} +} + +func (_c *Pipeliner_ClusterAddSlots_Call) Run(run func(ctx context.Context, slots ...int)) *Pipeliner_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 *Pipeliner_ClusterAddSlots_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterAddSlots_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterAddSlots_Call) RunAndReturn(run func(context.Context, ...int) *redis.StatusCmd) *Pipeliner_ClusterAddSlots_Call { + _c.Call.Return(run) + return _c +} + // ClusterAddSlotsRange provides a mock function with given fields: ctx, min, max func (_m *Pipeliner) ClusterAddSlotsRange(ctx context.Context, min int, max int) *redis.StatusCmd { ret := _m.Called(ctx, min, max) @@ -536,6 +1417,36 @@ func (_m *Pipeliner) ClusterAddSlotsRange(ctx context.Context, min int, max int) return r0 } +// Pipeliner_ClusterAddSlotsRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterAddSlotsRange' +type Pipeliner_ClusterAddSlotsRange_Call struct { + *mock.Call +} + +// ClusterAddSlotsRange is a helper method to define mock.On call +// - ctx context.Context +// - min int +// - max int +func (_e *Pipeliner_Expecter) ClusterAddSlotsRange(ctx interface{}, min interface{}, max interface{}) *Pipeliner_ClusterAddSlotsRange_Call { + return &Pipeliner_ClusterAddSlotsRange_Call{Call: _e.mock.On("ClusterAddSlotsRange", ctx, min, max)} +} + +func (_c *Pipeliner_ClusterAddSlotsRange_Call) Run(run func(ctx context.Context, min int, max int)) *Pipeliner_ClusterAddSlotsRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *Pipeliner_ClusterAddSlotsRange_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterAddSlotsRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterAddSlotsRange_Call) RunAndReturn(run func(context.Context, int, int) *redis.StatusCmd) *Pipeliner_ClusterAddSlotsRange_Call { + _c.Call.Return(run) + return _c +} + // ClusterCountFailureReports provides a mock function with given fields: ctx, nodeID func (_m *Pipeliner) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd { ret := _m.Called(ctx, nodeID) @@ -552,6 +1463,35 @@ func (_m *Pipeliner) ClusterCountFailureReports(ctx context.Context, nodeID stri return r0 } +// Pipeliner_ClusterCountFailureReports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterCountFailureReports' +type Pipeliner_ClusterCountFailureReports_Call struct { + *mock.Call +} + +// ClusterCountFailureReports is a helper method to define mock.On call +// - ctx context.Context +// - nodeID string +func (_e *Pipeliner_Expecter) ClusterCountFailureReports(ctx interface{}, nodeID interface{}) *Pipeliner_ClusterCountFailureReports_Call { + return &Pipeliner_ClusterCountFailureReports_Call{Call: _e.mock.On("ClusterCountFailureReports", ctx, nodeID)} +} + +func (_c *Pipeliner_ClusterCountFailureReports_Call) Run(run func(ctx context.Context, nodeID string)) *Pipeliner_ClusterCountFailureReports_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ClusterCountFailureReports_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClusterCountFailureReports_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterCountFailureReports_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_ClusterCountFailureReports_Call { + _c.Call.Return(run) + return _c +} + // ClusterCountKeysInSlot provides a mock function with given fields: ctx, slot func (_m *Pipeliner) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd { ret := _m.Called(ctx, slot) @@ -568,6 +1508,35 @@ func (_m *Pipeliner) ClusterCountKeysInSlot(ctx context.Context, slot int) *redi return r0 } +// Pipeliner_ClusterCountKeysInSlot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterCountKeysInSlot' +type Pipeliner_ClusterCountKeysInSlot_Call struct { + *mock.Call +} + +// ClusterCountKeysInSlot is a helper method to define mock.On call +// - ctx context.Context +// - slot int +func (_e *Pipeliner_Expecter) ClusterCountKeysInSlot(ctx interface{}, slot interface{}) *Pipeliner_ClusterCountKeysInSlot_Call { + return &Pipeliner_ClusterCountKeysInSlot_Call{Call: _e.mock.On("ClusterCountKeysInSlot", ctx, slot)} +} + +func (_c *Pipeliner_ClusterCountKeysInSlot_Call) Run(run func(ctx context.Context, slot int)) *Pipeliner_ClusterCountKeysInSlot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int)) + }) + return _c +} + +func (_c *Pipeliner_ClusterCountKeysInSlot_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClusterCountKeysInSlot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterCountKeysInSlot_Call) RunAndReturn(run func(context.Context, int) *redis.IntCmd) *Pipeliner_ClusterCountKeysInSlot_Call { + _c.Call.Return(run) + return _c +} + // ClusterDelSlots provides a mock function with given fields: ctx, slots func (_m *Pipeliner) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd { _va := make([]interface{}, len(slots)) @@ -591,6 +1560,42 @@ func (_m *Pipeliner) ClusterDelSlots(ctx context.Context, slots ...int) *redis.S return r0 } +// Pipeliner_ClusterDelSlots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterDelSlots' +type Pipeliner_ClusterDelSlots_Call struct { + *mock.Call +} + +// ClusterDelSlots is a helper method to define mock.On call +// - ctx context.Context +// - slots ...int +func (_e *Pipeliner_Expecter) ClusterDelSlots(ctx interface{}, slots ...interface{}) *Pipeliner_ClusterDelSlots_Call { + return &Pipeliner_ClusterDelSlots_Call{Call: _e.mock.On("ClusterDelSlots", + append([]interface{}{ctx}, slots...)...)} +} + +func (_c *Pipeliner_ClusterDelSlots_Call) Run(run func(ctx context.Context, slots ...int)) *Pipeliner_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 *Pipeliner_ClusterDelSlots_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterDelSlots_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterDelSlots_Call) RunAndReturn(run func(context.Context, ...int) *redis.StatusCmd) *Pipeliner_ClusterDelSlots_Call { + _c.Call.Return(run) + return _c +} + // ClusterDelSlotsRange provides a mock function with given fields: ctx, min, max func (_m *Pipeliner) ClusterDelSlotsRange(ctx context.Context, min int, max int) *redis.StatusCmd { ret := _m.Called(ctx, min, max) @@ -607,6 +1612,36 @@ func (_m *Pipeliner) ClusterDelSlotsRange(ctx context.Context, min int, max int) return r0 } +// Pipeliner_ClusterDelSlotsRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterDelSlotsRange' +type Pipeliner_ClusterDelSlotsRange_Call struct { + *mock.Call +} + +// ClusterDelSlotsRange is a helper method to define mock.On call +// - ctx context.Context +// - min int +// - max int +func (_e *Pipeliner_Expecter) ClusterDelSlotsRange(ctx interface{}, min interface{}, max interface{}) *Pipeliner_ClusterDelSlotsRange_Call { + return &Pipeliner_ClusterDelSlotsRange_Call{Call: _e.mock.On("ClusterDelSlotsRange", ctx, min, max)} +} + +func (_c *Pipeliner_ClusterDelSlotsRange_Call) Run(run func(ctx context.Context, min int, max int)) *Pipeliner_ClusterDelSlotsRange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *Pipeliner_ClusterDelSlotsRange_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterDelSlotsRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterDelSlotsRange_Call) RunAndReturn(run func(context.Context, int, int) *redis.StatusCmd) *Pipeliner_ClusterDelSlotsRange_Call { + _c.Call.Return(run) + return _c +} + // ClusterFailover provides a mock function with given fields: ctx func (_m *Pipeliner) ClusterFailover(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -623,6 +1658,34 @@ func (_m *Pipeliner) ClusterFailover(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ClusterFailover_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterFailover' +type Pipeliner_ClusterFailover_Call struct { + *mock.Call +} + +// ClusterFailover is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClusterFailover(ctx interface{}) *Pipeliner_ClusterFailover_Call { + return &Pipeliner_ClusterFailover_Call{Call: _e.mock.On("ClusterFailover", ctx)} +} + +func (_c *Pipeliner_ClusterFailover_Call) Run(run func(ctx context.Context)) *Pipeliner_ClusterFailover_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClusterFailover_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterFailover_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterFailover_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ClusterFailover_Call { + _c.Call.Return(run) + return _c +} + // ClusterForget provides a mock function with given fields: ctx, nodeID func (_m *Pipeliner) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd { ret := _m.Called(ctx, nodeID) @@ -639,6 +1702,35 @@ func (_m *Pipeliner) ClusterForget(ctx context.Context, nodeID string) *redis.St return r0 } +// Pipeliner_ClusterForget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterForget' +type Pipeliner_ClusterForget_Call struct { + *mock.Call +} + +// ClusterForget is a helper method to define mock.On call +// - ctx context.Context +// - nodeID string +func (_e *Pipeliner_Expecter) ClusterForget(ctx interface{}, nodeID interface{}) *Pipeliner_ClusterForget_Call { + return &Pipeliner_ClusterForget_Call{Call: _e.mock.On("ClusterForget", ctx, nodeID)} +} + +func (_c *Pipeliner_ClusterForget_Call) Run(run func(ctx context.Context, nodeID string)) *Pipeliner_ClusterForget_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ClusterForget_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterForget_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterForget_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_ClusterForget_Call { + _c.Call.Return(run) + return _c +} + // ClusterGetKeysInSlot provides a mock function with given fields: ctx, slot, count func (_m *Pipeliner) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *redis.StringSliceCmd { ret := _m.Called(ctx, slot, count) @@ -655,6 +1747,36 @@ func (_m *Pipeliner) ClusterGetKeysInSlot(ctx context.Context, slot int, count i return r0 } +// Pipeliner_ClusterGetKeysInSlot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterGetKeysInSlot' +type Pipeliner_ClusterGetKeysInSlot_Call struct { + *mock.Call +} + +// ClusterGetKeysInSlot is a helper method to define mock.On call +// - ctx context.Context +// - slot int +// - count int +func (_e *Pipeliner_Expecter) ClusterGetKeysInSlot(ctx interface{}, slot interface{}, count interface{}) *Pipeliner_ClusterGetKeysInSlot_Call { + return &Pipeliner_ClusterGetKeysInSlot_Call{Call: _e.mock.On("ClusterGetKeysInSlot", ctx, slot, count)} +} + +func (_c *Pipeliner_ClusterGetKeysInSlot_Call) Run(run func(ctx context.Context, slot int, count int)) *Pipeliner_ClusterGetKeysInSlot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *Pipeliner_ClusterGetKeysInSlot_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ClusterGetKeysInSlot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterGetKeysInSlot_Call) RunAndReturn(run func(context.Context, int, int) *redis.StringSliceCmd) *Pipeliner_ClusterGetKeysInSlot_Call { + _c.Call.Return(run) + return _c +} + // ClusterInfo provides a mock function with given fields: ctx func (_m *Pipeliner) ClusterInfo(ctx context.Context) *redis.StringCmd { ret := _m.Called(ctx) @@ -671,6 +1793,34 @@ func (_m *Pipeliner) ClusterInfo(ctx context.Context) *redis.StringCmd { return r0 } +// Pipeliner_ClusterInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterInfo' +type Pipeliner_ClusterInfo_Call struct { + *mock.Call +} + +// ClusterInfo is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClusterInfo(ctx interface{}) *Pipeliner_ClusterInfo_Call { + return &Pipeliner_ClusterInfo_Call{Call: _e.mock.On("ClusterInfo", ctx)} +} + +func (_c *Pipeliner_ClusterInfo_Call) Run(run func(ctx context.Context)) *Pipeliner_ClusterInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClusterInfo_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ClusterInfo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterInfo_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_ClusterInfo_Call { + _c.Call.Return(run) + return _c +} + // ClusterKeySlot provides a mock function with given fields: ctx, key func (_m *Pipeliner) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -687,6 +1837,35 @@ func (_m *Pipeliner) ClusterKeySlot(ctx context.Context, key string) *redis.IntC return r0 } +// Pipeliner_ClusterKeySlot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterKeySlot' +type Pipeliner_ClusterKeySlot_Call struct { + *mock.Call +} + +// ClusterKeySlot is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) ClusterKeySlot(ctx interface{}, key interface{}) *Pipeliner_ClusterKeySlot_Call { + return &Pipeliner_ClusterKeySlot_Call{Call: _e.mock.On("ClusterKeySlot", ctx, key)} +} + +func (_c *Pipeliner_ClusterKeySlot_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_ClusterKeySlot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ClusterKeySlot_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClusterKeySlot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterKeySlot_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_ClusterKeySlot_Call { + _c.Call.Return(run) + return _c +} + // ClusterMeet provides a mock function with given fields: ctx, host, port func (_m *Pipeliner) ClusterMeet(ctx context.Context, host string, port string) *redis.StatusCmd { ret := _m.Called(ctx, host, port) @@ -703,6 +1882,36 @@ func (_m *Pipeliner) ClusterMeet(ctx context.Context, host string, port string) return r0 } +// Pipeliner_ClusterMeet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterMeet' +type Pipeliner_ClusterMeet_Call struct { + *mock.Call +} + +// ClusterMeet is a helper method to define mock.On call +// - ctx context.Context +// - host string +// - port string +func (_e *Pipeliner_Expecter) ClusterMeet(ctx interface{}, host interface{}, port interface{}) *Pipeliner_ClusterMeet_Call { + return &Pipeliner_ClusterMeet_Call{Call: _e.mock.On("ClusterMeet", ctx, host, port)} +} + +func (_c *Pipeliner_ClusterMeet_Call) Run(run func(ctx context.Context, host string, port string)) *Pipeliner_ClusterMeet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_ClusterMeet_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterMeet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterMeet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_ClusterMeet_Call { + _c.Call.Return(run) + return _c +} + // ClusterNodes provides a mock function with given fields: ctx func (_m *Pipeliner) ClusterNodes(ctx context.Context) *redis.StringCmd { ret := _m.Called(ctx) @@ -719,6 +1928,34 @@ func (_m *Pipeliner) ClusterNodes(ctx context.Context) *redis.StringCmd { return r0 } +// Pipeliner_ClusterNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterNodes' +type Pipeliner_ClusterNodes_Call struct { + *mock.Call +} + +// ClusterNodes is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClusterNodes(ctx interface{}) *Pipeliner_ClusterNodes_Call { + return &Pipeliner_ClusterNodes_Call{Call: _e.mock.On("ClusterNodes", ctx)} +} + +func (_c *Pipeliner_ClusterNodes_Call) Run(run func(ctx context.Context)) *Pipeliner_ClusterNodes_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClusterNodes_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ClusterNodes_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterNodes_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_ClusterNodes_Call { + _c.Call.Return(run) + return _c +} + // ClusterReplicate provides a mock function with given fields: ctx, nodeID func (_m *Pipeliner) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd { ret := _m.Called(ctx, nodeID) @@ -735,6 +1972,35 @@ func (_m *Pipeliner) ClusterReplicate(ctx context.Context, nodeID string) *redis return r0 } +// Pipeliner_ClusterReplicate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterReplicate' +type Pipeliner_ClusterReplicate_Call struct { + *mock.Call +} + +// ClusterReplicate is a helper method to define mock.On call +// - ctx context.Context +// - nodeID string +func (_e *Pipeliner_Expecter) ClusterReplicate(ctx interface{}, nodeID interface{}) *Pipeliner_ClusterReplicate_Call { + return &Pipeliner_ClusterReplicate_Call{Call: _e.mock.On("ClusterReplicate", ctx, nodeID)} +} + +func (_c *Pipeliner_ClusterReplicate_Call) Run(run func(ctx context.Context, nodeID string)) *Pipeliner_ClusterReplicate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ClusterReplicate_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterReplicate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterReplicate_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_ClusterReplicate_Call { + _c.Call.Return(run) + return _c +} + // ClusterResetHard provides a mock function with given fields: ctx func (_m *Pipeliner) ClusterResetHard(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -751,6 +2017,34 @@ func (_m *Pipeliner) ClusterResetHard(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ClusterResetHard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterResetHard' +type Pipeliner_ClusterResetHard_Call struct { + *mock.Call +} + +// ClusterResetHard is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClusterResetHard(ctx interface{}) *Pipeliner_ClusterResetHard_Call { + return &Pipeliner_ClusterResetHard_Call{Call: _e.mock.On("ClusterResetHard", ctx)} +} + +func (_c *Pipeliner_ClusterResetHard_Call) Run(run func(ctx context.Context)) *Pipeliner_ClusterResetHard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClusterResetHard_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterResetHard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterResetHard_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ClusterResetHard_Call { + _c.Call.Return(run) + return _c +} + // ClusterResetSoft provides a mock function with given fields: ctx func (_m *Pipeliner) ClusterResetSoft(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -767,6 +2061,34 @@ func (_m *Pipeliner) ClusterResetSoft(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ClusterResetSoft_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterResetSoft' +type Pipeliner_ClusterResetSoft_Call struct { + *mock.Call +} + +// ClusterResetSoft is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClusterResetSoft(ctx interface{}) *Pipeliner_ClusterResetSoft_Call { + return &Pipeliner_ClusterResetSoft_Call{Call: _e.mock.On("ClusterResetSoft", ctx)} +} + +func (_c *Pipeliner_ClusterResetSoft_Call) Run(run func(ctx context.Context)) *Pipeliner_ClusterResetSoft_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClusterResetSoft_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterResetSoft_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterResetSoft_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ClusterResetSoft_Call { + _c.Call.Return(run) + return _c +} + // ClusterSaveConfig provides a mock function with given fields: ctx func (_m *Pipeliner) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -783,6 +2105,34 @@ func (_m *Pipeliner) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ClusterSaveConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterSaveConfig' +type Pipeliner_ClusterSaveConfig_Call struct { + *mock.Call +} + +// ClusterSaveConfig is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClusterSaveConfig(ctx interface{}) *Pipeliner_ClusterSaveConfig_Call { + return &Pipeliner_ClusterSaveConfig_Call{Call: _e.mock.On("ClusterSaveConfig", ctx)} +} + +func (_c *Pipeliner_ClusterSaveConfig_Call) Run(run func(ctx context.Context)) *Pipeliner_ClusterSaveConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClusterSaveConfig_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterSaveConfig_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterSaveConfig_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ClusterSaveConfig_Call { + _c.Call.Return(run) + return _c +} + // ClusterSlaves provides a mock function with given fields: ctx, nodeID func (_m *Pipeliner) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd { ret := _m.Called(ctx, nodeID) @@ -799,6 +2149,35 @@ func (_m *Pipeliner) ClusterSlaves(ctx context.Context, nodeID string) *redis.St return r0 } +// Pipeliner_ClusterSlaves_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterSlaves' +type Pipeliner_ClusterSlaves_Call struct { + *mock.Call +} + +// ClusterSlaves is a helper method to define mock.On call +// - ctx context.Context +// - nodeID string +func (_e *Pipeliner_Expecter) ClusterSlaves(ctx interface{}, nodeID interface{}) *Pipeliner_ClusterSlaves_Call { + return &Pipeliner_ClusterSlaves_Call{Call: _e.mock.On("ClusterSlaves", ctx, nodeID)} +} + +func (_c *Pipeliner_ClusterSlaves_Call) Run(run func(ctx context.Context, nodeID string)) *Pipeliner_ClusterSlaves_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ClusterSlaves_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ClusterSlaves_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterSlaves_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_ClusterSlaves_Call { + _c.Call.Return(run) + return _c +} + // ClusterSlots provides a mock function with given fields: ctx func (_m *Pipeliner) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd { ret := _m.Called(ctx) @@ -815,6 +2194,34 @@ func (_m *Pipeliner) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd { return r0 } +// Pipeliner_ClusterSlots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterSlots' +type Pipeliner_ClusterSlots_Call struct { + *mock.Call +} + +// ClusterSlots is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ClusterSlots(ctx interface{}) *Pipeliner_ClusterSlots_Call { + return &Pipeliner_ClusterSlots_Call{Call: _e.mock.On("ClusterSlots", ctx)} +} + +func (_c *Pipeliner_ClusterSlots_Call) Run(run func(ctx context.Context)) *Pipeliner_ClusterSlots_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ClusterSlots_Call) Return(_a0 *redis.ClusterSlotsCmd) *Pipeliner_ClusterSlots_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ClusterSlots_Call) RunAndReturn(run func(context.Context) *redis.ClusterSlotsCmd) *Pipeliner_ClusterSlots_Call { + _c.Call.Return(run) + return _c +} + // Command provides a mock function with given fields: ctx func (_m *Pipeliner) Command(ctx context.Context) *redis.CommandsInfoCmd { ret := _m.Called(ctx) @@ -831,6 +2238,34 @@ func (_m *Pipeliner) Command(ctx context.Context) *redis.CommandsInfoCmd { return r0 } +// Pipeliner_Command_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Command' +type Pipeliner_Command_Call struct { + *mock.Call +} + +// Command is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) Command(ctx interface{}) *Pipeliner_Command_Call { + return &Pipeliner_Command_Call{Call: _e.mock.On("Command", ctx)} +} + +func (_c *Pipeliner_Command_Call) Run(run func(ctx context.Context)) *Pipeliner_Command_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_Command_Call) Return(_a0 *redis.CommandsInfoCmd) *Pipeliner_Command_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Command_Call) RunAndReturn(run func(context.Context) *redis.CommandsInfoCmd) *Pipeliner_Command_Call { + _c.Call.Return(run) + return _c +} + // ConfigGet provides a mock function with given fields: ctx, parameter func (_m *Pipeliner) ConfigGet(ctx context.Context, parameter string) *redis.SliceCmd { ret := _m.Called(ctx, parameter) @@ -847,6 +2282,35 @@ func (_m *Pipeliner) ConfigGet(ctx context.Context, parameter string) *redis.Sli return r0 } +// Pipeliner_ConfigGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigGet' +type Pipeliner_ConfigGet_Call struct { + *mock.Call +} + +// ConfigGet is a helper method to define mock.On call +// - ctx context.Context +// - parameter string +func (_e *Pipeliner_Expecter) ConfigGet(ctx interface{}, parameter interface{}) *Pipeliner_ConfigGet_Call { + return &Pipeliner_ConfigGet_Call{Call: _e.mock.On("ConfigGet", ctx, parameter)} +} + +func (_c *Pipeliner_ConfigGet_Call) Run(run func(ctx context.Context, parameter string)) *Pipeliner_ConfigGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ConfigGet_Call) Return(_a0 *redis.SliceCmd) *Pipeliner_ConfigGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ConfigGet_Call) RunAndReturn(run func(context.Context, string) *redis.SliceCmd) *Pipeliner_ConfigGet_Call { + _c.Call.Return(run) + return _c +} + // ConfigResetStat provides a mock function with given fields: ctx func (_m *Pipeliner) ConfigResetStat(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -863,6 +2327,34 @@ func (_m *Pipeliner) ConfigResetStat(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ConfigResetStat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigResetStat' +type Pipeliner_ConfigResetStat_Call struct { + *mock.Call +} + +// ConfigResetStat is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ConfigResetStat(ctx interface{}) *Pipeliner_ConfigResetStat_Call { + return &Pipeliner_ConfigResetStat_Call{Call: _e.mock.On("ConfigResetStat", ctx)} +} + +func (_c *Pipeliner_ConfigResetStat_Call) Run(run func(ctx context.Context)) *Pipeliner_ConfigResetStat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ConfigResetStat_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ConfigResetStat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ConfigResetStat_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ConfigResetStat_Call { + _c.Call.Return(run) + return _c +} + // ConfigRewrite provides a mock function with given fields: ctx func (_m *Pipeliner) ConfigRewrite(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -879,6 +2371,34 @@ func (_m *Pipeliner) ConfigRewrite(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ConfigRewrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigRewrite' +type Pipeliner_ConfigRewrite_Call struct { + *mock.Call +} + +// ConfigRewrite is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ConfigRewrite(ctx interface{}) *Pipeliner_ConfigRewrite_Call { + return &Pipeliner_ConfigRewrite_Call{Call: _e.mock.On("ConfigRewrite", ctx)} +} + +func (_c *Pipeliner_ConfigRewrite_Call) Run(run func(ctx context.Context)) *Pipeliner_ConfigRewrite_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ConfigRewrite_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ConfigRewrite_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ConfigRewrite_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ConfigRewrite_Call { + _c.Call.Return(run) + return _c +} + // ConfigSet provides a mock function with given fields: ctx, parameter, value func (_m *Pipeliner) ConfigSet(ctx context.Context, parameter string, value string) *redis.StatusCmd { ret := _m.Called(ctx, parameter, value) @@ -895,8 +2415,38 @@ func (_m *Pipeliner) ConfigSet(ctx context.Context, parameter string, value stri return r0 } -// Copy provides a mock function with given fields: ctx, sourceKey, destKey, db, replace -func (_m *Pipeliner) Copy(ctx context.Context, sourceKey string, destKey string, db int, replace bool) *redis.IntCmd { +// Pipeliner_ConfigSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigSet' +type Pipeliner_ConfigSet_Call struct { + *mock.Call +} + +// ConfigSet is a helper method to define mock.On call +// - ctx context.Context +// - parameter string +// - value string +func (_e *Pipeliner_Expecter) ConfigSet(ctx interface{}, parameter interface{}, value interface{}) *Pipeliner_ConfigSet_Call { + return &Pipeliner_ConfigSet_Call{Call: _e.mock.On("ConfigSet", ctx, parameter, value)} +} + +func (_c *Pipeliner_ConfigSet_Call) Run(run func(ctx context.Context, parameter string, value string)) *Pipeliner_ConfigSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_ConfigSet_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ConfigSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ConfigSet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_ConfigSet_Call { + _c.Call.Return(run) + return _c +} + +// Copy provides a mock function with given fields: ctx, sourceKey, destKey, db, replace +func (_m *Pipeliner) Copy(ctx context.Context, sourceKey string, destKey string, db int, replace bool) *redis.IntCmd { ret := _m.Called(ctx, sourceKey, destKey, db, replace) var r0 *redis.IntCmd @@ -911,6 +2461,38 @@ func (_m *Pipeliner) Copy(ctx context.Context, sourceKey string, destKey string, return r0 } +// Pipeliner_Copy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Copy' +type Pipeliner_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 *Pipeliner_Expecter) Copy(ctx interface{}, sourceKey interface{}, destKey interface{}, db interface{}, replace interface{}) *Pipeliner_Copy_Call { + return &Pipeliner_Copy_Call{Call: _e.mock.On("Copy", ctx, sourceKey, destKey, db, replace)} +} + +func (_c *Pipeliner_Copy_Call) Run(run func(ctx context.Context, sourceKey string, destKey string, db int, replace bool)) *Pipeliner_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 *Pipeliner_Copy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Copy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Copy_Call) RunAndReturn(run func(context.Context, string, string, int, bool) *redis.IntCmd) *Pipeliner_Copy_Call { + _c.Call.Return(run) + return _c +} + // DBSize provides a mock function with given fields: ctx func (_m *Pipeliner) DBSize(ctx context.Context) *redis.IntCmd { ret := _m.Called(ctx) @@ -927,6 +2509,34 @@ func (_m *Pipeliner) DBSize(ctx context.Context) *redis.IntCmd { return r0 } +// Pipeliner_DBSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DBSize' +type Pipeliner_DBSize_Call struct { + *mock.Call +} + +// DBSize is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) DBSize(ctx interface{}) *Pipeliner_DBSize_Call { + return &Pipeliner_DBSize_Call{Call: _e.mock.On("DBSize", ctx)} +} + +func (_c *Pipeliner_DBSize_Call) Run(run func(ctx context.Context)) *Pipeliner_DBSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_DBSize_Call) Return(_a0 *redis.IntCmd) *Pipeliner_DBSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_DBSize_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *Pipeliner_DBSize_Call { + _c.Call.Return(run) + return _c +} + // DebugObject provides a mock function with given fields: ctx, key func (_m *Pipeliner) DebugObject(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -943,6 +2553,35 @@ func (_m *Pipeliner) DebugObject(ctx context.Context, key string) *redis.StringC return r0 } +// Pipeliner_DebugObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DebugObject' +type Pipeliner_DebugObject_Call struct { + *mock.Call +} + +// DebugObject is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) DebugObject(ctx interface{}, key interface{}) *Pipeliner_DebugObject_Call { + return &Pipeliner_DebugObject_Call{Call: _e.mock.On("DebugObject", ctx, key)} +} + +func (_c *Pipeliner_DebugObject_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_DebugObject_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_DebugObject_Call) Return(_a0 *redis.StringCmd) *Pipeliner_DebugObject_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_DebugObject_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_DebugObject_Call { + _c.Call.Return(run) + return _c +} + // Decr provides a mock function with given fields: ctx, key func (_m *Pipeliner) Decr(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -959,6 +2598,35 @@ func (_m *Pipeliner) Decr(ctx context.Context, key string) *redis.IntCmd { return r0 } +// Pipeliner_Decr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Decr' +type Pipeliner_Decr_Call struct { + *mock.Call +} + +// Decr is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) Decr(ctx interface{}, key interface{}) *Pipeliner_Decr_Call { + return &Pipeliner_Decr_Call{Call: _e.mock.On("Decr", ctx, key)} +} + +func (_c *Pipeliner_Decr_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_Decr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_Decr_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Decr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Decr_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_Decr_Call { + _c.Call.Return(run) + return _c +} + // DecrBy provides a mock function with given fields: ctx, key, decrement func (_m *Pipeliner) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd { ret := _m.Called(ctx, key, decrement) @@ -975,6 +2643,36 @@ func (_m *Pipeliner) DecrBy(ctx context.Context, key string, decrement int64) *r return r0 } +// Pipeliner_DecrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DecrBy' +type Pipeliner_DecrBy_Call struct { + *mock.Call +} + +// DecrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - decrement int64 +func (_e *Pipeliner_Expecter) DecrBy(ctx interface{}, key interface{}, decrement interface{}) *Pipeliner_DecrBy_Call { + return &Pipeliner_DecrBy_Call{Call: _e.mock.On("DecrBy", ctx, key, decrement)} +} + +func (_c *Pipeliner_DecrBy_Call) Run(run func(ctx context.Context, key string, decrement int64)) *Pipeliner_DecrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_DecrBy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_DecrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_DecrBy_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_DecrBy_Call { + _c.Call.Return(run) + return _c +} + // Del provides a mock function with given fields: ctx, keys func (_m *Pipeliner) Del(ctx context.Context, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -998,6 +2696,42 @@ func (_m *Pipeliner) Del(ctx context.Context, keys ...string) *redis.IntCmd { return r0 } +// Pipeliner_Del_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Del' +type Pipeliner_Del_Call struct { + *mock.Call +} + +// Del is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) Del(ctx interface{}, keys ...interface{}) *Pipeliner_Del_Call { + return &Pipeliner_Del_Call{Call: _e.mock.On("Del", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_Del_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_Del_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Del_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Del_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_Del_Call { + _c.Call.Return(run) + return _c +} + // Discard provides a mock function with given fields: func (_m *Pipeliner) Discard() error { ret := _m.Called() @@ -1012,6 +2746,33 @@ func (_m *Pipeliner) Discard() error { return r0 } +// Pipeliner_Discard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Discard' +type Pipeliner_Discard_Call struct { + *mock.Call +} + +// Discard is a helper method to define mock.On call +func (_e *Pipeliner_Expecter) Discard() *Pipeliner_Discard_Call { + return &Pipeliner_Discard_Call{Call: _e.mock.On("Discard")} +} + +func (_c *Pipeliner_Discard_Call) Run(run func()) *Pipeliner_Discard_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Pipeliner_Discard_Call) Return(_a0 error) *Pipeliner_Discard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Discard_Call) RunAndReturn(run func() error) *Pipeliner_Discard_Call { + _c.Call.Return(run) + return _c +} + // Do provides a mock function with given fields: ctx, args func (_m *Pipeliner) Do(ctx context.Context, args ...interface{}) *redis.Cmd { var _ca []interface{} @@ -1031,6 +2792,42 @@ func (_m *Pipeliner) Do(ctx context.Context, args ...interface{}) *redis.Cmd { return r0 } +// Pipeliner_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do' +type Pipeliner_Do_Call struct { + *mock.Call +} + +// Do is a helper method to define mock.On call +// - ctx context.Context +// - args ...interface{} +func (_e *Pipeliner_Expecter) Do(ctx interface{}, args ...interface{}) *Pipeliner_Do_Call { + return &Pipeliner_Do_Call{Call: _e.mock.On("Do", + append([]interface{}{ctx}, args...)...)} +} + +func (_c *Pipeliner_Do_Call) Run(run func(ctx context.Context, args ...interface{})) *Pipeliner_Do_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 *Pipeliner_Do_Call) Return(_a0 *redis.Cmd) *Pipeliner_Do_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Do_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.Cmd) *Pipeliner_Do_Call { + _c.Call.Return(run) + return _c +} + // Dump provides a mock function with given fields: ctx, key func (_m *Pipeliner) Dump(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -1047,6 +2844,35 @@ func (_m *Pipeliner) Dump(ctx context.Context, key string) *redis.StringCmd { return r0 } +// Pipeliner_Dump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dump' +type Pipeliner_Dump_Call struct { + *mock.Call +} + +// Dump is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) Dump(ctx interface{}, key interface{}) *Pipeliner_Dump_Call { + return &Pipeliner_Dump_Call{Call: _e.mock.On("Dump", ctx, key)} +} + +func (_c *Pipeliner_Dump_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_Dump_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_Dump_Call) Return(_a0 *redis.StringCmd) *Pipeliner_Dump_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Dump_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_Dump_Call { + _c.Call.Return(run) + return _c +} + // Echo provides a mock function with given fields: ctx, message func (_m *Pipeliner) Echo(ctx context.Context, message interface{}) *redis.StringCmd { ret := _m.Called(ctx, message) @@ -1063,6 +2889,35 @@ func (_m *Pipeliner) Echo(ctx context.Context, message interface{}) *redis.Strin return r0 } +// Pipeliner_Echo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Echo' +type Pipeliner_Echo_Call struct { + *mock.Call +} + +// Echo is a helper method to define mock.On call +// - ctx context.Context +// - message interface{} +func (_e *Pipeliner_Expecter) Echo(ctx interface{}, message interface{}) *Pipeliner_Echo_Call { + return &Pipeliner_Echo_Call{Call: _e.mock.On("Echo", ctx, message)} +} + +func (_c *Pipeliner_Echo_Call) Run(run func(ctx context.Context, message interface{})) *Pipeliner_Echo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{})) + }) + return _c +} + +func (_c *Pipeliner_Echo_Call) Return(_a0 *redis.StringCmd) *Pipeliner_Echo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Echo_Call) RunAndReturn(run func(context.Context, interface{}) *redis.StringCmd) *Pipeliner_Echo_Call { + _c.Call.Return(run) + return _c +} + // Eval provides a mock function with given fields: ctx, script, keys, args func (_m *Pipeliner) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd { var _ca []interface{} @@ -1082,6 +2937,44 @@ func (_m *Pipeliner) Eval(ctx context.Context, script string, keys []string, arg return r0 } +// Pipeliner_Eval_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Eval' +type Pipeliner_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 *Pipeliner_Expecter) Eval(ctx interface{}, script interface{}, keys interface{}, args ...interface{}) *Pipeliner_Eval_Call { + return &Pipeliner_Eval_Call{Call: _e.mock.On("Eval", + append([]interface{}{ctx, script, keys}, args...)...)} +} + +func (_c *Pipeliner_Eval_Call) Run(run func(ctx context.Context, script string, keys []string, args ...interface{})) *Pipeliner_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 *Pipeliner_Eval_Call) Return(_a0 *redis.Cmd) *Pipeliner_Eval_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Eval_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *Pipeliner_Eval_Call { + _c.Call.Return(run) + return _c +} + // EvalSha provides a mock function with given fields: ctx, sha1, keys, args func (_m *Pipeliner) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd { var _ca []interface{} @@ -1101,6 +2994,44 @@ func (_m *Pipeliner) EvalSha(ctx context.Context, sha1 string, keys []string, ar return r0 } +// Pipeliner_EvalSha_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EvalSha' +type Pipeliner_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 *Pipeliner_Expecter) EvalSha(ctx interface{}, sha1 interface{}, keys interface{}, args ...interface{}) *Pipeliner_EvalSha_Call { + return &Pipeliner_EvalSha_Call{Call: _e.mock.On("EvalSha", + append([]interface{}{ctx, sha1, keys}, args...)...)} +} + +func (_c *Pipeliner_EvalSha_Call) Run(run func(ctx context.Context, sha1 string, keys []string, args ...interface{})) *Pipeliner_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 *Pipeliner_EvalSha_Call) Return(_a0 *redis.Cmd) *Pipeliner_EvalSha_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_EvalSha_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *Pipeliner_EvalSha_Call { + _c.Call.Return(run) + return _c +} + // Exec provides a mock function with given fields: ctx func (_m *Pipeliner) Exec(ctx context.Context) ([]redis.Cmder, error) { ret := _m.Called(ctx) @@ -1127,6 +3058,34 @@ func (_m *Pipeliner) Exec(ctx context.Context) ([]redis.Cmder, error) { return r0, r1 } +// Pipeliner_Exec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exec' +type Pipeliner_Exec_Call struct { + *mock.Call +} + +// Exec is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) Exec(ctx interface{}) *Pipeliner_Exec_Call { + return &Pipeliner_Exec_Call{Call: _e.mock.On("Exec", ctx)} +} + +func (_c *Pipeliner_Exec_Call) Run(run func(ctx context.Context)) *Pipeliner_Exec_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_Exec_Call) Return(_a0 []redis.Cmder, _a1 error) *Pipeliner_Exec_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Pipeliner_Exec_Call) RunAndReturn(run func(context.Context) ([]redis.Cmder, error)) *Pipeliner_Exec_Call { + _c.Call.Return(run) + return _c +} + // Exists provides a mock function with given fields: ctx, keys func (_m *Pipeliner) Exists(ctx context.Context, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -1150,6 +3109,42 @@ func (_m *Pipeliner) Exists(ctx context.Context, keys ...string) *redis.IntCmd { return r0 } +// Pipeliner_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists' +type Pipeliner_Exists_Call struct { + *mock.Call +} + +// Exists is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) Exists(ctx interface{}, keys ...interface{}) *Pipeliner_Exists_Call { + return &Pipeliner_Exists_Call{Call: _e.mock.On("Exists", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_Exists_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_Exists_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Exists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Exists_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_Exists_Call { + _c.Call.Return(run) + return _c +} + // Expire provides a mock function with given fields: ctx, key, expiration func (_m *Pipeliner) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { ret := _m.Called(ctx, key, expiration) @@ -1166,6 +3161,36 @@ func (_m *Pipeliner) Expire(ctx context.Context, key string, expiration time.Dur return r0 } +// Pipeliner_Expire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expire' +type Pipeliner_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 *Pipeliner_Expecter) Expire(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_Expire_Call { + return &Pipeliner_Expire_Call{Call: _e.mock.On("Expire", ctx, key, expiration)} +} + +func (_c *Pipeliner_Expire_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *Pipeliner_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 *Pipeliner_Expire_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_Expire_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Expire_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_Expire_Call { + _c.Call.Return(run) + return _c +} + // ExpireAt provides a mock function with given fields: ctx, key, tm func (_m *Pipeliner) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { ret := _m.Called(ctx, key, tm) @@ -1182,6 +3207,36 @@ func (_m *Pipeliner) ExpireAt(ctx context.Context, key string, tm time.Time) *re return r0 } +// Pipeliner_ExpireAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireAt' +type Pipeliner_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 *Pipeliner_Expecter) ExpireAt(ctx interface{}, key interface{}, tm interface{}) *Pipeliner_ExpireAt_Call { + return &Pipeliner_ExpireAt_Call{Call: _e.mock.On("ExpireAt", ctx, key, tm)} +} + +func (_c *Pipeliner_ExpireAt_Call) Run(run func(ctx context.Context, key string, tm time.Time)) *Pipeliner_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 *Pipeliner_ExpireAt_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireAt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ExpireAt_Call) RunAndReturn(run func(context.Context, string, time.Time) *redis.BoolCmd) *Pipeliner_ExpireAt_Call { + _c.Call.Return(run) + return _c +} + // ExpireGT provides a mock function with given fields: ctx, key, expiration func (_m *Pipeliner) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { ret := _m.Called(ctx, key, expiration) @@ -1198,6 +3253,36 @@ func (_m *Pipeliner) ExpireGT(ctx context.Context, key string, expiration time.D return r0 } +// Pipeliner_ExpireGT_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireGT' +type Pipeliner_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 *Pipeliner_Expecter) ExpireGT(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_ExpireGT_Call { + return &Pipeliner_ExpireGT_Call{Call: _e.mock.On("ExpireGT", ctx, key, expiration)} +} + +func (_c *Pipeliner_ExpireGT_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *Pipeliner_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 *Pipeliner_ExpireGT_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireGT_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ExpireGT_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_ExpireGT_Call { + _c.Call.Return(run) + return _c +} + // ExpireLT provides a mock function with given fields: ctx, key, expiration func (_m *Pipeliner) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { ret := _m.Called(ctx, key, expiration) @@ -1214,6 +3299,36 @@ func (_m *Pipeliner) ExpireLT(ctx context.Context, key string, expiration time.D return r0 } +// Pipeliner_ExpireLT_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireLT' +type Pipeliner_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 *Pipeliner_Expecter) ExpireLT(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_ExpireLT_Call { + return &Pipeliner_ExpireLT_Call{Call: _e.mock.On("ExpireLT", ctx, key, expiration)} +} + +func (_c *Pipeliner_ExpireLT_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *Pipeliner_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 *Pipeliner_ExpireLT_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireLT_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ExpireLT_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_ExpireLT_Call { + _c.Call.Return(run) + return _c +} + // ExpireNX provides a mock function with given fields: ctx, key, expiration func (_m *Pipeliner) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { ret := _m.Called(ctx, key, expiration) @@ -1230,6 +3345,36 @@ func (_m *Pipeliner) ExpireNX(ctx context.Context, key string, expiration time.D return r0 } +// Pipeliner_ExpireNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireNX' +type Pipeliner_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 *Pipeliner_Expecter) ExpireNX(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_ExpireNX_Call { + return &Pipeliner_ExpireNX_Call{Call: _e.mock.On("ExpireNX", ctx, key, expiration)} +} + +func (_c *Pipeliner_ExpireNX_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *Pipeliner_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 *Pipeliner_ExpireNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ExpireNX_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_ExpireNX_Call { + _c.Call.Return(run) + return _c +} + // ExpireXX provides a mock function with given fields: ctx, key, expiration func (_m *Pipeliner) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { ret := _m.Called(ctx, key, expiration) @@ -1246,6 +3391,36 @@ func (_m *Pipeliner) ExpireXX(ctx context.Context, key string, expiration time.D return r0 } +// Pipeliner_ExpireXX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExpireXX' +type Pipeliner_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 *Pipeliner_Expecter) ExpireXX(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_ExpireXX_Call { + return &Pipeliner_ExpireXX_Call{Call: _e.mock.On("ExpireXX", ctx, key, expiration)} +} + +func (_c *Pipeliner_ExpireXX_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *Pipeliner_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 *Pipeliner_ExpireXX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireXX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ExpireXX_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_ExpireXX_Call { + _c.Call.Return(run) + return _c +} + // FlushAll provides a mock function with given fields: ctx func (_m *Pipeliner) FlushAll(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -1262,6 +3437,34 @@ func (_m *Pipeliner) FlushAll(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_FlushAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushAll' +type Pipeliner_FlushAll_Call struct { + *mock.Call +} + +// FlushAll is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) FlushAll(ctx interface{}) *Pipeliner_FlushAll_Call { + return &Pipeliner_FlushAll_Call{Call: _e.mock.On("FlushAll", ctx)} +} + +func (_c *Pipeliner_FlushAll_Call) Run(run func(ctx context.Context)) *Pipeliner_FlushAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_FlushAll_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_FlushAll_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_FlushAll_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_FlushAll_Call { + _c.Call.Return(run) + return _c +} + // FlushAllAsync provides a mock function with given fields: ctx func (_m *Pipeliner) FlushAllAsync(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -1278,6 +3481,34 @@ func (_m *Pipeliner) FlushAllAsync(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_FlushAllAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushAllAsync' +type Pipeliner_FlushAllAsync_Call struct { + *mock.Call +} + +// FlushAllAsync is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) FlushAllAsync(ctx interface{}) *Pipeliner_FlushAllAsync_Call { + return &Pipeliner_FlushAllAsync_Call{Call: _e.mock.On("FlushAllAsync", ctx)} +} + +func (_c *Pipeliner_FlushAllAsync_Call) Run(run func(ctx context.Context)) *Pipeliner_FlushAllAsync_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_FlushAllAsync_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_FlushAllAsync_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_FlushAllAsync_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_FlushAllAsync_Call { + _c.Call.Return(run) + return _c +} + // FlushDB provides a mock function with given fields: ctx func (_m *Pipeliner) FlushDB(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -1294,6 +3525,34 @@ func (_m *Pipeliner) FlushDB(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_FlushDB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushDB' +type Pipeliner_FlushDB_Call struct { + *mock.Call +} + +// FlushDB is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) FlushDB(ctx interface{}) *Pipeliner_FlushDB_Call { + return &Pipeliner_FlushDB_Call{Call: _e.mock.On("FlushDB", ctx)} +} + +func (_c *Pipeliner_FlushDB_Call) Run(run func(ctx context.Context)) *Pipeliner_FlushDB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_FlushDB_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_FlushDB_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_FlushDB_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_FlushDB_Call { + _c.Call.Return(run) + return _c +} + // FlushDBAsync provides a mock function with given fields: ctx func (_m *Pipeliner) FlushDBAsync(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -1310,15 +3569,43 @@ func (_m *Pipeliner) FlushDBAsync(ctx context.Context) *redis.StatusCmd { return r0 } -// GeoAdd provides a mock function with given fields: ctx, key, geoLocation -func (_m *Pipeliner) 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...) +// Pipeliner_FlushDBAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushDBAsync' +type Pipeliner_FlushDBAsync_Call struct { + *mock.Call +} + +// FlushDBAsync is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) FlushDBAsync(ctx interface{}) *Pipeliner_FlushDBAsync_Call { + return &Pipeliner_FlushDBAsync_Call{Call: _e.mock.On("FlushDBAsync", ctx)} +} + +func (_c *Pipeliner_FlushDBAsync_Call) Run(run func(ctx context.Context)) *Pipeliner_FlushDBAsync_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_FlushDBAsync_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_FlushDBAsync_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_FlushDBAsync_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_FlushDBAsync_Call { + _c.Call.Return(run) + return _c +} + +// GeoAdd provides a mock function with given fields: ctx, key, geoLocation +func (_m *Pipeliner) 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...) var r0 *redis.IntCmd @@ -1333,6 +3620,43 @@ func (_m *Pipeliner) GeoAdd(ctx context.Context, key string, geoLocation ...*red return r0 } +// Pipeliner_GeoAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoAdd' +type Pipeliner_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 *Pipeliner_Expecter) GeoAdd(ctx interface{}, key interface{}, geoLocation ...interface{}) *Pipeliner_GeoAdd_Call { + return &Pipeliner_GeoAdd_Call{Call: _e.mock.On("GeoAdd", + append([]interface{}{ctx, key}, geoLocation...)...)} +} + +func (_c *Pipeliner_GeoAdd_Call) Run(run func(ctx context.Context, key string, geoLocation ...*redis.GeoLocation)) *Pipeliner_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 *Pipeliner_GeoAdd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GeoAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoAdd_Call) RunAndReturn(run func(context.Context, string, ...*redis.GeoLocation) *redis.IntCmd) *Pipeliner_GeoAdd_Call { + _c.Call.Return(run) + return _c +} + // GeoDist provides a mock function with given fields: ctx, key, member1, member2, unit func (_m *Pipeliner) GeoDist(ctx context.Context, key string, member1 string, member2 string, unit string) *redis.FloatCmd { ret := _m.Called(ctx, key, member1, member2, unit) @@ -1349,6 +3673,38 @@ func (_m *Pipeliner) GeoDist(ctx context.Context, key string, member1 string, me return r0 } +// Pipeliner_GeoDist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoDist' +type Pipeliner_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 *Pipeliner_Expecter) GeoDist(ctx interface{}, key interface{}, member1 interface{}, member2 interface{}, unit interface{}) *Pipeliner_GeoDist_Call { + return &Pipeliner_GeoDist_Call{Call: _e.mock.On("GeoDist", ctx, key, member1, member2, unit)} +} + +func (_c *Pipeliner_GeoDist_Call) Run(run func(ctx context.Context, key string, member1 string, member2 string, unit string)) *Pipeliner_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 *Pipeliner_GeoDist_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_GeoDist_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoDist_Call) RunAndReturn(run func(context.Context, string, string, string, string) *redis.FloatCmd) *Pipeliner_GeoDist_Call { + _c.Call.Return(run) + return _c +} + // GeoHash provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd { _va := make([]interface{}, len(members)) @@ -1372,6 +3728,43 @@ func (_m *Pipeliner) GeoHash(ctx context.Context, key string, members ...string) return r0 } +// Pipeliner_GeoHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoHash' +type Pipeliner_GeoHash_Call struct { + *mock.Call +} + +// GeoHash is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...string +func (_e *Pipeliner_Expecter) GeoHash(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_GeoHash_Call { + return &Pipeliner_GeoHash_Call{Call: _e.mock.On("GeoHash", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_GeoHash_Call) Run(run func(ctx context.Context, key string, members ...string)) *Pipeliner_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 *Pipeliner_GeoHash_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_GeoHash_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoHash_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.StringSliceCmd) *Pipeliner_GeoHash_Call { + _c.Call.Return(run) + return _c +} + // GeoPos provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd { _va := make([]interface{}, len(members)) @@ -1395,6 +3788,43 @@ func (_m *Pipeliner) GeoPos(ctx context.Context, key string, members ...string) return r0 } +// Pipeliner_GeoPos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoPos' +type Pipeliner_GeoPos_Call struct { + *mock.Call +} + +// GeoPos is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...string +func (_e *Pipeliner_Expecter) GeoPos(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_GeoPos_Call { + return &Pipeliner_GeoPos_Call{Call: _e.mock.On("GeoPos", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_GeoPos_Call) Run(run func(ctx context.Context, key string, members ...string)) *Pipeliner_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 *Pipeliner_GeoPos_Call) Return(_a0 *redis.GeoPosCmd) *Pipeliner_GeoPos_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoPos_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.GeoPosCmd) *Pipeliner_GeoPos_Call { + _c.Call.Return(run) + return _c +} + // GeoRadius provides a mock function with given fields: ctx, key, longitude, latitude, query func (_m *Pipeliner) GeoRadius(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { ret := _m.Called(ctx, key, longitude, latitude, query) @@ -1411,6 +3841,38 @@ func (_m *Pipeliner) GeoRadius(ctx context.Context, key string, longitude float6 return r0 } +// Pipeliner_GeoRadius_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoRadius' +type Pipeliner_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 *Pipeliner_Expecter) GeoRadius(ctx interface{}, key interface{}, longitude interface{}, latitude interface{}, query interface{}) *Pipeliner_GeoRadius_Call { + return &Pipeliner_GeoRadius_Call{Call: _e.mock.On("GeoRadius", ctx, key, longitude, latitude, query)} +} + +func (_c *Pipeliner_GeoRadius_Call) Run(run func(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery)) *Pipeliner_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 *Pipeliner_GeoRadius_Call) Return(_a0 *redis.GeoLocationCmd) *Pipeliner_GeoRadius_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoRadius_Call) RunAndReturn(run func(context.Context, string, float64, float64, *redis.GeoRadiusQuery) *redis.GeoLocationCmd) *Pipeliner_GeoRadius_Call { + _c.Call.Return(run) + return _c +} + // GeoRadiusByMember provides a mock function with given fields: ctx, key, member, query func (_m *Pipeliner) GeoRadiusByMember(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { ret := _m.Called(ctx, key, member, query) @@ -1427,6 +3889,37 @@ func (_m *Pipeliner) GeoRadiusByMember(ctx context.Context, key string, member s return r0 } +// Pipeliner_GeoRadiusByMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoRadiusByMember' +type Pipeliner_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 *Pipeliner_Expecter) GeoRadiusByMember(ctx interface{}, key interface{}, member interface{}, query interface{}) *Pipeliner_GeoRadiusByMember_Call { + return &Pipeliner_GeoRadiusByMember_Call{Call: _e.mock.On("GeoRadiusByMember", ctx, key, member, query)} +} + +func (_c *Pipeliner_GeoRadiusByMember_Call) Run(run func(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery)) *Pipeliner_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 *Pipeliner_GeoRadiusByMember_Call) Return(_a0 *redis.GeoLocationCmd) *Pipeliner_GeoRadiusByMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoRadiusByMember_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoRadiusQuery) *redis.GeoLocationCmd) *Pipeliner_GeoRadiusByMember_Call { + _c.Call.Return(run) + return _c +} + // GeoRadiusByMemberStore provides a mock function with given fields: ctx, key, member, query func (_m *Pipeliner) GeoRadiusByMemberStore(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery) *redis.IntCmd { ret := _m.Called(ctx, key, member, query) @@ -1443,6 +3936,37 @@ func (_m *Pipeliner) GeoRadiusByMemberStore(ctx context.Context, key string, mem return r0 } +// Pipeliner_GeoRadiusByMemberStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoRadiusByMemberStore' +type Pipeliner_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 *Pipeliner_Expecter) GeoRadiusByMemberStore(ctx interface{}, key interface{}, member interface{}, query interface{}) *Pipeliner_GeoRadiusByMemberStore_Call { + return &Pipeliner_GeoRadiusByMemberStore_Call{Call: _e.mock.On("GeoRadiusByMemberStore", ctx, key, member, query)} +} + +func (_c *Pipeliner_GeoRadiusByMemberStore_Call) Run(run func(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery)) *Pipeliner_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 *Pipeliner_GeoRadiusByMemberStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GeoRadiusByMemberStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoRadiusByMemberStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoRadiusQuery) *redis.IntCmd) *Pipeliner_GeoRadiusByMemberStore_Call { + _c.Call.Return(run) + return _c +} + // GeoRadiusStore provides a mock function with given fields: ctx, key, longitude, latitude, query func (_m *Pipeliner) GeoRadiusStore(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd { ret := _m.Called(ctx, key, longitude, latitude, query) @@ -1459,6 +3983,38 @@ func (_m *Pipeliner) GeoRadiusStore(ctx context.Context, key string, longitude f return r0 } +// Pipeliner_GeoRadiusStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoRadiusStore' +type Pipeliner_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 *Pipeliner_Expecter) GeoRadiusStore(ctx interface{}, key interface{}, longitude interface{}, latitude interface{}, query interface{}) *Pipeliner_GeoRadiusStore_Call { + return &Pipeliner_GeoRadiusStore_Call{Call: _e.mock.On("GeoRadiusStore", ctx, key, longitude, latitude, query)} +} + +func (_c *Pipeliner_GeoRadiusStore_Call) Run(run func(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery)) *Pipeliner_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 *Pipeliner_GeoRadiusStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GeoRadiusStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoRadiusStore_Call) RunAndReturn(run func(context.Context, string, float64, float64, *redis.GeoRadiusQuery) *redis.IntCmd) *Pipeliner_GeoRadiusStore_Call { + _c.Call.Return(run) + return _c +} + // GeoSearch provides a mock function with given fields: ctx, key, q func (_m *Pipeliner) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd { ret := _m.Called(ctx, key, q) @@ -1475,6 +4031,36 @@ func (_m *Pipeliner) GeoSearch(ctx context.Context, key string, q *redis.GeoSear return r0 } +// Pipeliner_GeoSearch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoSearch' +type Pipeliner_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 *Pipeliner_Expecter) GeoSearch(ctx interface{}, key interface{}, q interface{}) *Pipeliner_GeoSearch_Call { + return &Pipeliner_GeoSearch_Call{Call: _e.mock.On("GeoSearch", ctx, key, q)} +} + +func (_c *Pipeliner_GeoSearch_Call) Run(run func(ctx context.Context, key string, q *redis.GeoSearchQuery)) *Pipeliner_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 *Pipeliner_GeoSearch_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_GeoSearch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoSearch_Call) RunAndReturn(run func(context.Context, string, *redis.GeoSearchQuery) *redis.StringSliceCmd) *Pipeliner_GeoSearch_Call { + _c.Call.Return(run) + return _c +} + // GeoSearchLocation provides a mock function with given fields: ctx, key, q func (_m *Pipeliner) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { ret := _m.Called(ctx, key, q) @@ -1491,6 +4077,36 @@ func (_m *Pipeliner) GeoSearchLocation(ctx context.Context, key string, q *redis return r0 } +// Pipeliner_GeoSearchLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoSearchLocation' +type Pipeliner_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 *Pipeliner_Expecter) GeoSearchLocation(ctx interface{}, key interface{}, q interface{}) *Pipeliner_GeoSearchLocation_Call { + return &Pipeliner_GeoSearchLocation_Call{Call: _e.mock.On("GeoSearchLocation", ctx, key, q)} +} + +func (_c *Pipeliner_GeoSearchLocation_Call) Run(run func(ctx context.Context, key string, q *redis.GeoSearchLocationQuery)) *Pipeliner_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 *Pipeliner_GeoSearchLocation_Call) Return(_a0 *redis.GeoSearchLocationCmd) *Pipeliner_GeoSearchLocation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoSearchLocation_Call) RunAndReturn(run func(context.Context, string, *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd) *Pipeliner_GeoSearchLocation_Call { + _c.Call.Return(run) + return _c +} + // GeoSearchStore provides a mock function with given fields: ctx, key, store, q func (_m *Pipeliner) GeoSearchStore(ctx context.Context, key string, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd { ret := _m.Called(ctx, key, store, q) @@ -1507,6 +4123,37 @@ func (_m *Pipeliner) GeoSearchStore(ctx context.Context, key string, store strin return r0 } +// Pipeliner_GeoSearchStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeoSearchStore' +type Pipeliner_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 *Pipeliner_Expecter) GeoSearchStore(ctx interface{}, key interface{}, store interface{}, q interface{}) *Pipeliner_GeoSearchStore_Call { + return &Pipeliner_GeoSearchStore_Call{Call: _e.mock.On("GeoSearchStore", ctx, key, store, q)} +} + +func (_c *Pipeliner_GeoSearchStore_Call) Run(run func(ctx context.Context, key string, store string, q *redis.GeoSearchStoreQuery)) *Pipeliner_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 *Pipeliner_GeoSearchStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GeoSearchStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GeoSearchStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoSearchStoreQuery) *redis.IntCmd) *Pipeliner_GeoSearchStore_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: ctx, key func (_m *Pipeliner) Get(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -1523,6 +4170,35 @@ func (_m *Pipeliner) Get(ctx context.Context, key string) *redis.StringCmd { return r0 } +// Pipeliner_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Pipeliner_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) Get(ctx interface{}, key interface{}) *Pipeliner_Get_Call { + return &Pipeliner_Get_Call{Call: _e.mock.On("Get", ctx, key)} +} + +func (_c *Pipeliner_Get_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_Get_Call) Return(_a0 *redis.StringCmd) *Pipeliner_Get_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Get_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_Get_Call { + _c.Call.Return(run) + return _c +} + // GetBit provides a mock function with given fields: ctx, key, offset func (_m *Pipeliner) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd { ret := _m.Called(ctx, key, offset) @@ -1539,6 +4215,36 @@ func (_m *Pipeliner) GetBit(ctx context.Context, key string, offset int64) *redi return r0 } +// Pipeliner_GetBit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBit' +type Pipeliner_GetBit_Call struct { + *mock.Call +} + +// GetBit is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - offset int64 +func (_e *Pipeliner_Expecter) GetBit(ctx interface{}, key interface{}, offset interface{}) *Pipeliner_GetBit_Call { + return &Pipeliner_GetBit_Call{Call: _e.mock.On("GetBit", ctx, key, offset)} +} + +func (_c *Pipeliner_GetBit_Call) Run(run func(ctx context.Context, key string, offset int64)) *Pipeliner_GetBit_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_GetBit_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GetBit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GetBit_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_GetBit_Call { + _c.Call.Return(run) + return _c +} + // GetDel provides a mock function with given fields: ctx, key func (_m *Pipeliner) GetDel(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -1555,6 +4261,35 @@ func (_m *Pipeliner) GetDel(ctx context.Context, key string) *redis.StringCmd { return r0 } +// Pipeliner_GetDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDel' +type Pipeliner_GetDel_Call struct { + *mock.Call +} + +// GetDel is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) GetDel(ctx interface{}, key interface{}) *Pipeliner_GetDel_Call { + return &Pipeliner_GetDel_Call{Call: _e.mock.On("GetDel", ctx, key)} +} + +func (_c *Pipeliner_GetDel_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_GetDel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_GetDel_Call) Return(_a0 *redis.StringCmd) *Pipeliner_GetDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GetDel_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_GetDel_Call { + _c.Call.Return(run) + return _c +} + // GetEx provides a mock function with given fields: ctx, key, expiration func (_m *Pipeliner) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd { ret := _m.Called(ctx, key, expiration) @@ -1571,6 +4306,36 @@ func (_m *Pipeliner) GetEx(ctx context.Context, key string, expiration time.Dura return r0 } +// Pipeliner_GetEx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEx' +type Pipeliner_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 *Pipeliner_Expecter) GetEx(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_GetEx_Call { + return &Pipeliner_GetEx_Call{Call: _e.mock.On("GetEx", ctx, key, expiration)} +} + +func (_c *Pipeliner_GetEx_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *Pipeliner_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 *Pipeliner_GetEx_Call) Return(_a0 *redis.StringCmd) *Pipeliner_GetEx_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GetEx_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.StringCmd) *Pipeliner_GetEx_Call { + _c.Call.Return(run) + return _c +} + // GetRange provides a mock function with given fields: ctx, key, start, end func (_m *Pipeliner) GetRange(ctx context.Context, key string, start int64, end int64) *redis.StringCmd { ret := _m.Called(ctx, key, start, end) @@ -1587,6 +4352,37 @@ func (_m *Pipeliner) GetRange(ctx context.Context, key string, start int64, end return r0 } +// Pipeliner_GetRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRange' +type Pipeliner_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 *Pipeliner_Expecter) GetRange(ctx interface{}, key interface{}, start interface{}, end interface{}) *Pipeliner_GetRange_Call { + return &Pipeliner_GetRange_Call{Call: _e.mock.On("GetRange", ctx, key, start, end)} +} + +func (_c *Pipeliner_GetRange_Call) Run(run func(ctx context.Context, key string, start int64, end int64)) *Pipeliner_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 *Pipeliner_GetRange_Call) Return(_a0 *redis.StringCmd) *Pipeliner_GetRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GetRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringCmd) *Pipeliner_GetRange_Call { + _c.Call.Return(run) + return _c +} + // GetSet provides a mock function with given fields: ctx, key, value func (_m *Pipeliner) GetSet(ctx context.Context, key string, value interface{}) *redis.StringCmd { ret := _m.Called(ctx, key, value) @@ -1603,6 +4399,36 @@ func (_m *Pipeliner) GetSet(ctx context.Context, key string, value interface{}) return r0 } +// Pipeliner_GetSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSet' +type Pipeliner_GetSet_Call struct { + *mock.Call +} + +// GetSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value interface{} +func (_e *Pipeliner_Expecter) GetSet(ctx interface{}, key interface{}, value interface{}) *Pipeliner_GetSet_Call { + return &Pipeliner_GetSet_Call{Call: _e.mock.On("GetSet", ctx, key, value)} +} + +func (_c *Pipeliner_GetSet_Call) Run(run func(ctx context.Context, key string, value interface{})) *Pipeliner_GetSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *Pipeliner_GetSet_Call) Return(_a0 *redis.StringCmd) *Pipeliner_GetSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_GetSet_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.StringCmd) *Pipeliner_GetSet_Call { + _c.Call.Return(run) + return _c +} + // HDel provides a mock function with given fields: ctx, key, fields func (_m *Pipeliner) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd { _va := make([]interface{}, len(fields)) @@ -1626,6 +4452,43 @@ func (_m *Pipeliner) HDel(ctx context.Context, key string, fields ...string) *re return r0 } +// Pipeliner_HDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HDel' +type Pipeliner_HDel_Call struct { + *mock.Call +} + +// HDel is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *Pipeliner_Expecter) HDel(ctx interface{}, key interface{}, fields ...interface{}) *Pipeliner_HDel_Call { + return &Pipeliner_HDel_Call{Call: _e.mock.On("HDel", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *Pipeliner_HDel_Call) Run(run func(ctx context.Context, key string, fields ...string)) *Pipeliner_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 *Pipeliner_HDel_Call) Return(_a0 *redis.IntCmd) *Pipeliner_HDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HDel_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_HDel_Call { + _c.Call.Return(run) + return _c +} + // HExists provides a mock function with given fields: ctx, key, field func (_m *Pipeliner) HExists(ctx context.Context, key string, field string) *redis.BoolCmd { ret := _m.Called(ctx, key, field) @@ -1642,6 +4505,36 @@ func (_m *Pipeliner) HExists(ctx context.Context, key string, field string) *red return r0 } +// Pipeliner_HExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HExists' +type Pipeliner_HExists_Call struct { + *mock.Call +} + +// HExists is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +func (_e *Pipeliner_Expecter) HExists(ctx interface{}, key interface{}, field interface{}) *Pipeliner_HExists_Call { + return &Pipeliner_HExists_Call{Call: _e.mock.On("HExists", ctx, key, field)} +} + +func (_c *Pipeliner_HExists_Call) Run(run func(ctx context.Context, key string, field string)) *Pipeliner_HExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_HExists_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_HExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HExists_Call) RunAndReturn(run func(context.Context, string, string) *redis.BoolCmd) *Pipeliner_HExists_Call { + _c.Call.Return(run) + return _c +} + // HGet provides a mock function with given fields: ctx, key, field func (_m *Pipeliner) HGet(ctx context.Context, key string, field string) *redis.StringCmd { ret := _m.Called(ctx, key, field) @@ -1658,6 +4551,36 @@ func (_m *Pipeliner) HGet(ctx context.Context, key string, field string) *redis. return r0 } +// Pipeliner_HGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HGet' +type Pipeliner_HGet_Call struct { + *mock.Call +} + +// HGet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - field string +func (_e *Pipeliner_Expecter) HGet(ctx interface{}, key interface{}, field interface{}) *Pipeliner_HGet_Call { + return &Pipeliner_HGet_Call{Call: _e.mock.On("HGet", ctx, key, field)} +} + +func (_c *Pipeliner_HGet_Call) Run(run func(ctx context.Context, key string, field string)) *Pipeliner_HGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_HGet_Call) Return(_a0 *redis.StringCmd) *Pipeliner_HGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HGet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StringCmd) *Pipeliner_HGet_Call { + _c.Call.Return(run) + return _c +} + // HGetAll provides a mock function with given fields: ctx, key func (_m *Pipeliner) HGetAll(ctx context.Context, key string) *redis.StringStringMapCmd { ret := _m.Called(ctx, key) @@ -1674,6 +4597,35 @@ func (_m *Pipeliner) HGetAll(ctx context.Context, key string) *redis.StringStrin return r0 } +// Pipeliner_HGetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HGetAll' +type Pipeliner_HGetAll_Call struct { + *mock.Call +} + +// HGetAll is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) HGetAll(ctx interface{}, key interface{}) *Pipeliner_HGetAll_Call { + return &Pipeliner_HGetAll_Call{Call: _e.mock.On("HGetAll", ctx, key)} +} + +func (_c *Pipeliner_HGetAll_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_HGetAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_HGetAll_Call) Return(_a0 *redis.StringStringMapCmd) *Pipeliner_HGetAll_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HGetAll_Call) RunAndReturn(run func(context.Context, string) *redis.StringStringMapCmd) *Pipeliner_HGetAll_Call { + _c.Call.Return(run) + return _c +} + // HIncrBy provides a mock function with given fields: ctx, key, field, incr func (_m *Pipeliner) HIncrBy(ctx context.Context, key string, field string, incr int64) *redis.IntCmd { ret := _m.Called(ctx, key, field, incr) @@ -1690,6 +4642,37 @@ func (_m *Pipeliner) HIncrBy(ctx context.Context, key string, field string, incr return r0 } +// Pipeliner_HIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HIncrBy' +type Pipeliner_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 *Pipeliner_Expecter) HIncrBy(ctx interface{}, key interface{}, field interface{}, incr interface{}) *Pipeliner_HIncrBy_Call { + return &Pipeliner_HIncrBy_Call{Call: _e.mock.On("HIncrBy", ctx, key, field, incr)} +} + +func (_c *Pipeliner_HIncrBy_Call) Run(run func(ctx context.Context, key string, field string, incr int64)) *Pipeliner_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 *Pipeliner_HIncrBy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_HIncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HIncrBy_Call) RunAndReturn(run func(context.Context, string, string, int64) *redis.IntCmd) *Pipeliner_HIncrBy_Call { + _c.Call.Return(run) + return _c +} + // HIncrByFloat provides a mock function with given fields: ctx, key, field, incr func (_m *Pipeliner) HIncrByFloat(ctx context.Context, key string, field string, incr float64) *redis.FloatCmd { ret := _m.Called(ctx, key, field, incr) @@ -1706,6 +4689,37 @@ func (_m *Pipeliner) HIncrByFloat(ctx context.Context, key string, field string, return r0 } +// Pipeliner_HIncrByFloat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HIncrByFloat' +type Pipeliner_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 *Pipeliner_Expecter) HIncrByFloat(ctx interface{}, key interface{}, field interface{}, incr interface{}) *Pipeliner_HIncrByFloat_Call { + return &Pipeliner_HIncrByFloat_Call{Call: _e.mock.On("HIncrByFloat", ctx, key, field, incr)} +} + +func (_c *Pipeliner_HIncrByFloat_Call) Run(run func(ctx context.Context, key string, field string, incr float64)) *Pipeliner_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 *Pipeliner_HIncrByFloat_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_HIncrByFloat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HIncrByFloat_Call) RunAndReturn(run func(context.Context, string, string, float64) *redis.FloatCmd) *Pipeliner_HIncrByFloat_Call { + _c.Call.Return(run) + return _c +} + // HKeys provides a mock function with given fields: ctx, key func (_m *Pipeliner) HKeys(ctx context.Context, key string) *redis.StringSliceCmd { ret := _m.Called(ctx, key) @@ -1722,6 +4736,35 @@ func (_m *Pipeliner) HKeys(ctx context.Context, key string) *redis.StringSliceCm return r0 } +// Pipeliner_HKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HKeys' +type Pipeliner_HKeys_Call struct { + *mock.Call +} + +// HKeys is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) HKeys(ctx interface{}, key interface{}) *Pipeliner_HKeys_Call { + return &Pipeliner_HKeys_Call{Call: _e.mock.On("HKeys", ctx, key)} +} + +func (_c *Pipeliner_HKeys_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_HKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_HKeys_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_HKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HKeys_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_HKeys_Call { + _c.Call.Return(run) + return _c +} + // HLen provides a mock function with given fields: ctx, key func (_m *Pipeliner) HLen(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -1738,6 +4781,35 @@ func (_m *Pipeliner) HLen(ctx context.Context, key string) *redis.IntCmd { return r0 } +// Pipeliner_HLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HLen' +type Pipeliner_HLen_Call struct { + *mock.Call +} + +// HLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) HLen(ctx interface{}, key interface{}) *Pipeliner_HLen_Call { + return &Pipeliner_HLen_Call{Call: _e.mock.On("HLen", ctx, key)} +} + +func (_c *Pipeliner_HLen_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_HLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_HLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_HLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_HLen_Call { + _c.Call.Return(run) + return _c +} + // HMGet provides a mock function with given fields: ctx, key, fields func (_m *Pipeliner) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd { _va := make([]interface{}, len(fields)) @@ -1756,9 +4828,46 @@ func (_m *Pipeliner) HMGet(ctx context.Context, key string, fields ...string) *r if ret.Get(0) != nil { r0 = ret.Get(0).(*redis.SliceCmd) } - } + } + + return r0 +} + +// Pipeliner_HMGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HMGet' +type Pipeliner_HMGet_Call struct { + *mock.Call +} + +// HMGet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - fields ...string +func (_e *Pipeliner_Expecter) HMGet(ctx interface{}, key interface{}, fields ...interface{}) *Pipeliner_HMGet_Call { + return &Pipeliner_HMGet_Call{Call: _e.mock.On("HMGet", + append([]interface{}{ctx, key}, fields...)...)} +} + +func (_c *Pipeliner_HMGet_Call) Run(run func(ctx context.Context, key string, fields ...string)) *Pipeliner_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 +} - return r0 +func (_c *Pipeliner_HMGet_Call) Return(_a0 *redis.SliceCmd) *Pipeliner_HMGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HMGet_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.SliceCmd) *Pipeliner_HMGet_Call { + _c.Call.Return(run) + return _c } // HMSet provides a mock function with given fields: ctx, key, values @@ -1780,6 +4889,43 @@ func (_m *Pipeliner) HMSet(ctx context.Context, key string, values ...interface{ return r0 } +// Pipeliner_HMSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HMSet' +type Pipeliner_HMSet_Call struct { + *mock.Call +} + +// HMSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Pipeliner_Expecter) HMSet(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_HMSet_Call { + return &Pipeliner_HMSet_Call{Call: _e.mock.On("HMSet", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Pipeliner_HMSet_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Pipeliner_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 *Pipeliner_HMSet_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_HMSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HMSet_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolCmd) *Pipeliner_HMSet_Call { + _c.Call.Return(run) + return _c +} + // HRandField provides a mock function with given fields: ctx, key, count, withValues func (_m *Pipeliner) HRandField(ctx context.Context, key string, count int, withValues bool) *redis.StringSliceCmd { ret := _m.Called(ctx, key, count, withValues) @@ -1796,6 +4942,37 @@ func (_m *Pipeliner) HRandField(ctx context.Context, key string, count int, with return r0 } +// Pipeliner_HRandField_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HRandField' +type Pipeliner_HRandField_Call struct { + *mock.Call +} + +// HRandField is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +// - withValues bool +func (_e *Pipeliner_Expecter) HRandField(ctx interface{}, key interface{}, count interface{}, withValues interface{}) *Pipeliner_HRandField_Call { + return &Pipeliner_HRandField_Call{Call: _e.mock.On("HRandField", ctx, key, count, withValues)} +} + +func (_c *Pipeliner_HRandField_Call) Run(run func(ctx context.Context, key string, count int, withValues bool)) *Pipeliner_HRandField_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(bool)) + }) + return _c +} + +func (_c *Pipeliner_HRandField_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_HRandField_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HRandField_Call) RunAndReturn(run func(context.Context, string, int, bool) *redis.StringSliceCmd) *Pipeliner_HRandField_Call { + _c.Call.Return(run) + return _c +} + // HScan provides a mock function with given fields: ctx, key, cursor, match, count func (_m *Pipeliner) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { ret := _m.Called(ctx, key, cursor, match, count) @@ -1812,6 +4989,38 @@ func (_m *Pipeliner) HScan(ctx context.Context, key string, cursor uint64, match return r0 } +// Pipeliner_HScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HScan' +type Pipeliner_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 *Pipeliner_Expecter) HScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *Pipeliner_HScan_Call { + return &Pipeliner_HScan_Call{Call: _e.mock.On("HScan", ctx, key, cursor, match, count)} +} + +func (_c *Pipeliner_HScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *Pipeliner_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 *Pipeliner_HScan_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_HScan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *Pipeliner_HScan_Call { + _c.Call.Return(run) + return _c +} + // HSet provides a mock function with given fields: ctx, key, values func (_m *Pipeliner) HSet(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -1831,6 +5040,43 @@ func (_m *Pipeliner) HSet(ctx context.Context, key string, values ...interface{} return r0 } +// Pipeliner_HSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HSet' +type Pipeliner_HSet_Call struct { + *mock.Call +} + +// HSet is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Pipeliner_Expecter) HSet(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_HSet_Call { + return &Pipeliner_HSet_Call{Call: _e.mock.On("HSet", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Pipeliner_HSet_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Pipeliner_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 *Pipeliner_HSet_Call) Return(_a0 *redis.IntCmd) *Pipeliner_HSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HSet_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_HSet_Call { + _c.Call.Return(run) + return _c +} + // HSetNX provides a mock function with given fields: ctx, key, field, value func (_m *Pipeliner) HSetNX(ctx context.Context, key string, field string, value interface{}) *redis.BoolCmd { ret := _m.Called(ctx, key, field, value) @@ -1847,6 +5093,37 @@ func (_m *Pipeliner) HSetNX(ctx context.Context, key string, field string, value return r0 } +// Pipeliner_HSetNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HSetNX' +type Pipeliner_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 *Pipeliner_Expecter) HSetNX(ctx interface{}, key interface{}, field interface{}, value interface{}) *Pipeliner_HSetNX_Call { + return &Pipeliner_HSetNX_Call{Call: _e.mock.On("HSetNX", ctx, key, field, value)} +} + +func (_c *Pipeliner_HSetNX_Call) Run(run func(ctx context.Context, key string, field string, value interface{})) *Pipeliner_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 *Pipeliner_HSetNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_HSetNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HSetNX_Call) RunAndReturn(run func(context.Context, string, string, interface{}) *redis.BoolCmd) *Pipeliner_HSetNX_Call { + _c.Call.Return(run) + return _c +} + // HVals provides a mock function with given fields: ctx, key func (_m *Pipeliner) HVals(ctx context.Context, key string) *redis.StringSliceCmd { ret := _m.Called(ctx, key) @@ -1863,6 +5140,35 @@ func (_m *Pipeliner) HVals(ctx context.Context, key string) *redis.StringSliceCm return r0 } +// Pipeliner_HVals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HVals' +type Pipeliner_HVals_Call struct { + *mock.Call +} + +// HVals is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) HVals(ctx interface{}, key interface{}) *Pipeliner_HVals_Call { + return &Pipeliner_HVals_Call{Call: _e.mock.On("HVals", ctx, key)} +} + +func (_c *Pipeliner_HVals_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_HVals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_HVals_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_HVals_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_HVals_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_HVals_Call { + _c.Call.Return(run) + return _c +} + // Incr provides a mock function with given fields: ctx, key func (_m *Pipeliner) Incr(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -1879,6 +5185,35 @@ func (_m *Pipeliner) Incr(ctx context.Context, key string) *redis.IntCmd { return r0 } +// Pipeliner_Incr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Incr' +type Pipeliner_Incr_Call struct { + *mock.Call +} + +// Incr is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) Incr(ctx interface{}, key interface{}) *Pipeliner_Incr_Call { + return &Pipeliner_Incr_Call{Call: _e.mock.On("Incr", ctx, key)} +} + +func (_c *Pipeliner_Incr_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_Incr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_Incr_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Incr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Incr_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_Incr_Call { + _c.Call.Return(run) + return _c +} + // IncrBy provides a mock function with given fields: ctx, key, value func (_m *Pipeliner) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd { ret := _m.Called(ctx, key, value) @@ -1895,6 +5230,36 @@ func (_m *Pipeliner) IncrBy(ctx context.Context, key string, value int64) *redis return r0 } +// Pipeliner_IncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrBy' +type Pipeliner_IncrBy_Call struct { + *mock.Call +} + +// IncrBy is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value int64 +func (_e *Pipeliner_Expecter) IncrBy(ctx interface{}, key interface{}, value interface{}) *Pipeliner_IncrBy_Call { + return &Pipeliner_IncrBy_Call{Call: _e.mock.On("IncrBy", ctx, key, value)} +} + +func (_c *Pipeliner_IncrBy_Call) Run(run func(ctx context.Context, key string, value int64)) *Pipeliner_IncrBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_IncrBy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_IncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_IncrBy_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_IncrBy_Call { + _c.Call.Return(run) + return _c +} + // IncrByFloat provides a mock function with given fields: ctx, key, value func (_m *Pipeliner) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd { ret := _m.Called(ctx, key, value) @@ -1911,6 +5276,36 @@ func (_m *Pipeliner) IncrByFloat(ctx context.Context, key string, value float64) return r0 } +// Pipeliner_IncrByFloat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrByFloat' +type Pipeliner_IncrByFloat_Call struct { + *mock.Call +} + +// IncrByFloat is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - value float64 +func (_e *Pipeliner_Expecter) IncrByFloat(ctx interface{}, key interface{}, value interface{}) *Pipeliner_IncrByFloat_Call { + return &Pipeliner_IncrByFloat_Call{Call: _e.mock.On("IncrByFloat", ctx, key, value)} +} + +func (_c *Pipeliner_IncrByFloat_Call) Run(run func(ctx context.Context, key string, value float64)) *Pipeliner_IncrByFloat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(float64)) + }) + return _c +} + +func (_c *Pipeliner_IncrByFloat_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_IncrByFloat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_IncrByFloat_Call) RunAndReturn(run func(context.Context, string, float64) *redis.FloatCmd) *Pipeliner_IncrByFloat_Call { + _c.Call.Return(run) + return _c +} + // Info provides a mock function with given fields: ctx, section func (_m *Pipeliner) Info(ctx context.Context, section ...string) *redis.StringCmd { _va := make([]interface{}, len(section)) @@ -1934,6 +5329,42 @@ func (_m *Pipeliner) Info(ctx context.Context, section ...string) *redis.StringC return r0 } +// Pipeliner_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info' +type Pipeliner_Info_Call struct { + *mock.Call +} + +// Info is a helper method to define mock.On call +// - ctx context.Context +// - section ...string +func (_e *Pipeliner_Expecter) Info(ctx interface{}, section ...interface{}) *Pipeliner_Info_Call { + return &Pipeliner_Info_Call{Call: _e.mock.On("Info", + append([]interface{}{ctx}, section...)...)} +} + +func (_c *Pipeliner_Info_Call) Run(run func(ctx context.Context, section ...string)) *Pipeliner_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 *Pipeliner_Info_Call) Return(_a0 *redis.StringCmd) *Pipeliner_Info_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Info_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringCmd) *Pipeliner_Info_Call { + _c.Call.Return(run) + return _c +} + // Keys provides a mock function with given fields: ctx, pattern func (_m *Pipeliner) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd { ret := _m.Called(ctx, pattern) @@ -1950,6 +5381,35 @@ func (_m *Pipeliner) Keys(ctx context.Context, pattern string) *redis.StringSlic return r0 } +// Pipeliner_Keys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Keys' +type Pipeliner_Keys_Call struct { + *mock.Call +} + +// Keys is a helper method to define mock.On call +// - ctx context.Context +// - pattern string +func (_e *Pipeliner_Expecter) Keys(ctx interface{}, pattern interface{}) *Pipeliner_Keys_Call { + return &Pipeliner_Keys_Call{Call: _e.mock.On("Keys", ctx, pattern)} +} + +func (_c *Pipeliner_Keys_Call) Run(run func(ctx context.Context, pattern string)) *Pipeliner_Keys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_Keys_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_Keys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Keys_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_Keys_Call { + _c.Call.Return(run) + return _c +} + // LIndex provides a mock function with given fields: ctx, key, index func (_m *Pipeliner) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd { ret := _m.Called(ctx, key, index) @@ -1966,6 +5426,36 @@ func (_m *Pipeliner) LIndex(ctx context.Context, key string, index int64) *redis return r0 } +// Pipeliner_LIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LIndex' +type Pipeliner_LIndex_Call struct { + *mock.Call +} + +// LIndex is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - index int64 +func (_e *Pipeliner_Expecter) LIndex(ctx interface{}, key interface{}, index interface{}) *Pipeliner_LIndex_Call { + return &Pipeliner_LIndex_Call{Call: _e.mock.On("LIndex", ctx, key, index)} +} + +func (_c *Pipeliner_LIndex_Call) Run(run func(ctx context.Context, key string, index int64)) *Pipeliner_LIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_LIndex_Call) Return(_a0 *redis.StringCmd) *Pipeliner_LIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LIndex_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringCmd) *Pipeliner_LIndex_Call { + _c.Call.Return(run) + return _c +} + // LInsert provides a mock function with given fields: ctx, key, op, pivot, value func (_m *Pipeliner) LInsert(ctx context.Context, key string, op string, pivot interface{}, value interface{}) *redis.IntCmd { ret := _m.Called(ctx, key, op, pivot, value) @@ -1982,6 +5472,38 @@ func (_m *Pipeliner) LInsert(ctx context.Context, key string, op string, pivot i return r0 } +// Pipeliner_LInsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LInsert' +type Pipeliner_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 *Pipeliner_Expecter) LInsert(ctx interface{}, key interface{}, op interface{}, pivot interface{}, value interface{}) *Pipeliner_LInsert_Call { + return &Pipeliner_LInsert_Call{Call: _e.mock.On("LInsert", ctx, key, op, pivot, value)} +} + +func (_c *Pipeliner_LInsert_Call) Run(run func(ctx context.Context, key string, op string, pivot interface{}, value interface{})) *Pipeliner_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 *Pipeliner_LInsert_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LInsert_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LInsert_Call) RunAndReturn(run func(context.Context, string, string, interface{}, interface{}) *redis.IntCmd) *Pipeliner_LInsert_Call { + _c.Call.Return(run) + return _c +} + // LInsertAfter provides a mock function with given fields: ctx, key, pivot, value func (_m *Pipeliner) LInsertAfter(ctx context.Context, key string, pivot interface{}, value interface{}) *redis.IntCmd { ret := _m.Called(ctx, key, pivot, value) @@ -1998,6 +5520,37 @@ func (_m *Pipeliner) LInsertAfter(ctx context.Context, key string, pivot interfa return r0 } +// Pipeliner_LInsertAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LInsertAfter' +type Pipeliner_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 *Pipeliner_Expecter) LInsertAfter(ctx interface{}, key interface{}, pivot interface{}, value interface{}) *Pipeliner_LInsertAfter_Call { + return &Pipeliner_LInsertAfter_Call{Call: _e.mock.On("LInsertAfter", ctx, key, pivot, value)} +} + +func (_c *Pipeliner_LInsertAfter_Call) Run(run func(ctx context.Context, key string, pivot interface{}, value interface{})) *Pipeliner_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 *Pipeliner_LInsertAfter_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LInsertAfter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LInsertAfter_Call) RunAndReturn(run func(context.Context, string, interface{}, interface{}) *redis.IntCmd) *Pipeliner_LInsertAfter_Call { + _c.Call.Return(run) + return _c +} + // LInsertBefore provides a mock function with given fields: ctx, key, pivot, value func (_m *Pipeliner) LInsertBefore(ctx context.Context, key string, pivot interface{}, value interface{}) *redis.IntCmd { ret := _m.Called(ctx, key, pivot, value) @@ -2014,6 +5567,37 @@ func (_m *Pipeliner) LInsertBefore(ctx context.Context, key string, pivot interf return r0 } +// Pipeliner_LInsertBefore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LInsertBefore' +type Pipeliner_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 *Pipeliner_Expecter) LInsertBefore(ctx interface{}, key interface{}, pivot interface{}, value interface{}) *Pipeliner_LInsertBefore_Call { + return &Pipeliner_LInsertBefore_Call{Call: _e.mock.On("LInsertBefore", ctx, key, pivot, value)} +} + +func (_c *Pipeliner_LInsertBefore_Call) Run(run func(ctx context.Context, key string, pivot interface{}, value interface{})) *Pipeliner_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 *Pipeliner_LInsertBefore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LInsertBefore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LInsertBefore_Call) RunAndReturn(run func(context.Context, string, interface{}, interface{}) *redis.IntCmd) *Pipeliner_LInsertBefore_Call { + _c.Call.Return(run) + return _c +} + // LLen provides a mock function with given fields: ctx, key func (_m *Pipeliner) LLen(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -2030,6 +5614,35 @@ func (_m *Pipeliner) LLen(ctx context.Context, key string) *redis.IntCmd { return r0 } +// Pipeliner_LLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LLen' +type Pipeliner_LLen_Call struct { + *mock.Call +} + +// LLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) LLen(ctx interface{}, key interface{}) *Pipeliner_LLen_Call { + return &Pipeliner_LLen_Call{Call: _e.mock.On("LLen", ctx, key)} +} + +func (_c *Pipeliner_LLen_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_LLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_LLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_LLen_Call { + _c.Call.Return(run) + return _c +} + // LMove provides a mock function with given fields: ctx, source, destination, srcpos, destpos func (_m *Pipeliner) LMove(ctx context.Context, source string, destination string, srcpos string, destpos string) *redis.StringCmd { ret := _m.Called(ctx, source, destination, srcpos, destpos) @@ -2046,6 +5659,38 @@ func (_m *Pipeliner) LMove(ctx context.Context, source string, destination strin return r0 } +// Pipeliner_LMove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LMove' +type Pipeliner_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 *Pipeliner_Expecter) LMove(ctx interface{}, source interface{}, destination interface{}, srcpos interface{}, destpos interface{}) *Pipeliner_LMove_Call { + return &Pipeliner_LMove_Call{Call: _e.mock.On("LMove", ctx, source, destination, srcpos, destpos)} +} + +func (_c *Pipeliner_LMove_Call) Run(run func(ctx context.Context, source string, destination string, srcpos string, destpos string)) *Pipeliner_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 *Pipeliner_LMove_Call) Return(_a0 *redis.StringCmd) *Pipeliner_LMove_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LMove_Call) RunAndReturn(run func(context.Context, string, string, string, string) *redis.StringCmd) *Pipeliner_LMove_Call { + _c.Call.Return(run) + return _c +} + // LPop provides a mock function with given fields: ctx, key func (_m *Pipeliner) LPop(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -2062,6 +5707,35 @@ func (_m *Pipeliner) LPop(ctx context.Context, key string) *redis.StringCmd { return r0 } +// Pipeliner_LPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPop' +type Pipeliner_LPop_Call struct { + *mock.Call +} + +// LPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) LPop(ctx interface{}, key interface{}) *Pipeliner_LPop_Call { + return &Pipeliner_LPop_Call{Call: _e.mock.On("LPop", ctx, key)} +} + +func (_c *Pipeliner_LPop_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_LPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_LPop_Call) Return(_a0 *redis.StringCmd) *Pipeliner_LPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_LPop_Call { + _c.Call.Return(run) + return _c +} + // LPopCount provides a mock function with given fields: ctx, key, count func (_m *Pipeliner) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { ret := _m.Called(ctx, key, count) @@ -2078,6 +5752,36 @@ func (_m *Pipeliner) LPopCount(ctx context.Context, key string, count int) *redi return r0 } +// Pipeliner_LPopCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPopCount' +type Pipeliner_LPopCount_Call struct { + *mock.Call +} + +// LPopCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *Pipeliner_Expecter) LPopCount(ctx interface{}, key interface{}, count interface{}) *Pipeliner_LPopCount_Call { + return &Pipeliner_LPopCount_Call{Call: _e.mock.On("LPopCount", ctx, key, count)} +} + +func (_c *Pipeliner_LPopCount_Call) Run(run func(ctx context.Context, key string, count int)) *Pipeliner_LPopCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *Pipeliner_LPopCount_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_LPopCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LPopCount_Call) RunAndReturn(run func(context.Context, string, int) *redis.StringSliceCmd) *Pipeliner_LPopCount_Call { + _c.Call.Return(run) + return _c +} + // LPos provides a mock function with given fields: ctx, key, value, args func (_m *Pipeliner) LPos(ctx context.Context, key string, value string, args redis.LPosArgs) *redis.IntCmd { ret := _m.Called(ctx, key, value, args) @@ -2094,6 +5798,37 @@ func (_m *Pipeliner) LPos(ctx context.Context, key string, value string, args re return r0 } +// Pipeliner_LPos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPos' +type Pipeliner_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 *Pipeliner_Expecter) LPos(ctx interface{}, key interface{}, value interface{}, args interface{}) *Pipeliner_LPos_Call { + return &Pipeliner_LPos_Call{Call: _e.mock.On("LPos", ctx, key, value, args)} +} + +func (_c *Pipeliner_LPos_Call) Run(run func(ctx context.Context, key string, value string, args redis.LPosArgs)) *Pipeliner_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 *Pipeliner_LPos_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LPos_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LPos_Call) RunAndReturn(run func(context.Context, string, string, redis.LPosArgs) *redis.IntCmd) *Pipeliner_LPos_Call { + _c.Call.Return(run) + return _c +} + // LPosCount provides a mock function with given fields: ctx, key, value, count, args func (_m *Pipeliner) LPosCount(ctx context.Context, key string, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd { ret := _m.Called(ctx, key, value, count, args) @@ -2110,6 +5845,38 @@ func (_m *Pipeliner) LPosCount(ctx context.Context, key string, value string, co return r0 } +// Pipeliner_LPosCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPosCount' +type Pipeliner_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 *Pipeliner_Expecter) LPosCount(ctx interface{}, key interface{}, value interface{}, count interface{}, args interface{}) *Pipeliner_LPosCount_Call { + return &Pipeliner_LPosCount_Call{Call: _e.mock.On("LPosCount", ctx, key, value, count, args)} +} + +func (_c *Pipeliner_LPosCount_Call) Run(run func(ctx context.Context, key string, value string, count int64, args redis.LPosArgs)) *Pipeliner_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 *Pipeliner_LPosCount_Call) Return(_a0 *redis.IntSliceCmd) *Pipeliner_LPosCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LPosCount_Call) RunAndReturn(run func(context.Context, string, string, int64, redis.LPosArgs) *redis.IntSliceCmd) *Pipeliner_LPosCount_Call { + _c.Call.Return(run) + return _c +} + // LPush provides a mock function with given fields: ctx, key, values func (_m *Pipeliner) LPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -2129,6 +5896,43 @@ func (_m *Pipeliner) LPush(ctx context.Context, key string, values ...interface{ return r0 } +// Pipeliner_LPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPush' +type Pipeliner_LPush_Call struct { + *mock.Call +} + +// LPush is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Pipeliner_Expecter) LPush(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_LPush_Call { + return &Pipeliner_LPush_Call{Call: _e.mock.On("LPush", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Pipeliner_LPush_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Pipeliner_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 *Pipeliner_LPush_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LPush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LPush_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_LPush_Call { + _c.Call.Return(run) + return _c +} + // LPushX provides a mock function with given fields: ctx, key, values func (_m *Pipeliner) LPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -2148,6 +5952,43 @@ func (_m *Pipeliner) LPushX(ctx context.Context, key string, values ...interface return r0 } +// Pipeliner_LPushX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LPushX' +type Pipeliner_LPushX_Call struct { + *mock.Call +} + +// LPushX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Pipeliner_Expecter) LPushX(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_LPushX_Call { + return &Pipeliner_LPushX_Call{Call: _e.mock.On("LPushX", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Pipeliner_LPushX_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Pipeliner_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 *Pipeliner_LPushX_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LPushX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LPushX_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_LPushX_Call { + _c.Call.Return(run) + return _c +} + // LRange provides a mock function with given fields: ctx, key, start, stop func (_m *Pipeliner) LRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd { ret := _m.Called(ctx, key, start, stop) @@ -2164,6 +6005,37 @@ func (_m *Pipeliner) LRange(ctx context.Context, key string, start int64, stop i return r0 } +// Pipeliner_LRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LRange' +type Pipeliner_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 *Pipeliner_Expecter) LRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_LRange_Call { + return &Pipeliner_LRange_Call{Call: _e.mock.On("LRange", ctx, key, start, stop)} +} + +func (_c *Pipeliner_LRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_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 *Pipeliner_LRange_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_LRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *Pipeliner_LRange_Call { + _c.Call.Return(run) + return _c +} + // LRem provides a mock function with given fields: ctx, key, count, value func (_m *Pipeliner) LRem(ctx context.Context, key string, count int64, value interface{}) *redis.IntCmd { ret := _m.Called(ctx, key, count, value) @@ -2177,7 +6049,38 @@ func (_m *Pipeliner) LRem(ctx context.Context, key string, count int64, value in } } - return r0 + return r0 +} + +// Pipeliner_LRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LRem' +type Pipeliner_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 *Pipeliner_Expecter) LRem(ctx interface{}, key interface{}, count interface{}, value interface{}) *Pipeliner_LRem_Call { + return &Pipeliner_LRem_Call{Call: _e.mock.On("LRem", ctx, key, count, value)} +} + +func (_c *Pipeliner_LRem_Call) Run(run func(ctx context.Context, key string, count int64, value interface{})) *Pipeliner_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 *Pipeliner_LRem_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LRem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LRem_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) *redis.IntCmd) *Pipeliner_LRem_Call { + _c.Call.Return(run) + return _c } // LSet provides a mock function with given fields: ctx, key, index, value @@ -2196,6 +6099,37 @@ func (_m *Pipeliner) LSet(ctx context.Context, key string, index int64, value in return r0 } +// Pipeliner_LSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LSet' +type Pipeliner_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 *Pipeliner_Expecter) LSet(ctx interface{}, key interface{}, index interface{}, value interface{}) *Pipeliner_LSet_Call { + return &Pipeliner_LSet_Call{Call: _e.mock.On("LSet", ctx, key, index, value)} +} + +func (_c *Pipeliner_LSet_Call) Run(run func(ctx context.Context, key string, index int64, value interface{})) *Pipeliner_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 *Pipeliner_LSet_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_LSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LSet_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) *redis.StatusCmd) *Pipeliner_LSet_Call { + _c.Call.Return(run) + return _c +} + // LTrim provides a mock function with given fields: ctx, key, start, stop func (_m *Pipeliner) LTrim(ctx context.Context, key string, start int64, stop int64) *redis.StatusCmd { ret := _m.Called(ctx, key, start, stop) @@ -2212,6 +6146,37 @@ func (_m *Pipeliner) LTrim(ctx context.Context, key string, start int64, stop in return r0 } +// Pipeliner_LTrim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LTrim' +type Pipeliner_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 *Pipeliner_Expecter) LTrim(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_LTrim_Call { + return &Pipeliner_LTrim_Call{Call: _e.mock.On("LTrim", ctx, key, start, stop)} +} + +func (_c *Pipeliner_LTrim_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_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 *Pipeliner_LTrim_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_LTrim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LTrim_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StatusCmd) *Pipeliner_LTrim_Call { + _c.Call.Return(run) + return _c +} + // LastSave provides a mock function with given fields: ctx func (_m *Pipeliner) LastSave(ctx context.Context) *redis.IntCmd { ret := _m.Called(ctx) @@ -2228,6 +6193,34 @@ func (_m *Pipeliner) LastSave(ctx context.Context) *redis.IntCmd { return r0 } +// Pipeliner_LastSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastSave' +type Pipeliner_LastSave_Call struct { + *mock.Call +} + +// LastSave is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) LastSave(ctx interface{}) *Pipeliner_LastSave_Call { + return &Pipeliner_LastSave_Call{Call: _e.mock.On("LastSave", ctx)} +} + +func (_c *Pipeliner_LastSave_Call) Run(run func(ctx context.Context)) *Pipeliner_LastSave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_LastSave_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LastSave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_LastSave_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *Pipeliner_LastSave_Call { + _c.Call.Return(run) + return _c +} + // Len provides a mock function with given fields: func (_m *Pipeliner) Len() int { ret := _m.Called() @@ -2242,6 +6235,33 @@ func (_m *Pipeliner) Len() int { return r0 } +// Pipeliner_Len_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Len' +type Pipeliner_Len_Call struct { + *mock.Call +} + +// Len is a helper method to define mock.On call +func (_e *Pipeliner_Expecter) Len() *Pipeliner_Len_Call { + return &Pipeliner_Len_Call{Call: _e.mock.On("Len")} +} + +func (_c *Pipeliner_Len_Call) Run(run func()) *Pipeliner_Len_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Pipeliner_Len_Call) Return(_a0 int) *Pipeliner_Len_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Len_Call) RunAndReturn(run func() int) *Pipeliner_Len_Call { + _c.Call.Return(run) + return _c +} + // MGet provides a mock function with given fields: ctx, keys func (_m *Pipeliner) MGet(ctx context.Context, keys ...string) *redis.SliceCmd { _va := make([]interface{}, len(keys)) @@ -2265,6 +6285,42 @@ func (_m *Pipeliner) MGet(ctx context.Context, keys ...string) *redis.SliceCmd { return r0 } +// Pipeliner_MGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MGet' +type Pipeliner_MGet_Call struct { + *mock.Call +} + +// MGet is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) MGet(ctx interface{}, keys ...interface{}) *Pipeliner_MGet_Call { + return &Pipeliner_MGet_Call{Call: _e.mock.On("MGet", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_MGet_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_MGet_Call) Return(_a0 *redis.SliceCmd) *Pipeliner_MGet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_MGet_Call) RunAndReturn(run func(context.Context, ...string) *redis.SliceCmd) *Pipeliner_MGet_Call { + _c.Call.Return(run) + return _c +} + // MSet provides a mock function with given fields: ctx, values func (_m *Pipeliner) MSet(ctx context.Context, values ...interface{}) *redis.StatusCmd { var _ca []interface{} @@ -2284,6 +6340,42 @@ func (_m *Pipeliner) MSet(ctx context.Context, values ...interface{}) *redis.Sta return r0 } +// Pipeliner_MSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MSet' +type Pipeliner_MSet_Call struct { + *mock.Call +} + +// MSet is a helper method to define mock.On call +// - ctx context.Context +// - values ...interface{} +func (_e *Pipeliner_Expecter) MSet(ctx interface{}, values ...interface{}) *Pipeliner_MSet_Call { + return &Pipeliner_MSet_Call{Call: _e.mock.On("MSet", + append([]interface{}{ctx}, values...)...)} +} + +func (_c *Pipeliner_MSet_Call) Run(run func(ctx context.Context, values ...interface{})) *Pipeliner_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 *Pipeliner_MSet_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_MSet_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_MSet_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.StatusCmd) *Pipeliner_MSet_Call { + _c.Call.Return(run) + return _c +} + // MSetNX provides a mock function with given fields: ctx, values func (_m *Pipeliner) MSetNX(ctx context.Context, values ...interface{}) *redis.BoolCmd { var _ca []interface{} @@ -2303,6 +6395,42 @@ func (_m *Pipeliner) MSetNX(ctx context.Context, values ...interface{}) *redis.B return r0 } +// Pipeliner_MSetNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MSetNX' +type Pipeliner_MSetNX_Call struct { + *mock.Call +} + +// MSetNX is a helper method to define mock.On call +// - ctx context.Context +// - values ...interface{} +func (_e *Pipeliner_Expecter) MSetNX(ctx interface{}, values ...interface{}) *Pipeliner_MSetNX_Call { + return &Pipeliner_MSetNX_Call{Call: _e.mock.On("MSetNX", + append([]interface{}{ctx}, values...)...)} +} + +func (_c *Pipeliner_MSetNX_Call) Run(run func(ctx context.Context, values ...interface{})) *Pipeliner_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 *Pipeliner_MSetNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_MSetNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_MSetNX_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.BoolCmd) *Pipeliner_MSetNX_Call { + _c.Call.Return(run) + return _c +} + // MemoryUsage provides a mock function with given fields: ctx, key, samples func (_m *Pipeliner) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd { _va := make([]interface{}, len(samples)) @@ -2326,6 +6454,43 @@ func (_m *Pipeliner) MemoryUsage(ctx context.Context, key string, samples ...int return r0 } +// Pipeliner_MemoryUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MemoryUsage' +type Pipeliner_MemoryUsage_Call struct { + *mock.Call +} + +// MemoryUsage is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - samples ...int +func (_e *Pipeliner_Expecter) MemoryUsage(ctx interface{}, key interface{}, samples ...interface{}) *Pipeliner_MemoryUsage_Call { + return &Pipeliner_MemoryUsage_Call{Call: _e.mock.On("MemoryUsage", + append([]interface{}{ctx, key}, samples...)...)} +} + +func (_c *Pipeliner_MemoryUsage_Call) Run(run func(ctx context.Context, key string, samples ...int)) *Pipeliner_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 *Pipeliner_MemoryUsage_Call) Return(_a0 *redis.IntCmd) *Pipeliner_MemoryUsage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_MemoryUsage_Call) RunAndReturn(run func(context.Context, string, ...int) *redis.IntCmd) *Pipeliner_MemoryUsage_Call { + _c.Call.Return(run) + return _c +} + // Migrate provides a mock function with given fields: ctx, host, port, key, db, timeout func (_m *Pipeliner) 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) @@ -2342,6 +6507,39 @@ func (_m *Pipeliner) Migrate(ctx context.Context, host string, port string, key return r0 } +// Pipeliner_Migrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Migrate' +type Pipeliner_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 *Pipeliner_Expecter) Migrate(ctx interface{}, host interface{}, port interface{}, key interface{}, db interface{}, timeout interface{}) *Pipeliner_Migrate_Call { + return &Pipeliner_Migrate_Call{Call: _e.mock.On("Migrate", ctx, host, port, key, db, timeout)} +} + +func (_c *Pipeliner_Migrate_Call) Run(run func(ctx context.Context, host string, port string, key string, db int, timeout time.Duration)) *Pipeliner_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 *Pipeliner_Migrate_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Migrate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Migrate_Call) RunAndReturn(run func(context.Context, string, string, string, int, time.Duration) *redis.StatusCmd) *Pipeliner_Migrate_Call { + _c.Call.Return(run) + return _c +} + // Move provides a mock function with given fields: ctx, key, db func (_m *Pipeliner) Move(ctx context.Context, key string, db int) *redis.BoolCmd { ret := _m.Called(ctx, key, db) @@ -2358,6 +6556,36 @@ func (_m *Pipeliner) Move(ctx context.Context, key string, db int) *redis.BoolCm return r0 } +// Pipeliner_Move_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Move' +type Pipeliner_Move_Call struct { + *mock.Call +} + +// Move is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - db int +func (_e *Pipeliner_Expecter) Move(ctx interface{}, key interface{}, db interface{}) *Pipeliner_Move_Call { + return &Pipeliner_Move_Call{Call: _e.mock.On("Move", ctx, key, db)} +} + +func (_c *Pipeliner_Move_Call) Run(run func(ctx context.Context, key string, db int)) *Pipeliner_Move_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *Pipeliner_Move_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_Move_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Move_Call) RunAndReturn(run func(context.Context, string, int) *redis.BoolCmd) *Pipeliner_Move_Call { + _c.Call.Return(run) + return _c +} + // ObjectEncoding provides a mock function with given fields: ctx, key func (_m *Pipeliner) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -2374,6 +6602,35 @@ func (_m *Pipeliner) ObjectEncoding(ctx context.Context, key string) *redis.Stri return r0 } +// Pipeliner_ObjectEncoding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObjectEncoding' +type Pipeliner_ObjectEncoding_Call struct { + *mock.Call +} + +// ObjectEncoding is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) ObjectEncoding(ctx interface{}, key interface{}) *Pipeliner_ObjectEncoding_Call { + return &Pipeliner_ObjectEncoding_Call{Call: _e.mock.On("ObjectEncoding", ctx, key)} +} + +func (_c *Pipeliner_ObjectEncoding_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_ObjectEncoding_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ObjectEncoding_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ObjectEncoding_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ObjectEncoding_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_ObjectEncoding_Call { + _c.Call.Return(run) + return _c +} + // ObjectIdleTime provides a mock function with given fields: ctx, key func (_m *Pipeliner) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd { ret := _m.Called(ctx, key) @@ -2390,6 +6647,35 @@ func (_m *Pipeliner) ObjectIdleTime(ctx context.Context, key string) *redis.Dura return r0 } +// Pipeliner_ObjectIdleTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObjectIdleTime' +type Pipeliner_ObjectIdleTime_Call struct { + *mock.Call +} + +// ObjectIdleTime is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) ObjectIdleTime(ctx interface{}, key interface{}) *Pipeliner_ObjectIdleTime_Call { + return &Pipeliner_ObjectIdleTime_Call{Call: _e.mock.On("ObjectIdleTime", ctx, key)} +} + +func (_c *Pipeliner_ObjectIdleTime_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_ObjectIdleTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ObjectIdleTime_Call) Return(_a0 *redis.DurationCmd) *Pipeliner_ObjectIdleTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ObjectIdleTime_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *Pipeliner_ObjectIdleTime_Call { + _c.Call.Return(run) + return _c +} + // ObjectRefCount provides a mock function with given fields: ctx, key func (_m *Pipeliner) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -2406,6 +6692,35 @@ func (_m *Pipeliner) ObjectRefCount(ctx context.Context, key string) *redis.IntC return r0 } +// Pipeliner_ObjectRefCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObjectRefCount' +type Pipeliner_ObjectRefCount_Call struct { + *mock.Call +} + +// ObjectRefCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) ObjectRefCount(ctx interface{}, key interface{}) *Pipeliner_ObjectRefCount_Call { + return &Pipeliner_ObjectRefCount_Call{Call: _e.mock.On("ObjectRefCount", ctx, key)} +} + +func (_c *Pipeliner_ObjectRefCount_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_ObjectRefCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ObjectRefCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ObjectRefCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ObjectRefCount_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_ObjectRefCount_Call { + _c.Call.Return(run) + return _c +} + // PExpire provides a mock function with given fields: ctx, key, expiration func (_m *Pipeliner) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { ret := _m.Called(ctx, key, expiration) @@ -2422,6 +6737,36 @@ func (_m *Pipeliner) PExpire(ctx context.Context, key string, expiration time.Du return r0 } +// Pipeliner_PExpire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PExpire' +type Pipeliner_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 *Pipeliner_Expecter) PExpire(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_PExpire_Call { + return &Pipeliner_PExpire_Call{Call: _e.mock.On("PExpire", ctx, key, expiration)} +} + +func (_c *Pipeliner_PExpire_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *Pipeliner_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 *Pipeliner_PExpire_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_PExpire_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PExpire_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_PExpire_Call { + _c.Call.Return(run) + return _c +} + // PExpireAt provides a mock function with given fields: ctx, key, tm func (_m *Pipeliner) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { ret := _m.Called(ctx, key, tm) @@ -2438,6 +6783,36 @@ func (_m *Pipeliner) PExpireAt(ctx context.Context, key string, tm time.Time) *r return r0 } +// Pipeliner_PExpireAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PExpireAt' +type Pipeliner_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 *Pipeliner_Expecter) PExpireAt(ctx interface{}, key interface{}, tm interface{}) *Pipeliner_PExpireAt_Call { + return &Pipeliner_PExpireAt_Call{Call: _e.mock.On("PExpireAt", ctx, key, tm)} +} + +func (_c *Pipeliner_PExpireAt_Call) Run(run func(ctx context.Context, key string, tm time.Time)) *Pipeliner_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 *Pipeliner_PExpireAt_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_PExpireAt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PExpireAt_Call) RunAndReturn(run func(context.Context, string, time.Time) *redis.BoolCmd) *Pipeliner_PExpireAt_Call { + _c.Call.Return(run) + return _c +} + // PFAdd provides a mock function with given fields: ctx, key, els func (_m *Pipeliner) PFAdd(ctx context.Context, key string, els ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -2457,6 +6832,43 @@ func (_m *Pipeliner) PFAdd(ctx context.Context, key string, els ...interface{}) return r0 } +// Pipeliner_PFAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFAdd' +type Pipeliner_PFAdd_Call struct { + *mock.Call +} + +// PFAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - els ...interface{} +func (_e *Pipeliner_Expecter) PFAdd(ctx interface{}, key interface{}, els ...interface{}) *Pipeliner_PFAdd_Call { + return &Pipeliner_PFAdd_Call{Call: _e.mock.On("PFAdd", + append([]interface{}{ctx, key}, els...)...)} +} + +func (_c *Pipeliner_PFAdd_Call) Run(run func(ctx context.Context, key string, els ...interface{})) *Pipeliner_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 *Pipeliner_PFAdd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_PFAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PFAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_PFAdd_Call { + _c.Call.Return(run) + return _c +} + // PFCount provides a mock function with given fields: ctx, keys func (_m *Pipeliner) PFCount(ctx context.Context, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -2480,6 +6892,42 @@ func (_m *Pipeliner) PFCount(ctx context.Context, keys ...string) *redis.IntCmd return r0 } +// Pipeliner_PFCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFCount' +type Pipeliner_PFCount_Call struct { + *mock.Call +} + +// PFCount is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) PFCount(ctx interface{}, keys ...interface{}) *Pipeliner_PFCount_Call { + return &Pipeliner_PFCount_Call{Call: _e.mock.On("PFCount", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_PFCount_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_PFCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_PFCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PFCount_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_PFCount_Call { + _c.Call.Return(run) + return _c +} + // PFMerge provides a mock function with given fields: ctx, dest, keys func (_m *Pipeliner) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd { _va := make([]interface{}, len(keys)) @@ -2503,6 +6951,43 @@ func (_m *Pipeliner) PFMerge(ctx context.Context, dest string, keys ...string) * return r0 } +// Pipeliner_PFMerge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PFMerge' +type Pipeliner_PFMerge_Call struct { + *mock.Call +} + +// PFMerge is a helper method to define mock.On call +// - ctx context.Context +// - dest string +// - keys ...string +func (_e *Pipeliner_Expecter) PFMerge(ctx interface{}, dest interface{}, keys ...interface{}) *Pipeliner_PFMerge_Call { + return &Pipeliner_PFMerge_Call{Call: _e.mock.On("PFMerge", + append([]interface{}{ctx, dest}, keys...)...)} +} + +func (_c *Pipeliner_PFMerge_Call) Run(run func(ctx context.Context, dest string, keys ...string)) *Pipeliner_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 *Pipeliner_PFMerge_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_PFMerge_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PFMerge_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.StatusCmd) *Pipeliner_PFMerge_Call { + _c.Call.Return(run) + return _c +} + // PTTL provides a mock function with given fields: ctx, key func (_m *Pipeliner) PTTL(ctx context.Context, key string) *redis.DurationCmd { ret := _m.Called(ctx, key) @@ -2519,6 +7004,35 @@ func (_m *Pipeliner) PTTL(ctx context.Context, key string) *redis.DurationCmd { return r0 } +// Pipeliner_PTTL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PTTL' +type Pipeliner_PTTL_Call struct { + *mock.Call +} + +// PTTL is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) PTTL(ctx interface{}, key interface{}) *Pipeliner_PTTL_Call { + return &Pipeliner_PTTL_Call{Call: _e.mock.On("PTTL", ctx, key)} +} + +func (_c *Pipeliner_PTTL_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_PTTL_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_PTTL_Call) Return(_a0 *redis.DurationCmd) *Pipeliner_PTTL_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PTTL_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *Pipeliner_PTTL_Call { + _c.Call.Return(run) + return _c +} + // Persist provides a mock function with given fields: ctx, key func (_m *Pipeliner) Persist(ctx context.Context, key string) *redis.BoolCmd { ret := _m.Called(ctx, key) @@ -2535,6 +7049,35 @@ func (_m *Pipeliner) Persist(ctx context.Context, key string) *redis.BoolCmd { return r0 } +// Pipeliner_Persist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Persist' +type Pipeliner_Persist_Call struct { + *mock.Call +} + +// Persist is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) Persist(ctx interface{}, key interface{}) *Pipeliner_Persist_Call { + return &Pipeliner_Persist_Call{Call: _e.mock.On("Persist", ctx, key)} +} + +func (_c *Pipeliner_Persist_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_Persist_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_Persist_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_Persist_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Persist_Call) RunAndReturn(run func(context.Context, string) *redis.BoolCmd) *Pipeliner_Persist_Call { + _c.Call.Return(run) + return _c +} + // Ping provides a mock function with given fields: ctx func (_m *Pipeliner) Ping(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -2551,6 +7094,34 @@ func (_m *Pipeliner) Ping(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_Ping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ping' +type Pipeliner_Ping_Call struct { + *mock.Call +} + +// Ping is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) Ping(ctx interface{}) *Pipeliner_Ping_Call { + return &Pipeliner_Ping_Call{Call: _e.mock.On("Ping", ctx)} +} + +func (_c *Pipeliner_Ping_Call) Run(run func(ctx context.Context)) *Pipeliner_Ping_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_Ping_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Ping_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Ping_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_Ping_Call { + _c.Call.Return(run) + return _c +} + // Pipeline provides a mock function with given fields: func (_m *Pipeliner) Pipeline() redis.Pipeliner { ret := _m.Called() @@ -2567,6 +7138,33 @@ func (_m *Pipeliner) Pipeline() redis.Pipeliner { return r0 } +// Pipeliner_Pipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pipeline' +type Pipeliner_Pipeline_Call struct { + *mock.Call +} + +// Pipeline is a helper method to define mock.On call +func (_e *Pipeliner_Expecter) Pipeline() *Pipeliner_Pipeline_Call { + return &Pipeliner_Pipeline_Call{Call: _e.mock.On("Pipeline")} +} + +func (_c *Pipeliner_Pipeline_Call) Run(run func()) *Pipeliner_Pipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Pipeliner_Pipeline_Call) Return(_a0 redis.Pipeliner) *Pipeliner_Pipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Pipeline_Call) RunAndReturn(run func() redis.Pipeliner) *Pipeliner_Pipeline_Call { + _c.Call.Return(run) + return _c +} + // Pipelined provides a mock function with given fields: ctx, fn func (_m *Pipeliner) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { ret := _m.Called(ctx, fn) @@ -2593,6 +7191,35 @@ func (_m *Pipeliner) Pipelined(ctx context.Context, fn func(redis.Pipeliner) err return r0, r1 } +// Pipeliner_Pipelined_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pipelined' +type Pipeliner_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 *Pipeliner_Expecter) Pipelined(ctx interface{}, fn interface{}) *Pipeliner_Pipelined_Call { + return &Pipeliner_Pipelined_Call{Call: _e.mock.On("Pipelined", ctx, fn)} +} + +func (_c *Pipeliner_Pipelined_Call) Run(run func(ctx context.Context, fn func(redis.Pipeliner) error)) *Pipeliner_Pipelined_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(func(redis.Pipeliner) error)) + }) + return _c +} + +func (_c *Pipeliner_Pipelined_Call) Return(_a0 []redis.Cmder, _a1 error) *Pipeliner_Pipelined_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Pipeliner_Pipelined_Call) RunAndReturn(run func(context.Context, func(redis.Pipeliner) error) ([]redis.Cmder, error)) *Pipeliner_Pipelined_Call { + _c.Call.Return(run) + return _c +} + // Process provides a mock function with given fields: ctx, cmd func (_m *Pipeliner) Process(ctx context.Context, cmd redis.Cmder) error { ret := _m.Called(ctx, cmd) @@ -2604,7 +7231,36 @@ func (_m *Pipeliner) Process(ctx context.Context, cmd redis.Cmder) error { r0 = ret.Error(0) } - return r0 + return r0 +} + +// Pipeliner_Process_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Process' +type Pipeliner_Process_Call struct { + *mock.Call +} + +// Process is a helper method to define mock.On call +// - ctx context.Context +// - cmd redis.Cmder +func (_e *Pipeliner_Expecter) Process(ctx interface{}, cmd interface{}) *Pipeliner_Process_Call { + return &Pipeliner_Process_Call{Call: _e.mock.On("Process", ctx, cmd)} +} + +func (_c *Pipeliner_Process_Call) Run(run func(ctx context.Context, cmd redis.Cmder)) *Pipeliner_Process_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.Cmder)) + }) + return _c +} + +func (_c *Pipeliner_Process_Call) Return(_a0 error) *Pipeliner_Process_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Process_Call) RunAndReturn(run func(context.Context, redis.Cmder) error) *Pipeliner_Process_Call { + _c.Call.Return(run) + return _c } // PubSubChannels provides a mock function with given fields: ctx, pattern @@ -2623,6 +7279,35 @@ func (_m *Pipeliner) PubSubChannels(ctx context.Context, pattern string) *redis. return r0 } +// Pipeliner_PubSubChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubSubChannels' +type Pipeliner_PubSubChannels_Call struct { + *mock.Call +} + +// PubSubChannels is a helper method to define mock.On call +// - ctx context.Context +// - pattern string +func (_e *Pipeliner_Expecter) PubSubChannels(ctx interface{}, pattern interface{}) *Pipeliner_PubSubChannels_Call { + return &Pipeliner_PubSubChannels_Call{Call: _e.mock.On("PubSubChannels", ctx, pattern)} +} + +func (_c *Pipeliner_PubSubChannels_Call) Run(run func(ctx context.Context, pattern string)) *Pipeliner_PubSubChannels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_PubSubChannels_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_PubSubChannels_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PubSubChannels_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_PubSubChannels_Call { + _c.Call.Return(run) + return _c +} + // PubSubNumPat provides a mock function with given fields: ctx func (_m *Pipeliner) PubSubNumPat(ctx context.Context) *redis.IntCmd { ret := _m.Called(ctx) @@ -2639,6 +7324,34 @@ func (_m *Pipeliner) PubSubNumPat(ctx context.Context) *redis.IntCmd { return r0 } +// Pipeliner_PubSubNumPat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubSubNumPat' +type Pipeliner_PubSubNumPat_Call struct { + *mock.Call +} + +// PubSubNumPat is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) PubSubNumPat(ctx interface{}) *Pipeliner_PubSubNumPat_Call { + return &Pipeliner_PubSubNumPat_Call{Call: _e.mock.On("PubSubNumPat", ctx)} +} + +func (_c *Pipeliner_PubSubNumPat_Call) Run(run func(ctx context.Context)) *Pipeliner_PubSubNumPat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_PubSubNumPat_Call) Return(_a0 *redis.IntCmd) *Pipeliner_PubSubNumPat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PubSubNumPat_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *Pipeliner_PubSubNumPat_Call { + _c.Call.Return(run) + return _c +} + // PubSubNumSub provides a mock function with given fields: ctx, channels func (_m *Pipeliner) PubSubNumSub(ctx context.Context, channels ...string) *redis.StringIntMapCmd { _va := make([]interface{}, len(channels)) @@ -2662,6 +7375,42 @@ func (_m *Pipeliner) PubSubNumSub(ctx context.Context, channels ...string) *redi return r0 } +// Pipeliner_PubSubNumSub_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubSubNumSub' +type Pipeliner_PubSubNumSub_Call struct { + *mock.Call +} + +// PubSubNumSub is a helper method to define mock.On call +// - ctx context.Context +// - channels ...string +func (_e *Pipeliner_Expecter) PubSubNumSub(ctx interface{}, channels ...interface{}) *Pipeliner_PubSubNumSub_Call { + return &Pipeliner_PubSubNumSub_Call{Call: _e.mock.On("PubSubNumSub", + append([]interface{}{ctx}, channels...)...)} +} + +func (_c *Pipeliner_PubSubNumSub_Call) Run(run func(ctx context.Context, channels ...string)) *Pipeliner_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 *Pipeliner_PubSubNumSub_Call) Return(_a0 *redis.StringIntMapCmd) *Pipeliner_PubSubNumSub_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_PubSubNumSub_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringIntMapCmd) *Pipeliner_PubSubNumSub_Call { + _c.Call.Return(run) + return _c +} + // Publish provides a mock function with given fields: ctx, channel, message func (_m *Pipeliner) Publish(ctx context.Context, channel string, message interface{}) *redis.IntCmd { ret := _m.Called(ctx, channel, message) @@ -2678,6 +7427,36 @@ func (_m *Pipeliner) Publish(ctx context.Context, channel string, message interf return r0 } +// Pipeliner_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish' +type Pipeliner_Publish_Call struct { + *mock.Call +} + +// Publish is a helper method to define mock.On call +// - ctx context.Context +// - channel string +// - message interface{} +func (_e *Pipeliner_Expecter) Publish(ctx interface{}, channel interface{}, message interface{}) *Pipeliner_Publish_Call { + return &Pipeliner_Publish_Call{Call: _e.mock.On("Publish", ctx, channel, message)} +} + +func (_c *Pipeliner_Publish_Call) Run(run func(ctx context.Context, channel string, message interface{})) *Pipeliner_Publish_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *Pipeliner_Publish_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Publish_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Publish_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.IntCmd) *Pipeliner_Publish_Call { + _c.Call.Return(run) + return _c +} + // Quit provides a mock function with given fields: ctx func (_m *Pipeliner) Quit(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -2694,6 +7473,34 @@ func (_m *Pipeliner) Quit(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_Quit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Quit' +type Pipeliner_Quit_Call struct { + *mock.Call +} + +// Quit is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) Quit(ctx interface{}) *Pipeliner_Quit_Call { + return &Pipeliner_Quit_Call{Call: _e.mock.On("Quit", ctx)} +} + +func (_c *Pipeliner_Quit_Call) Run(run func(ctx context.Context)) *Pipeliner_Quit_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_Quit_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Quit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Quit_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_Quit_Call { + _c.Call.Return(run) + return _c +} + // RPop provides a mock function with given fields: ctx, key func (_m *Pipeliner) RPop(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -2710,6 +7517,35 @@ func (_m *Pipeliner) RPop(ctx context.Context, key string) *redis.StringCmd { return r0 } +// Pipeliner_RPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPop' +type Pipeliner_RPop_Call struct { + *mock.Call +} + +// RPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) RPop(ctx interface{}, key interface{}) *Pipeliner_RPop_Call { + return &Pipeliner_RPop_Call{Call: _e.mock.On("RPop", ctx, key)} +} + +func (_c *Pipeliner_RPop_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_RPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_RPop_Call) Return(_a0 *redis.StringCmd) *Pipeliner_RPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_RPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_RPop_Call { + _c.Call.Return(run) + return _c +} + // RPopCount provides a mock function with given fields: ctx, key, count func (_m *Pipeliner) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { ret := _m.Called(ctx, key, count) @@ -2726,6 +7562,36 @@ func (_m *Pipeliner) RPopCount(ctx context.Context, key string, count int) *redi return r0 } +// Pipeliner_RPopCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPopCount' +type Pipeliner_RPopCount_Call struct { + *mock.Call +} + +// RPopCount is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *Pipeliner_Expecter) RPopCount(ctx interface{}, key interface{}, count interface{}) *Pipeliner_RPopCount_Call { + return &Pipeliner_RPopCount_Call{Call: _e.mock.On("RPopCount", ctx, key, count)} +} + +func (_c *Pipeliner_RPopCount_Call) Run(run func(ctx context.Context, key string, count int)) *Pipeliner_RPopCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *Pipeliner_RPopCount_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_RPopCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_RPopCount_Call) RunAndReturn(run func(context.Context, string, int) *redis.StringSliceCmd) *Pipeliner_RPopCount_Call { + _c.Call.Return(run) + return _c +} + // RPopLPush provides a mock function with given fields: ctx, source, destination func (_m *Pipeliner) RPopLPush(ctx context.Context, source string, destination string) *redis.StringCmd { ret := _m.Called(ctx, source, destination) @@ -2742,6 +7608,36 @@ func (_m *Pipeliner) RPopLPush(ctx context.Context, source string, destination s return r0 } +// Pipeliner_RPopLPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPopLPush' +type Pipeliner_RPopLPush_Call struct { + *mock.Call +} + +// RPopLPush is a helper method to define mock.On call +// - ctx context.Context +// - source string +// - destination string +func (_e *Pipeliner_Expecter) RPopLPush(ctx interface{}, source interface{}, destination interface{}) *Pipeliner_RPopLPush_Call { + return &Pipeliner_RPopLPush_Call{Call: _e.mock.On("RPopLPush", ctx, source, destination)} +} + +func (_c *Pipeliner_RPopLPush_Call) Run(run func(ctx context.Context, source string, destination string)) *Pipeliner_RPopLPush_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_RPopLPush_Call) Return(_a0 *redis.StringCmd) *Pipeliner_RPopLPush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_RPopLPush_Call) RunAndReturn(run func(context.Context, string, string) *redis.StringCmd) *Pipeliner_RPopLPush_Call { + _c.Call.Return(run) + return _c +} + // RPush provides a mock function with given fields: ctx, key, values func (_m *Pipeliner) RPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -2761,6 +7657,43 @@ func (_m *Pipeliner) RPush(ctx context.Context, key string, values ...interface{ return r0 } +// Pipeliner_RPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPush' +type Pipeliner_RPush_Call struct { + *mock.Call +} + +// RPush is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Pipeliner_Expecter) RPush(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_RPush_Call { + return &Pipeliner_RPush_Call{Call: _e.mock.On("RPush", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Pipeliner_RPush_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Pipeliner_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 *Pipeliner_RPush_Call) Return(_a0 *redis.IntCmd) *Pipeliner_RPush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_RPush_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_RPush_Call { + _c.Call.Return(run) + return _c +} + // RPushX provides a mock function with given fields: ctx, key, values func (_m *Pipeliner) RPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -2780,6 +7713,43 @@ func (_m *Pipeliner) RPushX(ctx context.Context, key string, values ...interface return r0 } +// Pipeliner_RPushX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RPushX' +type Pipeliner_RPushX_Call struct { + *mock.Call +} + +// RPushX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - values ...interface{} +func (_e *Pipeliner_Expecter) RPushX(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_RPushX_Call { + return &Pipeliner_RPushX_Call{Call: _e.mock.On("RPushX", + append([]interface{}{ctx, key}, values...)...)} +} + +func (_c *Pipeliner_RPushX_Call) Run(run func(ctx context.Context, key string, values ...interface{})) *Pipeliner_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 *Pipeliner_RPushX_Call) Return(_a0 *redis.IntCmd) *Pipeliner_RPushX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_RPushX_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_RPushX_Call { + _c.Call.Return(run) + return _c +} + // RandomKey provides a mock function with given fields: ctx func (_m *Pipeliner) RandomKey(ctx context.Context) *redis.StringCmd { ret := _m.Called(ctx) @@ -2796,6 +7766,34 @@ func (_m *Pipeliner) RandomKey(ctx context.Context) *redis.StringCmd { return r0 } +// Pipeliner_RandomKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RandomKey' +type Pipeliner_RandomKey_Call struct { + *mock.Call +} + +// RandomKey is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) RandomKey(ctx interface{}) *Pipeliner_RandomKey_Call { + return &Pipeliner_RandomKey_Call{Call: _e.mock.On("RandomKey", ctx)} +} + +func (_c *Pipeliner_RandomKey_Call) Run(run func(ctx context.Context)) *Pipeliner_RandomKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_RandomKey_Call) Return(_a0 *redis.StringCmd) *Pipeliner_RandomKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_RandomKey_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_RandomKey_Call { + _c.Call.Return(run) + return _c +} + // ReadOnly provides a mock function with given fields: ctx func (_m *Pipeliner) ReadOnly(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -2812,6 +7810,34 @@ func (_m *Pipeliner) ReadOnly(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ReadOnly_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOnly' +type Pipeliner_ReadOnly_Call struct { + *mock.Call +} + +// ReadOnly is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ReadOnly(ctx interface{}) *Pipeliner_ReadOnly_Call { + return &Pipeliner_ReadOnly_Call{Call: _e.mock.On("ReadOnly", ctx)} +} + +func (_c *Pipeliner_ReadOnly_Call) Run(run func(ctx context.Context)) *Pipeliner_ReadOnly_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ReadOnly_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ReadOnly_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ReadOnly_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ReadOnly_Call { + _c.Call.Return(run) + return _c +} + // ReadWrite provides a mock function with given fields: ctx func (_m *Pipeliner) ReadWrite(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -2828,6 +7854,34 @@ func (_m *Pipeliner) ReadWrite(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ReadWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadWrite' +type Pipeliner_ReadWrite_Call struct { + *mock.Call +} + +// ReadWrite is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ReadWrite(ctx interface{}) *Pipeliner_ReadWrite_Call { + return &Pipeliner_ReadWrite_Call{Call: _e.mock.On("ReadWrite", ctx)} +} + +func (_c *Pipeliner_ReadWrite_Call) Run(run func(ctx context.Context)) *Pipeliner_ReadWrite_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ReadWrite_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ReadWrite_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ReadWrite_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ReadWrite_Call { + _c.Call.Return(run) + return _c +} + // Rename provides a mock function with given fields: ctx, key, newkey func (_m *Pipeliner) Rename(ctx context.Context, key string, newkey string) *redis.StatusCmd { ret := _m.Called(ctx, key, newkey) @@ -2844,6 +7898,36 @@ func (_m *Pipeliner) Rename(ctx context.Context, key string, newkey string) *red return r0 } +// Pipeliner_Rename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Rename' +type Pipeliner_Rename_Call struct { + *mock.Call +} + +// Rename is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - newkey string +func (_e *Pipeliner_Expecter) Rename(ctx interface{}, key interface{}, newkey interface{}) *Pipeliner_Rename_Call { + return &Pipeliner_Rename_Call{Call: _e.mock.On("Rename", ctx, key, newkey)} +} + +func (_c *Pipeliner_Rename_Call) Run(run func(ctx context.Context, key string, newkey string)) *Pipeliner_Rename_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_Rename_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Rename_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Rename_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_Rename_Call { + _c.Call.Return(run) + return _c +} + // RenameNX provides a mock function with given fields: ctx, key, newkey func (_m *Pipeliner) RenameNX(ctx context.Context, key string, newkey string) *redis.BoolCmd { ret := _m.Called(ctx, key, newkey) @@ -2860,6 +7944,36 @@ func (_m *Pipeliner) RenameNX(ctx context.Context, key string, newkey string) *r return r0 } +// Pipeliner_RenameNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameNX' +type Pipeliner_RenameNX_Call struct { + *mock.Call +} + +// RenameNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - newkey string +func (_e *Pipeliner_Expecter) RenameNX(ctx interface{}, key interface{}, newkey interface{}) *Pipeliner_RenameNX_Call { + return &Pipeliner_RenameNX_Call{Call: _e.mock.On("RenameNX", ctx, key, newkey)} +} + +func (_c *Pipeliner_RenameNX_Call) Run(run func(ctx context.Context, key string, newkey string)) *Pipeliner_RenameNX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_RenameNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_RenameNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_RenameNX_Call) RunAndReturn(run func(context.Context, string, string) *redis.BoolCmd) *Pipeliner_RenameNX_Call { + _c.Call.Return(run) + return _c +} + // Restore provides a mock function with given fields: ctx, key, ttl, value func (_m *Pipeliner) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { ret := _m.Called(ctx, key, ttl, value) @@ -2876,6 +7990,37 @@ func (_m *Pipeliner) Restore(ctx context.Context, key string, ttl time.Duration, return r0 } +// Pipeliner_Restore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Restore' +type Pipeliner_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 *Pipeliner_Expecter) Restore(ctx interface{}, key interface{}, ttl interface{}, value interface{}) *Pipeliner_Restore_Call { + return &Pipeliner_Restore_Call{Call: _e.mock.On("Restore", ctx, key, ttl, value)} +} + +func (_c *Pipeliner_Restore_Call) Run(run func(ctx context.Context, key string, ttl time.Duration, value string)) *Pipeliner_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 *Pipeliner_Restore_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Restore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Restore_Call) RunAndReturn(run func(context.Context, string, time.Duration, string) *redis.StatusCmd) *Pipeliner_Restore_Call { + _c.Call.Return(run) + return _c +} + // RestoreReplace provides a mock function with given fields: ctx, key, ttl, value func (_m *Pipeliner) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { ret := _m.Called(ctx, key, ttl, value) @@ -2892,6 +8037,37 @@ func (_m *Pipeliner) RestoreReplace(ctx context.Context, key string, ttl time.Du return r0 } +// Pipeliner_RestoreReplace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreReplace' +type Pipeliner_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 *Pipeliner_Expecter) RestoreReplace(ctx interface{}, key interface{}, ttl interface{}, value interface{}) *Pipeliner_RestoreReplace_Call { + return &Pipeliner_RestoreReplace_Call{Call: _e.mock.On("RestoreReplace", ctx, key, ttl, value)} +} + +func (_c *Pipeliner_RestoreReplace_Call) Run(run func(ctx context.Context, key string, ttl time.Duration, value string)) *Pipeliner_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 *Pipeliner_RestoreReplace_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_RestoreReplace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_RestoreReplace_Call) RunAndReturn(run func(context.Context, string, time.Duration, string) *redis.StatusCmd) *Pipeliner_RestoreReplace_Call { + _c.Call.Return(run) + return _c +} + // SAdd provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) SAdd(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -2911,6 +8087,43 @@ func (_m *Pipeliner) SAdd(ctx context.Context, key string, members ...interface{ return r0 } +// Pipeliner_SAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SAdd' +type Pipeliner_SAdd_Call struct { + *mock.Call +} + +// SAdd is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...interface{} +func (_e *Pipeliner_Expecter) SAdd(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_SAdd_Call { + return &Pipeliner_SAdd_Call{Call: _e.mock.On("SAdd", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_SAdd_Call) Run(run func(ctx context.Context, key string, members ...interface{})) *Pipeliner_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 *Pipeliner_SAdd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_SAdd_Call { + _c.Call.Return(run) + return _c +} + // SCard provides a mock function with given fields: ctx, key func (_m *Pipeliner) SCard(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -2927,6 +8140,35 @@ func (_m *Pipeliner) SCard(ctx context.Context, key string) *redis.IntCmd { return r0 } +// Pipeliner_SCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SCard' +type Pipeliner_SCard_Call struct { + *mock.Call +} + +// SCard is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) SCard(ctx interface{}, key interface{}) *Pipeliner_SCard_Call { + return &Pipeliner_SCard_Call{Call: _e.mock.On("SCard", ctx, key)} +} + +func (_c *Pipeliner_SCard_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_SCard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_SCard_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SCard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SCard_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_SCard_Call { + _c.Call.Return(run) + return _c +} + // SDiff provides a mock function with given fields: ctx, keys func (_m *Pipeliner) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { _va := make([]interface{}, len(keys)) @@ -2950,6 +8192,42 @@ func (_m *Pipeliner) SDiff(ctx context.Context, keys ...string) *redis.StringSli return r0 } +// Pipeliner_SDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SDiff' +type Pipeliner_SDiff_Call struct { + *mock.Call +} + +// SDiff is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) SDiff(ctx interface{}, keys ...interface{}) *Pipeliner_SDiff_Call { + return &Pipeliner_SDiff_Call{Call: _e.mock.On("SDiff", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_SDiff_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_SDiff_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SDiff_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SDiff_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *Pipeliner_SDiff_Call { + _c.Call.Return(run) + return _c +} + // SDiffStore provides a mock function with given fields: ctx, destination, keys func (_m *Pipeliner) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -2973,6 +8251,43 @@ func (_m *Pipeliner) SDiffStore(ctx context.Context, destination string, keys .. return r0 } +// Pipeliner_SDiffStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SDiffStore' +type Pipeliner_SDiffStore_Call struct { + *mock.Call +} + +// SDiffStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *Pipeliner_Expecter) SDiffStore(ctx interface{}, destination interface{}, keys ...interface{}) *Pipeliner_SDiffStore_Call { + return &Pipeliner_SDiffStore_Call{Call: _e.mock.On("SDiffStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *Pipeliner_SDiffStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Pipeliner_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 *Pipeliner_SDiffStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SDiffStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SDiffStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_SDiffStore_Call { + _c.Call.Return(run) + return _c +} + // SInter provides a mock function with given fields: ctx, keys func (_m *Pipeliner) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd { _va := make([]interface{}, len(keys)) @@ -2996,6 +8311,42 @@ func (_m *Pipeliner) SInter(ctx context.Context, keys ...string) *redis.StringSl return r0 } +// Pipeliner_SInter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SInter' +type Pipeliner_SInter_Call struct { + *mock.Call +} + +// SInter is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) SInter(ctx interface{}, keys ...interface{}) *Pipeliner_SInter_Call { + return &Pipeliner_SInter_Call{Call: _e.mock.On("SInter", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_SInter_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_SInter_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SInter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SInter_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *Pipeliner_SInter_Call { + _c.Call.Return(run) + return _c +} + // SInterStore provides a mock function with given fields: ctx, destination, keys func (_m *Pipeliner) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -3019,6 +8370,43 @@ func (_m *Pipeliner) SInterStore(ctx context.Context, destination string, keys . return r0 } +// Pipeliner_SInterStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SInterStore' +type Pipeliner_SInterStore_Call struct { + *mock.Call +} + +// SInterStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *Pipeliner_Expecter) SInterStore(ctx interface{}, destination interface{}, keys ...interface{}) *Pipeliner_SInterStore_Call { + return &Pipeliner_SInterStore_Call{Call: _e.mock.On("SInterStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *Pipeliner_SInterStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Pipeliner_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 *Pipeliner_SInterStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SInterStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SInterStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_SInterStore_Call { + _c.Call.Return(run) + return _c +} + // SIsMember provides a mock function with given fields: ctx, key, member func (_m *Pipeliner) SIsMember(ctx context.Context, key string, member interface{}) *redis.BoolCmd { ret := _m.Called(ctx, key, member) @@ -3035,6 +8423,36 @@ func (_m *Pipeliner) SIsMember(ctx context.Context, key string, member interface return r0 } +// Pipeliner_SIsMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SIsMember' +type Pipeliner_SIsMember_Call struct { + *mock.Call +} + +// SIsMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member interface{} +func (_e *Pipeliner_Expecter) SIsMember(ctx interface{}, key interface{}, member interface{}) *Pipeliner_SIsMember_Call { + return &Pipeliner_SIsMember_Call{Call: _e.mock.On("SIsMember", ctx, key, member)} +} + +func (_c *Pipeliner_SIsMember_Call) Run(run func(ctx context.Context, key string, member interface{})) *Pipeliner_SIsMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(interface{})) + }) + return _c +} + +func (_c *Pipeliner_SIsMember_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_SIsMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SIsMember_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *Pipeliner_SIsMember_Call { + _c.Call.Return(run) + return _c +} + // SMIsMember provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) SMIsMember(ctx context.Context, key string, members ...interface{}) *redis.BoolSliceCmd { var _ca []interface{} @@ -3049,9 +8467,46 @@ func (_m *Pipeliner) SMIsMember(ctx context.Context, key string, members ...inte if ret.Get(0) != nil { r0 = ret.Get(0).(*redis.BoolSliceCmd) } - } + } + + return r0 +} + +// Pipeliner_SMIsMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMIsMember' +type Pipeliner_SMIsMember_Call struct { + *mock.Call +} + +// SMIsMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...interface{} +func (_e *Pipeliner_Expecter) SMIsMember(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_SMIsMember_Call { + return &Pipeliner_SMIsMember_Call{Call: _e.mock.On("SMIsMember", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_SMIsMember_Call) Run(run func(ctx context.Context, key string, members ...interface{})) *Pipeliner_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 +} - return r0 +func (_c *Pipeliner_SMIsMember_Call) Return(_a0 *redis.BoolSliceCmd) *Pipeliner_SMIsMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SMIsMember_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolSliceCmd) *Pipeliner_SMIsMember_Call { + _c.Call.Return(run) + return _c } // SMembers provides a mock function with given fields: ctx, key @@ -3070,6 +8525,35 @@ func (_m *Pipeliner) SMembers(ctx context.Context, key string) *redis.StringSlic return r0 } +// Pipeliner_SMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMembers' +type Pipeliner_SMembers_Call struct { + *mock.Call +} + +// SMembers is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) SMembers(ctx interface{}, key interface{}) *Pipeliner_SMembers_Call { + return &Pipeliner_SMembers_Call{Call: _e.mock.On("SMembers", ctx, key)} +} + +func (_c *Pipeliner_SMembers_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_SMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_SMembers_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SMembers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SMembers_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_SMembers_Call { + _c.Call.Return(run) + return _c +} + // SMembersMap provides a mock function with given fields: ctx, key func (_m *Pipeliner) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd { ret := _m.Called(ctx, key) @@ -3086,6 +8570,35 @@ func (_m *Pipeliner) SMembersMap(ctx context.Context, key string) *redis.StringS return r0 } +// Pipeliner_SMembersMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMembersMap' +type Pipeliner_SMembersMap_Call struct { + *mock.Call +} + +// SMembersMap is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) SMembersMap(ctx interface{}, key interface{}) *Pipeliner_SMembersMap_Call { + return &Pipeliner_SMembersMap_Call{Call: _e.mock.On("SMembersMap", ctx, key)} +} + +func (_c *Pipeliner_SMembersMap_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_SMembersMap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_SMembersMap_Call) Return(_a0 *redis.StringStructMapCmd) *Pipeliner_SMembersMap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SMembersMap_Call) RunAndReturn(run func(context.Context, string) *redis.StringStructMapCmd) *Pipeliner_SMembersMap_Call { + _c.Call.Return(run) + return _c +} + // SMove provides a mock function with given fields: ctx, source, destination, member func (_m *Pipeliner) SMove(ctx context.Context, source string, destination string, member interface{}) *redis.BoolCmd { ret := _m.Called(ctx, source, destination, member) @@ -3102,6 +8615,37 @@ func (_m *Pipeliner) SMove(ctx context.Context, source string, destination strin return r0 } +// Pipeliner_SMove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SMove' +type Pipeliner_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 *Pipeliner_Expecter) SMove(ctx interface{}, source interface{}, destination interface{}, member interface{}) *Pipeliner_SMove_Call { + return &Pipeliner_SMove_Call{Call: _e.mock.On("SMove", ctx, source, destination, member)} +} + +func (_c *Pipeliner_SMove_Call) Run(run func(ctx context.Context, source string, destination string, member interface{})) *Pipeliner_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 *Pipeliner_SMove_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_SMove_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SMove_Call) RunAndReturn(run func(context.Context, string, string, interface{}) *redis.BoolCmd) *Pipeliner_SMove_Call { + _c.Call.Return(run) + return _c +} + // SPop provides a mock function with given fields: ctx, key func (_m *Pipeliner) SPop(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -3118,6 +8662,35 @@ func (_m *Pipeliner) SPop(ctx context.Context, key string) *redis.StringCmd { return r0 } +// Pipeliner_SPop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SPop' +type Pipeliner_SPop_Call struct { + *mock.Call +} + +// SPop is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) SPop(ctx interface{}, key interface{}) *Pipeliner_SPop_Call { + return &Pipeliner_SPop_Call{Call: _e.mock.On("SPop", ctx, key)} +} + +func (_c *Pipeliner_SPop_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_SPop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_SPop_Call) Return(_a0 *redis.StringCmd) *Pipeliner_SPop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_SPop_Call { + _c.Call.Return(run) + return _c +} + // SPopN provides a mock function with given fields: ctx, key, count func (_m *Pipeliner) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { ret := _m.Called(ctx, key, count) @@ -3134,6 +8707,36 @@ func (_m *Pipeliner) SPopN(ctx context.Context, key string, count int64) *redis. return r0 } +// Pipeliner_SPopN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SPopN' +type Pipeliner_SPopN_Call struct { + *mock.Call +} + +// SPopN is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int64 +func (_e *Pipeliner_Expecter) SPopN(ctx interface{}, key interface{}, count interface{}) *Pipeliner_SPopN_Call { + return &Pipeliner_SPopN_Call{Call: _e.mock.On("SPopN", ctx, key, count)} +} + +func (_c *Pipeliner_SPopN_Call) Run(run func(ctx context.Context, key string, count int64)) *Pipeliner_SPopN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_SPopN_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SPopN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SPopN_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringSliceCmd) *Pipeliner_SPopN_Call { + _c.Call.Return(run) + return _c +} + // SRandMember provides a mock function with given fields: ctx, key func (_m *Pipeliner) SRandMember(ctx context.Context, key string) *redis.StringCmd { ret := _m.Called(ctx, key) @@ -3150,6 +8753,35 @@ func (_m *Pipeliner) SRandMember(ctx context.Context, key string) *redis.StringC return r0 } +// Pipeliner_SRandMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SRandMember' +type Pipeliner_SRandMember_Call struct { + *mock.Call +} + +// SRandMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) SRandMember(ctx interface{}, key interface{}) *Pipeliner_SRandMember_Call { + return &Pipeliner_SRandMember_Call{Call: _e.mock.On("SRandMember", ctx, key)} +} + +func (_c *Pipeliner_SRandMember_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_SRandMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_SRandMember_Call) Return(_a0 *redis.StringCmd) *Pipeliner_SRandMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SRandMember_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_SRandMember_Call { + _c.Call.Return(run) + return _c +} + // SRandMemberN provides a mock function with given fields: ctx, key, count func (_m *Pipeliner) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { ret := _m.Called(ctx, key, count) @@ -3166,6 +8798,36 @@ func (_m *Pipeliner) SRandMemberN(ctx context.Context, key string, count int64) return r0 } +// Pipeliner_SRandMemberN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SRandMemberN' +type Pipeliner_SRandMemberN_Call struct { + *mock.Call +} + +// SRandMemberN is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int64 +func (_e *Pipeliner_Expecter) SRandMemberN(ctx interface{}, key interface{}, count interface{}) *Pipeliner_SRandMemberN_Call { + return &Pipeliner_SRandMemberN_Call{Call: _e.mock.On("SRandMemberN", ctx, key, count)} +} + +func (_c *Pipeliner_SRandMemberN_Call) Run(run func(ctx context.Context, key string, count int64)) *Pipeliner_SRandMemberN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_SRandMemberN_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SRandMemberN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SRandMemberN_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringSliceCmd) *Pipeliner_SRandMemberN_Call { + _c.Call.Return(run) + return _c +} + // SRem provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) SRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -3185,6 +8847,43 @@ func (_m *Pipeliner) SRem(ctx context.Context, key string, members ...interface{ return r0 } +// Pipeliner_SRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SRem' +type Pipeliner_SRem_Call struct { + *mock.Call +} + +// SRem is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...interface{} +func (_e *Pipeliner_Expecter) SRem(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_SRem_Call { + return &Pipeliner_SRem_Call{Call: _e.mock.On("SRem", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_SRem_Call) Run(run func(ctx context.Context, key string, members ...interface{})) *Pipeliner_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 *Pipeliner_SRem_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SRem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SRem_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_SRem_Call { + _c.Call.Return(run) + return _c +} + // SScan provides a mock function with given fields: ctx, key, cursor, match, count func (_m *Pipeliner) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { ret := _m.Called(ctx, key, cursor, match, count) @@ -3201,6 +8900,38 @@ func (_m *Pipeliner) SScan(ctx context.Context, key string, cursor uint64, match return r0 } +// Pipeliner_SScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SScan' +type Pipeliner_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 *Pipeliner_Expecter) SScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *Pipeliner_SScan_Call { + return &Pipeliner_SScan_Call{Call: _e.mock.On("SScan", ctx, key, cursor, match, count)} +} + +func (_c *Pipeliner_SScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *Pipeliner_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 *Pipeliner_SScan_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_SScan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *Pipeliner_SScan_Call { + _c.Call.Return(run) + return _c +} + // SUnion provides a mock function with given fields: ctx, keys func (_m *Pipeliner) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd { _va := make([]interface{}, len(keys)) @@ -3224,6 +8955,42 @@ func (_m *Pipeliner) SUnion(ctx context.Context, keys ...string) *redis.StringSl return r0 } +// Pipeliner_SUnion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SUnion' +type Pipeliner_SUnion_Call struct { + *mock.Call +} + +// SUnion is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) SUnion(ctx interface{}, keys ...interface{}) *Pipeliner_SUnion_Call { + return &Pipeliner_SUnion_Call{Call: _e.mock.On("SUnion", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_SUnion_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_SUnion_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SUnion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SUnion_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *Pipeliner_SUnion_Call { + _c.Call.Return(run) + return _c +} + // SUnionStore provides a mock function with given fields: ctx, destination, keys func (_m *Pipeliner) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -3247,6 +9014,43 @@ func (_m *Pipeliner) SUnionStore(ctx context.Context, destination string, keys . return r0 } +// Pipeliner_SUnionStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SUnionStore' +type Pipeliner_SUnionStore_Call struct { + *mock.Call +} + +// SUnionStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *Pipeliner_Expecter) SUnionStore(ctx interface{}, destination interface{}, keys ...interface{}) *Pipeliner_SUnionStore_Call { + return &Pipeliner_SUnionStore_Call{Call: _e.mock.On("SUnionStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *Pipeliner_SUnionStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Pipeliner_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 *Pipeliner_SUnionStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SUnionStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SUnionStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_SUnionStore_Call { + _c.Call.Return(run) + return _c +} + // Save provides a mock function with given fields: ctx func (_m *Pipeliner) Save(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -3263,6 +9067,34 @@ func (_m *Pipeliner) Save(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save' +type Pipeliner_Save_Call struct { + *mock.Call +} + +// Save is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) Save(ctx interface{}) *Pipeliner_Save_Call { + return &Pipeliner_Save_Call{Call: _e.mock.On("Save", ctx)} +} + +func (_c *Pipeliner_Save_Call) Run(run func(ctx context.Context)) *Pipeliner_Save_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_Save_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Save_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Save_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_Save_Call { + _c.Call.Return(run) + return _c +} + // Scan provides a mock function with given fields: ctx, cursor, match, count func (_m *Pipeliner) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd { ret := _m.Called(ctx, cursor, match, count) @@ -3279,6 +9111,37 @@ func (_m *Pipeliner) Scan(ctx context.Context, cursor uint64, match string, coun return r0 } +// Pipeliner_Scan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Scan' +type Pipeliner_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 *Pipeliner_Expecter) Scan(ctx interface{}, cursor interface{}, match interface{}, count interface{}) *Pipeliner_Scan_Call { + return &Pipeliner_Scan_Call{Call: _e.mock.On("Scan", ctx, cursor, match, count)} +} + +func (_c *Pipeliner_Scan_Call) Run(run func(ctx context.Context, cursor uint64, match string, count int64)) *Pipeliner_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 *Pipeliner_Scan_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_Scan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Scan_Call) RunAndReturn(run func(context.Context, uint64, string, int64) *redis.ScanCmd) *Pipeliner_Scan_Call { + _c.Call.Return(run) + return _c +} + // ScanType provides a mock function with given fields: ctx, cursor, match, count, keyType func (_m *Pipeliner) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd { ret := _m.Called(ctx, cursor, match, count, keyType) @@ -3295,6 +9158,38 @@ func (_m *Pipeliner) ScanType(ctx context.Context, cursor uint64, match string, return r0 } +// Pipeliner_ScanType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanType' +type Pipeliner_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 *Pipeliner_Expecter) ScanType(ctx interface{}, cursor interface{}, match interface{}, count interface{}, keyType interface{}) *Pipeliner_ScanType_Call { + return &Pipeliner_ScanType_Call{Call: _e.mock.On("ScanType", ctx, cursor, match, count, keyType)} +} + +func (_c *Pipeliner_ScanType_Call) Run(run func(ctx context.Context, cursor uint64, match string, count int64, keyType string)) *Pipeliner_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 *Pipeliner_ScanType_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_ScanType_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ScanType_Call) RunAndReturn(run func(context.Context, uint64, string, int64, string) *redis.ScanCmd) *Pipeliner_ScanType_Call { + _c.Call.Return(run) + return _c +} + // ScriptExists provides a mock function with given fields: ctx, hashes func (_m *Pipeliner) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd { _va := make([]interface{}, len(hashes)) @@ -3318,6 +9213,42 @@ func (_m *Pipeliner) ScriptExists(ctx context.Context, hashes ...string) *redis. return r0 } +// Pipeliner_ScriptExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptExists' +type Pipeliner_ScriptExists_Call struct { + *mock.Call +} + +// ScriptExists is a helper method to define mock.On call +// - ctx context.Context +// - hashes ...string +func (_e *Pipeliner_Expecter) ScriptExists(ctx interface{}, hashes ...interface{}) *Pipeliner_ScriptExists_Call { + return &Pipeliner_ScriptExists_Call{Call: _e.mock.On("ScriptExists", + append([]interface{}{ctx}, hashes...)...)} +} + +func (_c *Pipeliner_ScriptExists_Call) Run(run func(ctx context.Context, hashes ...string)) *Pipeliner_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 *Pipeliner_ScriptExists_Call) Return(_a0 *redis.BoolSliceCmd) *Pipeliner_ScriptExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ScriptExists_Call) RunAndReturn(run func(context.Context, ...string) *redis.BoolSliceCmd) *Pipeliner_ScriptExists_Call { + _c.Call.Return(run) + return _c +} + // ScriptFlush provides a mock function with given fields: ctx func (_m *Pipeliner) ScriptFlush(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -3334,6 +9265,34 @@ func (_m *Pipeliner) ScriptFlush(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ScriptFlush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptFlush' +type Pipeliner_ScriptFlush_Call struct { + *mock.Call +} + +// ScriptFlush is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ScriptFlush(ctx interface{}) *Pipeliner_ScriptFlush_Call { + return &Pipeliner_ScriptFlush_Call{Call: _e.mock.On("ScriptFlush", ctx)} +} + +func (_c *Pipeliner_ScriptFlush_Call) Run(run func(ctx context.Context)) *Pipeliner_ScriptFlush_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ScriptFlush_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ScriptFlush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ScriptFlush_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ScriptFlush_Call { + _c.Call.Return(run) + return _c +} + // ScriptKill provides a mock function with given fields: ctx func (_m *Pipeliner) ScriptKill(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -3350,6 +9309,34 @@ func (_m *Pipeliner) ScriptKill(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ScriptKill_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptKill' +type Pipeliner_ScriptKill_Call struct { + *mock.Call +} + +// ScriptKill is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ScriptKill(ctx interface{}) *Pipeliner_ScriptKill_Call { + return &Pipeliner_ScriptKill_Call{Call: _e.mock.On("ScriptKill", ctx)} +} + +func (_c *Pipeliner_ScriptKill_Call) Run(run func(ctx context.Context)) *Pipeliner_ScriptKill_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ScriptKill_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ScriptKill_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ScriptKill_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ScriptKill_Call { + _c.Call.Return(run) + return _c +} + // ScriptLoad provides a mock function with given fields: ctx, script func (_m *Pipeliner) ScriptLoad(ctx context.Context, script string) *redis.StringCmd { ret := _m.Called(ctx, script) @@ -3366,6 +9353,35 @@ func (_m *Pipeliner) ScriptLoad(ctx context.Context, script string) *redis.Strin return r0 } +// Pipeliner_ScriptLoad_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptLoad' +type Pipeliner_ScriptLoad_Call struct { + *mock.Call +} + +// ScriptLoad is a helper method to define mock.On call +// - ctx context.Context +// - script string +func (_e *Pipeliner_Expecter) ScriptLoad(ctx interface{}, script interface{}) *Pipeliner_ScriptLoad_Call { + return &Pipeliner_ScriptLoad_Call{Call: _e.mock.On("ScriptLoad", ctx, script)} +} + +func (_c *Pipeliner_ScriptLoad_Call) Run(run func(ctx context.Context, script string)) *Pipeliner_ScriptLoad_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ScriptLoad_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ScriptLoad_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ScriptLoad_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_ScriptLoad_Call { + _c.Call.Return(run) + return _c +} + // Select provides a mock function with given fields: ctx, index func (_m *Pipeliner) Select(ctx context.Context, index int) *redis.StatusCmd { ret := _m.Called(ctx, index) @@ -3382,6 +9398,35 @@ func (_m *Pipeliner) Select(ctx context.Context, index int) *redis.StatusCmd { return r0 } +// Pipeliner_Select_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Select' +type Pipeliner_Select_Call struct { + *mock.Call +} + +// Select is a helper method to define mock.On call +// - ctx context.Context +// - index int +func (_e *Pipeliner_Expecter) Select(ctx interface{}, index interface{}) *Pipeliner_Select_Call { + return &Pipeliner_Select_Call{Call: _e.mock.On("Select", ctx, index)} +} + +func (_c *Pipeliner_Select_Call) Run(run func(ctx context.Context, index int)) *Pipeliner_Select_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int)) + }) + return _c +} + +func (_c *Pipeliner_Select_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Select_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Select_Call) RunAndReturn(run func(context.Context, int) *redis.StatusCmd) *Pipeliner_Select_Call { + _c.Call.Return(run) + return _c +} + // Set provides a mock function with given fields: ctx, key, value, expiration func (_m *Pipeliner) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd { ret := _m.Called(ctx, key, value, expiration) @@ -3398,6 +9443,37 @@ func (_m *Pipeliner) Set(ctx context.Context, key string, value interface{}, exp return r0 } +// Pipeliner_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set' +type Pipeliner_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 *Pipeliner_Expecter) Set(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *Pipeliner_Set_Call { + return &Pipeliner_Set_Call{Call: _e.mock.On("Set", ctx, key, value, expiration)} +} + +func (_c *Pipeliner_Set_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *Pipeliner_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 *Pipeliner_Set_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Set_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Set_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.StatusCmd) *Pipeliner_Set_Call { + _c.Call.Return(run) + return _c +} + // SetArgs provides a mock function with given fields: ctx, key, value, a func (_m *Pipeliner) SetArgs(ctx context.Context, key string, value interface{}, a redis.SetArgs) *redis.StatusCmd { ret := _m.Called(ctx, key, value, a) @@ -3414,6 +9490,37 @@ func (_m *Pipeliner) SetArgs(ctx context.Context, key string, value interface{}, return r0 } +// Pipeliner_SetArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetArgs' +type Pipeliner_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 *Pipeliner_Expecter) SetArgs(ctx interface{}, key interface{}, value interface{}, a interface{}) *Pipeliner_SetArgs_Call { + return &Pipeliner_SetArgs_Call{Call: _e.mock.On("SetArgs", ctx, key, value, a)} +} + +func (_c *Pipeliner_SetArgs_Call) Run(run func(ctx context.Context, key string, value interface{}, a redis.SetArgs)) *Pipeliner_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 *Pipeliner_SetArgs_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_SetArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SetArgs_Call) RunAndReturn(run func(context.Context, string, interface{}, redis.SetArgs) *redis.StatusCmd) *Pipeliner_SetArgs_Call { + _c.Call.Return(run) + return _c +} + // SetBit provides a mock function with given fields: ctx, key, offset, value func (_m *Pipeliner) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd { ret := _m.Called(ctx, key, offset, value) @@ -3430,6 +9537,37 @@ func (_m *Pipeliner) SetBit(ctx context.Context, key string, offset int64, value return r0 } +// Pipeliner_SetBit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBit' +type Pipeliner_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 *Pipeliner_Expecter) SetBit(ctx interface{}, key interface{}, offset interface{}, value interface{}) *Pipeliner_SetBit_Call { + return &Pipeliner_SetBit_Call{Call: _e.mock.On("SetBit", ctx, key, offset, value)} +} + +func (_c *Pipeliner_SetBit_Call) Run(run func(ctx context.Context, key string, offset int64, value int)) *Pipeliner_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 *Pipeliner_SetBit_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SetBit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SetBit_Call) RunAndReturn(run func(context.Context, string, int64, int) *redis.IntCmd) *Pipeliner_SetBit_Call { + _c.Call.Return(run) + return _c +} + // SetEX provides a mock function with given fields: ctx, key, value, expiration func (_m *Pipeliner) SetEX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd { ret := _m.Called(ctx, key, value, expiration) @@ -3446,6 +9584,37 @@ func (_m *Pipeliner) SetEX(ctx context.Context, key string, value interface{}, e return r0 } +// Pipeliner_SetEX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEX' +type Pipeliner_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 *Pipeliner_Expecter) SetEX(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *Pipeliner_SetEX_Call { + return &Pipeliner_SetEX_Call{Call: _e.mock.On("SetEX", ctx, key, value, expiration)} +} + +func (_c *Pipeliner_SetEX_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *Pipeliner_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 *Pipeliner_SetEX_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_SetEX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SetEX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.StatusCmd) *Pipeliner_SetEX_Call { + _c.Call.Return(run) + return _c +} + // SetNX provides a mock function with given fields: ctx, key, value, expiration func (_m *Pipeliner) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd { ret := _m.Called(ctx, key, value, expiration) @@ -3462,6 +9631,37 @@ func (_m *Pipeliner) SetNX(ctx context.Context, key string, value interface{}, e return r0 } +// Pipeliner_SetNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNX' +type Pipeliner_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 *Pipeliner_Expecter) SetNX(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *Pipeliner_SetNX_Call { + return &Pipeliner_SetNX_Call{Call: _e.mock.On("SetNX", ctx, key, value, expiration)} +} + +func (_c *Pipeliner_SetNX_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *Pipeliner_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 *Pipeliner_SetNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_SetNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SetNX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.BoolCmd) *Pipeliner_SetNX_Call { + _c.Call.Return(run) + return _c +} + // SetRange provides a mock function with given fields: ctx, key, offset, value func (_m *Pipeliner) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd { ret := _m.Called(ctx, key, offset, value) @@ -3475,7 +9675,38 @@ func (_m *Pipeliner) SetRange(ctx context.Context, key string, offset int64, val } } - return r0 + return r0 +} + +// Pipeliner_SetRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetRange' +type Pipeliner_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 *Pipeliner_Expecter) SetRange(ctx interface{}, key interface{}, offset interface{}, value interface{}) *Pipeliner_SetRange_Call { + return &Pipeliner_SetRange_Call{Call: _e.mock.On("SetRange", ctx, key, offset, value)} +} + +func (_c *Pipeliner_SetRange_Call) Run(run func(ctx context.Context, key string, offset int64, value string)) *Pipeliner_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 *Pipeliner_SetRange_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SetRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SetRange_Call) RunAndReturn(run func(context.Context, string, int64, string) *redis.IntCmd) *Pipeliner_SetRange_Call { + _c.Call.Return(run) + return _c } // SetXX provides a mock function with given fields: ctx, key, value, expiration @@ -3494,6 +9725,37 @@ func (_m *Pipeliner) SetXX(ctx context.Context, key string, value interface{}, e return r0 } +// Pipeliner_SetXX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetXX' +type Pipeliner_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 *Pipeliner_Expecter) SetXX(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *Pipeliner_SetXX_Call { + return &Pipeliner_SetXX_Call{Call: _e.mock.On("SetXX", ctx, key, value, expiration)} +} + +func (_c *Pipeliner_SetXX_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *Pipeliner_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 *Pipeliner_SetXX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_SetXX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SetXX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.BoolCmd) *Pipeliner_SetXX_Call { + _c.Call.Return(run) + return _c +} + // Shutdown provides a mock function with given fields: ctx func (_m *Pipeliner) Shutdown(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -3510,6 +9772,34 @@ func (_m *Pipeliner) Shutdown(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown' +type Pipeliner_Shutdown_Call struct { + *mock.Call +} + +// Shutdown is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) Shutdown(ctx interface{}) *Pipeliner_Shutdown_Call { + return &Pipeliner_Shutdown_Call{Call: _e.mock.On("Shutdown", ctx)} +} + +func (_c *Pipeliner_Shutdown_Call) Run(run func(ctx context.Context)) *Pipeliner_Shutdown_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_Shutdown_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Shutdown_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Shutdown_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_Shutdown_Call { + _c.Call.Return(run) + return _c +} + // ShutdownNoSave provides a mock function with given fields: ctx func (_m *Pipeliner) ShutdownNoSave(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -3526,6 +9816,34 @@ func (_m *Pipeliner) ShutdownNoSave(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ShutdownNoSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShutdownNoSave' +type Pipeliner_ShutdownNoSave_Call struct { + *mock.Call +} + +// ShutdownNoSave is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ShutdownNoSave(ctx interface{}) *Pipeliner_ShutdownNoSave_Call { + return &Pipeliner_ShutdownNoSave_Call{Call: _e.mock.On("ShutdownNoSave", ctx)} +} + +func (_c *Pipeliner_ShutdownNoSave_Call) Run(run func(ctx context.Context)) *Pipeliner_ShutdownNoSave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ShutdownNoSave_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ShutdownNoSave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ShutdownNoSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ShutdownNoSave_Call { + _c.Call.Return(run) + return _c +} + // ShutdownSave provides a mock function with given fields: ctx func (_m *Pipeliner) ShutdownSave(ctx context.Context) *redis.StatusCmd { ret := _m.Called(ctx) @@ -3542,6 +9860,34 @@ func (_m *Pipeliner) ShutdownSave(ctx context.Context) *redis.StatusCmd { return r0 } +// Pipeliner_ShutdownSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShutdownSave' +type Pipeliner_ShutdownSave_Call struct { + *mock.Call +} + +// ShutdownSave is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) ShutdownSave(ctx interface{}) *Pipeliner_ShutdownSave_Call { + return &Pipeliner_ShutdownSave_Call{Call: _e.mock.On("ShutdownSave", ctx)} +} + +func (_c *Pipeliner_ShutdownSave_Call) Run(run func(ctx context.Context)) *Pipeliner_ShutdownSave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_ShutdownSave_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ShutdownSave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ShutdownSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ShutdownSave_Call { + _c.Call.Return(run) + return _c +} + // SlaveOf provides a mock function with given fields: ctx, host, port func (_m *Pipeliner) SlaveOf(ctx context.Context, host string, port string) *redis.StatusCmd { ret := _m.Called(ctx, host, port) @@ -3558,6 +9904,36 @@ func (_m *Pipeliner) SlaveOf(ctx context.Context, host string, port string) *red return r0 } +// Pipeliner_SlaveOf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlaveOf' +type Pipeliner_SlaveOf_Call struct { + *mock.Call +} + +// SlaveOf is a helper method to define mock.On call +// - ctx context.Context +// - host string +// - port string +func (_e *Pipeliner_Expecter) SlaveOf(ctx interface{}, host interface{}, port interface{}) *Pipeliner_SlaveOf_Call { + return &Pipeliner_SlaveOf_Call{Call: _e.mock.On("SlaveOf", ctx, host, port)} +} + +func (_c *Pipeliner_SlaveOf_Call) Run(run func(ctx context.Context, host string, port string)) *Pipeliner_SlaveOf_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_SlaveOf_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_SlaveOf_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SlaveOf_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_SlaveOf_Call { + _c.Call.Return(run) + return _c +} + // Sort provides a mock function with given fields: ctx, key, sort func (_m *Pipeliner) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { ret := _m.Called(ctx, key, sort) @@ -3574,6 +9950,36 @@ func (_m *Pipeliner) Sort(ctx context.Context, key string, sort *redis.Sort) *re return r0 } +// Pipeliner_Sort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sort' +type Pipeliner_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 *Pipeliner_Expecter) Sort(ctx interface{}, key interface{}, sort interface{}) *Pipeliner_Sort_Call { + return &Pipeliner_Sort_Call{Call: _e.mock.On("Sort", ctx, key, sort)} +} + +func (_c *Pipeliner_Sort_Call) Run(run func(ctx context.Context, key string, sort *redis.Sort)) *Pipeliner_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 *Pipeliner_Sort_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_Sort_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Sort_Call) RunAndReturn(run func(context.Context, string, *redis.Sort) *redis.StringSliceCmd) *Pipeliner_Sort_Call { + _c.Call.Return(run) + return _c +} + // SortInterfaces provides a mock function with given fields: ctx, key, sort func (_m *Pipeliner) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd { ret := _m.Called(ctx, key, sort) @@ -3590,6 +9996,36 @@ func (_m *Pipeliner) SortInterfaces(ctx context.Context, key string, sort *redis return r0 } +// Pipeliner_SortInterfaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SortInterfaces' +type Pipeliner_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 *Pipeliner_Expecter) SortInterfaces(ctx interface{}, key interface{}, sort interface{}) *Pipeliner_SortInterfaces_Call { + return &Pipeliner_SortInterfaces_Call{Call: _e.mock.On("SortInterfaces", ctx, key, sort)} +} + +func (_c *Pipeliner_SortInterfaces_Call) Run(run func(ctx context.Context, key string, sort *redis.Sort)) *Pipeliner_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 *Pipeliner_SortInterfaces_Call) Return(_a0 *redis.SliceCmd) *Pipeliner_SortInterfaces_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SortInterfaces_Call) RunAndReturn(run func(context.Context, string, *redis.Sort) *redis.SliceCmd) *Pipeliner_SortInterfaces_Call { + _c.Call.Return(run) + return _c +} + // SortStore provides a mock function with given fields: ctx, key, store, sort func (_m *Pipeliner) SortStore(ctx context.Context, key string, store string, sort *redis.Sort) *redis.IntCmd { ret := _m.Called(ctx, key, store, sort) @@ -3606,6 +10042,37 @@ func (_m *Pipeliner) SortStore(ctx context.Context, key string, store string, so return r0 } +// Pipeliner_SortStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SortStore' +type Pipeliner_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 *Pipeliner_Expecter) SortStore(ctx interface{}, key interface{}, store interface{}, sort interface{}) *Pipeliner_SortStore_Call { + return &Pipeliner_SortStore_Call{Call: _e.mock.On("SortStore", ctx, key, store, sort)} +} + +func (_c *Pipeliner_SortStore_Call) Run(run func(ctx context.Context, key string, store string, sort *redis.Sort)) *Pipeliner_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 *Pipeliner_SortStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SortStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SortStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.Sort) *redis.IntCmd) *Pipeliner_SortStore_Call { + _c.Call.Return(run) + return _c +} + // StrLen provides a mock function with given fields: ctx, key func (_m *Pipeliner) StrLen(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -3622,6 +10089,35 @@ func (_m *Pipeliner) StrLen(ctx context.Context, key string) *redis.IntCmd { return r0 } +// Pipeliner_StrLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StrLen' +type Pipeliner_StrLen_Call struct { + *mock.Call +} + +// StrLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) StrLen(ctx interface{}, key interface{}) *Pipeliner_StrLen_Call { + return &Pipeliner_StrLen_Call{Call: _e.mock.On("StrLen", ctx, key)} +} + +func (_c *Pipeliner_StrLen_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_StrLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_StrLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_StrLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_StrLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_StrLen_Call { + _c.Call.Return(run) + return _c +} + // SwapDB provides a mock function with given fields: ctx, index1, index2 func (_m *Pipeliner) SwapDB(ctx context.Context, index1 int, index2 int) *redis.StatusCmd { ret := _m.Called(ctx, index1, index2) @@ -3638,6 +10134,36 @@ func (_m *Pipeliner) SwapDB(ctx context.Context, index1 int, index2 int) *redis. return r0 } +// Pipeliner_SwapDB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwapDB' +type Pipeliner_SwapDB_Call struct { + *mock.Call +} + +// SwapDB is a helper method to define mock.On call +// - ctx context.Context +// - index1 int +// - index2 int +func (_e *Pipeliner_Expecter) SwapDB(ctx interface{}, index1 interface{}, index2 interface{}) *Pipeliner_SwapDB_Call { + return &Pipeliner_SwapDB_Call{Call: _e.mock.On("SwapDB", ctx, index1, index2)} +} + +func (_c *Pipeliner_SwapDB_Call) Run(run func(ctx context.Context, index1 int, index2 int)) *Pipeliner_SwapDB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *Pipeliner_SwapDB_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_SwapDB_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_SwapDB_Call) RunAndReturn(run func(context.Context, int, int) *redis.StatusCmd) *Pipeliner_SwapDB_Call { + _c.Call.Return(run) + return _c +} + // TTL provides a mock function with given fields: ctx, key func (_m *Pipeliner) TTL(ctx context.Context, key string) *redis.DurationCmd { ret := _m.Called(ctx, key) @@ -3654,6 +10180,35 @@ func (_m *Pipeliner) TTL(ctx context.Context, key string) *redis.DurationCmd { return r0 } +// Pipeliner_TTL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TTL' +type Pipeliner_TTL_Call struct { + *mock.Call +} + +// TTL is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) TTL(ctx interface{}, key interface{}) *Pipeliner_TTL_Call { + return &Pipeliner_TTL_Call{Call: _e.mock.On("TTL", ctx, key)} +} + +func (_c *Pipeliner_TTL_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_TTL_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_TTL_Call) Return(_a0 *redis.DurationCmd) *Pipeliner_TTL_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_TTL_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *Pipeliner_TTL_Call { + _c.Call.Return(run) + return _c +} + // Time provides a mock function with given fields: ctx func (_m *Pipeliner) Time(ctx context.Context) *redis.TimeCmd { ret := _m.Called(ctx) @@ -3670,6 +10225,34 @@ func (_m *Pipeliner) Time(ctx context.Context) *redis.TimeCmd { return r0 } +// Pipeliner_Time_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Time' +type Pipeliner_Time_Call struct { + *mock.Call +} + +// Time is a helper method to define mock.On call +// - ctx context.Context +func (_e *Pipeliner_Expecter) Time(ctx interface{}) *Pipeliner_Time_Call { + return &Pipeliner_Time_Call{Call: _e.mock.On("Time", ctx)} +} + +func (_c *Pipeliner_Time_Call) Run(run func(ctx context.Context)) *Pipeliner_Time_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Pipeliner_Time_Call) Return(_a0 *redis.TimeCmd) *Pipeliner_Time_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Time_Call) RunAndReturn(run func(context.Context) *redis.TimeCmd) *Pipeliner_Time_Call { + _c.Call.Return(run) + return _c +} + // Touch provides a mock function with given fields: ctx, keys func (_m *Pipeliner) Touch(ctx context.Context, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -3693,6 +10276,42 @@ func (_m *Pipeliner) Touch(ctx context.Context, keys ...string) *redis.IntCmd { return r0 } +// Pipeliner_Touch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Touch' +type Pipeliner_Touch_Call struct { + *mock.Call +} + +// Touch is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) Touch(ctx interface{}, keys ...interface{}) *Pipeliner_Touch_Call { + return &Pipeliner_Touch_Call{Call: _e.mock.On("Touch", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_Touch_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_Touch_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Touch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Touch_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_Touch_Call { + _c.Call.Return(run) + return _c +} + // TxPipeline provides a mock function with given fields: func (_m *Pipeliner) TxPipeline() redis.Pipeliner { ret := _m.Called() @@ -3709,6 +10328,33 @@ func (_m *Pipeliner) TxPipeline() redis.Pipeliner { return r0 } +// Pipeliner_TxPipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxPipeline' +type Pipeliner_TxPipeline_Call struct { + *mock.Call +} + +// TxPipeline is a helper method to define mock.On call +func (_e *Pipeliner_Expecter) TxPipeline() *Pipeliner_TxPipeline_Call { + return &Pipeliner_TxPipeline_Call{Call: _e.mock.On("TxPipeline")} +} + +func (_c *Pipeliner_TxPipeline_Call) Run(run func()) *Pipeliner_TxPipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Pipeliner_TxPipeline_Call) Return(_a0 redis.Pipeliner) *Pipeliner_TxPipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_TxPipeline_Call) RunAndReturn(run func() redis.Pipeliner) *Pipeliner_TxPipeline_Call { + _c.Call.Return(run) + return _c +} + // TxPipelined provides a mock function with given fields: ctx, fn func (_m *Pipeliner) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { ret := _m.Called(ctx, fn) @@ -3735,6 +10381,35 @@ func (_m *Pipeliner) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) e return r0, r1 } +// Pipeliner_TxPipelined_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxPipelined' +type Pipeliner_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 *Pipeliner_Expecter) TxPipelined(ctx interface{}, fn interface{}) *Pipeliner_TxPipelined_Call { + return &Pipeliner_TxPipelined_Call{Call: _e.mock.On("TxPipelined", ctx, fn)} +} + +func (_c *Pipeliner_TxPipelined_Call) Run(run func(ctx context.Context, fn func(redis.Pipeliner) error)) *Pipeliner_TxPipelined_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(func(redis.Pipeliner) error)) + }) + return _c +} + +func (_c *Pipeliner_TxPipelined_Call) Return(_a0 []redis.Cmder, _a1 error) *Pipeliner_TxPipelined_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Pipeliner_TxPipelined_Call) RunAndReturn(run func(context.Context, func(redis.Pipeliner) error) ([]redis.Cmder, error)) *Pipeliner_TxPipelined_Call { + _c.Call.Return(run) + return _c +} + // Type provides a mock function with given fields: ctx, key func (_m *Pipeliner) Type(ctx context.Context, key string) *redis.StatusCmd { ret := _m.Called(ctx, key) @@ -3751,6 +10426,35 @@ func (_m *Pipeliner) Type(ctx context.Context, key string) *redis.StatusCmd { return r0 } +// Pipeliner_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type' +type Pipeliner_Type_Call struct { + *mock.Call +} + +// Type is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) Type(ctx interface{}, key interface{}) *Pipeliner_Type_Call { + return &Pipeliner_Type_Call{Call: _e.mock.On("Type", ctx, key)} +} + +func (_c *Pipeliner_Type_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_Type_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_Type_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Type_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Type_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_Type_Call { + _c.Call.Return(run) + return _c +} + // Unlink provides a mock function with given fields: ctx, keys func (_m *Pipeliner) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -3774,6 +10478,42 @@ func (_m *Pipeliner) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { return r0 } +// Pipeliner_Unlink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unlink' +type Pipeliner_Unlink_Call struct { + *mock.Call +} + +// Unlink is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) Unlink(ctx interface{}, keys ...interface{}) *Pipeliner_Unlink_Call { + return &Pipeliner_Unlink_Call{Call: _e.mock.On("Unlink", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_Unlink_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_Unlink_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Unlink_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_Unlink_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_Unlink_Call { + _c.Call.Return(run) + return _c +} + // XAck provides a mock function with given fields: ctx, stream, group, ids func (_m *Pipeliner) XAck(ctx context.Context, stream string, group string, ids ...string) *redis.IntCmd { _va := make([]interface{}, len(ids)) @@ -3797,6 +10537,44 @@ func (_m *Pipeliner) XAck(ctx context.Context, stream string, group string, ids return r0 } +// Pipeliner_XAck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XAck' +type Pipeliner_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 *Pipeliner_Expecter) XAck(ctx interface{}, stream interface{}, group interface{}, ids ...interface{}) *Pipeliner_XAck_Call { + return &Pipeliner_XAck_Call{Call: _e.mock.On("XAck", + append([]interface{}{ctx, stream, group}, ids...)...)} +} + +func (_c *Pipeliner_XAck_Call) Run(run func(ctx context.Context, stream string, group string, ids ...string)) *Pipeliner_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 *Pipeliner_XAck_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XAck_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XAck_Call) RunAndReturn(run func(context.Context, string, string, ...string) *redis.IntCmd) *Pipeliner_XAck_Call { + _c.Call.Return(run) + return _c +} + // XAdd provides a mock function with given fields: ctx, a func (_m *Pipeliner) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd { ret := _m.Called(ctx, a) @@ -3813,6 +10591,35 @@ func (_m *Pipeliner) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringC return r0 } +// Pipeliner_XAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XAdd' +type Pipeliner_XAdd_Call struct { + *mock.Call +} + +// XAdd is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XAddArgs +func (_e *Pipeliner_Expecter) XAdd(ctx interface{}, a interface{}) *Pipeliner_XAdd_Call { + return &Pipeliner_XAdd_Call{Call: _e.mock.On("XAdd", ctx, a)} +} + +func (_c *Pipeliner_XAdd_Call) Run(run func(ctx context.Context, a *redis.XAddArgs)) *Pipeliner_XAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XAddArgs)) + }) + return _c +} + +func (_c *Pipeliner_XAdd_Call) Return(_a0 *redis.StringCmd) *Pipeliner_XAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XAdd_Call) RunAndReturn(run func(context.Context, *redis.XAddArgs) *redis.StringCmd) *Pipeliner_XAdd_Call { + _c.Call.Return(run) + return _c +} + // XAutoClaim provides a mock function with given fields: ctx, a func (_m *Pipeliner) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { ret := _m.Called(ctx, a) @@ -3829,6 +10636,35 @@ func (_m *Pipeliner) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *r return r0 } +// Pipeliner_XAutoClaim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XAutoClaim' +type Pipeliner_XAutoClaim_Call struct { + *mock.Call +} + +// XAutoClaim is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XAutoClaimArgs +func (_e *Pipeliner_Expecter) XAutoClaim(ctx interface{}, a interface{}) *Pipeliner_XAutoClaim_Call { + return &Pipeliner_XAutoClaim_Call{Call: _e.mock.On("XAutoClaim", ctx, a)} +} + +func (_c *Pipeliner_XAutoClaim_Call) Run(run func(ctx context.Context, a *redis.XAutoClaimArgs)) *Pipeliner_XAutoClaim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XAutoClaimArgs)) + }) + return _c +} + +func (_c *Pipeliner_XAutoClaim_Call) Return(_a0 *redis.XAutoClaimCmd) *Pipeliner_XAutoClaim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XAutoClaim_Call) RunAndReturn(run func(context.Context, *redis.XAutoClaimArgs) *redis.XAutoClaimCmd) *Pipeliner_XAutoClaim_Call { + _c.Call.Return(run) + return _c +} + // XAutoClaimJustID provides a mock function with given fields: ctx, a func (_m *Pipeliner) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { ret := _m.Called(ctx, a) @@ -3845,6 +10681,35 @@ func (_m *Pipeliner) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimAr return r0 } +// Pipeliner_XAutoClaimJustID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XAutoClaimJustID' +type Pipeliner_XAutoClaimJustID_Call struct { + *mock.Call +} + +// XAutoClaimJustID is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XAutoClaimArgs +func (_e *Pipeliner_Expecter) XAutoClaimJustID(ctx interface{}, a interface{}) *Pipeliner_XAutoClaimJustID_Call { + return &Pipeliner_XAutoClaimJustID_Call{Call: _e.mock.On("XAutoClaimJustID", ctx, a)} +} + +func (_c *Pipeliner_XAutoClaimJustID_Call) Run(run func(ctx context.Context, a *redis.XAutoClaimArgs)) *Pipeliner_XAutoClaimJustID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XAutoClaimArgs)) + }) + return _c +} + +func (_c *Pipeliner_XAutoClaimJustID_Call) Return(_a0 *redis.XAutoClaimJustIDCmd) *Pipeliner_XAutoClaimJustID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XAutoClaimJustID_Call) RunAndReturn(run func(context.Context, *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd) *Pipeliner_XAutoClaimJustID_Call { + _c.Call.Return(run) + return _c +} + // XClaim provides a mock function with given fields: ctx, a func (_m *Pipeliner) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd { ret := _m.Called(ctx, a) @@ -3861,6 +10726,35 @@ func (_m *Pipeliner) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMe return r0 } +// Pipeliner_XClaim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XClaim' +type Pipeliner_XClaim_Call struct { + *mock.Call +} + +// XClaim is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XClaimArgs +func (_e *Pipeliner_Expecter) XClaim(ctx interface{}, a interface{}) *Pipeliner_XClaim_Call { + return &Pipeliner_XClaim_Call{Call: _e.mock.On("XClaim", ctx, a)} +} + +func (_c *Pipeliner_XClaim_Call) Run(run func(ctx context.Context, a *redis.XClaimArgs)) *Pipeliner_XClaim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XClaimArgs)) + }) + return _c +} + +func (_c *Pipeliner_XClaim_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XClaim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XClaim_Call) RunAndReturn(run func(context.Context, *redis.XClaimArgs) *redis.XMessageSliceCmd) *Pipeliner_XClaim_Call { + _c.Call.Return(run) + return _c +} + // XClaimJustID provides a mock function with given fields: ctx, a func (_m *Pipeliner) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd { ret := _m.Called(ctx, a) @@ -3877,6 +10771,35 @@ func (_m *Pipeliner) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *red return r0 } +// Pipeliner_XClaimJustID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XClaimJustID' +type Pipeliner_XClaimJustID_Call struct { + *mock.Call +} + +// XClaimJustID is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XClaimArgs +func (_e *Pipeliner_Expecter) XClaimJustID(ctx interface{}, a interface{}) *Pipeliner_XClaimJustID_Call { + return &Pipeliner_XClaimJustID_Call{Call: _e.mock.On("XClaimJustID", ctx, a)} +} + +func (_c *Pipeliner_XClaimJustID_Call) Run(run func(ctx context.Context, a *redis.XClaimArgs)) *Pipeliner_XClaimJustID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XClaimArgs)) + }) + return _c +} + +func (_c *Pipeliner_XClaimJustID_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_XClaimJustID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XClaimJustID_Call) RunAndReturn(run func(context.Context, *redis.XClaimArgs) *redis.StringSliceCmd) *Pipeliner_XClaimJustID_Call { + _c.Call.Return(run) + return _c +} + // XDel provides a mock function with given fields: ctx, stream, ids func (_m *Pipeliner) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd { _va := make([]interface{}, len(ids)) @@ -3900,6 +10823,43 @@ func (_m *Pipeliner) XDel(ctx context.Context, stream string, ids ...string) *re return r0 } +// Pipeliner_XDel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XDel' +type Pipeliner_XDel_Call struct { + *mock.Call +} + +// XDel is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - ids ...string +func (_e *Pipeliner_Expecter) XDel(ctx interface{}, stream interface{}, ids ...interface{}) *Pipeliner_XDel_Call { + return &Pipeliner_XDel_Call{Call: _e.mock.On("XDel", + append([]interface{}{ctx, stream}, ids...)...)} +} + +func (_c *Pipeliner_XDel_Call) Run(run func(ctx context.Context, stream string, ids ...string)) *Pipeliner_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 *Pipeliner_XDel_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XDel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XDel_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_XDel_Call { + _c.Call.Return(run) + return _c +} + // XGroupCreate provides a mock function with given fields: ctx, stream, group, start func (_m *Pipeliner) XGroupCreate(ctx context.Context, stream string, group string, start string) *redis.StatusCmd { ret := _m.Called(ctx, stream, group, start) @@ -3913,7 +10873,38 @@ func (_m *Pipeliner) XGroupCreate(ctx context.Context, stream string, group stri } } - return r0 + return r0 +} + +// Pipeliner_XGroupCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupCreate' +type Pipeliner_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 *Pipeliner_Expecter) XGroupCreate(ctx interface{}, stream interface{}, group interface{}, start interface{}) *Pipeliner_XGroupCreate_Call { + return &Pipeliner_XGroupCreate_Call{Call: _e.mock.On("XGroupCreate", ctx, stream, group, start)} +} + +func (_c *Pipeliner_XGroupCreate_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *Pipeliner_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 *Pipeliner_XGroupCreate_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_XGroupCreate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XGroupCreate_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *Pipeliner_XGroupCreate_Call { + _c.Call.Return(run) + return _c } // XGroupCreateConsumer provides a mock function with given fields: ctx, stream, group, consumer @@ -3932,6 +10923,37 @@ func (_m *Pipeliner) XGroupCreateConsumer(ctx context.Context, stream string, gr return r0 } +// Pipeliner_XGroupCreateConsumer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupCreateConsumer' +type Pipeliner_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 *Pipeliner_Expecter) XGroupCreateConsumer(ctx interface{}, stream interface{}, group interface{}, consumer interface{}) *Pipeliner_XGroupCreateConsumer_Call { + return &Pipeliner_XGroupCreateConsumer_Call{Call: _e.mock.On("XGroupCreateConsumer", ctx, stream, group, consumer)} +} + +func (_c *Pipeliner_XGroupCreateConsumer_Call) Run(run func(ctx context.Context, stream string, group string, consumer string)) *Pipeliner_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 *Pipeliner_XGroupCreateConsumer_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XGroupCreateConsumer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XGroupCreateConsumer_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_XGroupCreateConsumer_Call { + _c.Call.Return(run) + return _c +} + // XGroupCreateMkStream provides a mock function with given fields: ctx, stream, group, start func (_m *Pipeliner) XGroupCreateMkStream(ctx context.Context, stream string, group string, start string) *redis.StatusCmd { ret := _m.Called(ctx, stream, group, start) @@ -3948,6 +10970,37 @@ func (_m *Pipeliner) XGroupCreateMkStream(ctx context.Context, stream string, gr return r0 } +// Pipeliner_XGroupCreateMkStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupCreateMkStream' +type Pipeliner_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 *Pipeliner_Expecter) XGroupCreateMkStream(ctx interface{}, stream interface{}, group interface{}, start interface{}) *Pipeliner_XGroupCreateMkStream_Call { + return &Pipeliner_XGroupCreateMkStream_Call{Call: _e.mock.On("XGroupCreateMkStream", ctx, stream, group, start)} +} + +func (_c *Pipeliner_XGroupCreateMkStream_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *Pipeliner_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 *Pipeliner_XGroupCreateMkStream_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_XGroupCreateMkStream_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XGroupCreateMkStream_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *Pipeliner_XGroupCreateMkStream_Call { + _c.Call.Return(run) + return _c +} + // XGroupDelConsumer provides a mock function with given fields: ctx, stream, group, consumer func (_m *Pipeliner) XGroupDelConsumer(ctx context.Context, stream string, group string, consumer string) *redis.IntCmd { ret := _m.Called(ctx, stream, group, consumer) @@ -3964,6 +11017,37 @@ func (_m *Pipeliner) XGroupDelConsumer(ctx context.Context, stream string, group return r0 } +// Pipeliner_XGroupDelConsumer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupDelConsumer' +type Pipeliner_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 *Pipeliner_Expecter) XGroupDelConsumer(ctx interface{}, stream interface{}, group interface{}, consumer interface{}) *Pipeliner_XGroupDelConsumer_Call { + return &Pipeliner_XGroupDelConsumer_Call{Call: _e.mock.On("XGroupDelConsumer", ctx, stream, group, consumer)} +} + +func (_c *Pipeliner_XGroupDelConsumer_Call) Run(run func(ctx context.Context, stream string, group string, consumer string)) *Pipeliner_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 *Pipeliner_XGroupDelConsumer_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XGroupDelConsumer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XGroupDelConsumer_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_XGroupDelConsumer_Call { + _c.Call.Return(run) + return _c +} + // XGroupDestroy provides a mock function with given fields: ctx, stream, group func (_m *Pipeliner) XGroupDestroy(ctx context.Context, stream string, group string) *redis.IntCmd { ret := _m.Called(ctx, stream, group) @@ -3980,6 +11064,36 @@ func (_m *Pipeliner) XGroupDestroy(ctx context.Context, stream string, group str return r0 } +// Pipeliner_XGroupDestroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupDestroy' +type Pipeliner_XGroupDestroy_Call struct { + *mock.Call +} + +// XGroupDestroy is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +func (_e *Pipeliner_Expecter) XGroupDestroy(ctx interface{}, stream interface{}, group interface{}) *Pipeliner_XGroupDestroy_Call { + return &Pipeliner_XGroupDestroy_Call{Call: _e.mock.On("XGroupDestroy", ctx, stream, group)} +} + +func (_c *Pipeliner_XGroupDestroy_Call) Run(run func(ctx context.Context, stream string, group string)) *Pipeliner_XGroupDestroy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_XGroupDestroy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XGroupDestroy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XGroupDestroy_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_XGroupDestroy_Call { + _c.Call.Return(run) + return _c +} + // XGroupSetID provides a mock function with given fields: ctx, stream, group, start func (_m *Pipeliner) XGroupSetID(ctx context.Context, stream string, group string, start string) *redis.StatusCmd { ret := _m.Called(ctx, stream, group, start) @@ -3996,6 +11110,37 @@ func (_m *Pipeliner) XGroupSetID(ctx context.Context, stream string, group strin return r0 } +// Pipeliner_XGroupSetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XGroupSetID' +type Pipeliner_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 *Pipeliner_Expecter) XGroupSetID(ctx interface{}, stream interface{}, group interface{}, start interface{}) *Pipeliner_XGroupSetID_Call { + return &Pipeliner_XGroupSetID_Call{Call: _e.mock.On("XGroupSetID", ctx, stream, group, start)} +} + +func (_c *Pipeliner_XGroupSetID_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *Pipeliner_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 *Pipeliner_XGroupSetID_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_XGroupSetID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XGroupSetID_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *Pipeliner_XGroupSetID_Call { + _c.Call.Return(run) + return _c +} + // XInfoConsumers provides a mock function with given fields: ctx, key, group func (_m *Pipeliner) XInfoConsumers(ctx context.Context, key string, group string) *redis.XInfoConsumersCmd { ret := _m.Called(ctx, key, group) @@ -4012,6 +11157,36 @@ func (_m *Pipeliner) XInfoConsumers(ctx context.Context, key string, group strin return r0 } +// Pipeliner_XInfoConsumers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XInfoConsumers' +type Pipeliner_XInfoConsumers_Call struct { + *mock.Call +} + +// XInfoConsumers is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - group string +func (_e *Pipeliner_Expecter) XInfoConsumers(ctx interface{}, key interface{}, group interface{}) *Pipeliner_XInfoConsumers_Call { + return &Pipeliner_XInfoConsumers_Call{Call: _e.mock.On("XInfoConsumers", ctx, key, group)} +} + +func (_c *Pipeliner_XInfoConsumers_Call) Run(run func(ctx context.Context, key string, group string)) *Pipeliner_XInfoConsumers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_XInfoConsumers_Call) Return(_a0 *redis.XInfoConsumersCmd) *Pipeliner_XInfoConsumers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XInfoConsumers_Call) RunAndReturn(run func(context.Context, string, string) *redis.XInfoConsumersCmd) *Pipeliner_XInfoConsumers_Call { + _c.Call.Return(run) + return _c +} + // XInfoGroups provides a mock function with given fields: ctx, key func (_m *Pipeliner) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd { ret := _m.Called(ctx, key) @@ -4028,6 +11203,35 @@ func (_m *Pipeliner) XInfoGroups(ctx context.Context, key string) *redis.XInfoGr return r0 } +// Pipeliner_XInfoGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XInfoGroups' +type Pipeliner_XInfoGroups_Call struct { + *mock.Call +} + +// XInfoGroups is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) XInfoGroups(ctx interface{}, key interface{}) *Pipeliner_XInfoGroups_Call { + return &Pipeliner_XInfoGroups_Call{Call: _e.mock.On("XInfoGroups", ctx, key)} +} + +func (_c *Pipeliner_XInfoGroups_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_XInfoGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_XInfoGroups_Call) Return(_a0 *redis.XInfoGroupsCmd) *Pipeliner_XInfoGroups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XInfoGroups_Call) RunAndReturn(run func(context.Context, string) *redis.XInfoGroupsCmd) *Pipeliner_XInfoGroups_Call { + _c.Call.Return(run) + return _c +} + // XInfoStream provides a mock function with given fields: ctx, key func (_m *Pipeliner) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd { ret := _m.Called(ctx, key) @@ -4044,6 +11248,35 @@ func (_m *Pipeliner) XInfoStream(ctx context.Context, key string) *redis.XInfoSt return r0 } +// Pipeliner_XInfoStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XInfoStream' +type Pipeliner_XInfoStream_Call struct { + *mock.Call +} + +// XInfoStream is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) XInfoStream(ctx interface{}, key interface{}) *Pipeliner_XInfoStream_Call { + return &Pipeliner_XInfoStream_Call{Call: _e.mock.On("XInfoStream", ctx, key)} +} + +func (_c *Pipeliner_XInfoStream_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_XInfoStream_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_XInfoStream_Call) Return(_a0 *redis.XInfoStreamCmd) *Pipeliner_XInfoStream_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XInfoStream_Call) RunAndReturn(run func(context.Context, string) *redis.XInfoStreamCmd) *Pipeliner_XInfoStream_Call { + _c.Call.Return(run) + return _c +} + // XInfoStreamFull provides a mock function with given fields: ctx, key, count func (_m *Pipeliner) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd { ret := _m.Called(ctx, key, count) @@ -4060,6 +11293,36 @@ func (_m *Pipeliner) XInfoStreamFull(ctx context.Context, key string, count int) return r0 } +// Pipeliner_XInfoStreamFull_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XInfoStreamFull' +type Pipeliner_XInfoStreamFull_Call struct { + *mock.Call +} + +// XInfoStreamFull is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +func (_e *Pipeliner_Expecter) XInfoStreamFull(ctx interface{}, key interface{}, count interface{}) *Pipeliner_XInfoStreamFull_Call { + return &Pipeliner_XInfoStreamFull_Call{Call: _e.mock.On("XInfoStreamFull", ctx, key, count)} +} + +func (_c *Pipeliner_XInfoStreamFull_Call) Run(run func(ctx context.Context, key string, count int)) *Pipeliner_XInfoStreamFull_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *Pipeliner_XInfoStreamFull_Call) Return(_a0 *redis.XInfoStreamFullCmd) *Pipeliner_XInfoStreamFull_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XInfoStreamFull_Call) RunAndReturn(run func(context.Context, string, int) *redis.XInfoStreamFullCmd) *Pipeliner_XInfoStreamFull_Call { + _c.Call.Return(run) + return _c +} + // XLen provides a mock function with given fields: ctx, stream func (_m *Pipeliner) XLen(ctx context.Context, stream string) *redis.IntCmd { ret := _m.Called(ctx, stream) @@ -4076,6 +11339,35 @@ func (_m *Pipeliner) XLen(ctx context.Context, stream string) *redis.IntCmd { return r0 } +// Pipeliner_XLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XLen' +type Pipeliner_XLen_Call struct { + *mock.Call +} + +// XLen is a helper method to define mock.On call +// - ctx context.Context +// - stream string +func (_e *Pipeliner_Expecter) XLen(ctx interface{}, stream interface{}) *Pipeliner_XLen_Call { + return &Pipeliner_XLen_Call{Call: _e.mock.On("XLen", ctx, stream)} +} + +func (_c *Pipeliner_XLen_Call) Run(run func(ctx context.Context, stream string)) *Pipeliner_XLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_XLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_XLen_Call { + _c.Call.Return(run) + return _c +} + // XPending provides a mock function with given fields: ctx, stream, group func (_m *Pipeliner) XPending(ctx context.Context, stream string, group string) *redis.XPendingCmd { ret := _m.Called(ctx, stream, group) @@ -4092,6 +11384,36 @@ func (_m *Pipeliner) XPending(ctx context.Context, stream string, group string) return r0 } +// Pipeliner_XPending_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XPending' +type Pipeliner_XPending_Call struct { + *mock.Call +} + +// XPending is a helper method to define mock.On call +// - ctx context.Context +// - stream string +// - group string +func (_e *Pipeliner_Expecter) XPending(ctx interface{}, stream interface{}, group interface{}) *Pipeliner_XPending_Call { + return &Pipeliner_XPending_Call{Call: _e.mock.On("XPending", ctx, stream, group)} +} + +func (_c *Pipeliner_XPending_Call) Run(run func(ctx context.Context, stream string, group string)) *Pipeliner_XPending_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_XPending_Call) Return(_a0 *redis.XPendingCmd) *Pipeliner_XPending_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XPending_Call) RunAndReturn(run func(context.Context, string, string) *redis.XPendingCmd) *Pipeliner_XPending_Call { + _c.Call.Return(run) + return _c +} + // XPendingExt provides a mock function with given fields: ctx, a func (_m *Pipeliner) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd { ret := _m.Called(ctx, a) @@ -4108,6 +11430,35 @@ func (_m *Pipeliner) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) return r0 } +// Pipeliner_XPendingExt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XPendingExt' +type Pipeliner_XPendingExt_Call struct { + *mock.Call +} + +// XPendingExt is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XPendingExtArgs +func (_e *Pipeliner_Expecter) XPendingExt(ctx interface{}, a interface{}) *Pipeliner_XPendingExt_Call { + return &Pipeliner_XPendingExt_Call{Call: _e.mock.On("XPendingExt", ctx, a)} +} + +func (_c *Pipeliner_XPendingExt_Call) Run(run func(ctx context.Context, a *redis.XPendingExtArgs)) *Pipeliner_XPendingExt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XPendingExtArgs)) + }) + return _c +} + +func (_c *Pipeliner_XPendingExt_Call) Return(_a0 *redis.XPendingExtCmd) *Pipeliner_XPendingExt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XPendingExt_Call) RunAndReturn(run func(context.Context, *redis.XPendingExtArgs) *redis.XPendingExtCmd) *Pipeliner_XPendingExt_Call { + _c.Call.Return(run) + return _c +} + // XRange provides a mock function with given fields: ctx, stream, start, stop func (_m *Pipeliner) XRange(ctx context.Context, stream string, start string, stop string) *redis.XMessageSliceCmd { ret := _m.Called(ctx, stream, start, stop) @@ -4124,6 +11475,37 @@ func (_m *Pipeliner) XRange(ctx context.Context, stream string, start string, st return r0 } +// Pipeliner_XRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRange' +type Pipeliner_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 *Pipeliner_Expecter) XRange(ctx interface{}, stream interface{}, start interface{}, stop interface{}) *Pipeliner_XRange_Call { + return &Pipeliner_XRange_Call{Call: _e.mock.On("XRange", ctx, stream, start, stop)} +} + +func (_c *Pipeliner_XRange_Call) Run(run func(ctx context.Context, stream string, start string, stop string)) *Pipeliner_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 *Pipeliner_XRange_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XRange_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.XMessageSliceCmd) *Pipeliner_XRange_Call { + _c.Call.Return(run) + return _c +} + // XRangeN provides a mock function with given fields: ctx, stream, start, stop, count func (_m *Pipeliner) XRangeN(ctx context.Context, stream string, start string, stop string, count int64) *redis.XMessageSliceCmd { ret := _m.Called(ctx, stream, start, stop, count) @@ -4140,6 +11522,38 @@ func (_m *Pipeliner) XRangeN(ctx context.Context, stream string, start string, s return r0 } +// Pipeliner_XRangeN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRangeN' +type Pipeliner_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 *Pipeliner_Expecter) XRangeN(ctx interface{}, stream interface{}, start interface{}, stop interface{}, count interface{}) *Pipeliner_XRangeN_Call { + return &Pipeliner_XRangeN_Call{Call: _e.mock.On("XRangeN", ctx, stream, start, stop, count)} +} + +func (_c *Pipeliner_XRangeN_Call) Run(run func(ctx context.Context, stream string, start string, stop string, count int64)) *Pipeliner_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 *Pipeliner_XRangeN_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XRangeN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XRangeN_Call) RunAndReturn(run func(context.Context, string, string, string, int64) *redis.XMessageSliceCmd) *Pipeliner_XRangeN_Call { + _c.Call.Return(run) + return _c +} + // XRead provides a mock function with given fields: ctx, a func (_m *Pipeliner) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd { ret := _m.Called(ctx, a) @@ -4156,6 +11570,35 @@ func (_m *Pipeliner) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStre return r0 } +// Pipeliner_XRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRead' +type Pipeliner_XRead_Call struct { + *mock.Call +} + +// XRead is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XReadArgs +func (_e *Pipeliner_Expecter) XRead(ctx interface{}, a interface{}) *Pipeliner_XRead_Call { + return &Pipeliner_XRead_Call{Call: _e.mock.On("XRead", ctx, a)} +} + +func (_c *Pipeliner_XRead_Call) Run(run func(ctx context.Context, a *redis.XReadArgs)) *Pipeliner_XRead_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XReadArgs)) + }) + return _c +} + +func (_c *Pipeliner_XRead_Call) Return(_a0 *redis.XStreamSliceCmd) *Pipeliner_XRead_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XRead_Call) RunAndReturn(run func(context.Context, *redis.XReadArgs) *redis.XStreamSliceCmd) *Pipeliner_XRead_Call { + _c.Call.Return(run) + return _c +} + // XReadGroup provides a mock function with given fields: ctx, a func (_m *Pipeliner) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd { ret := _m.Called(ctx, a) @@ -4172,6 +11615,35 @@ func (_m *Pipeliner) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *r return r0 } +// Pipeliner_XReadGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XReadGroup' +type Pipeliner_XReadGroup_Call struct { + *mock.Call +} + +// XReadGroup is a helper method to define mock.On call +// - ctx context.Context +// - a *redis.XReadGroupArgs +func (_e *Pipeliner_Expecter) XReadGroup(ctx interface{}, a interface{}) *Pipeliner_XReadGroup_Call { + return &Pipeliner_XReadGroup_Call{Call: _e.mock.On("XReadGroup", ctx, a)} +} + +func (_c *Pipeliner_XReadGroup_Call) Run(run func(ctx context.Context, a *redis.XReadGroupArgs)) *Pipeliner_XReadGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.XReadGroupArgs)) + }) + return _c +} + +func (_c *Pipeliner_XReadGroup_Call) Return(_a0 *redis.XStreamSliceCmd) *Pipeliner_XReadGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XReadGroup_Call) RunAndReturn(run func(context.Context, *redis.XReadGroupArgs) *redis.XStreamSliceCmd) *Pipeliner_XReadGroup_Call { + _c.Call.Return(run) + return _c +} + // XReadStreams provides a mock function with given fields: ctx, streams func (_m *Pipeliner) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd { _va := make([]interface{}, len(streams)) @@ -4195,6 +11667,42 @@ func (_m *Pipeliner) XReadStreams(ctx context.Context, streams ...string) *redis return r0 } +// Pipeliner_XReadStreams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XReadStreams' +type Pipeliner_XReadStreams_Call struct { + *mock.Call +} + +// XReadStreams is a helper method to define mock.On call +// - ctx context.Context +// - streams ...string +func (_e *Pipeliner_Expecter) XReadStreams(ctx interface{}, streams ...interface{}) *Pipeliner_XReadStreams_Call { + return &Pipeliner_XReadStreams_Call{Call: _e.mock.On("XReadStreams", + append([]interface{}{ctx}, streams...)...)} +} + +func (_c *Pipeliner_XReadStreams_Call) Run(run func(ctx context.Context, streams ...string)) *Pipeliner_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 *Pipeliner_XReadStreams_Call) Return(_a0 *redis.XStreamSliceCmd) *Pipeliner_XReadStreams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XReadStreams_Call) RunAndReturn(run func(context.Context, ...string) *redis.XStreamSliceCmd) *Pipeliner_XReadStreams_Call { + _c.Call.Return(run) + return _c +} + // XRevRange provides a mock function with given fields: ctx, stream, start, stop func (_m *Pipeliner) XRevRange(ctx context.Context, stream string, start string, stop string) *redis.XMessageSliceCmd { ret := _m.Called(ctx, stream, start, stop) @@ -4211,6 +11719,37 @@ func (_m *Pipeliner) XRevRange(ctx context.Context, stream string, start string, return r0 } +// Pipeliner_XRevRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRevRange' +type Pipeliner_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 *Pipeliner_Expecter) XRevRange(ctx interface{}, stream interface{}, start interface{}, stop interface{}) *Pipeliner_XRevRange_Call { + return &Pipeliner_XRevRange_Call{Call: _e.mock.On("XRevRange", ctx, stream, start, stop)} +} + +func (_c *Pipeliner_XRevRange_Call) Run(run func(ctx context.Context, stream string, start string, stop string)) *Pipeliner_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 *Pipeliner_XRevRange_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XRevRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XRevRange_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.XMessageSliceCmd) *Pipeliner_XRevRange_Call { + _c.Call.Return(run) + return _c +} + // XRevRangeN provides a mock function with given fields: ctx, stream, start, stop, count func (_m *Pipeliner) XRevRangeN(ctx context.Context, stream string, start string, stop string, count int64) *redis.XMessageSliceCmd { ret := _m.Called(ctx, stream, start, stop, count) @@ -4227,6 +11766,38 @@ func (_m *Pipeliner) XRevRangeN(ctx context.Context, stream string, start string return r0 } +// Pipeliner_XRevRangeN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XRevRangeN' +type Pipeliner_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 *Pipeliner_Expecter) XRevRangeN(ctx interface{}, stream interface{}, start interface{}, stop interface{}, count interface{}) *Pipeliner_XRevRangeN_Call { + return &Pipeliner_XRevRangeN_Call{Call: _e.mock.On("XRevRangeN", ctx, stream, start, stop, count)} +} + +func (_c *Pipeliner_XRevRangeN_Call) Run(run func(ctx context.Context, stream string, start string, stop string, count int64)) *Pipeliner_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 *Pipeliner_XRevRangeN_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XRevRangeN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XRevRangeN_Call) RunAndReturn(run func(context.Context, string, string, string, int64) *redis.XMessageSliceCmd) *Pipeliner_XRevRangeN_Call { + _c.Call.Return(run) + return _c +} + // XTrim provides a mock function with given fields: ctx, key, maxLen func (_m *Pipeliner) XTrim(ctx context.Context, key string, maxLen int64) *redis.IntCmd { ret := _m.Called(ctx, key, maxLen) @@ -4243,6 +11814,36 @@ func (_m *Pipeliner) XTrim(ctx context.Context, key string, maxLen int64) *redis return r0 } +// Pipeliner_XTrim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrim' +type Pipeliner_XTrim_Call struct { + *mock.Call +} + +// XTrim is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - maxLen int64 +func (_e *Pipeliner_Expecter) XTrim(ctx interface{}, key interface{}, maxLen interface{}) *Pipeliner_XTrim_Call { + return &Pipeliner_XTrim_Call{Call: _e.mock.On("XTrim", ctx, key, maxLen)} +} + +func (_c *Pipeliner_XTrim_Call) Run(run func(ctx context.Context, key string, maxLen int64)) *Pipeliner_XTrim_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_XTrim_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrim_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XTrim_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_XTrim_Call { + _c.Call.Return(run) + return _c +} + // XTrimApprox provides a mock function with given fields: ctx, key, maxLen func (_m *Pipeliner) XTrimApprox(ctx context.Context, key string, maxLen int64) *redis.IntCmd { ret := _m.Called(ctx, key, maxLen) @@ -4259,6 +11860,36 @@ func (_m *Pipeliner) XTrimApprox(ctx context.Context, key string, maxLen int64) return r0 } +// Pipeliner_XTrimApprox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimApprox' +type Pipeliner_XTrimApprox_Call struct { + *mock.Call +} + +// XTrimApprox is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - maxLen int64 +func (_e *Pipeliner_Expecter) XTrimApprox(ctx interface{}, key interface{}, maxLen interface{}) *Pipeliner_XTrimApprox_Call { + return &Pipeliner_XTrimApprox_Call{Call: _e.mock.On("XTrimApprox", ctx, key, maxLen)} +} + +func (_c *Pipeliner_XTrimApprox_Call) Run(run func(ctx context.Context, key string, maxLen int64)) *Pipeliner_XTrimApprox_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_XTrimApprox_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimApprox_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XTrimApprox_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_XTrimApprox_Call { + _c.Call.Return(run) + return _c +} + // XTrimMaxLen provides a mock function with given fields: ctx, key, maxLen func (_m *Pipeliner) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd { ret := _m.Called(ctx, key, maxLen) @@ -4275,6 +11906,36 @@ func (_m *Pipeliner) XTrimMaxLen(ctx context.Context, key string, maxLen int64) return r0 } +// Pipeliner_XTrimMaxLen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimMaxLen' +type Pipeliner_XTrimMaxLen_Call struct { + *mock.Call +} + +// XTrimMaxLen is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - maxLen int64 +func (_e *Pipeliner_Expecter) XTrimMaxLen(ctx interface{}, key interface{}, maxLen interface{}) *Pipeliner_XTrimMaxLen_Call { + return &Pipeliner_XTrimMaxLen_Call{Call: _e.mock.On("XTrimMaxLen", ctx, key, maxLen)} +} + +func (_c *Pipeliner_XTrimMaxLen_Call) Run(run func(ctx context.Context, key string, maxLen int64)) *Pipeliner_XTrimMaxLen_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *Pipeliner_XTrimMaxLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimMaxLen_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XTrimMaxLen_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_XTrimMaxLen_Call { + _c.Call.Return(run) + return _c +} + // XTrimMaxLenApprox provides a mock function with given fields: ctx, key, maxLen, limit func (_m *Pipeliner) XTrimMaxLenApprox(ctx context.Context, key string, maxLen int64, limit int64) *redis.IntCmd { ret := _m.Called(ctx, key, maxLen, limit) @@ -4291,6 +11952,37 @@ func (_m *Pipeliner) XTrimMaxLenApprox(ctx context.Context, key string, maxLen i return r0 } +// Pipeliner_XTrimMaxLenApprox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimMaxLenApprox' +type Pipeliner_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 *Pipeliner_Expecter) XTrimMaxLenApprox(ctx interface{}, key interface{}, maxLen interface{}, limit interface{}) *Pipeliner_XTrimMaxLenApprox_Call { + return &Pipeliner_XTrimMaxLenApprox_Call{Call: _e.mock.On("XTrimMaxLenApprox", ctx, key, maxLen, limit)} +} + +func (_c *Pipeliner_XTrimMaxLenApprox_Call) Run(run func(ctx context.Context, key string, maxLen int64, limit int64)) *Pipeliner_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 *Pipeliner_XTrimMaxLenApprox_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimMaxLenApprox_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XTrimMaxLenApprox_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.IntCmd) *Pipeliner_XTrimMaxLenApprox_Call { + _c.Call.Return(run) + return _c +} + // XTrimMinID provides a mock function with given fields: ctx, key, minID func (_m *Pipeliner) XTrimMinID(ctx context.Context, key string, minID string) *redis.IntCmd { ret := _m.Called(ctx, key, minID) @@ -4307,6 +11999,36 @@ func (_m *Pipeliner) XTrimMinID(ctx context.Context, key string, minID string) * return r0 } +// Pipeliner_XTrimMinID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimMinID' +type Pipeliner_XTrimMinID_Call struct { + *mock.Call +} + +// XTrimMinID is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - minID string +func (_e *Pipeliner_Expecter) XTrimMinID(ctx interface{}, key interface{}, minID interface{}) *Pipeliner_XTrimMinID_Call { + return &Pipeliner_XTrimMinID_Call{Call: _e.mock.On("XTrimMinID", ctx, key, minID)} +} + +func (_c *Pipeliner_XTrimMinID_Call) Run(run func(ctx context.Context, key string, minID string)) *Pipeliner_XTrimMinID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_XTrimMinID_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimMinID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XTrimMinID_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_XTrimMinID_Call { + _c.Call.Return(run) + return _c +} + // XTrimMinIDApprox provides a mock function with given fields: ctx, key, minID, limit func (_m *Pipeliner) XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *redis.IntCmd { ret := _m.Called(ctx, key, minID, limit) @@ -4320,7 +12042,38 @@ func (_m *Pipeliner) XTrimMinIDApprox(ctx context.Context, key string, minID str } } - return r0 + return r0 +} + +// Pipeliner_XTrimMinIDApprox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'XTrimMinIDApprox' +type Pipeliner_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 *Pipeliner_Expecter) XTrimMinIDApprox(ctx interface{}, key interface{}, minID interface{}, limit interface{}) *Pipeliner_XTrimMinIDApprox_Call { + return &Pipeliner_XTrimMinIDApprox_Call{Call: _e.mock.On("XTrimMinIDApprox", ctx, key, minID, limit)} +} + +func (_c *Pipeliner_XTrimMinIDApprox_Call) Run(run func(ctx context.Context, key string, minID string, limit int64)) *Pipeliner_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 *Pipeliner_XTrimMinIDApprox_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimMinIDApprox_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_XTrimMinIDApprox_Call) RunAndReturn(run func(context.Context, string, string, int64) *redis.IntCmd) *Pipeliner_XTrimMinIDApprox_Call { + _c.Call.Return(run) + return _c } // ZAdd provides a mock function with given fields: ctx, key, members @@ -4346,6 +12099,43 @@ func (_m *Pipeliner) ZAdd(ctx context.Context, key string, members ...*redis.Z) return r0 } +// Pipeliner_ZAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAdd' +type Pipeliner_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 *Pipeliner_Expecter) ZAdd(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAdd_Call { + return &Pipeliner_ZAdd_Call{Call: _e.mock.On("ZAdd", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_ZAdd_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_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 *Pipeliner_ZAdd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZAdd_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAdd_Call { + _c.Call.Return(run) + return _c +} + // ZAddArgs provides a mock function with given fields: ctx, key, args func (_m *Pipeliner) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd { ret := _m.Called(ctx, key, args) @@ -4362,6 +12152,36 @@ func (_m *Pipeliner) ZAddArgs(ctx context.Context, key string, args redis.ZAddAr return r0 } +// Pipeliner_ZAddArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddArgs' +type Pipeliner_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 *Pipeliner_Expecter) ZAddArgs(ctx interface{}, key interface{}, args interface{}) *Pipeliner_ZAddArgs_Call { + return &Pipeliner_ZAddArgs_Call{Call: _e.mock.On("ZAddArgs", ctx, key, args)} +} + +func (_c *Pipeliner_ZAddArgs_Call) Run(run func(ctx context.Context, key string, args redis.ZAddArgs)) *Pipeliner_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 *Pipeliner_ZAddArgs_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZAddArgs_Call) RunAndReturn(run func(context.Context, string, redis.ZAddArgs) *redis.IntCmd) *Pipeliner_ZAddArgs_Call { + _c.Call.Return(run) + return _c +} + // ZAddArgsIncr provides a mock function with given fields: ctx, key, args func (_m *Pipeliner) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd { ret := _m.Called(ctx, key, args) @@ -4378,6 +12198,36 @@ func (_m *Pipeliner) ZAddArgsIncr(ctx context.Context, key string, args redis.ZA return r0 } +// Pipeliner_ZAddArgsIncr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddArgsIncr' +type Pipeliner_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 *Pipeliner_Expecter) ZAddArgsIncr(ctx interface{}, key interface{}, args interface{}) *Pipeliner_ZAddArgsIncr_Call { + return &Pipeliner_ZAddArgsIncr_Call{Call: _e.mock.On("ZAddArgsIncr", ctx, key, args)} +} + +func (_c *Pipeliner_ZAddArgsIncr_Call) Run(run func(ctx context.Context, key string, args redis.ZAddArgs)) *Pipeliner_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 *Pipeliner_ZAddArgsIncr_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZAddArgsIncr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZAddArgsIncr_Call) RunAndReturn(run func(context.Context, string, redis.ZAddArgs) *redis.FloatCmd) *Pipeliner_ZAddArgsIncr_Call { + _c.Call.Return(run) + return _c +} + // ZAddCh provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) ZAddCh(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd { _va := make([]interface{}, len(members)) @@ -4401,6 +12251,43 @@ func (_m *Pipeliner) ZAddCh(ctx context.Context, key string, members ...*redis.Z return r0 } +// Pipeliner_ZAddCh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddCh' +type Pipeliner_ZAddCh_Call struct { + *mock.Call +} + +// ZAddCh is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...*redis.Z +func (_e *Pipeliner_Expecter) ZAddCh(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddCh_Call { + return &Pipeliner_ZAddCh_Call{Call: _e.mock.On("ZAddCh", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_ZAddCh_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAddCh_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 *Pipeliner_ZAddCh_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddCh_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZAddCh_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddCh_Call { + _c.Call.Return(run) + return _c +} + // ZAddNX provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) ZAddNX(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd { _va := make([]interface{}, len(members)) @@ -4424,6 +12311,43 @@ func (_m *Pipeliner) ZAddNX(ctx context.Context, key string, members ...*redis.Z return r0 } +// Pipeliner_ZAddNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddNX' +type Pipeliner_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 *Pipeliner_Expecter) ZAddNX(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddNX_Call { + return &Pipeliner_ZAddNX_Call{Call: _e.mock.On("ZAddNX", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_ZAddNX_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_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 *Pipeliner_ZAddNX_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZAddNX_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddNX_Call { + _c.Call.Return(run) + return _c +} + // ZAddNXCh provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) ZAddNXCh(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd { _va := make([]interface{}, len(members)) @@ -4447,6 +12371,43 @@ func (_m *Pipeliner) ZAddNXCh(ctx context.Context, key string, members ...*redis return r0 } +// Pipeliner_ZAddNXCh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddNXCh' +type Pipeliner_ZAddNXCh_Call struct { + *mock.Call +} + +// ZAddNXCh is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...*redis.Z +func (_e *Pipeliner_Expecter) ZAddNXCh(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddNXCh_Call { + return &Pipeliner_ZAddNXCh_Call{Call: _e.mock.On("ZAddNXCh", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_ZAddNXCh_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAddNXCh_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 *Pipeliner_ZAddNXCh_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddNXCh_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZAddNXCh_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddNXCh_Call { + _c.Call.Return(run) + return _c +} + // ZAddXX provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) ZAddXX(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd { _va := make([]interface{}, len(members)) @@ -4470,6 +12431,43 @@ func (_m *Pipeliner) ZAddXX(ctx context.Context, key string, members ...*redis.Z return r0 } +// Pipeliner_ZAddXX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddXX' +type Pipeliner_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 *Pipeliner_Expecter) ZAddXX(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddXX_Call { + return &Pipeliner_ZAddXX_Call{Call: _e.mock.On("ZAddXX", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_ZAddXX_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_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 *Pipeliner_ZAddXX_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddXX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZAddXX_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddXX_Call { + _c.Call.Return(run) + return _c +} + // ZAddXXCh provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) ZAddXXCh(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd { _va := make([]interface{}, len(members)) @@ -4493,6 +12491,43 @@ func (_m *Pipeliner) ZAddXXCh(ctx context.Context, key string, members ...*redis return r0 } +// Pipeliner_ZAddXXCh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZAddXXCh' +type Pipeliner_ZAddXXCh_Call struct { + *mock.Call +} + +// ZAddXXCh is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...*redis.Z +func (_e *Pipeliner_Expecter) ZAddXXCh(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddXXCh_Call { + return &Pipeliner_ZAddXXCh_Call{Call: _e.mock.On("ZAddXXCh", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_ZAddXXCh_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAddXXCh_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 *Pipeliner_ZAddXXCh_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddXXCh_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZAddXXCh_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddXXCh_Call { + _c.Call.Return(run) + return _c +} + // ZCard provides a mock function with given fields: ctx, key func (_m *Pipeliner) ZCard(ctx context.Context, key string) *redis.IntCmd { ret := _m.Called(ctx, key) @@ -4509,6 +12544,35 @@ func (_m *Pipeliner) ZCard(ctx context.Context, key string) *redis.IntCmd { return r0 } +// Pipeliner_ZCard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZCard' +type Pipeliner_ZCard_Call struct { + *mock.Call +} + +// ZCard is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *Pipeliner_Expecter) ZCard(ctx interface{}, key interface{}) *Pipeliner_ZCard_Call { + return &Pipeliner_ZCard_Call{Call: _e.mock.On("ZCard", ctx, key)} +} + +func (_c *Pipeliner_ZCard_Call) Run(run func(ctx context.Context, key string)) *Pipeliner_ZCard_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Pipeliner_ZCard_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZCard_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZCard_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_ZCard_Call { + _c.Call.Return(run) + return _c +} + // ZCount provides a mock function with given fields: ctx, key, min, max func (_m *Pipeliner) ZCount(ctx context.Context, key string, min string, max string) *redis.IntCmd { ret := _m.Called(ctx, key, min, max) @@ -4525,6 +12589,37 @@ func (_m *Pipeliner) ZCount(ctx context.Context, key string, min string, max str return r0 } +// Pipeliner_ZCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZCount' +type Pipeliner_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 *Pipeliner_Expecter) ZCount(ctx interface{}, key interface{}, min interface{}, max interface{}) *Pipeliner_ZCount_Call { + return &Pipeliner_ZCount_Call{Call: _e.mock.On("ZCount", ctx, key, min, max)} +} + +func (_c *Pipeliner_ZCount_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Pipeliner_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 *Pipeliner_ZCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZCount_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_ZCount_Call { + _c.Call.Return(run) + return _c +} + // ZDiff provides a mock function with given fields: ctx, keys func (_m *Pipeliner) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { _va := make([]interface{}, len(keys)) @@ -4548,6 +12643,42 @@ func (_m *Pipeliner) ZDiff(ctx context.Context, keys ...string) *redis.StringSli return r0 } +// Pipeliner_ZDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZDiff' +type Pipeliner_ZDiff_Call struct { + *mock.Call +} + +// ZDiff is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) ZDiff(ctx interface{}, keys ...interface{}) *Pipeliner_ZDiff_Call { + return &Pipeliner_ZDiff_Call{Call: _e.mock.On("ZDiff", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_ZDiff_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_ZDiff_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZDiff_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZDiff_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *Pipeliner_ZDiff_Call { + _c.Call.Return(run) + return _c +} + // ZDiffStore provides a mock function with given fields: ctx, destination, keys func (_m *Pipeliner) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { _va := make([]interface{}, len(keys)) @@ -4571,6 +12702,43 @@ func (_m *Pipeliner) ZDiffStore(ctx context.Context, destination string, keys .. return r0 } +// Pipeliner_ZDiffStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZDiffStore' +type Pipeliner_ZDiffStore_Call struct { + *mock.Call +} + +// ZDiffStore is a helper method to define mock.On call +// - ctx context.Context +// - destination string +// - keys ...string +func (_e *Pipeliner_Expecter) ZDiffStore(ctx interface{}, destination interface{}, keys ...interface{}) *Pipeliner_ZDiffStore_Call { + return &Pipeliner_ZDiffStore_Call{Call: _e.mock.On("ZDiffStore", + append([]interface{}{ctx, destination}, keys...)...)} +} + +func (_c *Pipeliner_ZDiffStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Pipeliner_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 *Pipeliner_ZDiffStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZDiffStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZDiffStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_ZDiffStore_Call { + _c.Call.Return(run) + return _c +} + // ZDiffWithScores provides a mock function with given fields: ctx, keys func (_m *Pipeliner) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd { _va := make([]interface{}, len(keys)) @@ -4594,6 +12762,42 @@ func (_m *Pipeliner) ZDiffWithScores(ctx context.Context, keys ...string) *redis return r0 } +// Pipeliner_ZDiffWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZDiffWithScores' +type Pipeliner_ZDiffWithScores_Call struct { + *mock.Call +} + +// ZDiffWithScores is a helper method to define mock.On call +// - ctx context.Context +// - keys ...string +func (_e *Pipeliner_Expecter) ZDiffWithScores(ctx interface{}, keys ...interface{}) *Pipeliner_ZDiffWithScores_Call { + return &Pipeliner_ZDiffWithScores_Call{Call: _e.mock.On("ZDiffWithScores", + append([]interface{}{ctx}, keys...)...)} +} + +func (_c *Pipeliner_ZDiffWithScores_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_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 *Pipeliner_ZDiffWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZDiffWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZDiffWithScores_Call) RunAndReturn(run func(context.Context, ...string) *redis.ZSliceCmd) *Pipeliner_ZDiffWithScores_Call { + _c.Call.Return(run) + return _c +} + // ZIncr provides a mock function with given fields: ctx, key, member func (_m *Pipeliner) ZIncr(ctx context.Context, key string, member *redis.Z) *redis.FloatCmd { ret := _m.Called(ctx, key, member) @@ -4610,6 +12814,36 @@ func (_m *Pipeliner) ZIncr(ctx context.Context, key string, member *redis.Z) *re return r0 } +// Pipeliner_ZIncr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZIncr' +type Pipeliner_ZIncr_Call struct { + *mock.Call +} + +// ZIncr is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member *redis.Z +func (_e *Pipeliner_Expecter) ZIncr(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZIncr_Call { + return &Pipeliner_ZIncr_Call{Call: _e.mock.On("ZIncr", ctx, key, member)} +} + +func (_c *Pipeliner_ZIncr_Call) Run(run func(ctx context.Context, key string, member *redis.Z)) *Pipeliner_ZIncr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.Z)) + }) + return _c +} + +func (_c *Pipeliner_ZIncr_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZIncr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZIncr_Call) RunAndReturn(run func(context.Context, string, *redis.Z) *redis.FloatCmd) *Pipeliner_ZIncr_Call { + _c.Call.Return(run) + return _c +} + // ZIncrBy provides a mock function with given fields: ctx, key, increment, member func (_m *Pipeliner) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd { ret := _m.Called(ctx, key, increment, member) @@ -4626,6 +12860,37 @@ func (_m *Pipeliner) ZIncrBy(ctx context.Context, key string, increment float64, return r0 } +// Pipeliner_ZIncrBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZIncrBy' +type Pipeliner_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 *Pipeliner_Expecter) ZIncrBy(ctx interface{}, key interface{}, increment interface{}, member interface{}) *Pipeliner_ZIncrBy_Call { + return &Pipeliner_ZIncrBy_Call{Call: _e.mock.On("ZIncrBy", ctx, key, increment, member)} +} + +func (_c *Pipeliner_ZIncrBy_Call) Run(run func(ctx context.Context, key string, increment float64, member string)) *Pipeliner_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 *Pipeliner_ZIncrBy_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZIncrBy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZIncrBy_Call) RunAndReturn(run func(context.Context, string, float64, string) *redis.FloatCmd) *Pipeliner_ZIncrBy_Call { + _c.Call.Return(run) + return _c +} + // ZIncrNX provides a mock function with given fields: ctx, key, member func (_m *Pipeliner) ZIncrNX(ctx context.Context, key string, member *redis.Z) *redis.FloatCmd { ret := _m.Called(ctx, key, member) @@ -4642,6 +12907,36 @@ func (_m *Pipeliner) ZIncrNX(ctx context.Context, key string, member *redis.Z) * return r0 } +// Pipeliner_ZIncrNX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZIncrNX' +type Pipeliner_ZIncrNX_Call struct { + *mock.Call +} + +// ZIncrNX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member *redis.Z +func (_e *Pipeliner_Expecter) ZIncrNX(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZIncrNX_Call { + return &Pipeliner_ZIncrNX_Call{Call: _e.mock.On("ZIncrNX", ctx, key, member)} +} + +func (_c *Pipeliner_ZIncrNX_Call) Run(run func(ctx context.Context, key string, member *redis.Z)) *Pipeliner_ZIncrNX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.Z)) + }) + return _c +} + +func (_c *Pipeliner_ZIncrNX_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZIncrNX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZIncrNX_Call) RunAndReturn(run func(context.Context, string, *redis.Z) *redis.FloatCmd) *Pipeliner_ZIncrNX_Call { + _c.Call.Return(run) + return _c +} + // ZIncrXX provides a mock function with given fields: ctx, key, member func (_m *Pipeliner) ZIncrXX(ctx context.Context, key string, member *redis.Z) *redis.FloatCmd { ret := _m.Called(ctx, key, member) @@ -4658,6 +12953,36 @@ func (_m *Pipeliner) ZIncrXX(ctx context.Context, key string, member *redis.Z) * return r0 } +// Pipeliner_ZIncrXX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZIncrXX' +type Pipeliner_ZIncrXX_Call struct { + *mock.Call +} + +// ZIncrXX is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member *redis.Z +func (_e *Pipeliner_Expecter) ZIncrXX(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZIncrXX_Call { + return &Pipeliner_ZIncrXX_Call{Call: _e.mock.On("ZIncrXX", ctx, key, member)} +} + +func (_c *Pipeliner_ZIncrXX_Call) Run(run func(ctx context.Context, key string, member *redis.Z)) *Pipeliner_ZIncrXX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*redis.Z)) + }) + return _c +} + +func (_c *Pipeliner_ZIncrXX_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZIncrXX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZIncrXX_Call) RunAndReturn(run func(context.Context, string, *redis.Z) *redis.FloatCmd) *Pipeliner_ZIncrXX_Call { + _c.Call.Return(run) + return _c +} + // ZInter provides a mock function with given fields: ctx, store func (_m *Pipeliner) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd { ret := _m.Called(ctx, store) @@ -4674,6 +12999,35 @@ func (_m *Pipeliner) ZInter(ctx context.Context, store *redis.ZStore) *redis.Str return r0 } +// Pipeliner_ZInter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZInter' +type Pipeliner_ZInter_Call struct { + *mock.Call +} + +// ZInter is a helper method to define mock.On call +// - ctx context.Context +// - store *redis.ZStore +func (_e *Pipeliner_Expecter) ZInter(ctx interface{}, store interface{}) *Pipeliner_ZInter_Call { + return &Pipeliner_ZInter_Call{Call: _e.mock.On("ZInter", ctx, store)} +} + +func (_c *Pipeliner_ZInter_Call) Run(run func(ctx context.Context, store *redis.ZStore)) *Pipeliner_ZInter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.ZStore)) + }) + return _c +} + +func (_c *Pipeliner_ZInter_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZInter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZInter_Call) RunAndReturn(run func(context.Context, *redis.ZStore) *redis.StringSliceCmd) *Pipeliner_ZInter_Call { + _c.Call.Return(run) + return _c +} + // ZInterStore provides a mock function with given fields: ctx, destination, store func (_m *Pipeliner) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd { ret := _m.Called(ctx, destination, store) @@ -4690,6 +13044,36 @@ func (_m *Pipeliner) ZInterStore(ctx context.Context, destination string, store return r0 } +// Pipeliner_ZInterStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZInterStore' +type Pipeliner_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 *Pipeliner_Expecter) ZInterStore(ctx interface{}, destination interface{}, store interface{}) *Pipeliner_ZInterStore_Call { + return &Pipeliner_ZInterStore_Call{Call: _e.mock.On("ZInterStore", ctx, destination, store)} +} + +func (_c *Pipeliner_ZInterStore_Call) Run(run func(ctx context.Context, destination string, store *redis.ZStore)) *Pipeliner_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 *Pipeliner_ZInterStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZInterStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZInterStore_Call) RunAndReturn(run func(context.Context, string, *redis.ZStore) *redis.IntCmd) *Pipeliner_ZInterStore_Call { + _c.Call.Return(run) + return _c +} + // ZInterWithScores provides a mock function with given fields: ctx, store func (_m *Pipeliner) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd { ret := _m.Called(ctx, store) @@ -4706,6 +13090,35 @@ func (_m *Pipeliner) ZInterWithScores(ctx context.Context, store *redis.ZStore) return r0 } +// Pipeliner_ZInterWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZInterWithScores' +type Pipeliner_ZInterWithScores_Call struct { + *mock.Call +} + +// ZInterWithScores is a helper method to define mock.On call +// - ctx context.Context +// - store *redis.ZStore +func (_e *Pipeliner_Expecter) ZInterWithScores(ctx interface{}, store interface{}) *Pipeliner_ZInterWithScores_Call { + return &Pipeliner_ZInterWithScores_Call{Call: _e.mock.On("ZInterWithScores", ctx, store)} +} + +func (_c *Pipeliner_ZInterWithScores_Call) Run(run func(ctx context.Context, store *redis.ZStore)) *Pipeliner_ZInterWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*redis.ZStore)) + }) + return _c +} + +func (_c *Pipeliner_ZInterWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZInterWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZInterWithScores_Call) RunAndReturn(run func(context.Context, *redis.ZStore) *redis.ZSliceCmd) *Pipeliner_ZInterWithScores_Call { + _c.Call.Return(run) + return _c +} + // ZLexCount provides a mock function with given fields: ctx, key, min, max func (_m *Pipeliner) ZLexCount(ctx context.Context, key string, min string, max string) *redis.IntCmd { ret := _m.Called(ctx, key, min, max) @@ -4722,6 +13135,37 @@ func (_m *Pipeliner) ZLexCount(ctx context.Context, key string, min string, max return r0 } +// Pipeliner_ZLexCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZLexCount' +type Pipeliner_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 *Pipeliner_Expecter) ZLexCount(ctx interface{}, key interface{}, min interface{}, max interface{}) *Pipeliner_ZLexCount_Call { + return &Pipeliner_ZLexCount_Call{Call: _e.mock.On("ZLexCount", ctx, key, min, max)} +} + +func (_c *Pipeliner_ZLexCount_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Pipeliner_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 *Pipeliner_ZLexCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZLexCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZLexCount_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_ZLexCount_Call { + _c.Call.Return(run) + return _c +} + // ZMScore provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd { _va := make([]interface{}, len(members)) @@ -4745,6 +13189,43 @@ func (_m *Pipeliner) ZMScore(ctx context.Context, key string, members ...string) return r0 } +// Pipeliner_ZMScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZMScore' +type Pipeliner_ZMScore_Call struct { + *mock.Call +} + +// ZMScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...string +func (_e *Pipeliner_Expecter) ZMScore(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZMScore_Call { + return &Pipeliner_ZMScore_Call{Call: _e.mock.On("ZMScore", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_ZMScore_Call) Run(run func(ctx context.Context, key string, members ...string)) *Pipeliner_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 *Pipeliner_ZMScore_Call) Return(_a0 *redis.FloatSliceCmd) *Pipeliner_ZMScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZMScore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.FloatSliceCmd) *Pipeliner_ZMScore_Call { + _c.Call.Return(run) + return _c +} + // ZPopMax provides a mock function with given fields: ctx, key, count func (_m *Pipeliner) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { _va := make([]interface{}, len(count)) @@ -4768,6 +13249,43 @@ func (_m *Pipeliner) ZPopMax(ctx context.Context, key string, count ...int64) *r return r0 } +// Pipeliner_ZPopMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZPopMax' +type Pipeliner_ZPopMax_Call struct { + *mock.Call +} + +// ZPopMax is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count ...int64 +func (_e *Pipeliner_Expecter) ZPopMax(ctx interface{}, key interface{}, count ...interface{}) *Pipeliner_ZPopMax_Call { + return &Pipeliner_ZPopMax_Call{Call: _e.mock.On("ZPopMax", + append([]interface{}{ctx, key}, count...)...)} +} + +func (_c *Pipeliner_ZPopMax_Call) Run(run func(ctx context.Context, key string, count ...int64)) *Pipeliner_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 *Pipeliner_ZPopMax_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZPopMax_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZPopMax_Call) RunAndReturn(run func(context.Context, string, ...int64) *redis.ZSliceCmd) *Pipeliner_ZPopMax_Call { + _c.Call.Return(run) + return _c +} + // ZPopMin provides a mock function with given fields: ctx, key, count func (_m *Pipeliner) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { _va := make([]interface{}, len(count)) @@ -4786,9 +13304,46 @@ func (_m *Pipeliner) ZPopMin(ctx context.Context, key string, count ...int64) *r if ret.Get(0) != nil { r0 = ret.Get(0).(*redis.ZSliceCmd) } - } + } + + return r0 +} + +// Pipeliner_ZPopMin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZPopMin' +type Pipeliner_ZPopMin_Call struct { + *mock.Call +} + +// ZPopMin is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count ...int64 +func (_e *Pipeliner_Expecter) ZPopMin(ctx interface{}, key interface{}, count ...interface{}) *Pipeliner_ZPopMin_Call { + return &Pipeliner_ZPopMin_Call{Call: _e.mock.On("ZPopMin", + append([]interface{}{ctx, key}, count...)...)} +} + +func (_c *Pipeliner_ZPopMin_Call) Run(run func(ctx context.Context, key string, count ...int64)) *Pipeliner_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 +} - return r0 +func (_c *Pipeliner_ZPopMin_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZPopMin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZPopMin_Call) RunAndReturn(run func(context.Context, string, ...int64) *redis.ZSliceCmd) *Pipeliner_ZPopMin_Call { + _c.Call.Return(run) + return _c } // ZRandMember provides a mock function with given fields: ctx, key, count, withScores @@ -4807,6 +13362,37 @@ func (_m *Pipeliner) ZRandMember(ctx context.Context, key string, count int, wit return r0 } +// Pipeliner_ZRandMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRandMember' +type Pipeliner_ZRandMember_Call struct { + *mock.Call +} + +// ZRandMember is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - count int +// - withScores bool +func (_e *Pipeliner_Expecter) ZRandMember(ctx interface{}, key interface{}, count interface{}, withScores interface{}) *Pipeliner_ZRandMember_Call { + return &Pipeliner_ZRandMember_Call{Call: _e.mock.On("ZRandMember", ctx, key, count, withScores)} +} + +func (_c *Pipeliner_ZRandMember_Call) Run(run func(ctx context.Context, key string, count int, withScores bool)) *Pipeliner_ZRandMember_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(bool)) + }) + return _c +} + +func (_c *Pipeliner_ZRandMember_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRandMember_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRandMember_Call) RunAndReturn(run func(context.Context, string, int, bool) *redis.StringSliceCmd) *Pipeliner_ZRandMember_Call { + _c.Call.Return(run) + return _c +} + // ZRange provides a mock function with given fields: ctx, key, start, stop func (_m *Pipeliner) ZRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd { ret := _m.Called(ctx, key, start, stop) @@ -4823,6 +13409,37 @@ func (_m *Pipeliner) ZRange(ctx context.Context, key string, start int64, stop i return r0 } +// Pipeliner_ZRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRange' +type Pipeliner_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 *Pipeliner_Expecter) ZRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRange_Call { + return &Pipeliner_ZRange_Call{Call: _e.mock.On("ZRange", ctx, key, start, stop)} +} + +func (_c *Pipeliner_ZRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_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 *Pipeliner_ZRange_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *Pipeliner_ZRange_Call { + _c.Call.Return(run) + return _c +} + // ZRangeArgs provides a mock function with given fields: ctx, z func (_m *Pipeliner) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd { ret := _m.Called(ctx, z) @@ -4839,6 +13456,35 @@ func (_m *Pipeliner) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis. return r0 } +// Pipeliner_ZRangeArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeArgs' +type Pipeliner_ZRangeArgs_Call struct { + *mock.Call +} + +// ZRangeArgs is a helper method to define mock.On call +// - ctx context.Context +// - z redis.ZRangeArgs +func (_e *Pipeliner_Expecter) ZRangeArgs(ctx interface{}, z interface{}) *Pipeliner_ZRangeArgs_Call { + return &Pipeliner_ZRangeArgs_Call{Call: _e.mock.On("ZRangeArgs", ctx, z)} +} + +func (_c *Pipeliner_ZRangeArgs_Call) Run(run func(ctx context.Context, z redis.ZRangeArgs)) *Pipeliner_ZRangeArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZRangeArgs)) + }) + return _c +} + +func (_c *Pipeliner_ZRangeArgs_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRangeArgs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRangeArgs_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) *redis.StringSliceCmd) *Pipeliner_ZRangeArgs_Call { + _c.Call.Return(run) + return _c +} + // ZRangeArgsWithScores provides a mock function with given fields: ctx, z func (_m *Pipeliner) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd { ret := _m.Called(ctx, z) @@ -4855,6 +13501,35 @@ func (_m *Pipeliner) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArg return r0 } +// Pipeliner_ZRangeArgsWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeArgsWithScores' +type Pipeliner_ZRangeArgsWithScores_Call struct { + *mock.Call +} + +// ZRangeArgsWithScores is a helper method to define mock.On call +// - ctx context.Context +// - z redis.ZRangeArgs +func (_e *Pipeliner_Expecter) ZRangeArgsWithScores(ctx interface{}, z interface{}) *Pipeliner_ZRangeArgsWithScores_Call { + return &Pipeliner_ZRangeArgsWithScores_Call{Call: _e.mock.On("ZRangeArgsWithScores", ctx, z)} +} + +func (_c *Pipeliner_ZRangeArgsWithScores_Call) Run(run func(ctx context.Context, z redis.ZRangeArgs)) *Pipeliner_ZRangeArgsWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZRangeArgs)) + }) + return _c +} + +func (_c *Pipeliner_ZRangeArgsWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRangeArgsWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRangeArgsWithScores_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) *redis.ZSliceCmd) *Pipeliner_ZRangeArgsWithScores_Call { + _c.Call.Return(run) + return _c +} + // ZRangeByLex provides a mock function with given fields: ctx, key, opt func (_m *Pipeliner) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { ret := _m.Called(ctx, key, opt) @@ -4871,6 +13546,36 @@ func (_m *Pipeliner) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRa return r0 } +// Pipeliner_ZRangeByLex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeByLex' +type Pipeliner_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 *Pipeliner_Expecter) ZRangeByLex(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRangeByLex_Call { + return &Pipeliner_ZRangeByLex_Call{Call: _e.mock.On("ZRangeByLex", ctx, key, opt)} +} + +func (_c *Pipeliner_ZRangeByLex_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_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 *Pipeliner_ZRangeByLex_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRangeByLex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRangeByLex_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *Pipeliner_ZRangeByLex_Call { + _c.Call.Return(run) + return _c +} + // ZRangeByScore provides a mock function with given fields: ctx, key, opt func (_m *Pipeliner) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { ret := _m.Called(ctx, key, opt) @@ -4887,6 +13592,36 @@ func (_m *Pipeliner) ZRangeByScore(ctx context.Context, key string, opt *redis.Z return r0 } +// Pipeliner_ZRangeByScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeByScore' +type Pipeliner_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 *Pipeliner_Expecter) ZRangeByScore(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRangeByScore_Call { + return &Pipeliner_ZRangeByScore_Call{Call: _e.mock.On("ZRangeByScore", ctx, key, opt)} +} + +func (_c *Pipeliner_ZRangeByScore_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_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 *Pipeliner_ZRangeByScore_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRangeByScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRangeByScore_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *Pipeliner_ZRangeByScore_Call { + _c.Call.Return(run) + return _c +} + // ZRangeByScoreWithScores provides a mock function with given fields: ctx, key, opt func (_m *Pipeliner) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { ret := _m.Called(ctx, key, opt) @@ -4903,6 +13638,36 @@ func (_m *Pipeliner) ZRangeByScoreWithScores(ctx context.Context, key string, op return r0 } +// Pipeliner_ZRangeByScoreWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeByScoreWithScores' +type Pipeliner_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 *Pipeliner_Expecter) ZRangeByScoreWithScores(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRangeByScoreWithScores_Call { + return &Pipeliner_ZRangeByScoreWithScores_Call{Call: _e.mock.On("ZRangeByScoreWithScores", ctx, key, opt)} +} + +func (_c *Pipeliner_ZRangeByScoreWithScores_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_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 *Pipeliner_ZRangeByScoreWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRangeByScoreWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRangeByScoreWithScores_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.ZSliceCmd) *Pipeliner_ZRangeByScoreWithScores_Call { + _c.Call.Return(run) + return _c +} + // ZRangeStore provides a mock function with given fields: ctx, dst, z func (_m *Pipeliner) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd { ret := _m.Called(ctx, dst, z) @@ -4919,6 +13684,36 @@ func (_m *Pipeliner) ZRangeStore(ctx context.Context, dst string, z redis.ZRange return r0 } +// Pipeliner_ZRangeStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeStore' +type Pipeliner_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 *Pipeliner_Expecter) ZRangeStore(ctx interface{}, dst interface{}, z interface{}) *Pipeliner_ZRangeStore_Call { + return &Pipeliner_ZRangeStore_Call{Call: _e.mock.On("ZRangeStore", ctx, dst, z)} +} + +func (_c *Pipeliner_ZRangeStore_Call) Run(run func(ctx context.Context, dst string, z redis.ZRangeArgs)) *Pipeliner_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 *Pipeliner_ZRangeStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRangeStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRangeStore_Call) RunAndReturn(run func(context.Context, string, redis.ZRangeArgs) *redis.IntCmd) *Pipeliner_ZRangeStore_Call { + _c.Call.Return(run) + return _c +} + // ZRangeWithScores provides a mock function with given fields: ctx, key, start, stop func (_m *Pipeliner) ZRangeWithScores(ctx context.Context, key string, start int64, stop int64) *redis.ZSliceCmd { ret := _m.Called(ctx, key, start, stop) @@ -4935,6 +13730,37 @@ func (_m *Pipeliner) ZRangeWithScores(ctx context.Context, key string, start int return r0 } +// Pipeliner_ZRangeWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRangeWithScores' +type Pipeliner_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 *Pipeliner_Expecter) ZRangeWithScores(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRangeWithScores_Call { + return &Pipeliner_ZRangeWithScores_Call{Call: _e.mock.On("ZRangeWithScores", ctx, key, start, stop)} +} + +func (_c *Pipeliner_ZRangeWithScores_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_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 *Pipeliner_ZRangeWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRangeWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRangeWithScores_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.ZSliceCmd) *Pipeliner_ZRangeWithScores_Call { + _c.Call.Return(run) + return _c +} + // ZRank provides a mock function with given fields: ctx, key, member func (_m *Pipeliner) ZRank(ctx context.Context, key string, member string) *redis.IntCmd { ret := _m.Called(ctx, key, member) @@ -4951,6 +13777,36 @@ func (_m *Pipeliner) ZRank(ctx context.Context, key string, member string) *redi return r0 } +// Pipeliner_ZRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRank' +type Pipeliner_ZRank_Call struct { + *mock.Call +} + +// ZRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *Pipeliner_Expecter) ZRank(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZRank_Call { + return &Pipeliner_ZRank_Call{Call: _e.mock.On("ZRank", ctx, key, member)} +} + +func (_c *Pipeliner_ZRank_Call) Run(run func(ctx context.Context, key string, member string)) *Pipeliner_ZRank_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_ZRank_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRank_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_ZRank_Call { + _c.Call.Return(run) + return _c +} + // ZRem provides a mock function with given fields: ctx, key, members func (_m *Pipeliner) ZRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { var _ca []interface{} @@ -4970,6 +13826,43 @@ func (_m *Pipeliner) ZRem(ctx context.Context, key string, members ...interface{ return r0 } +// Pipeliner_ZRem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRem' +type Pipeliner_ZRem_Call struct { + *mock.Call +} + +// ZRem is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - members ...interface{} +func (_e *Pipeliner_Expecter) ZRem(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZRem_Call { + return &Pipeliner_ZRem_Call{Call: _e.mock.On("ZRem", + append([]interface{}{ctx, key}, members...)...)} +} + +func (_c *Pipeliner_ZRem_Call) Run(run func(ctx context.Context, key string, members ...interface{})) *Pipeliner_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 *Pipeliner_ZRem_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRem_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_ZRem_Call { + _c.Call.Return(run) + return _c +} + // ZRemRangeByLex provides a mock function with given fields: ctx, key, min, max func (_m *Pipeliner) ZRemRangeByLex(ctx context.Context, key string, min string, max string) *redis.IntCmd { ret := _m.Called(ctx, key, min, max) @@ -4986,6 +13879,37 @@ func (_m *Pipeliner) ZRemRangeByLex(ctx context.Context, key string, min string, return r0 } +// Pipeliner_ZRemRangeByLex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRemRangeByLex' +type Pipeliner_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 *Pipeliner_Expecter) ZRemRangeByLex(ctx interface{}, key interface{}, min interface{}, max interface{}) *Pipeliner_ZRemRangeByLex_Call { + return &Pipeliner_ZRemRangeByLex_Call{Call: _e.mock.On("ZRemRangeByLex", ctx, key, min, max)} +} + +func (_c *Pipeliner_ZRemRangeByLex_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Pipeliner_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 *Pipeliner_ZRemRangeByLex_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRemRangeByLex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRemRangeByLex_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_ZRemRangeByLex_Call { + _c.Call.Return(run) + return _c +} + // ZRemRangeByRank provides a mock function with given fields: ctx, key, start, stop func (_m *Pipeliner) ZRemRangeByRank(ctx context.Context, key string, start int64, stop int64) *redis.IntCmd { ret := _m.Called(ctx, key, start, stop) @@ -5002,6 +13926,37 @@ func (_m *Pipeliner) ZRemRangeByRank(ctx context.Context, key string, start int6 return r0 } +// Pipeliner_ZRemRangeByRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRemRangeByRank' +type Pipeliner_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 *Pipeliner_Expecter) ZRemRangeByRank(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRemRangeByRank_Call { + return &Pipeliner_ZRemRangeByRank_Call{Call: _e.mock.On("ZRemRangeByRank", ctx, key, start, stop)} +} + +func (_c *Pipeliner_ZRemRangeByRank_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_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 *Pipeliner_ZRemRangeByRank_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRemRangeByRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRemRangeByRank_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.IntCmd) *Pipeliner_ZRemRangeByRank_Call { + _c.Call.Return(run) + return _c +} + // ZRemRangeByScore provides a mock function with given fields: ctx, key, min, max func (_m *Pipeliner) ZRemRangeByScore(ctx context.Context, key string, min string, max string) *redis.IntCmd { ret := _m.Called(ctx, key, min, max) @@ -5018,6 +13973,37 @@ func (_m *Pipeliner) ZRemRangeByScore(ctx context.Context, key string, min strin return r0 } +// Pipeliner_ZRemRangeByScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRemRangeByScore' +type Pipeliner_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 *Pipeliner_Expecter) ZRemRangeByScore(ctx interface{}, key interface{}, min interface{}, max interface{}) *Pipeliner_ZRemRangeByScore_Call { + return &Pipeliner_ZRemRangeByScore_Call{Call: _e.mock.On("ZRemRangeByScore", ctx, key, min, max)} +} + +func (_c *Pipeliner_ZRemRangeByScore_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Pipeliner_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 *Pipeliner_ZRemRangeByScore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRemRangeByScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRemRangeByScore_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_ZRemRangeByScore_Call { + _c.Call.Return(run) + return _c +} + // ZRevRange provides a mock function with given fields: ctx, key, start, stop func (_m *Pipeliner) ZRevRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd { ret := _m.Called(ctx, key, start, stop) @@ -5034,6 +14020,37 @@ func (_m *Pipeliner) ZRevRange(ctx context.Context, key string, start int64, sto return r0 } +// Pipeliner_ZRevRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRange' +type Pipeliner_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 *Pipeliner_Expecter) ZRevRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRevRange_Call { + return &Pipeliner_ZRevRange_Call{Call: _e.mock.On("ZRevRange", ctx, key, start, stop)} +} + +func (_c *Pipeliner_ZRevRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_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 *Pipeliner_ZRevRange_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRevRange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRevRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *Pipeliner_ZRevRange_Call { + _c.Call.Return(run) + return _c +} + // ZRevRangeByLex provides a mock function with given fields: ctx, key, opt func (_m *Pipeliner) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { ret := _m.Called(ctx, key, opt) @@ -5050,6 +14067,36 @@ func (_m *Pipeliner) ZRevRangeByLex(ctx context.Context, key string, opt *redis. return r0 } +// Pipeliner_ZRevRangeByLex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRangeByLex' +type Pipeliner_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 *Pipeliner_Expecter) ZRevRangeByLex(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRevRangeByLex_Call { + return &Pipeliner_ZRevRangeByLex_Call{Call: _e.mock.On("ZRevRangeByLex", ctx, key, opt)} +} + +func (_c *Pipeliner_ZRevRangeByLex_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_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 *Pipeliner_ZRevRangeByLex_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRevRangeByLex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRevRangeByLex_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *Pipeliner_ZRevRangeByLex_Call { + _c.Call.Return(run) + return _c +} + // ZRevRangeByScore provides a mock function with given fields: ctx, key, opt func (_m *Pipeliner) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { ret := _m.Called(ctx, key, opt) @@ -5066,6 +14113,36 @@ func (_m *Pipeliner) ZRevRangeByScore(ctx context.Context, key string, opt *redi return r0 } +// Pipeliner_ZRevRangeByScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRangeByScore' +type Pipeliner_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 *Pipeliner_Expecter) ZRevRangeByScore(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRevRangeByScore_Call { + return &Pipeliner_ZRevRangeByScore_Call{Call: _e.mock.On("ZRevRangeByScore", ctx, key, opt)} +} + +func (_c *Pipeliner_ZRevRangeByScore_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_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 *Pipeliner_ZRevRangeByScore_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRevRangeByScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRevRangeByScore_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *Pipeliner_ZRevRangeByScore_Call { + _c.Call.Return(run) + return _c +} + // ZRevRangeByScoreWithScores provides a mock function with given fields: ctx, key, opt func (_m *Pipeliner) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { ret := _m.Called(ctx, key, opt) @@ -5082,6 +14159,36 @@ func (_m *Pipeliner) ZRevRangeByScoreWithScores(ctx context.Context, key string, return r0 } +// Pipeliner_ZRevRangeByScoreWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRangeByScoreWithScores' +type Pipeliner_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 *Pipeliner_Expecter) ZRevRangeByScoreWithScores(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRevRangeByScoreWithScores_Call { + return &Pipeliner_ZRevRangeByScoreWithScores_Call{Call: _e.mock.On("ZRevRangeByScoreWithScores", ctx, key, opt)} +} + +func (_c *Pipeliner_ZRevRangeByScoreWithScores_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_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 *Pipeliner_ZRevRangeByScoreWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRevRangeByScoreWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRevRangeByScoreWithScores_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.ZSliceCmd) *Pipeliner_ZRevRangeByScoreWithScores_Call { + _c.Call.Return(run) + return _c +} + // ZRevRangeWithScores provides a mock function with given fields: ctx, key, start, stop func (_m *Pipeliner) ZRevRangeWithScores(ctx context.Context, key string, start int64, stop int64) *redis.ZSliceCmd { ret := _m.Called(ctx, key, start, stop) @@ -5098,6 +14205,37 @@ func (_m *Pipeliner) ZRevRangeWithScores(ctx context.Context, key string, start return r0 } +// Pipeliner_ZRevRangeWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRangeWithScores' +type Pipeliner_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 *Pipeliner_Expecter) ZRevRangeWithScores(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRevRangeWithScores_Call { + return &Pipeliner_ZRevRangeWithScores_Call{Call: _e.mock.On("ZRevRangeWithScores", ctx, key, start, stop)} +} + +func (_c *Pipeliner_ZRevRangeWithScores_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_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 *Pipeliner_ZRevRangeWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRevRangeWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRevRangeWithScores_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.ZSliceCmd) *Pipeliner_ZRevRangeWithScores_Call { + _c.Call.Return(run) + return _c +} + // ZRevRank provides a mock function with given fields: ctx, key, member func (_m *Pipeliner) ZRevRank(ctx context.Context, key string, member string) *redis.IntCmd { ret := _m.Called(ctx, key, member) @@ -5114,6 +14252,36 @@ func (_m *Pipeliner) ZRevRank(ctx context.Context, key string, member string) *r return r0 } +// Pipeliner_ZRevRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZRevRank' +type Pipeliner_ZRevRank_Call struct { + *mock.Call +} + +// ZRevRank is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *Pipeliner_Expecter) ZRevRank(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZRevRank_Call { + return &Pipeliner_ZRevRank_Call{Call: _e.mock.On("ZRevRank", ctx, key, member)} +} + +func (_c *Pipeliner_ZRevRank_Call) Run(run func(ctx context.Context, key string, member string)) *Pipeliner_ZRevRank_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_ZRevRank_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRevRank_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZRevRank_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_ZRevRank_Call { + _c.Call.Return(run) + return _c +} + // ZScan provides a mock function with given fields: ctx, key, cursor, match, count func (_m *Pipeliner) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { ret := _m.Called(ctx, key, cursor, match, count) @@ -5130,6 +14298,38 @@ func (_m *Pipeliner) ZScan(ctx context.Context, key string, cursor uint64, match return r0 } +// Pipeliner_ZScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZScan' +type Pipeliner_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 *Pipeliner_Expecter) ZScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *Pipeliner_ZScan_Call { + return &Pipeliner_ZScan_Call{Call: _e.mock.On("ZScan", ctx, key, cursor, match, count)} +} + +func (_c *Pipeliner_ZScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *Pipeliner_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 *Pipeliner_ZScan_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_ZScan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *Pipeliner_ZScan_Call { + _c.Call.Return(run) + return _c +} + // ZScore provides a mock function with given fields: ctx, key, member func (_m *Pipeliner) ZScore(ctx context.Context, key string, member string) *redis.FloatCmd { ret := _m.Called(ctx, key, member) @@ -5146,6 +14346,36 @@ func (_m *Pipeliner) ZScore(ctx context.Context, key string, member string) *red return r0 } +// Pipeliner_ZScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZScore' +type Pipeliner_ZScore_Call struct { + *mock.Call +} + +// ZScore is a helper method to define mock.On call +// - ctx context.Context +// - key string +// - member string +func (_e *Pipeliner_Expecter) ZScore(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZScore_Call { + return &Pipeliner_ZScore_Call{Call: _e.mock.On("ZScore", ctx, key, member)} +} + +func (_c *Pipeliner_ZScore_Call) Run(run func(ctx context.Context, key string, member string)) *Pipeliner_ZScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Pipeliner_ZScore_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZScore_Call) RunAndReturn(run func(context.Context, string, string) *redis.FloatCmd) *Pipeliner_ZScore_Call { + _c.Call.Return(run) + return _c +} + // ZUnion provides a mock function with given fields: ctx, store func (_m *Pipeliner) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd { ret := _m.Called(ctx, store) @@ -5162,6 +14392,35 @@ func (_m *Pipeliner) ZUnion(ctx context.Context, store redis.ZStore) *redis.Stri return r0 } +// Pipeliner_ZUnion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZUnion' +type Pipeliner_ZUnion_Call struct { + *mock.Call +} + +// ZUnion is a helper method to define mock.On call +// - ctx context.Context +// - store redis.ZStore +func (_e *Pipeliner_Expecter) ZUnion(ctx interface{}, store interface{}) *Pipeliner_ZUnion_Call { + return &Pipeliner_ZUnion_Call{Call: _e.mock.On("ZUnion", ctx, store)} +} + +func (_c *Pipeliner_ZUnion_Call) Run(run func(ctx context.Context, store redis.ZStore)) *Pipeliner_ZUnion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZStore)) + }) + return _c +} + +func (_c *Pipeliner_ZUnion_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZUnion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZUnion_Call) RunAndReturn(run func(context.Context, redis.ZStore) *redis.StringSliceCmd) *Pipeliner_ZUnion_Call { + _c.Call.Return(run) + return _c +} + // ZUnionStore provides a mock function with given fields: ctx, dest, store func (_m *Pipeliner) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd { ret := _m.Called(ctx, dest, store) @@ -5178,6 +14437,36 @@ func (_m *Pipeliner) ZUnionStore(ctx context.Context, dest string, store *redis. return r0 } +// Pipeliner_ZUnionStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZUnionStore' +type Pipeliner_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 *Pipeliner_Expecter) ZUnionStore(ctx interface{}, dest interface{}, store interface{}) *Pipeliner_ZUnionStore_Call { + return &Pipeliner_ZUnionStore_Call{Call: _e.mock.On("ZUnionStore", ctx, dest, store)} +} + +func (_c *Pipeliner_ZUnionStore_Call) Run(run func(ctx context.Context, dest string, store *redis.ZStore)) *Pipeliner_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 *Pipeliner_ZUnionStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZUnionStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZUnionStore_Call) RunAndReturn(run func(context.Context, string, *redis.ZStore) *redis.IntCmd) *Pipeliner_ZUnionStore_Call { + _c.Call.Return(run) + return _c +} + // ZUnionWithScores provides a mock function with given fields: ctx, store func (_m *Pipeliner) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd { ret := _m.Called(ctx, store) @@ -5194,6 +14483,35 @@ func (_m *Pipeliner) ZUnionWithScores(ctx context.Context, store redis.ZStore) * return r0 } +// Pipeliner_ZUnionWithScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ZUnionWithScores' +type Pipeliner_ZUnionWithScores_Call struct { + *mock.Call +} + +// ZUnionWithScores is a helper method to define mock.On call +// - ctx context.Context +// - store redis.ZStore +func (_e *Pipeliner_Expecter) ZUnionWithScores(ctx interface{}, store interface{}) *Pipeliner_ZUnionWithScores_Call { + return &Pipeliner_ZUnionWithScores_Call{Call: _e.mock.On("ZUnionWithScores", ctx, store)} +} + +func (_c *Pipeliner_ZUnionWithScores_Call) Run(run func(ctx context.Context, store redis.ZStore)) *Pipeliner_ZUnionWithScores_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(redis.ZStore)) + }) + return _c +} + +func (_c *Pipeliner_ZUnionWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZUnionWithScores_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Pipeliner_ZUnionWithScores_Call) RunAndReturn(run func(context.Context, redis.ZStore) *redis.ZSliceCmd) *Pipeliner_ZUnionWithScores_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewPipeliner interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/AcknowledgeableInput.go b/pkg/stream/mocks/AcknowledgeableInput.go index e512677f9..410550e31 100644 --- a/pkg/stream/mocks/AcknowledgeableInput.go +++ b/pkg/stream/mocks/AcknowledgeableInput.go @@ -14,6 +14,14 @@ type AcknowledgeableInput struct { mock.Mock } +type AcknowledgeableInput_Expecter struct { + mock *mock.Mock +} + +func (_m *AcknowledgeableInput) EXPECT() *AcknowledgeableInput_Expecter { + return &AcknowledgeableInput_Expecter{mock: &_m.Mock} +} + // Ack provides a mock function with given fields: ctx, msg, ack func (_m *AcknowledgeableInput) Ack(ctx context.Context, msg *stream.Message, ack bool) error { ret := _m.Called(ctx, msg, ack) @@ -28,6 +36,36 @@ func (_m *AcknowledgeableInput) Ack(ctx context.Context, msg *stream.Message, ac return r0 } +// AcknowledgeableInput_Ack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ack' +type AcknowledgeableInput_Ack_Call struct { + *mock.Call +} + +// Ack is a helper method to define mock.On call +// - ctx context.Context +// - msg *stream.Message +// - ack bool +func (_e *AcknowledgeableInput_Expecter) Ack(ctx interface{}, msg interface{}, ack interface{}) *AcknowledgeableInput_Ack_Call { + return &AcknowledgeableInput_Ack_Call{Call: _e.mock.On("Ack", ctx, msg, ack)} +} + +func (_c *AcknowledgeableInput_Ack_Call) Run(run func(ctx context.Context, msg *stream.Message, ack bool)) *AcknowledgeableInput_Ack_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*stream.Message), args[2].(bool)) + }) + return _c +} + +func (_c *AcknowledgeableInput_Ack_Call) Return(_a0 error) *AcknowledgeableInput_Ack_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AcknowledgeableInput_Ack_Call) RunAndReturn(run func(context.Context, *stream.Message, bool) error) *AcknowledgeableInput_Ack_Call { + _c.Call.Return(run) + return _c +} + // AckBatch provides a mock function with given fields: ctx, msgs, acks func (_m *AcknowledgeableInput) AckBatch(ctx context.Context, msgs []*stream.Message, acks []bool) error { ret := _m.Called(ctx, msgs, acks) @@ -42,6 +80,36 @@ func (_m *AcknowledgeableInput) AckBatch(ctx context.Context, msgs []*stream.Mes return r0 } +// AcknowledgeableInput_AckBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AckBatch' +type AcknowledgeableInput_AckBatch_Call struct { + *mock.Call +} + +// AckBatch is a helper method to define mock.On call +// - ctx context.Context +// - msgs []*stream.Message +// - acks []bool +func (_e *AcknowledgeableInput_Expecter) AckBatch(ctx interface{}, msgs interface{}, acks interface{}) *AcknowledgeableInput_AckBatch_Call { + return &AcknowledgeableInput_AckBatch_Call{Call: _e.mock.On("AckBatch", ctx, msgs, acks)} +} + +func (_c *AcknowledgeableInput_AckBatch_Call) Run(run func(ctx context.Context, msgs []*stream.Message, acks []bool)) *AcknowledgeableInput_AckBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*stream.Message), args[2].([]bool)) + }) + return _c +} + +func (_c *AcknowledgeableInput_AckBatch_Call) Return(_a0 error) *AcknowledgeableInput_AckBatch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AcknowledgeableInput_AckBatch_Call) RunAndReturn(run func(context.Context, []*stream.Message, []bool) error) *AcknowledgeableInput_AckBatch_Call { + _c.Call.Return(run) + return _c +} + // Data provides a mock function with given fields: func (_m *AcknowledgeableInput) Data() <-chan *stream.Message { ret := _m.Called() @@ -58,6 +126,33 @@ func (_m *AcknowledgeableInput) Data() <-chan *stream.Message { return r0 } +// AcknowledgeableInput_Data_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Data' +type AcknowledgeableInput_Data_Call struct { + *mock.Call +} + +// Data is a helper method to define mock.On call +func (_e *AcknowledgeableInput_Expecter) Data() *AcknowledgeableInput_Data_Call { + return &AcknowledgeableInput_Data_Call{Call: _e.mock.On("Data")} +} + +func (_c *AcknowledgeableInput_Data_Call) Run(run func()) *AcknowledgeableInput_Data_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AcknowledgeableInput_Data_Call) Return(_a0 <-chan *stream.Message) *AcknowledgeableInput_Data_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AcknowledgeableInput_Data_Call) RunAndReturn(run func() <-chan *stream.Message) *AcknowledgeableInput_Data_Call { + _c.Call.Return(run) + return _c +} + // Run provides a mock function with given fields: ctx func (_m *AcknowledgeableInput) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -72,11 +167,66 @@ func (_m *AcknowledgeableInput) Run(ctx context.Context) error { return r0 } +// AcknowledgeableInput_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type AcknowledgeableInput_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *AcknowledgeableInput_Expecter) Run(ctx interface{}) *AcknowledgeableInput_Run_Call { + return &AcknowledgeableInput_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *AcknowledgeableInput_Run_Call) Run(run func(ctx context.Context)) *AcknowledgeableInput_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *AcknowledgeableInput_Run_Call) Return(_a0 error) *AcknowledgeableInput_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AcknowledgeableInput_Run_Call) RunAndReturn(run func(context.Context) error) *AcknowledgeableInput_Run_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *AcknowledgeableInput) Stop() { _m.Called() } +// AcknowledgeableInput_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type AcknowledgeableInput_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *AcknowledgeableInput_Expecter) Stop() *AcknowledgeableInput_Stop_Call { + return &AcknowledgeableInput_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *AcknowledgeableInput_Stop_Call) Run(run func()) *AcknowledgeableInput_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AcknowledgeableInput_Stop_Call) Return() *AcknowledgeableInput_Stop_Call { + _c.Call.Return() + return _c +} + +func (_c *AcknowledgeableInput_Stop_Call) RunAndReturn(run func()) *AcknowledgeableInput_Stop_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewAcknowledgeableInput interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/BatchConsumerCallback.go b/pkg/stream/mocks/BatchConsumerCallback.go index 6360761d9..e00b24454 100644 --- a/pkg/stream/mocks/BatchConsumerCallback.go +++ b/pkg/stream/mocks/BatchConsumerCallback.go @@ -13,6 +13,14 @@ type BatchConsumerCallback struct { mock.Mock } +type BatchConsumerCallback_Expecter struct { + mock *mock.Mock +} + +func (_m *BatchConsumerCallback) EXPECT() *BatchConsumerCallback_Expecter { + return &BatchConsumerCallback_Expecter{mock: &_m.Mock} +} + // Consume provides a mock function with given fields: ctx, models, attributes func (_m *BatchConsumerCallback) Consume(ctx context.Context, models []interface{}, attributes []map[string]interface{}) ([]bool, error) { ret := _m.Called(ctx, models, attributes) @@ -39,6 +47,36 @@ func (_m *BatchConsumerCallback) Consume(ctx context.Context, models []interface return r0, r1 } +// BatchConsumerCallback_Consume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Consume' +type BatchConsumerCallback_Consume_Call struct { + *mock.Call +} + +// Consume is a helper method to define mock.On call +// - ctx context.Context +// - models []interface{} +// - attributes []map[string]interface{} +func (_e *BatchConsumerCallback_Expecter) Consume(ctx interface{}, models interface{}, attributes interface{}) *BatchConsumerCallback_Consume_Call { + return &BatchConsumerCallback_Consume_Call{Call: _e.mock.On("Consume", ctx, models, attributes)} +} + +func (_c *BatchConsumerCallback_Consume_Call) Run(run func(ctx context.Context, models []interface{}, attributes []map[string]interface{})) *BatchConsumerCallback_Consume_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]interface{}), args[2].([]map[string]interface{})) + }) + return _c +} + +func (_c *BatchConsumerCallback_Consume_Call) Return(_a0 []bool, _a1 error) *BatchConsumerCallback_Consume_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *BatchConsumerCallback_Consume_Call) RunAndReturn(run func(context.Context, []interface{}, []map[string]interface{}) ([]bool, error)) *BatchConsumerCallback_Consume_Call { + _c.Call.Return(run) + return _c +} + // GetModel provides a mock function with given fields: attributes func (_m *BatchConsumerCallback) GetModel(attributes map[string]interface{}) interface{} { ret := _m.Called(attributes) @@ -55,6 +93,34 @@ func (_m *BatchConsumerCallback) GetModel(attributes map[string]interface{}) int return r0 } +// BatchConsumerCallback_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type BatchConsumerCallback_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +// - attributes map[string]interface{} +func (_e *BatchConsumerCallback_Expecter) GetModel(attributes interface{}) *BatchConsumerCallback_GetModel_Call { + return &BatchConsumerCallback_GetModel_Call{Call: _e.mock.On("GetModel", attributes)} +} + +func (_c *BatchConsumerCallback_GetModel_Call) Run(run func(attributes map[string]interface{})) *BatchConsumerCallback_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]interface{})) + }) + return _c +} + +func (_c *BatchConsumerCallback_GetModel_Call) Return(_a0 interface{}) *BatchConsumerCallback_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BatchConsumerCallback_GetModel_Call) RunAndReturn(run func(map[string]interface{}) interface{}) *BatchConsumerCallback_GetModel_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewBatchConsumerCallback interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/ConsumerCallback.go b/pkg/stream/mocks/ConsumerCallback.go index 6ed441f1b..23be5862e 100644 --- a/pkg/stream/mocks/ConsumerCallback.go +++ b/pkg/stream/mocks/ConsumerCallback.go @@ -13,6 +13,14 @@ type ConsumerCallback struct { mock.Mock } +type ConsumerCallback_Expecter struct { + mock *mock.Mock +} + +func (_m *ConsumerCallback) EXPECT() *ConsumerCallback_Expecter { + return &ConsumerCallback_Expecter{mock: &_m.Mock} +} + // Consume provides a mock function with given fields: ctx, model, attributes func (_m *ConsumerCallback) Consume(ctx context.Context, model interface{}, attributes map[string]interface{}) (bool, error) { ret := _m.Called(ctx, model, attributes) @@ -37,6 +45,36 @@ func (_m *ConsumerCallback) Consume(ctx context.Context, model interface{}, attr return r0, r1 } +// ConsumerCallback_Consume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Consume' +type ConsumerCallback_Consume_Call struct { + *mock.Call +} + +// Consume is a helper method to define mock.On call +// - ctx context.Context +// - model interface{} +// - attributes map[string]interface{} +func (_e *ConsumerCallback_Expecter) Consume(ctx interface{}, model interface{}, attributes interface{}) *ConsumerCallback_Consume_Call { + return &ConsumerCallback_Consume_Call{Call: _e.mock.On("Consume", ctx, model, attributes)} +} + +func (_c *ConsumerCallback_Consume_Call) Run(run func(ctx context.Context, model interface{}, attributes map[string]interface{})) *ConsumerCallback_Consume_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(map[string]interface{})) + }) + return _c +} + +func (_c *ConsumerCallback_Consume_Call) Return(_a0 bool, _a1 error) *ConsumerCallback_Consume_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ConsumerCallback_Consume_Call) RunAndReturn(run func(context.Context, interface{}, map[string]interface{}) (bool, error)) *ConsumerCallback_Consume_Call { + _c.Call.Return(run) + return _c +} + // GetModel provides a mock function with given fields: attributes func (_m *ConsumerCallback) GetModel(attributes map[string]interface{}) interface{} { ret := _m.Called(attributes) @@ -53,6 +91,34 @@ func (_m *ConsumerCallback) GetModel(attributes map[string]interface{}) interfac return r0 } +// ConsumerCallback_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type ConsumerCallback_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +// - attributes map[string]interface{} +func (_e *ConsumerCallback_Expecter) GetModel(attributes interface{}) *ConsumerCallback_GetModel_Call { + return &ConsumerCallback_GetModel_Call{Call: _e.mock.On("GetModel", attributes)} +} + +func (_c *ConsumerCallback_GetModel_Call) Run(run func(attributes map[string]interface{})) *ConsumerCallback_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]interface{})) + }) + return _c +} + +func (_c *ConsumerCallback_GetModel_Call) Return(_a0 interface{}) *ConsumerCallback_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ConsumerCallback_GetModel_Call) RunAndReturn(run func(map[string]interface{}) interface{}) *ConsumerCallback_GetModel_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewConsumerCallback interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/Input.go b/pkg/stream/mocks/Input.go index a4b278e55..3627246f4 100644 --- a/pkg/stream/mocks/Input.go +++ b/pkg/stream/mocks/Input.go @@ -14,6 +14,14 @@ type Input struct { mock.Mock } +type Input_Expecter struct { + mock *mock.Mock +} + +func (_m *Input) EXPECT() *Input_Expecter { + return &Input_Expecter{mock: &_m.Mock} +} + // Data provides a mock function with given fields: func (_m *Input) Data() <-chan *stream.Message { ret := _m.Called() @@ -30,6 +38,33 @@ func (_m *Input) Data() <-chan *stream.Message { return r0 } +// Input_Data_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Data' +type Input_Data_Call struct { + *mock.Call +} + +// Data is a helper method to define mock.On call +func (_e *Input_Expecter) Data() *Input_Data_Call { + return &Input_Data_Call{Call: _e.mock.On("Data")} +} + +func (_c *Input_Data_Call) Run(run func()) *Input_Data_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Input_Data_Call) Return(_a0 <-chan *stream.Message) *Input_Data_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Input_Data_Call) RunAndReturn(run func() <-chan *stream.Message) *Input_Data_Call { + _c.Call.Return(run) + return _c +} + // Run provides a mock function with given fields: ctx func (_m *Input) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -44,11 +79,66 @@ func (_m *Input) Run(ctx context.Context) error { return r0 } +// Input_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type Input_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *Input_Expecter) Run(ctx interface{}) *Input_Run_Call { + return &Input_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *Input_Run_Call) Run(run func(ctx context.Context)) *Input_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Input_Run_Call) Return(_a0 error) *Input_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Input_Run_Call) RunAndReturn(run func(context.Context) error) *Input_Run_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *Input) Stop() { _m.Called() } +// Input_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type Input_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *Input_Expecter) Stop() *Input_Stop_Call { + return &Input_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *Input_Stop_Call) Run(run func()) *Input_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Input_Stop_Call) Return() *Input_Stop_Call { + _c.Call.Return() + return _c +} + +func (_c *Input_Stop_Call) RunAndReturn(run func()) *Input_Stop_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewInput interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/MessageEncoder.go b/pkg/stream/mocks/MessageEncoder.go index 5106a54a0..ae7ea1382 100644 --- a/pkg/stream/mocks/MessageEncoder.go +++ b/pkg/stream/mocks/MessageEncoder.go @@ -14,6 +14,14 @@ type MessageEncoder struct { mock.Mock } +type MessageEncoder_Expecter struct { + mock *mock.Mock +} + +func (_m *MessageEncoder) EXPECT() *MessageEncoder_Expecter { + return &MessageEncoder_Expecter{mock: &_m.Mock} +} + // Decode provides a mock function with given fields: ctx, msg, out func (_m *MessageEncoder) Decode(ctx context.Context, msg *stream.Message, out interface{}) (context.Context, map[string]interface{}, error) { ret := _m.Called(ctx, msg, out) @@ -49,6 +57,36 @@ func (_m *MessageEncoder) Decode(ctx context.Context, msg *stream.Message, out i return r0, r1, r2 } +// MessageEncoder_Decode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Decode' +type MessageEncoder_Decode_Call struct { + *mock.Call +} + +// Decode is a helper method to define mock.On call +// - ctx context.Context +// - msg *stream.Message +// - out interface{} +func (_e *MessageEncoder_Expecter) Decode(ctx interface{}, msg interface{}, out interface{}) *MessageEncoder_Decode_Call { + return &MessageEncoder_Decode_Call{Call: _e.mock.On("Decode", ctx, msg, out)} +} + +func (_c *MessageEncoder_Decode_Call) Run(run func(ctx context.Context, msg *stream.Message, out interface{})) *MessageEncoder_Decode_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*stream.Message), args[2].(interface{})) + }) + return _c +} + +func (_c *MessageEncoder_Decode_Call) Return(_a0 context.Context, _a1 map[string]interface{}, _a2 error) *MessageEncoder_Decode_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MessageEncoder_Decode_Call) RunAndReturn(run func(context.Context, *stream.Message, interface{}) (context.Context, map[string]interface{}, error)) *MessageEncoder_Decode_Call { + _c.Call.Return(run) + return _c +} + // Encode provides a mock function with given fields: ctx, data, attributeSets func (_m *MessageEncoder) Encode(ctx context.Context, data interface{}, attributeSets ...map[string]interface{}) (*stream.Message, error) { _va := make([]interface{}, len(attributeSets)) @@ -82,6 +120,43 @@ func (_m *MessageEncoder) Encode(ctx context.Context, data interface{}, attribut return r0, r1 } +// MessageEncoder_Encode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Encode' +type MessageEncoder_Encode_Call struct { + *mock.Call +} + +// Encode is a helper method to define mock.On call +// - ctx context.Context +// - data interface{} +// - attributeSets ...map[string]interface{} +func (_e *MessageEncoder_Expecter) Encode(ctx interface{}, data interface{}, attributeSets ...interface{}) *MessageEncoder_Encode_Call { + return &MessageEncoder_Encode_Call{Call: _e.mock.On("Encode", + append([]interface{}{ctx, data}, attributeSets...)...)} +} + +func (_c *MessageEncoder_Encode_Call) Run(run func(ctx context.Context, data interface{}, attributeSets ...map[string]interface{})) *MessageEncoder_Encode_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(args[0].(context.Context), args[1].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *MessageEncoder_Encode_Call) Return(_a0 *stream.Message, _a1 error) *MessageEncoder_Encode_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MessageEncoder_Encode_Call) RunAndReturn(run func(context.Context, interface{}, ...map[string]interface{}) (*stream.Message, error)) *MessageEncoder_Encode_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewMessageEncoder interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/Output.go b/pkg/stream/mocks/Output.go index 385d955bb..6d6b1d0b7 100644 --- a/pkg/stream/mocks/Output.go +++ b/pkg/stream/mocks/Output.go @@ -14,6 +14,14 @@ type Output struct { mock.Mock } +type Output_Expecter struct { + mock *mock.Mock +} + +func (_m *Output) EXPECT() *Output_Expecter { + return &Output_Expecter{mock: &_m.Mock} +} + // Write provides a mock function with given fields: ctx, batch func (_m *Output) Write(ctx context.Context, batch []stream.WritableMessage) error { ret := _m.Called(ctx, batch) @@ -28,6 +36,35 @@ func (_m *Output) Write(ctx context.Context, batch []stream.WritableMessage) err return r0 } +// Output_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type Output_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - ctx context.Context +// - batch []stream.WritableMessage +func (_e *Output_Expecter) Write(ctx interface{}, batch interface{}) *Output_Write_Call { + return &Output_Write_Call{Call: _e.mock.On("Write", ctx, batch)} +} + +func (_c *Output_Write_Call) Run(run func(ctx context.Context, batch []stream.WritableMessage)) *Output_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]stream.WritableMessage)) + }) + return _c +} + +func (_c *Output_Write_Call) Return(_a0 error) *Output_Write_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Output_Write_Call) RunAndReturn(run func(context.Context, []stream.WritableMessage) error) *Output_Write_Call { + _c.Call.Return(run) + return _c +} + // WriteOne provides a mock function with given fields: ctx, msg func (_m *Output) WriteOne(ctx context.Context, msg stream.WritableMessage) error { ret := _m.Called(ctx, msg) @@ -42,6 +79,35 @@ func (_m *Output) WriteOne(ctx context.Context, msg stream.WritableMessage) erro return r0 } +// Output_WriteOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOne' +type Output_WriteOne_Call struct { + *mock.Call +} + +// WriteOne is a helper method to define mock.On call +// - ctx context.Context +// - msg stream.WritableMessage +func (_e *Output_Expecter) WriteOne(ctx interface{}, msg interface{}) *Output_WriteOne_Call { + return &Output_WriteOne_Call{Call: _e.mock.On("WriteOne", ctx, msg)} +} + +func (_c *Output_WriteOne_Call) Run(run func(ctx context.Context, msg stream.WritableMessage)) *Output_WriteOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(stream.WritableMessage)) + }) + return _c +} + +func (_c *Output_WriteOne_Call) Return(_a0 error) *Output_WriteOne_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Output_WriteOne_Call) RunAndReturn(run func(context.Context, stream.WritableMessage) error) *Output_WriteOne_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewOutput interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/PartitionedOutput.go b/pkg/stream/mocks/PartitionedOutput.go index 7befa659a..5979eb4a9 100644 --- a/pkg/stream/mocks/PartitionedOutput.go +++ b/pkg/stream/mocks/PartitionedOutput.go @@ -14,6 +14,14 @@ type PartitionedOutput struct { mock.Mock } +type PartitionedOutput_Expecter struct { + mock *mock.Mock +} + +func (_m *PartitionedOutput) EXPECT() *PartitionedOutput_Expecter { + return &PartitionedOutput_Expecter{mock: &_m.Mock} +} + // IsPartitionedOutput provides a mock function with given fields: func (_m *PartitionedOutput) IsPartitionedOutput() bool { ret := _m.Called() @@ -28,6 +36,33 @@ func (_m *PartitionedOutput) IsPartitionedOutput() bool { return r0 } +// PartitionedOutput_IsPartitionedOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPartitionedOutput' +type PartitionedOutput_IsPartitionedOutput_Call struct { + *mock.Call +} + +// IsPartitionedOutput is a helper method to define mock.On call +func (_e *PartitionedOutput_Expecter) IsPartitionedOutput() *PartitionedOutput_IsPartitionedOutput_Call { + return &PartitionedOutput_IsPartitionedOutput_Call{Call: _e.mock.On("IsPartitionedOutput")} +} + +func (_c *PartitionedOutput_IsPartitionedOutput_Call) Run(run func()) *PartitionedOutput_IsPartitionedOutput_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PartitionedOutput_IsPartitionedOutput_Call) Return(_a0 bool) *PartitionedOutput_IsPartitionedOutput_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PartitionedOutput_IsPartitionedOutput_Call) RunAndReturn(run func() bool) *PartitionedOutput_IsPartitionedOutput_Call { + _c.Call.Return(run) + return _c +} + // Write provides a mock function with given fields: ctx, batch func (_m *PartitionedOutput) Write(ctx context.Context, batch []stream.WritableMessage) error { ret := _m.Called(ctx, batch) @@ -42,6 +77,35 @@ func (_m *PartitionedOutput) Write(ctx context.Context, batch []stream.WritableM return r0 } +// PartitionedOutput_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type PartitionedOutput_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - ctx context.Context +// - batch []stream.WritableMessage +func (_e *PartitionedOutput_Expecter) Write(ctx interface{}, batch interface{}) *PartitionedOutput_Write_Call { + return &PartitionedOutput_Write_Call{Call: _e.mock.On("Write", ctx, batch)} +} + +func (_c *PartitionedOutput_Write_Call) Run(run func(ctx context.Context, batch []stream.WritableMessage)) *PartitionedOutput_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]stream.WritableMessage)) + }) + return _c +} + +func (_c *PartitionedOutput_Write_Call) Return(_a0 error) *PartitionedOutput_Write_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PartitionedOutput_Write_Call) RunAndReturn(run func(context.Context, []stream.WritableMessage) error) *PartitionedOutput_Write_Call { + _c.Call.Return(run) + return _c +} + // WriteOne provides a mock function with given fields: ctx, msg func (_m *PartitionedOutput) WriteOne(ctx context.Context, msg stream.WritableMessage) error { ret := _m.Called(ctx, msg) @@ -56,6 +120,35 @@ func (_m *PartitionedOutput) WriteOne(ctx context.Context, msg stream.WritableMe return r0 } +// PartitionedOutput_WriteOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOne' +type PartitionedOutput_WriteOne_Call struct { + *mock.Call +} + +// WriteOne is a helper method to define mock.On call +// - ctx context.Context +// - msg stream.WritableMessage +func (_e *PartitionedOutput_Expecter) WriteOne(ctx interface{}, msg interface{}) *PartitionedOutput_WriteOne_Call { + return &PartitionedOutput_WriteOne_Call{Call: _e.mock.On("WriteOne", ctx, msg)} +} + +func (_c *PartitionedOutput_WriteOne_Call) Run(run func(ctx context.Context, msg stream.WritableMessage)) *PartitionedOutput_WriteOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(stream.WritableMessage)) + }) + return _c +} + +func (_c *PartitionedOutput_WriteOne_Call) Return(_a0 error) *PartitionedOutput_WriteOne_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PartitionedOutput_WriteOne_Call) RunAndReturn(run func(context.Context, stream.WritableMessage) error) *PartitionedOutput_WriteOne_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewPartitionedOutput interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/PartitionerRand.go b/pkg/stream/mocks/PartitionerRand.go index 86a20c5a8..8e2decf49 100644 --- a/pkg/stream/mocks/PartitionerRand.go +++ b/pkg/stream/mocks/PartitionerRand.go @@ -9,6 +9,14 @@ type PartitionerRand struct { mock.Mock } +type PartitionerRand_Expecter struct { + mock *mock.Mock +} + +func (_m *PartitionerRand) EXPECT() *PartitionerRand_Expecter { + return &PartitionerRand_Expecter{mock: &_m.Mock} +} + // Intn provides a mock function with given fields: n func (_m *PartitionerRand) Intn(n int) int { ret := _m.Called(n) @@ -23,6 +31,34 @@ func (_m *PartitionerRand) Intn(n int) int { return r0 } +// PartitionerRand_Intn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Intn' +type PartitionerRand_Intn_Call struct { + *mock.Call +} + +// Intn is a helper method to define mock.On call +// - n int +func (_e *PartitionerRand_Expecter) Intn(n interface{}) *PartitionerRand_Intn_Call { + return &PartitionerRand_Intn_Call{Call: _e.mock.On("Intn", n)} +} + +func (_c *PartitionerRand_Intn_Call) Run(run func(n int)) *PartitionerRand_Intn_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *PartitionerRand_Intn_Call) Return(_a0 int) *PartitionerRand_Intn_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PartitionerRand_Intn_Call) RunAndReturn(run func(int) int) *PartitionerRand_Intn_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewPartitionerRand interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/Producer.go b/pkg/stream/mocks/Producer.go index fcad345c2..ad5ec43e3 100644 --- a/pkg/stream/mocks/Producer.go +++ b/pkg/stream/mocks/Producer.go @@ -13,6 +13,14 @@ type Producer struct { mock.Mock } +type Producer_Expecter struct { + mock *mock.Mock +} + +func (_m *Producer) EXPECT() *Producer_Expecter { + return &Producer_Expecter{mock: &_m.Mock} +} + // Write provides a mock function with given fields: ctx, models, attributeSets func (_m *Producer) Write(ctx context.Context, models interface{}, attributeSets ...map[string]interface{}) error { _va := make([]interface{}, len(attributeSets)) @@ -34,6 +42,43 @@ func (_m *Producer) Write(ctx context.Context, models interface{}, attributeSets return r0 } +// Producer_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type Producer_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - ctx context.Context +// - models interface{} +// - attributeSets ...map[string]interface{} +func (_e *Producer_Expecter) Write(ctx interface{}, models interface{}, attributeSets ...interface{}) *Producer_Write_Call { + return &Producer_Write_Call{Call: _e.mock.On("Write", + append([]interface{}{ctx, models}, attributeSets...)...)} +} + +func (_c *Producer_Write_Call) Run(run func(ctx context.Context, models interface{}, attributeSets ...map[string]interface{})) *Producer_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(args[0].(context.Context), args[1].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *Producer_Write_Call) Return(_a0 error) *Producer_Write_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Producer_Write_Call) RunAndReturn(run func(context.Context, interface{}, ...map[string]interface{}) error) *Producer_Write_Call { + _c.Call.Return(run) + return _c +} + // WriteOne provides a mock function with given fields: ctx, model, attributeSets func (_m *Producer) WriteOne(ctx context.Context, model interface{}, attributeSets ...map[string]interface{}) error { _va := make([]interface{}, len(attributeSets)) @@ -55,6 +100,43 @@ func (_m *Producer) WriteOne(ctx context.Context, model interface{}, attributeSe return r0 } +// Producer_WriteOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOne' +type Producer_WriteOne_Call struct { + *mock.Call +} + +// WriteOne is a helper method to define mock.On call +// - ctx context.Context +// - model interface{} +// - attributeSets ...map[string]interface{} +func (_e *Producer_Expecter) WriteOne(ctx interface{}, model interface{}, attributeSets ...interface{}) *Producer_WriteOne_Call { + return &Producer_WriteOne_Call{Call: _e.mock.On("WriteOne", + append([]interface{}{ctx, model}, attributeSets...)...)} +} + +func (_c *Producer_WriteOne_Call) Run(run func(ctx context.Context, model interface{}, attributeSets ...map[string]interface{})) *Producer_WriteOne_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(args[0].(context.Context), args[1].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *Producer_WriteOne_Call) Return(_a0 error) *Producer_WriteOne_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Producer_WriteOne_Call) RunAndReturn(run func(context.Context, interface{}, ...map[string]interface{}) error) *Producer_WriteOne_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewProducer interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/ProducerDaemonAggregator.go b/pkg/stream/mocks/ProducerDaemonAggregator.go index 1cd919935..a8b08b268 100644 --- a/pkg/stream/mocks/ProducerDaemonAggregator.go +++ b/pkg/stream/mocks/ProducerDaemonAggregator.go @@ -14,6 +14,14 @@ type ProducerDaemonAggregator struct { mock.Mock } +type ProducerDaemonAggregator_Expecter struct { + mock *mock.Mock +} + +func (_m *ProducerDaemonAggregator) EXPECT() *ProducerDaemonAggregator_Expecter { + return &ProducerDaemonAggregator_Expecter{mock: &_m.Mock} +} + // Flush provides a mock function with given fields: func (_m *ProducerDaemonAggregator) Flush() ([]stream.AggregateFlush, error) { ret := _m.Called() @@ -40,6 +48,33 @@ func (_m *ProducerDaemonAggregator) Flush() ([]stream.AggregateFlush, error) { return r0, r1 } +// ProducerDaemonAggregator_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush' +type ProducerDaemonAggregator_Flush_Call struct { + *mock.Call +} + +// Flush is a helper method to define mock.On call +func (_e *ProducerDaemonAggregator_Expecter) Flush() *ProducerDaemonAggregator_Flush_Call { + return &ProducerDaemonAggregator_Flush_Call{Call: _e.mock.On("Flush")} +} + +func (_c *ProducerDaemonAggregator_Flush_Call) Run(run func()) *ProducerDaemonAggregator_Flush_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ProducerDaemonAggregator_Flush_Call) Return(_a0 []stream.AggregateFlush, _a1 error) *ProducerDaemonAggregator_Flush_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ProducerDaemonAggregator_Flush_Call) RunAndReturn(run func() ([]stream.AggregateFlush, error)) *ProducerDaemonAggregator_Flush_Call { + _c.Call.Return(run) + return _c +} + // Write provides a mock function with given fields: ctx, msg func (_m *ProducerDaemonAggregator) Write(ctx context.Context, msg *stream.Message) ([]stream.AggregateFlush, error) { ret := _m.Called(ctx, msg) @@ -66,6 +101,35 @@ func (_m *ProducerDaemonAggregator) Write(ctx context.Context, msg *stream.Messa return r0, r1 } +// ProducerDaemonAggregator_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type ProducerDaemonAggregator_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - ctx context.Context +// - msg *stream.Message +func (_e *ProducerDaemonAggregator_Expecter) Write(ctx interface{}, msg interface{}) *ProducerDaemonAggregator_Write_Call { + return &ProducerDaemonAggregator_Write_Call{Call: _e.mock.On("Write", ctx, msg)} +} + +func (_c *ProducerDaemonAggregator_Write_Call) Run(run func(ctx context.Context, msg *stream.Message)) *ProducerDaemonAggregator_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*stream.Message)) + }) + return _c +} + +func (_c *ProducerDaemonAggregator_Write_Call) Return(_a0 []stream.AggregateFlush, _a1 error) *ProducerDaemonAggregator_Write_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ProducerDaemonAggregator_Write_Call) RunAndReturn(run func(context.Context, *stream.Message) ([]stream.AggregateFlush, error)) *ProducerDaemonAggregator_Write_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewProducerDaemonAggregator interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/ProducerDaemonBatcher.go b/pkg/stream/mocks/ProducerDaemonBatcher.go index 5d163c636..522dcc867 100644 --- a/pkg/stream/mocks/ProducerDaemonBatcher.go +++ b/pkg/stream/mocks/ProducerDaemonBatcher.go @@ -12,6 +12,14 @@ type ProducerDaemonBatcher struct { mock.Mock } +type ProducerDaemonBatcher_Expecter struct { + mock *mock.Mock +} + +func (_m *ProducerDaemonBatcher) EXPECT() *ProducerDaemonBatcher_Expecter { + return &ProducerDaemonBatcher_Expecter{mock: &_m.Mock} +} + // Append provides a mock function with given fields: msg func (_m *ProducerDaemonBatcher) Append(msg *stream.Message) ([]stream.WritableMessage, error) { ret := _m.Called(msg) @@ -38,6 +46,34 @@ func (_m *ProducerDaemonBatcher) Append(msg *stream.Message) ([]stream.WritableM return r0, r1 } +// ProducerDaemonBatcher_Append_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Append' +type ProducerDaemonBatcher_Append_Call struct { + *mock.Call +} + +// Append is a helper method to define mock.On call +// - msg *stream.Message +func (_e *ProducerDaemonBatcher_Expecter) Append(msg interface{}) *ProducerDaemonBatcher_Append_Call { + return &ProducerDaemonBatcher_Append_Call{Call: _e.mock.On("Append", msg)} +} + +func (_c *ProducerDaemonBatcher_Append_Call) Run(run func(msg *stream.Message)) *ProducerDaemonBatcher_Append_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*stream.Message)) + }) + return _c +} + +func (_c *ProducerDaemonBatcher_Append_Call) Return(_a0 []stream.WritableMessage, _a1 error) *ProducerDaemonBatcher_Append_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ProducerDaemonBatcher_Append_Call) RunAndReturn(run func(*stream.Message) ([]stream.WritableMessage, error)) *ProducerDaemonBatcher_Append_Call { + _c.Call.Return(run) + return _c +} + // Flush provides a mock function with given fields: func (_m *ProducerDaemonBatcher) Flush() []stream.WritableMessage { ret := _m.Called() @@ -54,6 +90,33 @@ func (_m *ProducerDaemonBatcher) Flush() []stream.WritableMessage { return r0 } +// ProducerDaemonBatcher_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush' +type ProducerDaemonBatcher_Flush_Call struct { + *mock.Call +} + +// Flush is a helper method to define mock.On call +func (_e *ProducerDaemonBatcher_Expecter) Flush() *ProducerDaemonBatcher_Flush_Call { + return &ProducerDaemonBatcher_Flush_Call{Call: _e.mock.On("Flush")} +} + +func (_c *ProducerDaemonBatcher_Flush_Call) Run(run func()) *ProducerDaemonBatcher_Flush_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ProducerDaemonBatcher_Flush_Call) Return(_a0 []stream.WritableMessage) *ProducerDaemonBatcher_Flush_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProducerDaemonBatcher_Flush_Call) RunAndReturn(run func() []stream.WritableMessage) *ProducerDaemonBatcher_Flush_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewProducerDaemonBatcher interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/RetryHandler.go b/pkg/stream/mocks/RetryHandler.go index 3866d77f1..9b57b3340 100644 --- a/pkg/stream/mocks/RetryHandler.go +++ b/pkg/stream/mocks/RetryHandler.go @@ -14,6 +14,14 @@ type RetryHandler struct { mock.Mock } +type RetryHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *RetryHandler) EXPECT() *RetryHandler_Expecter { + return &RetryHandler_Expecter{mock: &_m.Mock} +} + // Data provides a mock function with given fields: func (_m *RetryHandler) Data() <-chan *stream.Message { ret := _m.Called() @@ -30,6 +38,33 @@ func (_m *RetryHandler) Data() <-chan *stream.Message { return r0 } +// RetryHandler_Data_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Data' +type RetryHandler_Data_Call struct { + *mock.Call +} + +// Data is a helper method to define mock.On call +func (_e *RetryHandler_Expecter) Data() *RetryHandler_Data_Call { + return &RetryHandler_Data_Call{Call: _e.mock.On("Data")} +} + +func (_c *RetryHandler_Data_Call) Run(run func()) *RetryHandler_Data_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RetryHandler_Data_Call) Return(_a0 <-chan *stream.Message) *RetryHandler_Data_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RetryHandler_Data_Call) RunAndReturn(run func() <-chan *stream.Message) *RetryHandler_Data_Call { + _c.Call.Return(run) + return _c +} + // Put provides a mock function with given fields: ctx, msg func (_m *RetryHandler) Put(ctx context.Context, msg *stream.Message) error { ret := _m.Called(ctx, msg) @@ -44,6 +79,35 @@ func (_m *RetryHandler) Put(ctx context.Context, msg *stream.Message) error { return r0 } +// RetryHandler_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type RetryHandler_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - ctx context.Context +// - msg *stream.Message +func (_e *RetryHandler_Expecter) Put(ctx interface{}, msg interface{}) *RetryHandler_Put_Call { + return &RetryHandler_Put_Call{Call: _e.mock.On("Put", ctx, msg)} +} + +func (_c *RetryHandler_Put_Call) Run(run func(ctx context.Context, msg *stream.Message)) *RetryHandler_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*stream.Message)) + }) + return _c +} + +func (_c *RetryHandler_Put_Call) Return(_a0 error) *RetryHandler_Put_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RetryHandler_Put_Call) RunAndReturn(run func(context.Context, *stream.Message) error) *RetryHandler_Put_Call { + _c.Call.Return(run) + return _c +} + // Run provides a mock function with given fields: ctx func (_m *RetryHandler) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -58,11 +122,66 @@ func (_m *RetryHandler) Run(ctx context.Context) error { return r0 } +// RetryHandler_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type RetryHandler_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *RetryHandler_Expecter) Run(ctx interface{}) *RetryHandler_Run_Call { + return &RetryHandler_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *RetryHandler_Run_Call) Run(run func(ctx context.Context)) *RetryHandler_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *RetryHandler_Run_Call) Return(_a0 error) *RetryHandler_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RetryHandler_Run_Call) RunAndReturn(run func(context.Context) error) *RetryHandler_Run_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *RetryHandler) Stop() { _m.Called() } +// RetryHandler_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type RetryHandler_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *RetryHandler_Expecter) Stop() *RetryHandler_Stop_Call { + return &RetryHandler_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *RetryHandler_Stop_Call) Run(run func()) *RetryHandler_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RetryHandler_Stop_Call) Return() *RetryHandler_Stop_Call { + _c.Call.Return() + return _c +} + +func (_c *RetryHandler_Stop_Call) RunAndReturn(run func()) *RetryHandler_Stop_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRetryHandler interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/RunnableBatchConsumerCallback.go b/pkg/stream/mocks/RunnableBatchConsumerCallback.go index 2d7697f90..137492a99 100644 --- a/pkg/stream/mocks/RunnableBatchConsumerCallback.go +++ b/pkg/stream/mocks/RunnableBatchConsumerCallback.go @@ -13,6 +13,14 @@ type RunnableBatchConsumerCallback struct { mock.Mock } +type RunnableBatchConsumerCallback_Expecter struct { + mock *mock.Mock +} + +func (_m *RunnableBatchConsumerCallback) EXPECT() *RunnableBatchConsumerCallback_Expecter { + return &RunnableBatchConsumerCallback_Expecter{mock: &_m.Mock} +} + // Consume provides a mock function with given fields: ctx, models, attributes func (_m *RunnableBatchConsumerCallback) Consume(ctx context.Context, models []interface{}, attributes []map[string]interface{}) ([]bool, error) { ret := _m.Called(ctx, models, attributes) @@ -39,6 +47,36 @@ func (_m *RunnableBatchConsumerCallback) Consume(ctx context.Context, models []i return r0, r1 } +// RunnableBatchConsumerCallback_Consume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Consume' +type RunnableBatchConsumerCallback_Consume_Call struct { + *mock.Call +} + +// Consume is a helper method to define mock.On call +// - ctx context.Context +// - models []interface{} +// - attributes []map[string]interface{} +func (_e *RunnableBatchConsumerCallback_Expecter) Consume(ctx interface{}, models interface{}, attributes interface{}) *RunnableBatchConsumerCallback_Consume_Call { + return &RunnableBatchConsumerCallback_Consume_Call{Call: _e.mock.On("Consume", ctx, models, attributes)} +} + +func (_c *RunnableBatchConsumerCallback_Consume_Call) Run(run func(ctx context.Context, models []interface{}, attributes []map[string]interface{})) *RunnableBatchConsumerCallback_Consume_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]interface{}), args[2].([]map[string]interface{})) + }) + return _c +} + +func (_c *RunnableBatchConsumerCallback_Consume_Call) Return(_a0 []bool, _a1 error) *RunnableBatchConsumerCallback_Consume_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunnableBatchConsumerCallback_Consume_Call) RunAndReturn(run func(context.Context, []interface{}, []map[string]interface{}) ([]bool, error)) *RunnableBatchConsumerCallback_Consume_Call { + _c.Call.Return(run) + return _c +} + // GetModel provides a mock function with given fields: attributes func (_m *RunnableBatchConsumerCallback) GetModel(attributes map[string]interface{}) interface{} { ret := _m.Called(attributes) @@ -55,6 +93,34 @@ func (_m *RunnableBatchConsumerCallback) GetModel(attributes map[string]interfac return r0 } +// RunnableBatchConsumerCallback_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type RunnableBatchConsumerCallback_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +// - attributes map[string]interface{} +func (_e *RunnableBatchConsumerCallback_Expecter) GetModel(attributes interface{}) *RunnableBatchConsumerCallback_GetModel_Call { + return &RunnableBatchConsumerCallback_GetModel_Call{Call: _e.mock.On("GetModel", attributes)} +} + +func (_c *RunnableBatchConsumerCallback_GetModel_Call) Run(run func(attributes map[string]interface{})) *RunnableBatchConsumerCallback_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]interface{})) + }) + return _c +} + +func (_c *RunnableBatchConsumerCallback_GetModel_Call) Return(_a0 interface{}) *RunnableBatchConsumerCallback_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunnableBatchConsumerCallback_GetModel_Call) RunAndReturn(run func(map[string]interface{}) interface{}) *RunnableBatchConsumerCallback_GetModel_Call { + _c.Call.Return(run) + return _c +} + // Run provides a mock function with given fields: ctx func (_m *RunnableBatchConsumerCallback) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -69,6 +135,34 @@ func (_m *RunnableBatchConsumerCallback) Run(ctx context.Context) error { return r0 } +// RunnableBatchConsumerCallback_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type RunnableBatchConsumerCallback_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *RunnableBatchConsumerCallback_Expecter) Run(ctx interface{}) *RunnableBatchConsumerCallback_Run_Call { + return &RunnableBatchConsumerCallback_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *RunnableBatchConsumerCallback_Run_Call) Run(run func(ctx context.Context)) *RunnableBatchConsumerCallback_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *RunnableBatchConsumerCallback_Run_Call) Return(_a0 error) *RunnableBatchConsumerCallback_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunnableBatchConsumerCallback_Run_Call) RunAndReturn(run func(context.Context) error) *RunnableBatchConsumerCallback_Run_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRunnableBatchConsumerCallback interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/RunnableCallback.go b/pkg/stream/mocks/RunnableCallback.go index 96dbec8ee..1c28c69d7 100644 --- a/pkg/stream/mocks/RunnableCallback.go +++ b/pkg/stream/mocks/RunnableCallback.go @@ -13,6 +13,14 @@ type RunnableCallback struct { mock.Mock } +type RunnableCallback_Expecter struct { + mock *mock.Mock +} + +func (_m *RunnableCallback) EXPECT() *RunnableCallback_Expecter { + return &RunnableCallback_Expecter{mock: &_m.Mock} +} + // Run provides a mock function with given fields: ctx func (_m *RunnableCallback) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -27,6 +35,34 @@ func (_m *RunnableCallback) Run(ctx context.Context) error { return r0 } +// RunnableCallback_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type RunnableCallback_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *RunnableCallback_Expecter) Run(ctx interface{}) *RunnableCallback_Run_Call { + return &RunnableCallback_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *RunnableCallback_Run_Call) Run(run func(ctx context.Context)) *RunnableCallback_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *RunnableCallback_Run_Call) Return(_a0 error) *RunnableCallback_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunnableCallback_Run_Call) RunAndReturn(run func(context.Context) error) *RunnableCallback_Run_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRunnableCallback interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/RunnableConsumerCallback.go b/pkg/stream/mocks/RunnableConsumerCallback.go index be8258b81..a1d42c003 100644 --- a/pkg/stream/mocks/RunnableConsumerCallback.go +++ b/pkg/stream/mocks/RunnableConsumerCallback.go @@ -13,6 +13,14 @@ type RunnableConsumerCallback struct { mock.Mock } +type RunnableConsumerCallback_Expecter struct { + mock *mock.Mock +} + +func (_m *RunnableConsumerCallback) EXPECT() *RunnableConsumerCallback_Expecter { + return &RunnableConsumerCallback_Expecter{mock: &_m.Mock} +} + // Consume provides a mock function with given fields: ctx, model, attributes func (_m *RunnableConsumerCallback) Consume(ctx context.Context, model interface{}, attributes map[string]interface{}) (bool, error) { ret := _m.Called(ctx, model, attributes) @@ -37,6 +45,36 @@ func (_m *RunnableConsumerCallback) Consume(ctx context.Context, model interface return r0, r1 } +// RunnableConsumerCallback_Consume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Consume' +type RunnableConsumerCallback_Consume_Call struct { + *mock.Call +} + +// Consume is a helper method to define mock.On call +// - ctx context.Context +// - model interface{} +// - attributes map[string]interface{} +func (_e *RunnableConsumerCallback_Expecter) Consume(ctx interface{}, model interface{}, attributes interface{}) *RunnableConsumerCallback_Consume_Call { + return &RunnableConsumerCallback_Consume_Call{Call: _e.mock.On("Consume", ctx, model, attributes)} +} + +func (_c *RunnableConsumerCallback_Consume_Call) Run(run func(ctx context.Context, model interface{}, attributes map[string]interface{})) *RunnableConsumerCallback_Consume_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interface{}), args[2].(map[string]interface{})) + }) + return _c +} + +func (_c *RunnableConsumerCallback_Consume_Call) Return(_a0 bool, _a1 error) *RunnableConsumerCallback_Consume_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunnableConsumerCallback_Consume_Call) RunAndReturn(run func(context.Context, interface{}, map[string]interface{}) (bool, error)) *RunnableConsumerCallback_Consume_Call { + _c.Call.Return(run) + return _c +} + // GetModel provides a mock function with given fields: attributes func (_m *RunnableConsumerCallback) GetModel(attributes map[string]interface{}) interface{} { ret := _m.Called(attributes) @@ -53,6 +91,34 @@ func (_m *RunnableConsumerCallback) GetModel(attributes map[string]interface{}) return r0 } +// RunnableConsumerCallback_GetModel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModel' +type RunnableConsumerCallback_GetModel_Call struct { + *mock.Call +} + +// GetModel is a helper method to define mock.On call +// - attributes map[string]interface{} +func (_e *RunnableConsumerCallback_Expecter) GetModel(attributes interface{}) *RunnableConsumerCallback_GetModel_Call { + return &RunnableConsumerCallback_GetModel_Call{Call: _e.mock.On("GetModel", attributes)} +} + +func (_c *RunnableConsumerCallback_GetModel_Call) Run(run func(attributes map[string]interface{})) *RunnableConsumerCallback_GetModel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]interface{})) + }) + return _c +} + +func (_c *RunnableConsumerCallback_GetModel_Call) Return(_a0 interface{}) *RunnableConsumerCallback_GetModel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunnableConsumerCallback_GetModel_Call) RunAndReturn(run func(map[string]interface{}) interface{}) *RunnableConsumerCallback_GetModel_Call { + _c.Call.Return(run) + return _c +} + // Run provides a mock function with given fields: ctx func (_m *RunnableConsumerCallback) Run(ctx context.Context) error { ret := _m.Called(ctx) @@ -67,6 +133,34 @@ func (_m *RunnableConsumerCallback) Run(ctx context.Context) error { return r0 } +// RunnableConsumerCallback_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type RunnableConsumerCallback_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *RunnableConsumerCallback_Expecter) Run(ctx interface{}) *RunnableConsumerCallback_Run_Call { + return &RunnableConsumerCallback_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *RunnableConsumerCallback_Run_Call) Run(run func(ctx context.Context)) *RunnableConsumerCallback_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *RunnableConsumerCallback_Run_Call) Return(_a0 error) *RunnableConsumerCallback_Run_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunnableConsumerCallback_Run_Call) RunAndReturn(run func(context.Context) error) *RunnableConsumerCallback_Run_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewRunnableConsumerCallback interface { mock.TestingT Cleanup(func()) diff --git a/pkg/stream/mocks/SizeRestrictedOutput.go b/pkg/stream/mocks/SizeRestrictedOutput.go index 4ed9713e3..11dc1152a 100644 --- a/pkg/stream/mocks/SizeRestrictedOutput.go +++ b/pkg/stream/mocks/SizeRestrictedOutput.go @@ -14,6 +14,14 @@ type SizeRestrictedOutput struct { mock.Mock } +type SizeRestrictedOutput_Expecter struct { + mock *mock.Mock +} + +func (_m *SizeRestrictedOutput) EXPECT() *SizeRestrictedOutput_Expecter { + return &SizeRestrictedOutput_Expecter{mock: &_m.Mock} +} + // GetMaxBatchSize provides a mock function with given fields: func (_m *SizeRestrictedOutput) GetMaxBatchSize() *int { ret := _m.Called() @@ -30,6 +38,33 @@ func (_m *SizeRestrictedOutput) GetMaxBatchSize() *int { return r0 } +// SizeRestrictedOutput_GetMaxBatchSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMaxBatchSize' +type SizeRestrictedOutput_GetMaxBatchSize_Call struct { + *mock.Call +} + +// GetMaxBatchSize is a helper method to define mock.On call +func (_e *SizeRestrictedOutput_Expecter) GetMaxBatchSize() *SizeRestrictedOutput_GetMaxBatchSize_Call { + return &SizeRestrictedOutput_GetMaxBatchSize_Call{Call: _e.mock.On("GetMaxBatchSize")} +} + +func (_c *SizeRestrictedOutput_GetMaxBatchSize_Call) Run(run func()) *SizeRestrictedOutput_GetMaxBatchSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SizeRestrictedOutput_GetMaxBatchSize_Call) Return(_a0 *int) *SizeRestrictedOutput_GetMaxBatchSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizeRestrictedOutput_GetMaxBatchSize_Call) RunAndReturn(run func() *int) *SizeRestrictedOutput_GetMaxBatchSize_Call { + _c.Call.Return(run) + return _c +} + // GetMaxMessageSize provides a mock function with given fields: func (_m *SizeRestrictedOutput) GetMaxMessageSize() *int { ret := _m.Called() @@ -46,6 +81,33 @@ func (_m *SizeRestrictedOutput) GetMaxMessageSize() *int { return r0 } +// SizeRestrictedOutput_GetMaxMessageSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMaxMessageSize' +type SizeRestrictedOutput_GetMaxMessageSize_Call struct { + *mock.Call +} + +// GetMaxMessageSize is a helper method to define mock.On call +func (_e *SizeRestrictedOutput_Expecter) GetMaxMessageSize() *SizeRestrictedOutput_GetMaxMessageSize_Call { + return &SizeRestrictedOutput_GetMaxMessageSize_Call{Call: _e.mock.On("GetMaxMessageSize")} +} + +func (_c *SizeRestrictedOutput_GetMaxMessageSize_Call) Run(run func()) *SizeRestrictedOutput_GetMaxMessageSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SizeRestrictedOutput_GetMaxMessageSize_Call) Return(_a0 *int) *SizeRestrictedOutput_GetMaxMessageSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizeRestrictedOutput_GetMaxMessageSize_Call) RunAndReturn(run func() *int) *SizeRestrictedOutput_GetMaxMessageSize_Call { + _c.Call.Return(run) + return _c +} + // Write provides a mock function with given fields: ctx, batch func (_m *SizeRestrictedOutput) Write(ctx context.Context, batch []stream.WritableMessage) error { ret := _m.Called(ctx, batch) @@ -60,6 +122,35 @@ func (_m *SizeRestrictedOutput) Write(ctx context.Context, batch []stream.Writab return r0 } +// SizeRestrictedOutput_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type SizeRestrictedOutput_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - ctx context.Context +// - batch []stream.WritableMessage +func (_e *SizeRestrictedOutput_Expecter) Write(ctx interface{}, batch interface{}) *SizeRestrictedOutput_Write_Call { + return &SizeRestrictedOutput_Write_Call{Call: _e.mock.On("Write", ctx, batch)} +} + +func (_c *SizeRestrictedOutput_Write_Call) Run(run func(ctx context.Context, batch []stream.WritableMessage)) *SizeRestrictedOutput_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]stream.WritableMessage)) + }) + return _c +} + +func (_c *SizeRestrictedOutput_Write_Call) Return(_a0 error) *SizeRestrictedOutput_Write_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizeRestrictedOutput_Write_Call) RunAndReturn(run func(context.Context, []stream.WritableMessage) error) *SizeRestrictedOutput_Write_Call { + _c.Call.Return(run) + return _c +} + // WriteOne provides a mock function with given fields: ctx, msg func (_m *SizeRestrictedOutput) WriteOne(ctx context.Context, msg stream.WritableMessage) error { ret := _m.Called(ctx, msg) @@ -74,6 +165,35 @@ func (_m *SizeRestrictedOutput) WriteOne(ctx context.Context, msg stream.Writabl return r0 } +// SizeRestrictedOutput_WriteOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOne' +type SizeRestrictedOutput_WriteOne_Call struct { + *mock.Call +} + +// WriteOne is a helper method to define mock.On call +// - ctx context.Context +// - msg stream.WritableMessage +func (_e *SizeRestrictedOutput_Expecter) WriteOne(ctx interface{}, msg interface{}) *SizeRestrictedOutput_WriteOne_Call { + return &SizeRestrictedOutput_WriteOne_Call{Call: _e.mock.On("WriteOne", ctx, msg)} +} + +func (_c *SizeRestrictedOutput_WriteOne_Call) Run(run func(ctx context.Context, msg stream.WritableMessage)) *SizeRestrictedOutput_WriteOne_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(stream.WritableMessage)) + }) + return _c +} + +func (_c *SizeRestrictedOutput_WriteOne_Call) Return(_a0 error) *SizeRestrictedOutput_WriteOne_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SizeRestrictedOutput_WriteOne_Call) RunAndReturn(run func(context.Context, stream.WritableMessage) error) *SizeRestrictedOutput_WriteOne_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewSizeRestrictedOutput interface { mock.TestingT Cleanup(func()) diff --git a/pkg/tracing/mocks/Span.go b/pkg/tracing/mocks/Span.go index eab0852b1..4166e15bd 100644 --- a/pkg/tracing/mocks/Span.go +++ b/pkg/tracing/mocks/Span.go @@ -12,26 +12,147 @@ type Span struct { mock.Mock } +type Span_Expecter struct { + mock *mock.Mock +} + +func (_m *Span) EXPECT() *Span_Expecter { + return &Span_Expecter{mock: &_m.Mock} +} + // AddAnnotation provides a mock function with given fields: key, value func (_m *Span) AddAnnotation(key string, value string) { _m.Called(key, value) } +// Span_AddAnnotation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAnnotation' +type Span_AddAnnotation_Call struct { + *mock.Call +} + +// AddAnnotation is a helper method to define mock.On call +// - key string +// - value string +func (_e *Span_Expecter) AddAnnotation(key interface{}, value interface{}) *Span_AddAnnotation_Call { + return &Span_AddAnnotation_Call{Call: _e.mock.On("AddAnnotation", key, value)} +} + +func (_c *Span_AddAnnotation_Call) Run(run func(key string, value string)) *Span_AddAnnotation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *Span_AddAnnotation_Call) Return() *Span_AddAnnotation_Call { + _c.Call.Return() + return _c +} + +func (_c *Span_AddAnnotation_Call) RunAndReturn(run func(string, string)) *Span_AddAnnotation_Call { + _c.Call.Return(run) + return _c +} + // AddError provides a mock function with given fields: err func (_m *Span) AddError(err error) { _m.Called(err) } +// Span_AddError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddError' +type Span_AddError_Call struct { + *mock.Call +} + +// AddError is a helper method to define mock.On call +// - err error +func (_e *Span_Expecter) AddError(err interface{}) *Span_AddError_Call { + return &Span_AddError_Call{Call: _e.mock.On("AddError", err)} +} + +func (_c *Span_AddError_Call) Run(run func(err error)) *Span_AddError_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(error)) + }) + return _c +} + +func (_c *Span_AddError_Call) Return() *Span_AddError_Call { + _c.Call.Return() + return _c +} + +func (_c *Span_AddError_Call) RunAndReturn(run func(error)) *Span_AddError_Call { + _c.Call.Return(run) + return _c +} + // AddMetadata provides a mock function with given fields: key, value func (_m *Span) AddMetadata(key string, value interface{}) { _m.Called(key, value) } +// Span_AddMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddMetadata' +type Span_AddMetadata_Call struct { + *mock.Call +} + +// AddMetadata is a helper method to define mock.On call +// - key string +// - value interface{} +func (_e *Span_Expecter) AddMetadata(key interface{}, value interface{}) *Span_AddMetadata_Call { + return &Span_AddMetadata_Call{Call: _e.mock.On("AddMetadata", key, value)} +} + +func (_c *Span_AddMetadata_Call) Run(run func(key string, value interface{})) *Span_AddMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(interface{})) + }) + return _c +} + +func (_c *Span_AddMetadata_Call) Return() *Span_AddMetadata_Call { + _c.Call.Return() + return _c +} + +func (_c *Span_AddMetadata_Call) RunAndReturn(run func(string, interface{})) *Span_AddMetadata_Call { + _c.Call.Return(run) + return _c +} + // Finish provides a mock function with given fields: func (_m *Span) Finish() { _m.Called() } +// Span_Finish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Finish' +type Span_Finish_Call struct { + *mock.Call +} + +// Finish is a helper method to define mock.On call +func (_e *Span_Expecter) Finish() *Span_Finish_Call { + return &Span_Finish_Call{Call: _e.mock.On("Finish")} +} + +func (_c *Span_Finish_Call) Run(run func()) *Span_Finish_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Span_Finish_Call) Return() *Span_Finish_Call { + _c.Call.Return() + return _c +} + +func (_c *Span_Finish_Call) RunAndReturn(run func()) *Span_Finish_Call { + _c.Call.Return(run) + return _c +} + // GetId provides a mock function with given fields: func (_m *Span) GetId() string { ret := _m.Called() @@ -46,6 +167,33 @@ func (_m *Span) GetId() string { return r0 } +// Span_GetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetId' +type Span_GetId_Call struct { + *mock.Call +} + +// GetId is a helper method to define mock.On call +func (_e *Span_Expecter) GetId() *Span_GetId_Call { + return &Span_GetId_Call{Call: _e.mock.On("GetId")} +} + +func (_c *Span_GetId_Call) Run(run func()) *Span_GetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Span_GetId_Call) Return(_a0 string) *Span_GetId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Span_GetId_Call) RunAndReturn(run func() string) *Span_GetId_Call { + _c.Call.Return(run) + return _c +} + // GetTrace provides a mock function with given fields: func (_m *Span) GetTrace() *tracing.Trace { ret := _m.Called() @@ -62,6 +210,33 @@ func (_m *Span) GetTrace() *tracing.Trace { return r0 } +// Span_GetTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrace' +type Span_GetTrace_Call struct { + *mock.Call +} + +// GetTrace is a helper method to define mock.On call +func (_e *Span_Expecter) GetTrace() *Span_GetTrace_Call { + return &Span_GetTrace_Call{Call: _e.mock.On("GetTrace")} +} + +func (_c *Span_GetTrace_Call) Run(run func()) *Span_GetTrace_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Span_GetTrace_Call) Return(_a0 *tracing.Trace) *Span_GetTrace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Span_GetTrace_Call) RunAndReturn(run func() *tracing.Trace) *Span_GetTrace_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewSpan interface { mock.TestingT Cleanup(func()) diff --git a/pkg/tracing/mocks/TraceAble.go b/pkg/tracing/mocks/TraceAble.go index 6c1018dda..b2d4b5246 100644 --- a/pkg/tracing/mocks/TraceAble.go +++ b/pkg/tracing/mocks/TraceAble.go @@ -12,6 +12,14 @@ type TraceAble struct { mock.Mock } +type TraceAble_Expecter struct { + mock *mock.Mock +} + +func (_m *TraceAble) EXPECT() *TraceAble_Expecter { + return &TraceAble_Expecter{mock: &_m.Mock} +} + // GetTrace provides a mock function with given fields: func (_m *TraceAble) GetTrace() *tracing.Trace { ret := _m.Called() @@ -28,6 +36,33 @@ func (_m *TraceAble) GetTrace() *tracing.Trace { return r0 } +// TraceAble_GetTrace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrace' +type TraceAble_GetTrace_Call struct { + *mock.Call +} + +// GetTrace is a helper method to define mock.On call +func (_e *TraceAble_Expecter) GetTrace() *TraceAble_GetTrace_Call { + return &TraceAble_GetTrace_Call{Call: _e.mock.On("GetTrace")} +} + +func (_c *TraceAble_GetTrace_Call) Run(run func()) *TraceAble_GetTrace_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TraceAble_GetTrace_Call) Return(_a0 *tracing.Trace) *TraceAble_GetTrace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TraceAble_GetTrace_Call) RunAndReturn(run func() *tracing.Trace) *TraceAble_GetTrace_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTraceAble interface { mock.TestingT Cleanup(func()) diff --git a/pkg/tracing/mocks/Tracer.go b/pkg/tracing/mocks/Tracer.go index 548901eb0..fc876c9ed 100644 --- a/pkg/tracing/mocks/Tracer.go +++ b/pkg/tracing/mocks/Tracer.go @@ -16,6 +16,14 @@ type Tracer struct { mock.Mock } +type Tracer_Expecter struct { + mock *mock.Mock +} + +func (_m *Tracer) EXPECT() *Tracer_Expecter { + return &Tracer_Expecter{mock: &_m.Mock} +} + // HttpHandler provides a mock function with given fields: h func (_m *Tracer) HttpHandler(h http.Handler) http.Handler { ret := _m.Called(h) @@ -32,6 +40,34 @@ func (_m *Tracer) HttpHandler(h http.Handler) http.Handler { return r0 } +// Tracer_HttpHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HttpHandler' +type Tracer_HttpHandler_Call struct { + *mock.Call +} + +// HttpHandler is a helper method to define mock.On call +// - h http.Handler +func (_e *Tracer_Expecter) HttpHandler(h interface{}) *Tracer_HttpHandler_Call { + return &Tracer_HttpHandler_Call{Call: _e.mock.On("HttpHandler", h)} +} + +func (_c *Tracer_HttpHandler_Call) Run(run func(h http.Handler)) *Tracer_HttpHandler_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(http.Handler)) + }) + return _c +} + +func (_c *Tracer_HttpHandler_Call) Return(_a0 http.Handler) *Tracer_HttpHandler_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Tracer_HttpHandler_Call) RunAndReturn(run func(http.Handler) http.Handler) *Tracer_HttpHandler_Call { + _c.Call.Return(run) + return _c +} + // StartSpan provides a mock function with given fields: name func (_m *Tracer) StartSpan(name string) (context.Context, tracing.Span) { ret := _m.Called(name) @@ -60,6 +96,34 @@ func (_m *Tracer) StartSpan(name string) (context.Context, tracing.Span) { return r0, r1 } +// Tracer_StartSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartSpan' +type Tracer_StartSpan_Call struct { + *mock.Call +} + +// StartSpan is a helper method to define mock.On call +// - name string +func (_e *Tracer_Expecter) StartSpan(name interface{}) *Tracer_StartSpan_Call { + return &Tracer_StartSpan_Call{Call: _e.mock.On("StartSpan", name)} +} + +func (_c *Tracer_StartSpan_Call) Run(run func(name string)) *Tracer_StartSpan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Tracer_StartSpan_Call) Return(_a0 context.Context, _a1 tracing.Span) *Tracer_StartSpan_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Tracer_StartSpan_Call) RunAndReturn(run func(string) (context.Context, tracing.Span)) *Tracer_StartSpan_Call { + _c.Call.Return(run) + return _c +} + // StartSpanFromContext provides a mock function with given fields: ctx, name func (_m *Tracer) StartSpanFromContext(ctx context.Context, name string) (context.Context, tracing.Span) { ret := _m.Called(ctx, name) @@ -88,6 +152,35 @@ func (_m *Tracer) StartSpanFromContext(ctx context.Context, name string) (contex return r0, r1 } +// Tracer_StartSpanFromContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartSpanFromContext' +type Tracer_StartSpanFromContext_Call struct { + *mock.Call +} + +// StartSpanFromContext is a helper method to define mock.On call +// - ctx context.Context +// - name string +func (_e *Tracer_Expecter) StartSpanFromContext(ctx interface{}, name interface{}) *Tracer_StartSpanFromContext_Call { + return &Tracer_StartSpanFromContext_Call{Call: _e.mock.On("StartSpanFromContext", ctx, name)} +} + +func (_c *Tracer_StartSpanFromContext_Call) Run(run func(ctx context.Context, name string)) *Tracer_StartSpanFromContext_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Tracer_StartSpanFromContext_Call) Return(_a0 context.Context, _a1 tracing.Span) *Tracer_StartSpanFromContext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Tracer_StartSpanFromContext_Call) RunAndReturn(run func(context.Context, string) (context.Context, tracing.Span)) *Tracer_StartSpanFromContext_Call { + _c.Call.Return(run) + return _c +} + // StartSubSpan provides a mock function with given fields: ctx, name func (_m *Tracer) StartSubSpan(ctx context.Context, name string) (context.Context, tracing.Span) { ret := _m.Called(ctx, name) @@ -116,6 +209,35 @@ func (_m *Tracer) StartSubSpan(ctx context.Context, name string) (context.Contex return r0, r1 } +// Tracer_StartSubSpan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartSubSpan' +type Tracer_StartSubSpan_Call struct { + *mock.Call +} + +// StartSubSpan is a helper method to define mock.On call +// - ctx context.Context +// - name string +func (_e *Tracer_Expecter) StartSubSpan(ctx interface{}, name interface{}) *Tracer_StartSubSpan_Call { + return &Tracer_StartSubSpan_Call{Call: _e.mock.On("StartSubSpan", ctx, name)} +} + +func (_c *Tracer_StartSubSpan_Call) Run(run func(ctx context.Context, name string)) *Tracer_StartSubSpan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Tracer_StartSubSpan_Call) Return(_a0 context.Context, _a1 tracing.Span) *Tracer_StartSubSpan_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Tracer_StartSubSpan_Call) RunAndReturn(run func(context.Context, string) (context.Context, tracing.Span)) *Tracer_StartSubSpan_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewTracer interface { mock.TestingT Cleanup(func()) diff --git a/pkg/uuid/mocks/Uuid.go b/pkg/uuid/mocks/Uuid.go index 0be3391d3..457095a87 100644 --- a/pkg/uuid/mocks/Uuid.go +++ b/pkg/uuid/mocks/Uuid.go @@ -9,6 +9,14 @@ type Uuid struct { mock.Mock } +type Uuid_Expecter struct { + mock *mock.Mock +} + +func (_m *Uuid) EXPECT() *Uuid_Expecter { + return &Uuid_Expecter{mock: &_m.Mock} +} + // NewV4 provides a mock function with given fields: func (_m *Uuid) NewV4() string { ret := _m.Called() @@ -23,6 +31,33 @@ func (_m *Uuid) NewV4() string { return r0 } +// Uuid_NewV4_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewV4' +type Uuid_NewV4_Call struct { + *mock.Call +} + +// NewV4 is a helper method to define mock.On call +func (_e *Uuid_Expecter) NewV4() *Uuid_NewV4_Call { + return &Uuid_NewV4_Call{Call: _e.mock.On("NewV4")} +} + +func (_c *Uuid_NewV4_Call) Run(run func()) *Uuid_NewV4_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Uuid_NewV4_Call) Return(_a0 string) *Uuid_NewV4_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Uuid_NewV4_Call) RunAndReturn(run func() string) *Uuid_NewV4_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewUuid interface { mock.TestingT Cleanup(func())