Jay Brown
7d78e65d0c
Add semantic versioning to all services * working * Merge branch 'main' of bitbucket.org:aarete/query-orchestration into feature/semver * 1.24 mod * go upgrade * tool * Merge branch 'main' of bitbucket.org:aarete/query-orchestration into feature/semver
1445 lines
52 KiB
Go
1445 lines
52 KiB
Go
// Code generated by mockery v2.52.3. DO NOT EDIT.
|
|
|
|
package queuemock
|
|
|
|
import (
|
|
context "context"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
sqs "github.com/aws/aws-sdk-go-v2/service/sqs"
|
|
)
|
|
|
|
// MockSQSClient is an autogenerated mock type for the SQSClient type
|
|
type MockSQSClient struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockSQSClient_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockSQSClient) EXPECT() *MockSQSClient_Expecter {
|
|
return &MockSQSClient_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// AddPermission provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) AddPermission(ctx context.Context, params *sqs.AddPermissionInput, optFns ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddPermission")
|
|
}
|
|
|
|
var r0 *sqs.AddPermissionOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) *sqs.AddPermissionOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.AddPermissionOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_AddPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPermission'
|
|
type MockSQSClient_AddPermission_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddPermission is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.AddPermissionInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) AddPermission(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_AddPermission_Call {
|
|
return &MockSQSClient_AddPermission_Call{Call: _e.mock.On("AddPermission",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_AddPermission_Call) Run(run func(ctx context.Context, params *sqs.AddPermissionInput, optFns ...func(*sqs.Options))) *MockSQSClient_AddPermission_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.AddPermissionInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_AddPermission_Call) Return(_a0 *sqs.AddPermissionOutput, _a1 error) *MockSQSClient_AddPermission_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_AddPermission_Call) RunAndReturn(run func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error)) *MockSQSClient_AddPermission_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ChangeMessageVisibility provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) ChangeMessageVisibility(ctx context.Context, params *sqs.ChangeMessageVisibilityInput, optFns ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ChangeMessageVisibility")
|
|
}
|
|
|
|
var r0 *sqs.ChangeMessageVisibilityOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) *sqs.ChangeMessageVisibilityOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.ChangeMessageVisibilityOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_ChangeMessageVisibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeMessageVisibility'
|
|
type MockSQSClient_ChangeMessageVisibility_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ChangeMessageVisibility is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.ChangeMessageVisibilityInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) ChangeMessageVisibility(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ChangeMessageVisibility_Call {
|
|
return &MockSQSClient_ChangeMessageVisibility_Call{Call: _e.mock.On("ChangeMessageVisibility",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_ChangeMessageVisibility_Call) Run(run func(ctx context.Context, params *sqs.ChangeMessageVisibilityInput, optFns ...func(*sqs.Options))) *MockSQSClient_ChangeMessageVisibility_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.ChangeMessageVisibilityInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ChangeMessageVisibility_Call) Return(_a0 *sqs.ChangeMessageVisibilityOutput, _a1 error) *MockSQSClient_ChangeMessageVisibility_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ChangeMessageVisibility_Call) RunAndReturn(run func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error)) *MockSQSClient_ChangeMessageVisibility_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ChangeMessageVisibilityBatch provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) ChangeMessageVisibilityBatch(ctx context.Context, params *sqs.ChangeMessageVisibilityBatchInput, optFns ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ChangeMessageVisibilityBatch")
|
|
}
|
|
|
|
var r0 *sqs.ChangeMessageVisibilityBatchOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) *sqs.ChangeMessageVisibilityBatchOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.ChangeMessageVisibilityBatchOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_ChangeMessageVisibilityBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeMessageVisibilityBatch'
|
|
type MockSQSClient_ChangeMessageVisibilityBatch_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ChangeMessageVisibilityBatch is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.ChangeMessageVisibilityBatchInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) ChangeMessageVisibilityBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ChangeMessageVisibilityBatch_Call {
|
|
return &MockSQSClient_ChangeMessageVisibilityBatch_Call{Call: _e.mock.On("ChangeMessageVisibilityBatch",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) Run(run func(ctx context.Context, params *sqs.ChangeMessageVisibilityBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_ChangeMessageVisibilityBatch_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.ChangeMessageVisibilityBatchInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) Return(_a0 *sqs.ChangeMessageVisibilityBatchOutput, _a1 error) *MockSQSClient_ChangeMessageVisibilityBatch_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) RunAndReturn(run func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error)) *MockSQSClient_ChangeMessageVisibilityBatch_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateQueue provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) CreateQueue(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateQueue")
|
|
}
|
|
|
|
var r0 *sqs.CreateQueueOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) *sqs.CreateQueueOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.CreateQueueOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_CreateQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateQueue'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) CreateQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_CreateQueue_Call {
|
|
return &MockSQSClient_CreateQueue_Call{Call: _e.mock.On("CreateQueue",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_CreateQueue_Call) Run(run func(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_CreateQueue_Call) Return(_a0 *sqs.CreateQueueOutput, _a1 error) *MockSQSClient_CreateQueue_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_CreateQueue_Call) RunAndReturn(run func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error)) *MockSQSClient_CreateQueue_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteMessage provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) DeleteMessage(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteMessage")
|
|
}
|
|
|
|
var r0 *sqs.DeleteMessageOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) *sqs.DeleteMessageOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.DeleteMessageOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) DeleteMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteMessage_Call {
|
|
return &MockSQSClient_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_DeleteMessage_Call) Run(run func(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_DeleteMessage_Call) Return(_a0 *sqs.DeleteMessageOutput, _a1 error) *MockSQSClient_DeleteMessage_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_DeleteMessage_Call) RunAndReturn(run func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error)) *MockSQSClient_DeleteMessage_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteMessageBatch provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) DeleteMessageBatch(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteMessageBatch")
|
|
}
|
|
|
|
var r0 *sqs.DeleteMessageBatchOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) *sqs.DeleteMessageBatchOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.DeleteMessageBatchOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_DeleteMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessageBatch'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) DeleteMessageBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteMessageBatch_Call {
|
|
return &MockSQSClient_DeleteMessageBatch_Call{Call: _e.mock.On("DeleteMessageBatch",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_DeleteMessageBatch_Call) Run(run func(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_DeleteMessageBatch_Call) Return(_a0 *sqs.DeleteMessageBatchOutput, _a1 error) *MockSQSClient_DeleteMessageBatch_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_DeleteMessageBatch_Call) RunAndReturn(run func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error)) *MockSQSClient_DeleteMessageBatch_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteQueue provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) DeleteQueue(ctx context.Context, params *sqs.DeleteQueueInput, optFns ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteQueue")
|
|
}
|
|
|
|
var r0 *sqs.DeleteQueueOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) *sqs.DeleteQueueOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.DeleteQueueOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_DeleteQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteQueue'
|
|
type MockSQSClient_DeleteQueue_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteQueue is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.DeleteQueueInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) DeleteQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteQueue_Call {
|
|
return &MockSQSClient_DeleteQueue_Call{Call: _e.mock.On("DeleteQueue",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_DeleteQueue_Call) Run(run func(ctx context.Context, params *sqs.DeleteQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_DeleteQueue_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.DeleteQueueInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_DeleteQueue_Call) Return(_a0 *sqs.DeleteQueueOutput, _a1 error) *MockSQSClient_DeleteQueue_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_DeleteQueue_Call) RunAndReturn(run func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error)) *MockSQSClient_DeleteQueue_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetQueueAttributes provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) GetQueueAttributes(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetQueueAttributes")
|
|
}
|
|
|
|
var r0 *sqs.GetQueueAttributesOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) *sqs.GetQueueAttributesOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.GetQueueAttributesOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_GetQueueAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueueAttributes'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) GetQueueAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_GetQueueAttributes_Call {
|
|
return &MockSQSClient_GetQueueAttributes_Call{Call: _e.mock.On("GetQueueAttributes",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_GetQueueAttributes_Call) Run(run func(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_GetQueueAttributes_Call) Return(_a0 *sqs.GetQueueAttributesOutput, _a1 error) *MockSQSClient_GetQueueAttributes_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_GetQueueAttributes_Call) RunAndReturn(run func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error)) *MockSQSClient_GetQueueAttributes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetQueueUrl provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) GetQueueUrl(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetQueueUrl")
|
|
}
|
|
|
|
var r0 *sqs.GetQueueUrlOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) *sqs.GetQueueUrlOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.GetQueueUrlOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_GetQueueUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueueUrl'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) GetQueueUrl(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_GetQueueUrl_Call {
|
|
return &MockSQSClient_GetQueueUrl_Call{Call: _e.mock.On("GetQueueUrl",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_GetQueueUrl_Call) Run(run func(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_GetQueueUrl_Call) Return(_a0 *sqs.GetQueueUrlOutput, _a1 error) *MockSQSClient_GetQueueUrl_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_GetQueueUrl_Call) RunAndReturn(run func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error)) *MockSQSClient_GetQueueUrl_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListQueueTags provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) ListQueueTags(ctx context.Context, params *sqs.ListQueueTagsInput, optFns ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListQueueTags")
|
|
}
|
|
|
|
var r0 *sqs.ListQueueTagsOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) *sqs.ListQueueTagsOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.ListQueueTagsOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_ListQueueTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListQueueTags'
|
|
type MockSQSClient_ListQueueTags_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListQueueTags is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.ListQueueTagsInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) ListQueueTags(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ListQueueTags_Call {
|
|
return &MockSQSClient_ListQueueTags_Call{Call: _e.mock.On("ListQueueTags",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_ListQueueTags_Call) Run(run func(ctx context.Context, params *sqs.ListQueueTagsInput, optFns ...func(*sqs.Options))) *MockSQSClient_ListQueueTags_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.ListQueueTagsInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ListQueueTags_Call) Return(_a0 *sqs.ListQueueTagsOutput, _a1 error) *MockSQSClient_ListQueueTags_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ListQueueTags_Call) RunAndReturn(run func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error)) *MockSQSClient_ListQueueTags_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListQueues provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) ListQueues(ctx context.Context, params *sqs.ListQueuesInput, optFns ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListQueues")
|
|
}
|
|
|
|
var r0 *sqs.ListQueuesOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) *sqs.ListQueuesOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.ListQueuesOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_ListQueues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListQueues'
|
|
type MockSQSClient_ListQueues_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListQueues is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.ListQueuesInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) ListQueues(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ListQueues_Call {
|
|
return &MockSQSClient_ListQueues_Call{Call: _e.mock.On("ListQueues",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_ListQueues_Call) Run(run func(ctx context.Context, params *sqs.ListQueuesInput, optFns ...func(*sqs.Options))) *MockSQSClient_ListQueues_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.ListQueuesInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ListQueues_Call) Return(_a0 *sqs.ListQueuesOutput, _a1 error) *MockSQSClient_ListQueues_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ListQueues_Call) RunAndReturn(run func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error)) *MockSQSClient_ListQueues_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// PurgeQueue provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) PurgeQueue(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PurgeQueue")
|
|
}
|
|
|
|
var r0 *sqs.PurgeQueueOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) *sqs.PurgeQueueOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.PurgeQueueOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_PurgeQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurgeQueue'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) PurgeQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_PurgeQueue_Call {
|
|
return &MockSQSClient_PurgeQueue_Call{Call: _e.mock.On("PurgeQueue",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_PurgeQueue_Call) Run(run func(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_PurgeQueue_Call) Return(_a0 *sqs.PurgeQueueOutput, _a1 error) *MockSQSClient_PurgeQueue_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_PurgeQueue_Call) RunAndReturn(run func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error)) *MockSQSClient_PurgeQueue_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ReceiveMessage provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) ReceiveMessage(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ReceiveMessage")
|
|
}
|
|
|
|
var r0 *sqs.ReceiveMessageOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) *sqs.ReceiveMessageOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.ReceiveMessageOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_ReceiveMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReceiveMessage'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) ReceiveMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ReceiveMessage_Call {
|
|
return &MockSQSClient_ReceiveMessage_Call{Call: _e.mock.On("ReceiveMessage",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_ReceiveMessage_Call) Run(run func(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_ReceiveMessage_Call) Return(_a0 *sqs.ReceiveMessageOutput, _a1 error) *MockSQSClient_ReceiveMessage_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_ReceiveMessage_Call) RunAndReturn(run func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error)) *MockSQSClient_ReceiveMessage_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemovePermission provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) RemovePermission(ctx context.Context, params *sqs.RemovePermissionInput, optFns ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RemovePermission")
|
|
}
|
|
|
|
var r0 *sqs.RemovePermissionOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) *sqs.RemovePermissionOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.RemovePermissionOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_RemovePermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePermission'
|
|
type MockSQSClient_RemovePermission_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemovePermission is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.RemovePermissionInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) RemovePermission(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_RemovePermission_Call {
|
|
return &MockSQSClient_RemovePermission_Call{Call: _e.mock.On("RemovePermission",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_RemovePermission_Call) Run(run func(ctx context.Context, params *sqs.RemovePermissionInput, optFns ...func(*sqs.Options))) *MockSQSClient_RemovePermission_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.RemovePermissionInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_RemovePermission_Call) Return(_a0 *sqs.RemovePermissionOutput, _a1 error) *MockSQSClient_RemovePermission_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_RemovePermission_Call) RunAndReturn(run func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error)) *MockSQSClient_RemovePermission_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SendMessage provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) SendMessage(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SendMessage")
|
|
}
|
|
|
|
var r0 *sqs.SendMessageOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) (*sqs.SendMessageOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) *sqs.SendMessageOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.SendMessageOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_SendMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessage'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) SendMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SendMessage_Call {
|
|
return &MockSQSClient_SendMessage_Call{Call: _e.mock.On("SendMessage",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_SendMessage_Call) Run(run func(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_SendMessage_Call) Return(_a0 *sqs.SendMessageOutput, _a1 error) *MockSQSClient_SendMessage_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_SendMessage_Call) RunAndReturn(run func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) (*sqs.SendMessageOutput, error)) *MockSQSClient_SendMessage_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SendMessageBatch provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) SendMessageBatch(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SendMessageBatch")
|
|
}
|
|
|
|
var r0 *sqs.SendMessageBatchOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) *sqs.SendMessageBatchOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.SendMessageBatchOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_SendMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessageBatch'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) SendMessageBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SendMessageBatch_Call {
|
|
return &MockSQSClient_SendMessageBatch_Call{Call: _e.mock.On("SendMessageBatch",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_SendMessageBatch_Call) Run(run func(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_SendMessageBatch_Call) Return(_a0 *sqs.SendMessageBatchOutput, _a1 error) *MockSQSClient_SendMessageBatch_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_SendMessageBatch_Call) RunAndReturn(run func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error)) *MockSQSClient_SendMessageBatch_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetQueueAttributes provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) SetQueueAttributes(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetQueueAttributes")
|
|
}
|
|
|
|
var r0 *sqs.SetQueueAttributesOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) *sqs.SetQueueAttributesOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.SetQueueAttributesOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_SetQueueAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetQueueAttributes'
|
|
type MockSQSClient_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 *MockSQSClient_Expecter) SetQueueAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SetQueueAttributes_Call {
|
|
return &MockSQSClient_SetQueueAttributes_Call{Call: _e.mock.On("SetQueueAttributes",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_SetQueueAttributes_Call) Run(run func(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options))) *MockSQSClient_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 *MockSQSClient_SetQueueAttributes_Call) Return(_a0 *sqs.SetQueueAttributesOutput, _a1 error) *MockSQSClient_SetQueueAttributes_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_SetQueueAttributes_Call) RunAndReturn(run func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error)) *MockSQSClient_SetQueueAttributes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TagQueue provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) TagQueue(ctx context.Context, params *sqs.TagQueueInput, optFns ...func(*sqs.Options)) (*sqs.TagQueueOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TagQueue")
|
|
}
|
|
|
|
var r0 *sqs.TagQueueOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) (*sqs.TagQueueOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) *sqs.TagQueueOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.TagQueueOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_TagQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagQueue'
|
|
type MockSQSClient_TagQueue_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TagQueue is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.TagQueueInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) TagQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_TagQueue_Call {
|
|
return &MockSQSClient_TagQueue_Call{Call: _e.mock.On("TagQueue",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_TagQueue_Call) Run(run func(ctx context.Context, params *sqs.TagQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_TagQueue_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.TagQueueInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_TagQueue_Call) Return(_a0 *sqs.TagQueueOutput, _a1 error) *MockSQSClient_TagQueue_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_TagQueue_Call) RunAndReturn(run func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) (*sqs.TagQueueOutput, error)) *MockSQSClient_TagQueue_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UntagQueue provides a mock function with given fields: ctx, params, optFns
|
|
func (_m *MockSQSClient) UntagQueue(ctx context.Context, params *sqs.UntagQueueInput, optFns ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error) {
|
|
_va := make([]interface{}, len(optFns))
|
|
for _i := range optFns {
|
|
_va[_i] = optFns[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, params)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UntagQueue")
|
|
}
|
|
|
|
var r0 *sqs.UntagQueueOutput
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error)); ok {
|
|
return rf(ctx, params, optFns...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) *sqs.UntagQueueOutput); ok {
|
|
r0 = rf(ctx, params, optFns...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*sqs.UntagQueueOutput)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) error); ok {
|
|
r1 = rf(ctx, params, optFns...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSQSClient_UntagQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagQueue'
|
|
type MockSQSClient_UntagQueue_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UntagQueue is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - params *sqs.UntagQueueInput
|
|
// - optFns ...func(*sqs.Options)
|
|
func (_e *MockSQSClient_Expecter) UntagQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_UntagQueue_Call {
|
|
return &MockSQSClient_UntagQueue_Call{Call: _e.mock.On("UntagQueue",
|
|
append([]interface{}{ctx, params}, optFns...)...)}
|
|
}
|
|
|
|
func (_c *MockSQSClient_UntagQueue_Call) Run(run func(ctx context.Context, params *sqs.UntagQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_UntagQueue_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.UntagQueueInput), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_UntagQueue_Call) Return(_a0 *sqs.UntagQueueOutput, _a1 error) *MockSQSClient_UntagQueue_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSQSClient_UntagQueue_Call) RunAndReturn(run func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error)) *MockSQSClient_UntagQueue_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockSQSClient creates a new instance of MockSQSClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockSQSClient(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockSQSClient {
|
|
mock := &MockSQSClient{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|