From f673e72f0529c326d20a43e80fe4e2d8f152e243 Mon Sep 17 00:00:00 2001 From: Alex DeBrie Date: Sun, 25 Mar 2018 16:35:25 -0500 Subject: [PATCH] Add SQSProvider (#399) * Add SQSProvider * Update OpenAPI --- README.md | 8 +- cmd/event-gateway/main.go | 1 + docs/openapi/openapi-config-api.yaml | 46 +- providers/awssqs/awssqs.go | 106 ++++ providers/awssqs/awssqs_test.go | 125 +++++ providers/awssqs/mock/mock.go | 3 + providers/awssqs/mock/sqsiface.go | 784 +++++++++++++++++++++++++++ 7 files changed, 1067 insertions(+), 6 deletions(-) create mode 100644 providers/awssqs/awssqs.go create mode 100644 providers/awssqs/awssqs_test.go create mode 100644 providers/awssqs/mock/mock.go create mode 100644 providers/awssqs/mock/sqsiface.go diff --git a/README.md b/README.md index 6ad5d0b..07cff2d 100644 --- a/README.md +++ b/README.md @@ -85,7 +85,7 @@ Discover and call serverless functions from anything that can reach the Event Ga following function types: * FaaS functions (AWS Lambda, Google Cloud Functions, Azure Functions, OpenWhisk Actions) -* Connectors (AWS Kinesis, AWS Kinesis Firehose) +* Connectors (AWS Kinesis, AWS Kinesis Firehose, AWS SQS) * HTTP endpoints/Webhook (e.g. POST http://example.com/function) Function Discovery stores information about functions allowing the Event Gateway to call them as a reaction to received @@ -461,6 +461,12 @@ JSON object: * `awsAccessKeyId` - `string` - optional, AWS API key ID. By default credentials from the [environment](http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials) are used. * `awsSecretAccessKey` - `string` - optional, AWS API access key. By default credentials from the [environment](http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials) are used. * `awsSessionToken` - `string` - optional, AWS session token + * for AWS SQS connector: + * `queueUrl` - `string` - required, AWS SQS Queue URL + * `region` - `string` - required, region name + * `awsAccessKeyId` - `string` - optional, AWS API key ID. By default credentials from the [environment](http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials) are used. + * `awsSecretAccessKey` - `string` - optional, AWS API access key. By default credentials from the [environment](http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials) are used. + * `awsSessionToken` - `string` - optional, AWS session token **Response** diff --git a/cmd/event-gateway/main.go b/cmd/event-gateway/main.go index 9022b78..c77de06 100644 --- a/cmd/event-gateway/main.go +++ b/cmd/event-gateway/main.go @@ -26,6 +26,7 @@ import ( _ "github.com/serverless/event-gateway/providers/awsfirehose" _ "github.com/serverless/event-gateway/providers/awskinesis" _ "github.com/serverless/event-gateway/providers/awslambda" + _ "github.com/serverless/event-gateway/providers/awssqs" _ "github.com/serverless/event-gateway/providers/http" ) diff --git a/docs/openapi/openapi-config-api.yaml b/docs/openapi/openapi-config-api.yaml index a065fd0..d193f3d 100644 --- a/docs/openapi/openapi-config-api.yaml +++ b/docs/openapi/openapi-config-api.yaml @@ -213,15 +213,19 @@ components: type: string description: "function provider" enum: - - awslambda + - awsfirehose - awskinesis + - awslambda + - awssqs - http Provider: type: object description: "function provider configuration" oneOf: + - $ref: '#/components/schemas/AWSFirehose' - $ref: '#/components/schemas/AWSKinesis' - $ref: '#/components/schemas/AWSLambda' + - $ref: '#/components/schemas/AWSSQS' - $ref: '#/components/schemas/HTTP' Function: type: object @@ -265,11 +269,11 @@ components: type: array items: $ref: '#/components/schemas/Subscription' - AWSLambda: + AWSFirehose: type: object properties: - arn: - $ref: '#/components/schemas/ARN' + deliveryStreamName: + $ref: '#/components/schemas/DeliveryStreamName' region: $ref: '#/components/schemas/Region' awsAccessKeyId: @@ -291,6 +295,32 @@ components: $ref: '#/components/schemas/AWSSecretAccessKey' awsSessionToken: $ref: '#/components/schemas/AWSSessionToken' + AWSLambda: + type: object + properties: + arn: + $ref: '#/components/schemas/ARN' + region: + $ref: '#/components/schemas/Region' + awsAccessKeyId: + $ref: '#/components/schemas/AWSAccessKeyId' + awsSecretAccessKey: + $ref: '#/components/schemas/AWSSecretAccessKey' + awsSessionToken: + $ref: '#/components/schemas/AWSSessionToken' + AWSSQS: + type: object + properties: + queueUrl: + $ref: '#/components/schemas/QueueURL' + region: + $ref: '#/components/schemas/Region' + awsAccessKeyId: + $ref: '#/components/schemas/AWSAccessKeyId' + awsSecretAccessKey: + $ref: '#/components/schemas/AWSSecretAccessKey' + awsSessionToken: + $ref: '#/components/schemas/AWSSessionToken' HTTP: type: object properties: @@ -314,6 +344,12 @@ components: StreamName: type: string description: "AWS Kinesis stream name" + DeliveryStreamName: + type: string + description: "AWS Firehose delivery stream name" + QueueURL: + type: string + description: "AWS SQS Queue URL" URL: type: string format: url @@ -456,4 +492,4 @@ components: content: application/json: schema: - $ref: '#/components/schemas/Errors' \ No newline at end of file + $ref: '#/components/schemas/Errors' diff --git a/providers/awssqs/awssqs.go b/providers/awssqs/awssqs.go new file mode 100644 index 0000000..d44c137 --- /dev/null +++ b/providers/awssqs/awssqs.go @@ -0,0 +1,106 @@ +package awssqs + +import ( + "encoding/json" + "errors" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/credentials" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/sqs" + "github.com/aws/aws-sdk-go/service/sqs/sqsiface" + "github.com/serverless/event-gateway/function" + "go.uber.org/zap/zapcore" + validator "gopkg.in/go-playground/validator.v9" +) + +// Type of provider. +const Type = function.ProviderType("awssqs") + +func init() { + function.RegisterProvider(Type, ProviderLoader{}) +} + +// AWSSQS function implementation +type AWSSQS struct { + Service sqsiface.SQSAPI`json:"-" validate:"-"` + + QueueURL string `json:"queueUrl" validate:"required"` + Region string `json:"region" validate:"required"` + AWSAccessKeyID string `json:"awsAccessKeyId,omitempty"` + AWSSecretAccessKey string `json:"awsSecretAccessKey,omitempty"` + AWSSessionToken string `json:"awsSessionToken,omitempty"` +} + +// Call sends message to AWS SQS Queue +func (a AWSSQS) Call(payload []byte) ([]byte, error) { + body := string(payload) + sendMessageOutput, err := a.Service.SendMessage(&sqs.SendMessageInput{ + QueueUrl: &a.QueueURL, + MessageBody: &body, + }) + if err != nil { + if awserr, ok := err.(awserr.Error); ok { + return nil, &function.ErrFunctionCallFailed{Original: awserr} + } + } + + return []byte(*sendMessageOutput.MessageId), err +} + +// validate provider config. +func (a AWSSQS) validate() error { + validate := validator.New() + err := validate.Struct(a) + if err != nil { + return err + } + return nil +} + +// MarshalLogObject is a part of zapcore.ObjectMarshaler interface. +func (a AWSSQS) MarshalLogObject(enc zapcore.ObjectEncoder) error { + enc.AddString("queueUrl", a.QueueURL) + enc.AddString("region", a.Region) + if a.AWSAccessKeyID != "" { + enc.AddString("awsAccessKeyId", "*****") + } + if a.AWSSecretAccessKey != "" { + enc.AddString("awsSecretAccessKey", "*****") + } + if a.AWSSessionToken != "" { + enc.AddString("awsSessionToken", "*****") + } + return nil +} + +// ProviderLoader implementation +type ProviderLoader struct{} + +// Load decode JSON data as Config and return initialized Provider instance. +func (p ProviderLoader) Load(data []byte) (function.Provider, error) { + provider := &AWSSQS{} + err := json.Unmarshal(data, provider) + if err != nil { + return nil, errors.New("unable to load function provider config: " + err.Error()) + } + + err = provider.validate() + if err != nil { + return nil, errors.New("missing required fields for AWS SQS function") + } + + config := aws.NewConfig().WithRegion(provider.Region) + if provider.AWSAccessKeyID != "" && provider.AWSSecretAccessKey != "" { + config = config.WithCredentials(credentials.NewStaticCredentials(provider.AWSAccessKeyID, provider.AWSSecretAccessKey, provider.AWSSessionToken)) + } + + awsSession, err := session.NewSession(config) + if err != nil { + return nil, errors.New("unable to create AWS Session: " + err.Error()) + } + + provider.Service = sqs.New(awsSession) + return provider, nil +} diff --git a/providers/awssqs/awssqs_test.go b/providers/awssqs/awssqs_test.go new file mode 100644 index 0000000..9dbb284 --- /dev/null +++ b/providers/awssqs/awssqs_test.go @@ -0,0 +1,125 @@ +package awssqs_test + +import ( + "errors" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/sqs" + "github.com/golang/mock/gomock" + "github.com/serverless/event-gateway/function" + "github.com/serverless/event-gateway/providers/awssqs" + "github.com/serverless/event-gateway/providers/awssqs/mock" + "github.com/stretchr/testify/assert" + "go.uber.org/zap/zapcore" +) + +func TestLoad(t *testing.T) { + for _, testCase := range loadTests { + config := []byte(testCase.config) + loader := awssqs.ProviderLoader{} + + _, err := loader.Load(config) + + assert.Equal(t, testCase.expectedError, err) + } +} + +func TestCall(t *testing.T) { + for _, testCase := range callTests { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + serviceMock := mock.NewMockSQSAPI(mockCtrl) + serviceMock.EXPECT().SendMessage(gomock.Any()).Return(testCase.sendMessageResult, testCase.sendMessageError) + + provider := awssqs.AWSSQS{ + Service: serviceMock, + QueueURL: "https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue", + Region: "us-east-1", + } + + output, err := provider.Call([]byte("testpayload")) + + assert.Equal(t, testCase.expectedResult, output) + assert.Equal(t, testCase.expectedError, err) + } +} + +func TestMarshalLogObject(t *testing.T) { + for _, testCase := range logTests { + enc := zapcore.NewMapObjectEncoder() + + testCase.provider.MarshalLogObject(enc) + + assert.Equal(t, testCase.expectedFields, enc.Fields) + } +} + +var loadTests = []struct { + config string + expectedError error +}{ + { + `{"queueUrl": "", "region": `, + errors.New("unable to load function provider config: unexpected end of JSON input"), + }, + { + `{"queueUrl": "", "region": "us-east-1"}`, + errors.New("missing required fields for AWS SQS function"), + }, + { + `{"queueUrl": "https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue", "region": ""}`, + errors.New("missing required fields for AWS SQS function"), + }, +} + +var callTests = []struct { + sendMessageResult *sqs.SendMessageOutput + sendMessageError error + expectedResult []byte + expectedError error +}{ + { + &sqs.SendMessageOutput{MessageId: aws.String("testid")}, + nil, + []byte("testid"), + nil, + }, + { + nil, + awserr.New("", "", nil), + []byte(nil), + &function.ErrFunctionCallFailed{Original: awserr.New("", "", nil)}, + }, +} + +var logTests = []struct { + provider function.Provider + expectedFields map[string]interface{} +}{ + { + awssqs.AWSSQS{ + QueueURL : "https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue", + Region: "us-east-1", + }, + map[string]interface{}{ + "queueUrl": "https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue", + "region": "us-east-1", + }, + }, + { + awssqs.AWSSQS{ + AWSAccessKeyID: "id", + AWSSecretAccessKey: "key", + AWSSessionToken: "token", + }, + map[string]interface{}{ + "queueUrl": "", + "region": "", + "awsAccessKeyId": "*****", + "awsSecretAccessKey": "*****", + "awsSessionToken": "*****", + }, + }, +} diff --git a/providers/awssqs/mock/mock.go b/providers/awssqs/mock/mock.go new file mode 100644 index 0000000..b5550c6 --- /dev/null +++ b/providers/awssqs/mock/mock.go @@ -0,0 +1,3 @@ +//go:generate mockgen -package mock -destination sqsiface.go github.com/aws/aws-sdk-go/service/sqs/sqsiface SQSAPI + +package mock diff --git a/providers/awssqs/mock/sqsiface.go b/providers/awssqs/mock/sqsiface.go new file mode 100644 index 0000000..a040b5f --- /dev/null +++ b/providers/awssqs/mock/sqsiface.go @@ -0,0 +1,784 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/sqs/sqsiface (interfaces: SQSAPI) + +// Package mock is a generated GoMock package. +package mock + +import ( + aws "github.com/aws/aws-sdk-go/aws" + request "github.com/aws/aws-sdk-go/aws/request" + sqs "github.com/aws/aws-sdk-go/service/sqs" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockSQSAPI is a mock of SQSAPI interface +type MockSQSAPI struct { + ctrl *gomock.Controller + recorder *MockSQSAPIMockRecorder +} + +// MockSQSAPIMockRecorder is the mock recorder for MockSQSAPI +type MockSQSAPIMockRecorder struct { + mock *MockSQSAPI +} + +// NewMockSQSAPI creates a new mock instance +func NewMockSQSAPI(ctrl *gomock.Controller) *MockSQSAPI { + mock := &MockSQSAPI{ctrl: ctrl} + mock.recorder = &MockSQSAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockSQSAPI) EXPECT() *MockSQSAPIMockRecorder { + return m.recorder +} + +// AddPermission mocks base method +func (m *MockSQSAPI) AddPermission(arg0 *sqs.AddPermissionInput) (*sqs.AddPermissionOutput, error) { + ret := m.ctrl.Call(m, "AddPermission", arg0) + ret0, _ := ret[0].(*sqs.AddPermissionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddPermission indicates an expected call of AddPermission +func (mr *MockSQSAPIMockRecorder) AddPermission(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermission", reflect.TypeOf((*MockSQSAPI)(nil).AddPermission), arg0) +} + +// AddPermissionRequest mocks base method +func (m *MockSQSAPI) AddPermissionRequest(arg0 *sqs.AddPermissionInput) (*request.Request, *sqs.AddPermissionOutput) { + ret := m.ctrl.Call(m, "AddPermissionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.AddPermissionOutput) + return ret0, ret1 +} + +// AddPermissionRequest indicates an expected call of AddPermissionRequest +func (mr *MockSQSAPIMockRecorder) AddPermissionRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionRequest", reflect.TypeOf((*MockSQSAPI)(nil).AddPermissionRequest), arg0) +} + +// AddPermissionWithContext mocks base method +func (m *MockSQSAPI) AddPermissionWithContext(arg0 aws.Context, arg1 *sqs.AddPermissionInput, arg2 ...request.Option) (*sqs.AddPermissionOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddPermissionWithContext", varargs...) + ret0, _ := ret[0].(*sqs.AddPermissionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddPermissionWithContext indicates an expected call of AddPermissionWithContext +func (mr *MockSQSAPIMockRecorder) AddPermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionWithContext", reflect.TypeOf((*MockSQSAPI)(nil).AddPermissionWithContext), varargs...) +} + +// ChangeMessageVisibility mocks base method +func (m *MockSQSAPI) ChangeMessageVisibility(arg0 *sqs.ChangeMessageVisibilityInput) (*sqs.ChangeMessageVisibilityOutput, error) { + ret := m.ctrl.Call(m, "ChangeMessageVisibility", arg0) + ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeMessageVisibility indicates an expected call of ChangeMessageVisibility +func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibility(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibility", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibility), arg0) +} + +// ChangeMessageVisibilityBatch mocks base method +func (m *MockSQSAPI) ChangeMessageVisibilityBatch(arg0 *sqs.ChangeMessageVisibilityBatchInput) (*sqs.ChangeMessageVisibilityBatchOutput, error) { + ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatch", arg0) + ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityBatchOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeMessageVisibilityBatch indicates an expected call of ChangeMessageVisibilityBatch +func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityBatch(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatch", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityBatch), arg0) +} + +// ChangeMessageVisibilityBatchRequest mocks base method +func (m *MockSQSAPI) ChangeMessageVisibilityBatchRequest(arg0 *sqs.ChangeMessageVisibilityBatchInput) (*request.Request, *sqs.ChangeMessageVisibilityBatchOutput) { + ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatchRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.ChangeMessageVisibilityBatchOutput) + return ret0, ret1 +} + +// ChangeMessageVisibilityBatchRequest indicates an expected call of ChangeMessageVisibilityBatchRequest +func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityBatchRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityBatchRequest), arg0) +} + +// ChangeMessageVisibilityBatchWithContext mocks base method +func (m *MockSQSAPI) ChangeMessageVisibilityBatchWithContext(arg0 aws.Context, arg1 *sqs.ChangeMessageVisibilityBatchInput, arg2 ...request.Option) (*sqs.ChangeMessageVisibilityBatchOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatchWithContext", varargs...) + ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityBatchOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeMessageVisibilityBatchWithContext indicates an expected call of ChangeMessageVisibilityBatchWithContext +func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatchWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityBatchWithContext), varargs...) +} + +// ChangeMessageVisibilityRequest mocks base method +func (m *MockSQSAPI) ChangeMessageVisibilityRequest(arg0 *sqs.ChangeMessageVisibilityInput) (*request.Request, *sqs.ChangeMessageVisibilityOutput) { + ret := m.ctrl.Call(m, "ChangeMessageVisibilityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.ChangeMessageVisibilityOutput) + return ret0, ret1 +} + +// ChangeMessageVisibilityRequest indicates an expected call of ChangeMessageVisibilityRequest +func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityRequest", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityRequest), arg0) +} + +// ChangeMessageVisibilityWithContext mocks base method +func (m *MockSQSAPI) ChangeMessageVisibilityWithContext(arg0 aws.Context, arg1 *sqs.ChangeMessageVisibilityInput, arg2 ...request.Option) (*sqs.ChangeMessageVisibilityOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangeMessageVisibilityWithContext", varargs...) + ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeMessageVisibilityWithContext indicates an expected call of ChangeMessageVisibilityWithContext +func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityWithContext), varargs...) +} + +// CreateQueue mocks base method +func (m *MockSQSAPI) CreateQueue(arg0 *sqs.CreateQueueInput) (*sqs.CreateQueueOutput, error) { + ret := m.ctrl.Call(m, "CreateQueue", arg0) + ret0, _ := ret[0].(*sqs.CreateQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateQueue indicates an expected call of CreateQueue +func (mr *MockSQSAPIMockRecorder) CreateQueue(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueue", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueue), arg0) +} + +// CreateQueueRequest mocks base method +func (m *MockSQSAPI) CreateQueueRequest(arg0 *sqs.CreateQueueInput) (*request.Request, *sqs.CreateQueueOutput) { + ret := m.ctrl.Call(m, "CreateQueueRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.CreateQueueOutput) + return ret0, ret1 +} + +// CreateQueueRequest indicates an expected call of CreateQueueRequest +func (mr *MockSQSAPIMockRecorder) CreateQueueRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueueRequest), arg0) +} + +// CreateQueueWithContext mocks base method +func (m *MockSQSAPI) CreateQueueWithContext(arg0 aws.Context, arg1 *sqs.CreateQueueInput, arg2 ...request.Option) (*sqs.CreateQueueOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateQueueWithContext", varargs...) + ret0, _ := ret[0].(*sqs.CreateQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateQueueWithContext indicates an expected call of CreateQueueWithContext +func (mr *MockSQSAPIMockRecorder) CreateQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueueWithContext", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueueWithContext), varargs...) +} + +// DeleteMessage mocks base method +func (m *MockSQSAPI) DeleteMessage(arg0 *sqs.DeleteMessageInput) (*sqs.DeleteMessageOutput, error) { + ret := m.ctrl.Call(m, "DeleteMessage", arg0) + ret0, _ := ret[0].(*sqs.DeleteMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMessage indicates an expected call of DeleteMessage +func (mr *MockSQSAPIMockRecorder) DeleteMessage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessage), arg0) +} + +// DeleteMessageBatch mocks base method +func (m *MockSQSAPI) DeleteMessageBatch(arg0 *sqs.DeleteMessageBatchInput) (*sqs.DeleteMessageBatchOutput, error) { + ret := m.ctrl.Call(m, "DeleteMessageBatch", arg0) + ret0, _ := ret[0].(*sqs.DeleteMessageBatchOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMessageBatch indicates an expected call of DeleteMessageBatch +func (mr *MockSQSAPIMockRecorder) DeleteMessageBatch(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatch", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageBatch), arg0) +} + +// DeleteMessageBatchRequest mocks base method +func (m *MockSQSAPI) DeleteMessageBatchRequest(arg0 *sqs.DeleteMessageBatchInput) (*request.Request, *sqs.DeleteMessageBatchOutput) { + ret := m.ctrl.Call(m, "DeleteMessageBatchRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.DeleteMessageBatchOutput) + return ret0, ret1 +} + +// DeleteMessageBatchRequest indicates an expected call of DeleteMessageBatchRequest +func (mr *MockSQSAPIMockRecorder) DeleteMessageBatchRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageBatchRequest), arg0) +} + +// DeleteMessageBatchWithContext mocks base method +func (m *MockSQSAPI) DeleteMessageBatchWithContext(arg0 aws.Context, arg1 *sqs.DeleteMessageBatchInput, arg2 ...request.Option) (*sqs.DeleteMessageBatchOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteMessageBatchWithContext", varargs...) + ret0, _ := ret[0].(*sqs.DeleteMessageBatchOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMessageBatchWithContext indicates an expected call of DeleteMessageBatchWithContext +func (mr *MockSQSAPIMockRecorder) DeleteMessageBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatchWithContext", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageBatchWithContext), varargs...) +} + +// DeleteMessageRequest mocks base method +func (m *MockSQSAPI) DeleteMessageRequest(arg0 *sqs.DeleteMessageInput) (*request.Request, *sqs.DeleteMessageOutput) { + ret := m.ctrl.Call(m, "DeleteMessageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.DeleteMessageOutput) + return ret0, ret1 +} + +// DeleteMessageRequest indicates an expected call of DeleteMessageRequest +func (mr *MockSQSAPIMockRecorder) DeleteMessageRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageRequest), arg0) +} + +// DeleteMessageWithContext mocks base method +func (m *MockSQSAPI) DeleteMessageWithContext(arg0 aws.Context, arg1 *sqs.DeleteMessageInput, arg2 ...request.Option) (*sqs.DeleteMessageOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteMessageWithContext", varargs...) + ret0, _ := ret[0].(*sqs.DeleteMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMessageWithContext indicates an expected call of DeleteMessageWithContext +func (mr *MockSQSAPIMockRecorder) DeleteMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageWithContext", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageWithContext), varargs...) +} + +// DeleteQueue mocks base method +func (m *MockSQSAPI) DeleteQueue(arg0 *sqs.DeleteQueueInput) (*sqs.DeleteQueueOutput, error) { + ret := m.ctrl.Call(m, "DeleteQueue", arg0) + ret0, _ := ret[0].(*sqs.DeleteQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteQueue indicates an expected call of DeleteQueue +func (mr *MockSQSAPIMockRecorder) DeleteQueue(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueue", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueue), arg0) +} + +// DeleteQueueRequest mocks base method +func (m *MockSQSAPI) DeleteQueueRequest(arg0 *sqs.DeleteQueueInput) (*request.Request, *sqs.DeleteQueueOutput) { + ret := m.ctrl.Call(m, "DeleteQueueRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.DeleteQueueOutput) + return ret0, ret1 +} + +// DeleteQueueRequest indicates an expected call of DeleteQueueRequest +func (mr *MockSQSAPIMockRecorder) DeleteQueueRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueueRequest), arg0) +} + +// DeleteQueueWithContext mocks base method +func (m *MockSQSAPI) DeleteQueueWithContext(arg0 aws.Context, arg1 *sqs.DeleteQueueInput, arg2 ...request.Option) (*sqs.DeleteQueueOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteQueueWithContext", varargs...) + ret0, _ := ret[0].(*sqs.DeleteQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteQueueWithContext indicates an expected call of DeleteQueueWithContext +func (mr *MockSQSAPIMockRecorder) DeleteQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueueWithContext", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueueWithContext), varargs...) +} + +// GetQueueAttributes mocks base method +func (m *MockSQSAPI) GetQueueAttributes(arg0 *sqs.GetQueueAttributesInput) (*sqs.GetQueueAttributesOutput, error) { + ret := m.ctrl.Call(m, "GetQueueAttributes", arg0) + ret0, _ := ret[0].(*sqs.GetQueueAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueueAttributes indicates an expected call of GetQueueAttributes +func (mr *MockSQSAPIMockRecorder) GetQueueAttributes(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributes", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributes), arg0) +} + +// GetQueueAttributesRequest mocks base method +func (m *MockSQSAPI) GetQueueAttributesRequest(arg0 *sqs.GetQueueAttributesInput) (*request.Request, *sqs.GetQueueAttributesOutput) { + ret := m.ctrl.Call(m, "GetQueueAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.GetQueueAttributesOutput) + return ret0, ret1 +} + +// GetQueueAttributesRequest indicates an expected call of GetQueueAttributesRequest +func (mr *MockSQSAPIMockRecorder) GetQueueAttributesRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributesRequest", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributesRequest), arg0) +} + +// GetQueueAttributesWithContext mocks base method +func (m *MockSQSAPI) GetQueueAttributesWithContext(arg0 aws.Context, arg1 *sqs.GetQueueAttributesInput, arg2 ...request.Option) (*sqs.GetQueueAttributesOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetQueueAttributesWithContext", varargs...) + ret0, _ := ret[0].(*sqs.GetQueueAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueueAttributesWithContext indicates an expected call of GetQueueAttributesWithContext +func (mr *MockSQSAPIMockRecorder) GetQueueAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributesWithContext), varargs...) +} + +// GetQueueUrl mocks base method +func (m *MockSQSAPI) GetQueueUrl(arg0 *sqs.GetQueueUrlInput) (*sqs.GetQueueUrlOutput, error) { + ret := m.ctrl.Call(m, "GetQueueUrl", arg0) + ret0, _ := ret[0].(*sqs.GetQueueUrlOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueueUrl indicates an expected call of GetQueueUrl +func (mr *MockSQSAPIMockRecorder) GetQueueUrl(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrl", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrl), arg0) +} + +// GetQueueUrlRequest mocks base method +func (m *MockSQSAPI) GetQueueUrlRequest(arg0 *sqs.GetQueueUrlInput) (*request.Request, *sqs.GetQueueUrlOutput) { + ret := m.ctrl.Call(m, "GetQueueUrlRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.GetQueueUrlOutput) + return ret0, ret1 +} + +// GetQueueUrlRequest indicates an expected call of GetQueueUrlRequest +func (mr *MockSQSAPIMockRecorder) GetQueueUrlRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrlRequest", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrlRequest), arg0) +} + +// GetQueueUrlWithContext mocks base method +func (m *MockSQSAPI) GetQueueUrlWithContext(arg0 aws.Context, arg1 *sqs.GetQueueUrlInput, arg2 ...request.Option) (*sqs.GetQueueUrlOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetQueueUrlWithContext", varargs...) + ret0, _ := ret[0].(*sqs.GetQueueUrlOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueueUrlWithContext indicates an expected call of GetQueueUrlWithContext +func (mr *MockSQSAPIMockRecorder) GetQueueUrlWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrlWithContext", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrlWithContext), varargs...) +} + +// ListDeadLetterSourceQueues mocks base method +func (m *MockSQSAPI) ListDeadLetterSourceQueues(arg0 *sqs.ListDeadLetterSourceQueuesInput) (*sqs.ListDeadLetterSourceQueuesOutput, error) { + ret := m.ctrl.Call(m, "ListDeadLetterSourceQueues", arg0) + ret0, _ := ret[0].(*sqs.ListDeadLetterSourceQueuesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDeadLetterSourceQueues indicates an expected call of ListDeadLetterSourceQueues +func (mr *MockSQSAPIMockRecorder) ListDeadLetterSourceQueues(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueues", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueues), arg0) +} + +// ListDeadLetterSourceQueuesRequest mocks base method +func (m *MockSQSAPI) ListDeadLetterSourceQueuesRequest(arg0 *sqs.ListDeadLetterSourceQueuesInput) (*request.Request, *sqs.ListDeadLetterSourceQueuesOutput) { + ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.ListDeadLetterSourceQueuesOutput) + return ret0, ret1 +} + +// ListDeadLetterSourceQueuesRequest indicates an expected call of ListDeadLetterSourceQueuesRequest +func (mr *MockSQSAPIMockRecorder) ListDeadLetterSourceQueuesRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesRequest), arg0) +} + +// ListDeadLetterSourceQueuesWithContext mocks base method +func (m *MockSQSAPI) ListDeadLetterSourceQueuesWithContext(arg0 aws.Context, arg1 *sqs.ListDeadLetterSourceQueuesInput, arg2 ...request.Option) (*sqs.ListDeadLetterSourceQueuesOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesWithContext", varargs...) + ret0, _ := ret[0].(*sqs.ListDeadLetterSourceQueuesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDeadLetterSourceQueuesWithContext indicates an expected call of ListDeadLetterSourceQueuesWithContext +func (mr *MockSQSAPIMockRecorder) ListDeadLetterSourceQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesWithContext), varargs...) +} + +// ListQueues mocks base method +func (m *MockSQSAPI) ListQueues(arg0 *sqs.ListQueuesInput) (*sqs.ListQueuesOutput, error) { + ret := m.ctrl.Call(m, "ListQueues", arg0) + ret0, _ := ret[0].(*sqs.ListQueuesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListQueues indicates an expected call of ListQueues +func (mr *MockSQSAPIMockRecorder) ListQueues(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueues", reflect.TypeOf((*MockSQSAPI)(nil).ListQueues), arg0) +} + +// ListQueuesRequest mocks base method +func (m *MockSQSAPI) ListQueuesRequest(arg0 *sqs.ListQueuesInput) (*request.Request, *sqs.ListQueuesOutput) { + ret := m.ctrl.Call(m, "ListQueuesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.ListQueuesOutput) + return ret0, ret1 +} + +// ListQueuesRequest indicates an expected call of ListQueuesRequest +func (mr *MockSQSAPIMockRecorder) ListQueuesRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListQueuesRequest), arg0) +} + +// ListQueuesWithContext mocks base method +func (m *MockSQSAPI) ListQueuesWithContext(arg0 aws.Context, arg1 *sqs.ListQueuesInput, arg2 ...request.Option) (*sqs.ListQueuesOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListQueuesWithContext", varargs...) + ret0, _ := ret[0].(*sqs.ListQueuesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListQueuesWithContext indicates an expected call of ListQueuesWithContext +func (mr *MockSQSAPIMockRecorder) ListQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ListQueuesWithContext), varargs...) +} + +// PurgeQueue mocks base method +func (m *MockSQSAPI) PurgeQueue(arg0 *sqs.PurgeQueueInput) (*sqs.PurgeQueueOutput, error) { + ret := m.ctrl.Call(m, "PurgeQueue", arg0) + ret0, _ := ret[0].(*sqs.PurgeQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurgeQueue indicates an expected call of PurgeQueue +func (mr *MockSQSAPIMockRecorder) PurgeQueue(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueue", reflect.TypeOf((*MockSQSAPI)(nil).PurgeQueue), arg0) +} + +// PurgeQueueRequest mocks base method +func (m *MockSQSAPI) PurgeQueueRequest(arg0 *sqs.PurgeQueueInput) (*request.Request, *sqs.PurgeQueueOutput) { + ret := m.ctrl.Call(m, "PurgeQueueRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.PurgeQueueOutput) + return ret0, ret1 +} + +// PurgeQueueRequest indicates an expected call of PurgeQueueRequest +func (mr *MockSQSAPIMockRecorder) PurgeQueueRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).PurgeQueueRequest), arg0) +} + +// PurgeQueueWithContext mocks base method +func (m *MockSQSAPI) PurgeQueueWithContext(arg0 aws.Context, arg1 *sqs.PurgeQueueInput, arg2 ...request.Option) (*sqs.PurgeQueueOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PurgeQueueWithContext", varargs...) + ret0, _ := ret[0].(*sqs.PurgeQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurgeQueueWithContext indicates an expected call of PurgeQueueWithContext +func (mr *MockSQSAPIMockRecorder) PurgeQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueueWithContext", reflect.TypeOf((*MockSQSAPI)(nil).PurgeQueueWithContext), varargs...) +} + +// ReceiveMessage mocks base method +func (m *MockSQSAPI) ReceiveMessage(arg0 *sqs.ReceiveMessageInput) (*sqs.ReceiveMessageOutput, error) { + ret := m.ctrl.Call(m, "ReceiveMessage", arg0) + ret0, _ := ret[0].(*sqs.ReceiveMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReceiveMessage indicates an expected call of ReceiveMessage +func (mr *MockSQSAPIMockRecorder) ReceiveMessage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessage", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessage), arg0) +} + +// ReceiveMessageRequest mocks base method +func (m *MockSQSAPI) ReceiveMessageRequest(arg0 *sqs.ReceiveMessageInput) (*request.Request, *sqs.ReceiveMessageOutput) { + ret := m.ctrl.Call(m, "ReceiveMessageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.ReceiveMessageOutput) + return ret0, ret1 +} + +// ReceiveMessageRequest indicates an expected call of ReceiveMessageRequest +func (mr *MockSQSAPIMockRecorder) ReceiveMessageRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessageRequest), arg0) +} + +// ReceiveMessageWithContext mocks base method +func (m *MockSQSAPI) ReceiveMessageWithContext(arg0 aws.Context, arg1 *sqs.ReceiveMessageInput, arg2 ...request.Option) (*sqs.ReceiveMessageOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReceiveMessageWithContext", varargs...) + ret0, _ := ret[0].(*sqs.ReceiveMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReceiveMessageWithContext indicates an expected call of ReceiveMessageWithContext +func (mr *MockSQSAPIMockRecorder) ReceiveMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessageWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessageWithContext), varargs...) +} + +// RemovePermission mocks base method +func (m *MockSQSAPI) RemovePermission(arg0 *sqs.RemovePermissionInput) (*sqs.RemovePermissionOutput, error) { + ret := m.ctrl.Call(m, "RemovePermission", arg0) + ret0, _ := ret[0].(*sqs.RemovePermissionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemovePermission indicates an expected call of RemovePermission +func (mr *MockSQSAPIMockRecorder) RemovePermission(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermission", reflect.TypeOf((*MockSQSAPI)(nil).RemovePermission), arg0) +} + +// RemovePermissionRequest mocks base method +func (m *MockSQSAPI) RemovePermissionRequest(arg0 *sqs.RemovePermissionInput) (*request.Request, *sqs.RemovePermissionOutput) { + ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.RemovePermissionOutput) + return ret0, ret1 +} + +// RemovePermissionRequest indicates an expected call of RemovePermissionRequest +func (mr *MockSQSAPIMockRecorder) RemovePermissionRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionRequest", reflect.TypeOf((*MockSQSAPI)(nil).RemovePermissionRequest), arg0) +} + +// RemovePermissionWithContext mocks base method +func (m *MockSQSAPI) RemovePermissionWithContext(arg0 aws.Context, arg1 *sqs.RemovePermissionInput, arg2 ...request.Option) (*sqs.RemovePermissionOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RemovePermissionWithContext", varargs...) + ret0, _ := ret[0].(*sqs.RemovePermissionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemovePermissionWithContext indicates an expected call of RemovePermissionWithContext +func (mr *MockSQSAPIMockRecorder) RemovePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionWithContext", reflect.TypeOf((*MockSQSAPI)(nil).RemovePermissionWithContext), varargs...) +} + +// SendMessage mocks base method +func (m *MockSQSAPI) SendMessage(arg0 *sqs.SendMessageInput) (*sqs.SendMessageOutput, error) { + ret := m.ctrl.Call(m, "SendMessage", arg0) + ret0, _ := ret[0].(*sqs.SendMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMessage indicates an expected call of SendMessage +func (mr *MockSQSAPIMockRecorder) SendMessage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockSQSAPI)(nil).SendMessage), arg0) +} + +// SendMessageBatch mocks base method +func (m *MockSQSAPI) SendMessageBatch(arg0 *sqs.SendMessageBatchInput) (*sqs.SendMessageBatchOutput, error) { + ret := m.ctrl.Call(m, "SendMessageBatch", arg0) + ret0, _ := ret[0].(*sqs.SendMessageBatchOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMessageBatch indicates an expected call of SendMessageBatch +func (mr *MockSQSAPIMockRecorder) SendMessageBatch(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatch", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageBatch), arg0) +} + +// SendMessageBatchRequest mocks base method +func (m *MockSQSAPI) SendMessageBatchRequest(arg0 *sqs.SendMessageBatchInput) (*request.Request, *sqs.SendMessageBatchOutput) { + ret := m.ctrl.Call(m, "SendMessageBatchRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.SendMessageBatchOutput) + return ret0, ret1 +} + +// SendMessageBatchRequest indicates an expected call of SendMessageBatchRequest +func (mr *MockSQSAPIMockRecorder) SendMessageBatchRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageBatchRequest), arg0) +} + +// SendMessageBatchWithContext mocks base method +func (m *MockSQSAPI) SendMessageBatchWithContext(arg0 aws.Context, arg1 *sqs.SendMessageBatchInput, arg2 ...request.Option) (*sqs.SendMessageBatchOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendMessageBatchWithContext", varargs...) + ret0, _ := ret[0].(*sqs.SendMessageBatchOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMessageBatchWithContext indicates an expected call of SendMessageBatchWithContext +func (mr *MockSQSAPIMockRecorder) SendMessageBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatchWithContext", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageBatchWithContext), varargs...) +} + +// SendMessageRequest mocks base method +func (m *MockSQSAPI) SendMessageRequest(arg0 *sqs.SendMessageInput) (*request.Request, *sqs.SendMessageOutput) { + ret := m.ctrl.Call(m, "SendMessageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.SendMessageOutput) + return ret0, ret1 +} + +// SendMessageRequest indicates an expected call of SendMessageRequest +func (mr *MockSQSAPIMockRecorder) SendMessageRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageRequest), arg0) +} + +// SendMessageWithContext mocks base method +func (m *MockSQSAPI) SendMessageWithContext(arg0 aws.Context, arg1 *sqs.SendMessageInput, arg2 ...request.Option) (*sqs.SendMessageOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendMessageWithContext", varargs...) + ret0, _ := ret[0].(*sqs.SendMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMessageWithContext indicates an expected call of SendMessageWithContext +func (mr *MockSQSAPIMockRecorder) SendMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageWithContext", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageWithContext), varargs...) +} + +// SetQueueAttributes mocks base method +func (m *MockSQSAPI) SetQueueAttributes(arg0 *sqs.SetQueueAttributesInput) (*sqs.SetQueueAttributesOutput, error) { + ret := m.ctrl.Call(m, "SetQueueAttributes", arg0) + ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetQueueAttributes indicates an expected call of SetQueueAttributes +func (mr *MockSQSAPIMockRecorder) SetQueueAttributes(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributes", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributes), arg0) +} + +// SetQueueAttributesRequest mocks base method +func (m *MockSQSAPI) SetQueueAttributesRequest(arg0 *sqs.SetQueueAttributesInput) (*request.Request, *sqs.SetQueueAttributesOutput) { + ret := m.ctrl.Call(m, "SetQueueAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sqs.SetQueueAttributesOutput) + return ret0, ret1 +} + +// SetQueueAttributesRequest indicates an expected call of SetQueueAttributesRequest +func (mr *MockSQSAPIMockRecorder) SetQueueAttributesRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributesRequest", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributesRequest), arg0) +} + +// SetQueueAttributesWithContext mocks base method +func (m *MockSQSAPI) SetQueueAttributesWithContext(arg0 aws.Context, arg1 *sqs.SetQueueAttributesInput, arg2 ...request.Option) (*sqs.SetQueueAttributesOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetQueueAttributesWithContext", varargs...) + ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetQueueAttributesWithContext indicates an expected call of SetQueueAttributesWithContext +func (mr *MockSQSAPIMockRecorder) SetQueueAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributesWithContext), varargs...) +}