jacob-mathison/query-orchestration
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity
Files
3c1a77edbb9fbcce22ea385657076ff67f1d39af
query-orchestration/mocks/queue/mock_SQSClient.go
T

1445 lines
52 KiB
Go
Raw Normal View History

Merged in feature/semver (pull request #93)
2025-03-06 22:33:39 +00:00
// Code generated by mockery v2.52.3. DO NOT EDIT.
Merged in feature/docinitialisation (pull request #41)
2025-02-03 17:30:50 +00:00
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
}
Reference in New Issue Copy Permalink