From 3a016f2059ab79efe8181b283a3b9d00efdcfa0f Mon Sep 17 00:00:00 2001 From: jsteenb2 Date: Thu, 21 Jun 2018 09:43:29 -0700 Subject: [PATCH 1/2] add batching to sqs Transport publishing --- queues/sqs/sqs.go | 91 +- queues/sqs/sqs_test.go | 71 +- queues/sqs/sqsfakes/fake_sqsapi.go | 4080 ++++++++++++++++++++++++++++ 3 files changed, 4225 insertions(+), 17 deletions(-) create mode 100644 queues/sqs/sqsfakes/fake_sqsapi.go diff --git a/queues/sqs/sqs.go b/queues/sqs/sqs.go index f1fef78..bd15f57 100644 --- a/queues/sqs/sqs.go +++ b/queues/sqs/sqs.go @@ -2,8 +2,10 @@ package sqs import ( + "fmt" "strings" "sync" + "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" @@ -14,7 +16,9 @@ import ( // Transport is a vice.Transport for Amazon's SQS type Transport struct { - wg sync.WaitGroup + batchSize int + batchInterval time.Duration + wg *sync.WaitGroup sm sync.Mutex sendChans map[string]chan []byte @@ -34,14 +38,25 @@ type Transport struct { // Credentials are automatically sourced using the AWS SDK credential chain, // for more info see the AWS SDK docs: // https://godoc.org/github.com/aws/aws-sdk-go#hdr-Configuring_Credentials -func New() *Transport { +func New(batchSize int, batchInterval time.Duration) *Transport { + if batchSize > 10 { + batchSize = 10 + } + + if batchInterval == 0 { + batchInterval = 200 * time.Millisecond + } + return &Transport{ - sendChans: make(map[string]chan []byte), - receiveChans: make(map[string]chan []byte), - errChan: make(chan error, 10), - stopchan: make(chan struct{}), - stopPubChan: make(chan struct{}), - stopSubChan: make(chan struct{}), + wg: &sync.WaitGroup{}, + batchSize: batchSize, + batchInterval: batchInterval, + sendChans: make(map[string]chan []byte), + receiveChans: make(map[string]chan []byte), + errChan: make(chan error, 10), + stopchan: make(chan struct{}), + stopPubChan: make(chan struct{}), + stopSubChan: make(chan struct{}), NewService: func(region string) (sqsiface.SQSAPI, error) { awsConfig := aws.NewConfig().WithRegion(region) @@ -169,6 +184,16 @@ func (t *Transport) makePublisher(name string) (chan []byte, error) { t.wg.Add(1) go func() { defer t.wg.Done() + var accum []*sqs.SendMessageBatchRequestEntry + + defer func() { + if t.batchSize == 0 && len(accum) == 0 { + return + } + + t.sendBatch(svc, name, accum) + accum = make([]*sqs.SendMessageBatchRequestEntry, 0, t.batchSize) + }() for { select { case <-t.stopPubChan: @@ -178,21 +203,61 @@ func (t *Transport) makePublisher(name string) (chan []byte, error) { return case msg := <-ch: - params := &sqs.SendMessageInput{ + if t.batchSize == 0 { + params := &sqs.SendMessageInput{ + MessageBody: aws.String(string(msg)), + QueueUrl: aws.String(name), + } + _, err := svc.SendMessage(params) + if err != nil { + t.errChan <- vice.Err{Message: msg, Name: name, Err: err} + } + continue + } + + id := fmt.Sprintf("%d", time.Now().UnixNano()) + accum = append(accum, &sqs.SendMessageBatchRequestEntry{ MessageBody: aws.String(string(msg)), - QueueUrl: aws.String(name), + Id: aws.String(id), + }) + if len(accum) < t.batchSize { + continue } - _, err := svc.SendMessage(params) - if err != nil { - t.errChan <- vice.Err{Message: msg, Name: name, Err: err} + + t.sendBatch(svc, name, accum) + accum = make([]*sqs.SendMessageBatchRequestEntry, 0, t.batchSize) + case <-time.After(t.batchInterval): + if len(accum) == 0 { continue } + + t.sendBatch(svc, name, accum) + accum = make([]*sqs.SendMessageBatchRequestEntry, 0, t.batchSize) } } }() + return ch, nil } +func (t *Transport) sendBatch(svc sqsiface.SQSAPI, name string, entries []*sqs.SendMessageBatchRequestEntry) { + batchParams := &sqs.SendMessageBatchInput{ + Entries: entries, + QueueUrl: aws.String(name), + } + + resp, err := svc.SendMessageBatch(batchParams) + if err != nil { + t.errChan <- vice.Err{Name: name, Err: err} + return + } + + for _, v := range resp.Failed { + err := fmt.Errorf("%s", *v.Message) + t.errChan <- vice.Err{Name: name, Err: err} + } +} + // ErrChan gets the channel on which errors are sent. func (t *Transport) ErrChan() <-chan error { return t.errChan diff --git a/queues/sqs/sqs_test.go b/queues/sqs/sqs_test.go index c3df0cc..9ed837c 100644 --- a/queues/sqs/sqs_test.go +++ b/queues/sqs/sqs_test.go @@ -1,14 +1,20 @@ package sqs import ( + "strconv" "sync" "testing" + "time" + + "github.com/matryer/vice" + "github.com/matryer/vice/queues/sqs/sqsfakes" + "github.com/matryer/vice/vicetest" "github.com/aws/aws-sdk-go/service/sqs" "github.com/aws/aws-sdk-go/service/sqs/sqsiface" "github.com/matryer/is" - "github.com/matryer/vice" - "github.com/matryer/vice/vicetest" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTransport(t *testing.T) { @@ -18,7 +24,7 @@ func TestTransport(t *testing.T) { } new := func() vice.Transport { - transport := New() + transport := New(0, 10*time.Second) transport.NewService = func(region string) (sqsiface.SQSAPI, error) { return svc, nil } @@ -30,12 +36,69 @@ func TestTransport(t *testing.T) { close(svc.finish) } +func Test_Transport_BatchesWrites(t *testing.T) { + newTransport := New(10, 200*time.Millisecond) + svc := new(sqsfakes.FakeSQSAPI) + svc.SendMessageBatchReturns(&sqs.SendMessageBatchOutput{}, nil) + newTransport.NewService = func(region string) (sqsiface.SQSAPI, error) { return svc, nil } + + stream := newTransport.Send("svcWriter") + for i := 0; i < 30; i++ { + stream <- []byte(strconv.Itoa(i)) + } + time.Sleep(100 * time.Millisecond) + + require.Equal(t, 3, svc.SendMessageBatchCallCount()) + + batch0 := svc.SendMessageBatchArgsForCall(0) + require.Equal(t, 10, len(batch0.Entries)) + for i := 0; i < 10; i++ { + assert.Equal(t, strconv.Itoa(i), *batch0.Entries[i].MessageBody) + } + + batch1 := svc.SendMessageBatchArgsForCall(1) + require.Equal(t, 10, len(batch1.Entries)) + for i := 0; i < 10; i++ { + assert.Equal(t, strconv.Itoa(i+10), *batch1.Entries[i].MessageBody) + } + + batch2 := svc.SendMessageBatchArgsForCall(2) + require.Equal(t, 10, len(batch2.Entries)) + for i := 0; i < 10; i++ { + assert.Equal(t, strconv.Itoa(i+20), *batch2.Entries[i].MessageBody) + } +} + +func Test_Transport_BatchFlushesOnReturn(t *testing.T) { + newTransport := New(10, 1000*time.Millisecond) + svc := new(sqsfakes.FakeSQSAPI) + svc.SendMessageBatchReturns(&sqs.SendMessageBatchOutput{}, nil) + newTransport.NewService = func(region string) (sqsiface.SQSAPI, error) { return svc, nil } + + stream := newTransport.Send("svcWriter") + for i := 0; i < 9; i++ { + stream <- []byte(strconv.Itoa(i)) + } + time.Sleep(100 * time.Millisecond) + newTransport.Stop() + + time.Sleep(200 * time.Millisecond) + + require.Equal(t, 1, svc.SendMessageBatchCallCount()) + + batch0 := svc.SendMessageBatchArgsForCall(0) + require.Equal(t, 9, len(batch0.Entries)) + for i := 0; i < 9; i++ { + assert.Equal(t, strconv.Itoa(i), *batch0.Entries[i].MessageBody) + } +} + func TestParseRegion(t *testing.T) { is := is.New(t) reg := RegionFromURL("http://sqs.us-east-2.amazonaws.com/123456789012/MyQueue") is.Equal("us-east-2", reg) - reg = RegionFromURL("http://localhost/foo") + reg = RegionFromURL("http://localhost/svcWriter") is.Equal("", reg) } diff --git a/queues/sqs/sqsfakes/fake_sqsapi.go b/queues/sqs/sqsfakes/fake_sqsapi.go new file mode 100644 index 0000000..0d5ecf7 --- /dev/null +++ b/queues/sqs/sqsfakes/fake_sqsapi.go @@ -0,0 +1,4080 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package sqsfakes + +import ( + "sync" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/service/sqs" + "github.com/aws/aws-sdk-go/service/sqs/sqsiface" +) + +type FakeSQSAPI struct { + AddPermissionStub func(*sqs.AddPermissionInput) (*sqs.AddPermissionOutput, error) + addPermissionMutex sync.RWMutex + addPermissionArgsForCall []struct { + arg1 *sqs.AddPermissionInput + } + addPermissionReturns struct { + result1 *sqs.AddPermissionOutput + result2 error + } + addPermissionReturnsOnCall map[int]struct { + result1 *sqs.AddPermissionOutput + result2 error + } + AddPermissionWithContextStub func(aws.Context, *sqs.AddPermissionInput, ...request.Option) (*sqs.AddPermissionOutput, error) + addPermissionWithContextMutex sync.RWMutex + addPermissionWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.AddPermissionInput + arg3 []request.Option + } + addPermissionWithContextReturns struct { + result1 *sqs.AddPermissionOutput + result2 error + } + addPermissionWithContextReturnsOnCall map[int]struct { + result1 *sqs.AddPermissionOutput + result2 error + } + AddPermissionRequestStub func(*sqs.AddPermissionInput) (*request.Request, *sqs.AddPermissionOutput) + addPermissionRequestMutex sync.RWMutex + addPermissionRequestArgsForCall []struct { + arg1 *sqs.AddPermissionInput + } + addPermissionRequestReturns struct { + result1 *request.Request + result2 *sqs.AddPermissionOutput + } + addPermissionRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.AddPermissionOutput + } + ChangeMessageVisibilityStub func(*sqs.ChangeMessageVisibilityInput) (*sqs.ChangeMessageVisibilityOutput, error) + changeMessageVisibilityMutex sync.RWMutex + changeMessageVisibilityArgsForCall []struct { + arg1 *sqs.ChangeMessageVisibilityInput + } + changeMessageVisibilityReturns struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + } + changeMessageVisibilityReturnsOnCall map[int]struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + } + ChangeMessageVisibilityWithContextStub func(aws.Context, *sqs.ChangeMessageVisibilityInput, ...request.Option) (*sqs.ChangeMessageVisibilityOutput, error) + changeMessageVisibilityWithContextMutex sync.RWMutex + changeMessageVisibilityWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.ChangeMessageVisibilityInput + arg3 []request.Option + } + changeMessageVisibilityWithContextReturns struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + } + changeMessageVisibilityWithContextReturnsOnCall map[int]struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + } + ChangeMessageVisibilityRequestStub func(*sqs.ChangeMessageVisibilityInput) (*request.Request, *sqs.ChangeMessageVisibilityOutput) + changeMessageVisibilityRequestMutex sync.RWMutex + changeMessageVisibilityRequestArgsForCall []struct { + arg1 *sqs.ChangeMessageVisibilityInput + } + changeMessageVisibilityRequestReturns struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityOutput + } + changeMessageVisibilityRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityOutput + } + ChangeMessageVisibilityBatchStub func(*sqs.ChangeMessageVisibilityBatchInput) (*sqs.ChangeMessageVisibilityBatchOutput, error) + changeMessageVisibilityBatchMutex sync.RWMutex + changeMessageVisibilityBatchArgsForCall []struct { + arg1 *sqs.ChangeMessageVisibilityBatchInput + } + changeMessageVisibilityBatchReturns struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + } + changeMessageVisibilityBatchReturnsOnCall map[int]struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + } + ChangeMessageVisibilityBatchWithContextStub func(aws.Context, *sqs.ChangeMessageVisibilityBatchInput, ...request.Option) (*sqs.ChangeMessageVisibilityBatchOutput, error) + changeMessageVisibilityBatchWithContextMutex sync.RWMutex + changeMessageVisibilityBatchWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.ChangeMessageVisibilityBatchInput + arg3 []request.Option + } + changeMessageVisibilityBatchWithContextReturns struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + } + changeMessageVisibilityBatchWithContextReturnsOnCall map[int]struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + } + ChangeMessageVisibilityBatchRequestStub func(*sqs.ChangeMessageVisibilityBatchInput) (*request.Request, *sqs.ChangeMessageVisibilityBatchOutput) + changeMessageVisibilityBatchRequestMutex sync.RWMutex + changeMessageVisibilityBatchRequestArgsForCall []struct { + arg1 *sqs.ChangeMessageVisibilityBatchInput + } + changeMessageVisibilityBatchRequestReturns struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityBatchOutput + } + changeMessageVisibilityBatchRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityBatchOutput + } + CreateQueueStub func(*sqs.CreateQueueInput) (*sqs.CreateQueueOutput, error) + createQueueMutex sync.RWMutex + createQueueArgsForCall []struct { + arg1 *sqs.CreateQueueInput + } + createQueueReturns struct { + result1 *sqs.CreateQueueOutput + result2 error + } + createQueueReturnsOnCall map[int]struct { + result1 *sqs.CreateQueueOutput + result2 error + } + CreateQueueWithContextStub func(aws.Context, *sqs.CreateQueueInput, ...request.Option) (*sqs.CreateQueueOutput, error) + createQueueWithContextMutex sync.RWMutex + createQueueWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.CreateQueueInput + arg3 []request.Option + } + createQueueWithContextReturns struct { + result1 *sqs.CreateQueueOutput + result2 error + } + createQueueWithContextReturnsOnCall map[int]struct { + result1 *sqs.CreateQueueOutput + result2 error + } + CreateQueueRequestStub func(*sqs.CreateQueueInput) (*request.Request, *sqs.CreateQueueOutput) + createQueueRequestMutex sync.RWMutex + createQueueRequestArgsForCall []struct { + arg1 *sqs.CreateQueueInput + } + createQueueRequestReturns struct { + result1 *request.Request + result2 *sqs.CreateQueueOutput + } + createQueueRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.CreateQueueOutput + } + DeleteMessageStub func(*sqs.DeleteMessageInput) (*sqs.DeleteMessageOutput, error) + deleteMessageMutex sync.RWMutex + deleteMessageArgsForCall []struct { + arg1 *sqs.DeleteMessageInput + } + deleteMessageReturns struct { + result1 *sqs.DeleteMessageOutput + result2 error + } + deleteMessageReturnsOnCall map[int]struct { + result1 *sqs.DeleteMessageOutput + result2 error + } + DeleteMessageWithContextStub func(aws.Context, *sqs.DeleteMessageInput, ...request.Option) (*sqs.DeleteMessageOutput, error) + deleteMessageWithContextMutex sync.RWMutex + deleteMessageWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.DeleteMessageInput + arg3 []request.Option + } + deleteMessageWithContextReturns struct { + result1 *sqs.DeleteMessageOutput + result2 error + } + deleteMessageWithContextReturnsOnCall map[int]struct { + result1 *sqs.DeleteMessageOutput + result2 error + } + DeleteMessageRequestStub func(*sqs.DeleteMessageInput) (*request.Request, *sqs.DeleteMessageOutput) + deleteMessageRequestMutex sync.RWMutex + deleteMessageRequestArgsForCall []struct { + arg1 *sqs.DeleteMessageInput + } + deleteMessageRequestReturns struct { + result1 *request.Request + result2 *sqs.DeleteMessageOutput + } + deleteMessageRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.DeleteMessageOutput + } + DeleteMessageBatchStub func(*sqs.DeleteMessageBatchInput) (*sqs.DeleteMessageBatchOutput, error) + deleteMessageBatchMutex sync.RWMutex + deleteMessageBatchArgsForCall []struct { + arg1 *sqs.DeleteMessageBatchInput + } + deleteMessageBatchReturns struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + } + deleteMessageBatchReturnsOnCall map[int]struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + } + DeleteMessageBatchWithContextStub func(aws.Context, *sqs.DeleteMessageBatchInput, ...request.Option) (*sqs.DeleteMessageBatchOutput, error) + deleteMessageBatchWithContextMutex sync.RWMutex + deleteMessageBatchWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.DeleteMessageBatchInput + arg3 []request.Option + } + deleteMessageBatchWithContextReturns struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + } + deleteMessageBatchWithContextReturnsOnCall map[int]struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + } + DeleteMessageBatchRequestStub func(*sqs.DeleteMessageBatchInput) (*request.Request, *sqs.DeleteMessageBatchOutput) + deleteMessageBatchRequestMutex sync.RWMutex + deleteMessageBatchRequestArgsForCall []struct { + arg1 *sqs.DeleteMessageBatchInput + } + deleteMessageBatchRequestReturns struct { + result1 *request.Request + result2 *sqs.DeleteMessageBatchOutput + } + deleteMessageBatchRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.DeleteMessageBatchOutput + } + DeleteQueueStub func(*sqs.DeleteQueueInput) (*sqs.DeleteQueueOutput, error) + deleteQueueMutex sync.RWMutex + deleteQueueArgsForCall []struct { + arg1 *sqs.DeleteQueueInput + } + deleteQueueReturns struct { + result1 *sqs.DeleteQueueOutput + result2 error + } + deleteQueueReturnsOnCall map[int]struct { + result1 *sqs.DeleteQueueOutput + result2 error + } + DeleteQueueWithContextStub func(aws.Context, *sqs.DeleteQueueInput, ...request.Option) (*sqs.DeleteQueueOutput, error) + deleteQueueWithContextMutex sync.RWMutex + deleteQueueWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.DeleteQueueInput + arg3 []request.Option + } + deleteQueueWithContextReturns struct { + result1 *sqs.DeleteQueueOutput + result2 error + } + deleteQueueWithContextReturnsOnCall map[int]struct { + result1 *sqs.DeleteQueueOutput + result2 error + } + DeleteQueueRequestStub func(*sqs.DeleteQueueInput) (*request.Request, *sqs.DeleteQueueOutput) + deleteQueueRequestMutex sync.RWMutex + deleteQueueRequestArgsForCall []struct { + arg1 *sqs.DeleteQueueInput + } + deleteQueueRequestReturns struct { + result1 *request.Request + result2 *sqs.DeleteQueueOutput + } + deleteQueueRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.DeleteQueueOutput + } + GetQueueAttributesStub func(*sqs.GetQueueAttributesInput) (*sqs.GetQueueAttributesOutput, error) + getQueueAttributesMutex sync.RWMutex + getQueueAttributesArgsForCall []struct { + arg1 *sqs.GetQueueAttributesInput + } + getQueueAttributesReturns struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + } + getQueueAttributesReturnsOnCall map[int]struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + } + GetQueueAttributesWithContextStub func(aws.Context, *sqs.GetQueueAttributesInput, ...request.Option) (*sqs.GetQueueAttributesOutput, error) + getQueueAttributesWithContextMutex sync.RWMutex + getQueueAttributesWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.GetQueueAttributesInput + arg3 []request.Option + } + getQueueAttributesWithContextReturns struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + } + getQueueAttributesWithContextReturnsOnCall map[int]struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + } + GetQueueAttributesRequestStub func(*sqs.GetQueueAttributesInput) (*request.Request, *sqs.GetQueueAttributesOutput) + getQueueAttributesRequestMutex sync.RWMutex + getQueueAttributesRequestArgsForCall []struct { + arg1 *sqs.GetQueueAttributesInput + } + getQueueAttributesRequestReturns struct { + result1 *request.Request + result2 *sqs.GetQueueAttributesOutput + } + getQueueAttributesRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.GetQueueAttributesOutput + } + GetQueueUrlStub func(*sqs.GetQueueUrlInput) (*sqs.GetQueueUrlOutput, error) + getQueueUrlMutex sync.RWMutex + getQueueUrlArgsForCall []struct { + arg1 *sqs.GetQueueUrlInput + } + getQueueUrlReturns struct { + result1 *sqs.GetQueueUrlOutput + result2 error + } + getQueueUrlReturnsOnCall map[int]struct { + result1 *sqs.GetQueueUrlOutput + result2 error + } + GetQueueUrlWithContextStub func(aws.Context, *sqs.GetQueueUrlInput, ...request.Option) (*sqs.GetQueueUrlOutput, error) + getQueueUrlWithContextMutex sync.RWMutex + getQueueUrlWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.GetQueueUrlInput + arg3 []request.Option + } + getQueueUrlWithContextReturns struct { + result1 *sqs.GetQueueUrlOutput + result2 error + } + getQueueUrlWithContextReturnsOnCall map[int]struct { + result1 *sqs.GetQueueUrlOutput + result2 error + } + GetQueueUrlRequestStub func(*sqs.GetQueueUrlInput) (*request.Request, *sqs.GetQueueUrlOutput) + getQueueUrlRequestMutex sync.RWMutex + getQueueUrlRequestArgsForCall []struct { + arg1 *sqs.GetQueueUrlInput + } + getQueueUrlRequestReturns struct { + result1 *request.Request + result2 *sqs.GetQueueUrlOutput + } + getQueueUrlRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.GetQueueUrlOutput + } + ListDeadLetterSourceQueuesStub func(*sqs.ListDeadLetterSourceQueuesInput) (*sqs.ListDeadLetterSourceQueuesOutput, error) + listDeadLetterSourceQueuesMutex sync.RWMutex + listDeadLetterSourceQueuesArgsForCall []struct { + arg1 *sqs.ListDeadLetterSourceQueuesInput + } + listDeadLetterSourceQueuesReturns struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + } + listDeadLetterSourceQueuesReturnsOnCall map[int]struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + } + ListDeadLetterSourceQueuesWithContextStub func(aws.Context, *sqs.ListDeadLetterSourceQueuesInput, ...request.Option) (*sqs.ListDeadLetterSourceQueuesOutput, error) + listDeadLetterSourceQueuesWithContextMutex sync.RWMutex + listDeadLetterSourceQueuesWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.ListDeadLetterSourceQueuesInput + arg3 []request.Option + } + listDeadLetterSourceQueuesWithContextReturns struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + } + listDeadLetterSourceQueuesWithContextReturnsOnCall map[int]struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + } + ListDeadLetterSourceQueuesRequestStub func(*sqs.ListDeadLetterSourceQueuesInput) (*request.Request, *sqs.ListDeadLetterSourceQueuesOutput) + listDeadLetterSourceQueuesRequestMutex sync.RWMutex + listDeadLetterSourceQueuesRequestArgsForCall []struct { + arg1 *sqs.ListDeadLetterSourceQueuesInput + } + listDeadLetterSourceQueuesRequestReturns struct { + result1 *request.Request + result2 *sqs.ListDeadLetterSourceQueuesOutput + } + listDeadLetterSourceQueuesRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.ListDeadLetterSourceQueuesOutput + } + ListQueueTagsStub func(*sqs.ListQueueTagsInput) (*sqs.ListQueueTagsOutput, error) + listQueueTagsMutex sync.RWMutex + listQueueTagsArgsForCall []struct { + arg1 *sqs.ListQueueTagsInput + } + listQueueTagsReturns struct { + result1 *sqs.ListQueueTagsOutput + result2 error + } + listQueueTagsReturnsOnCall map[int]struct { + result1 *sqs.ListQueueTagsOutput + result2 error + } + ListQueueTagsWithContextStub func(aws.Context, *sqs.ListQueueTagsInput, ...request.Option) (*sqs.ListQueueTagsOutput, error) + listQueueTagsWithContextMutex sync.RWMutex + listQueueTagsWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.ListQueueTagsInput + arg3 []request.Option + } + listQueueTagsWithContextReturns struct { + result1 *sqs.ListQueueTagsOutput + result2 error + } + listQueueTagsWithContextReturnsOnCall map[int]struct { + result1 *sqs.ListQueueTagsOutput + result2 error + } + ListQueueTagsRequestStub func(*sqs.ListQueueTagsInput) (*request.Request, *sqs.ListQueueTagsOutput) + listQueueTagsRequestMutex sync.RWMutex + listQueueTagsRequestArgsForCall []struct { + arg1 *sqs.ListQueueTagsInput + } + listQueueTagsRequestReturns struct { + result1 *request.Request + result2 *sqs.ListQueueTagsOutput + } + listQueueTagsRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.ListQueueTagsOutput + } + ListQueuesStub func(*sqs.ListQueuesInput) (*sqs.ListQueuesOutput, error) + listQueuesMutex sync.RWMutex + listQueuesArgsForCall []struct { + arg1 *sqs.ListQueuesInput + } + listQueuesReturns struct { + result1 *sqs.ListQueuesOutput + result2 error + } + listQueuesReturnsOnCall map[int]struct { + result1 *sqs.ListQueuesOutput + result2 error + } + ListQueuesWithContextStub func(aws.Context, *sqs.ListQueuesInput, ...request.Option) (*sqs.ListQueuesOutput, error) + listQueuesWithContextMutex sync.RWMutex + listQueuesWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.ListQueuesInput + arg3 []request.Option + } + listQueuesWithContextReturns struct { + result1 *sqs.ListQueuesOutput + result2 error + } + listQueuesWithContextReturnsOnCall map[int]struct { + result1 *sqs.ListQueuesOutput + result2 error + } + ListQueuesRequestStub func(*sqs.ListQueuesInput) (*request.Request, *sqs.ListQueuesOutput) + listQueuesRequestMutex sync.RWMutex + listQueuesRequestArgsForCall []struct { + arg1 *sqs.ListQueuesInput + } + listQueuesRequestReturns struct { + result1 *request.Request + result2 *sqs.ListQueuesOutput + } + listQueuesRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.ListQueuesOutput + } + PurgeQueueStub func(*sqs.PurgeQueueInput) (*sqs.PurgeQueueOutput, error) + purgeQueueMutex sync.RWMutex + purgeQueueArgsForCall []struct { + arg1 *sqs.PurgeQueueInput + } + purgeQueueReturns struct { + result1 *sqs.PurgeQueueOutput + result2 error + } + purgeQueueReturnsOnCall map[int]struct { + result1 *sqs.PurgeQueueOutput + result2 error + } + PurgeQueueWithContextStub func(aws.Context, *sqs.PurgeQueueInput, ...request.Option) (*sqs.PurgeQueueOutput, error) + purgeQueueWithContextMutex sync.RWMutex + purgeQueueWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.PurgeQueueInput + arg3 []request.Option + } + purgeQueueWithContextReturns struct { + result1 *sqs.PurgeQueueOutput + result2 error + } + purgeQueueWithContextReturnsOnCall map[int]struct { + result1 *sqs.PurgeQueueOutput + result2 error + } + PurgeQueueRequestStub func(*sqs.PurgeQueueInput) (*request.Request, *sqs.PurgeQueueOutput) + purgeQueueRequestMutex sync.RWMutex + purgeQueueRequestArgsForCall []struct { + arg1 *sqs.PurgeQueueInput + } + purgeQueueRequestReturns struct { + result1 *request.Request + result2 *sqs.PurgeQueueOutput + } + purgeQueueRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.PurgeQueueOutput + } + ReceiveMessageStub func(*sqs.ReceiveMessageInput) (*sqs.ReceiveMessageOutput, error) + receiveMessageMutex sync.RWMutex + receiveMessageArgsForCall []struct { + arg1 *sqs.ReceiveMessageInput + } + receiveMessageReturns struct { + result1 *sqs.ReceiveMessageOutput + result2 error + } + receiveMessageReturnsOnCall map[int]struct { + result1 *sqs.ReceiveMessageOutput + result2 error + } + ReceiveMessageWithContextStub func(aws.Context, *sqs.ReceiveMessageInput, ...request.Option) (*sqs.ReceiveMessageOutput, error) + receiveMessageWithContextMutex sync.RWMutex + receiveMessageWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.ReceiveMessageInput + arg3 []request.Option + } + receiveMessageWithContextReturns struct { + result1 *sqs.ReceiveMessageOutput + result2 error + } + receiveMessageWithContextReturnsOnCall map[int]struct { + result1 *sqs.ReceiveMessageOutput + result2 error + } + ReceiveMessageRequestStub func(*sqs.ReceiveMessageInput) (*request.Request, *sqs.ReceiveMessageOutput) + receiveMessageRequestMutex sync.RWMutex + receiveMessageRequestArgsForCall []struct { + arg1 *sqs.ReceiveMessageInput + } + receiveMessageRequestReturns struct { + result1 *request.Request + result2 *sqs.ReceiveMessageOutput + } + receiveMessageRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.ReceiveMessageOutput + } + RemovePermissionStub func(*sqs.RemovePermissionInput) (*sqs.RemovePermissionOutput, error) + removePermissionMutex sync.RWMutex + removePermissionArgsForCall []struct { + arg1 *sqs.RemovePermissionInput + } + removePermissionReturns struct { + result1 *sqs.RemovePermissionOutput + result2 error + } + removePermissionReturnsOnCall map[int]struct { + result1 *sqs.RemovePermissionOutput + result2 error + } + RemovePermissionWithContextStub func(aws.Context, *sqs.RemovePermissionInput, ...request.Option) (*sqs.RemovePermissionOutput, error) + removePermissionWithContextMutex sync.RWMutex + removePermissionWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.RemovePermissionInput + arg3 []request.Option + } + removePermissionWithContextReturns struct { + result1 *sqs.RemovePermissionOutput + result2 error + } + removePermissionWithContextReturnsOnCall map[int]struct { + result1 *sqs.RemovePermissionOutput + result2 error + } + RemovePermissionRequestStub func(*sqs.RemovePermissionInput) (*request.Request, *sqs.RemovePermissionOutput) + removePermissionRequestMutex sync.RWMutex + removePermissionRequestArgsForCall []struct { + arg1 *sqs.RemovePermissionInput + } + removePermissionRequestReturns struct { + result1 *request.Request + result2 *sqs.RemovePermissionOutput + } + removePermissionRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.RemovePermissionOutput + } + SendMessageStub func(*sqs.SendMessageInput) (*sqs.SendMessageOutput, error) + sendMessageMutex sync.RWMutex + sendMessageArgsForCall []struct { + arg1 *sqs.SendMessageInput + } + sendMessageReturns struct { + result1 *sqs.SendMessageOutput + result2 error + } + sendMessageReturnsOnCall map[int]struct { + result1 *sqs.SendMessageOutput + result2 error + } + SendMessageWithContextStub func(aws.Context, *sqs.SendMessageInput, ...request.Option) (*sqs.SendMessageOutput, error) + sendMessageWithContextMutex sync.RWMutex + sendMessageWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.SendMessageInput + arg3 []request.Option + } + sendMessageWithContextReturns struct { + result1 *sqs.SendMessageOutput + result2 error + } + sendMessageWithContextReturnsOnCall map[int]struct { + result1 *sqs.SendMessageOutput + result2 error + } + SendMessageRequestStub func(*sqs.SendMessageInput) (*request.Request, *sqs.SendMessageOutput) + sendMessageRequestMutex sync.RWMutex + sendMessageRequestArgsForCall []struct { + arg1 *sqs.SendMessageInput + } + sendMessageRequestReturns struct { + result1 *request.Request + result2 *sqs.SendMessageOutput + } + sendMessageRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.SendMessageOutput + } + SendMessageBatchStub func(*sqs.SendMessageBatchInput) (*sqs.SendMessageBatchOutput, error) + sendMessageBatchMutex sync.RWMutex + sendMessageBatchArgsForCall []struct { + arg1 *sqs.SendMessageBatchInput + } + sendMessageBatchReturns struct { + result1 *sqs.SendMessageBatchOutput + result2 error + } + sendMessageBatchReturnsOnCall map[int]struct { + result1 *sqs.SendMessageBatchOutput + result2 error + } + SendMessageBatchWithContextStub func(aws.Context, *sqs.SendMessageBatchInput, ...request.Option) (*sqs.SendMessageBatchOutput, error) + sendMessageBatchWithContextMutex sync.RWMutex + sendMessageBatchWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.SendMessageBatchInput + arg3 []request.Option + } + sendMessageBatchWithContextReturns struct { + result1 *sqs.SendMessageBatchOutput + result2 error + } + sendMessageBatchWithContextReturnsOnCall map[int]struct { + result1 *sqs.SendMessageBatchOutput + result2 error + } + SendMessageBatchRequestStub func(*sqs.SendMessageBatchInput) (*request.Request, *sqs.SendMessageBatchOutput) + sendMessageBatchRequestMutex sync.RWMutex + sendMessageBatchRequestArgsForCall []struct { + arg1 *sqs.SendMessageBatchInput + } + sendMessageBatchRequestReturns struct { + result1 *request.Request + result2 *sqs.SendMessageBatchOutput + } + sendMessageBatchRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.SendMessageBatchOutput + } + SetQueueAttributesStub func(*sqs.SetQueueAttributesInput) (*sqs.SetQueueAttributesOutput, error) + setQueueAttributesMutex sync.RWMutex + setQueueAttributesArgsForCall []struct { + arg1 *sqs.SetQueueAttributesInput + } + setQueueAttributesReturns struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + } + setQueueAttributesReturnsOnCall map[int]struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + } + SetQueueAttributesWithContextStub func(aws.Context, *sqs.SetQueueAttributesInput, ...request.Option) (*sqs.SetQueueAttributesOutput, error) + setQueueAttributesWithContextMutex sync.RWMutex + setQueueAttributesWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.SetQueueAttributesInput + arg3 []request.Option + } + setQueueAttributesWithContextReturns struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + } + setQueueAttributesWithContextReturnsOnCall map[int]struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + } + SetQueueAttributesRequestStub func(*sqs.SetQueueAttributesInput) (*request.Request, *sqs.SetQueueAttributesOutput) + setQueueAttributesRequestMutex sync.RWMutex + setQueueAttributesRequestArgsForCall []struct { + arg1 *sqs.SetQueueAttributesInput + } + setQueueAttributesRequestReturns struct { + result1 *request.Request + result2 *sqs.SetQueueAttributesOutput + } + setQueueAttributesRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.SetQueueAttributesOutput + } + TagQueueStub func(*sqs.TagQueueInput) (*sqs.TagQueueOutput, error) + tagQueueMutex sync.RWMutex + tagQueueArgsForCall []struct { + arg1 *sqs.TagQueueInput + } + tagQueueReturns struct { + result1 *sqs.TagQueueOutput + result2 error + } + tagQueueReturnsOnCall map[int]struct { + result1 *sqs.TagQueueOutput + result2 error + } + TagQueueWithContextStub func(aws.Context, *sqs.TagQueueInput, ...request.Option) (*sqs.TagQueueOutput, error) + tagQueueWithContextMutex sync.RWMutex + tagQueueWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.TagQueueInput + arg3 []request.Option + } + tagQueueWithContextReturns struct { + result1 *sqs.TagQueueOutput + result2 error + } + tagQueueWithContextReturnsOnCall map[int]struct { + result1 *sqs.TagQueueOutput + result2 error + } + TagQueueRequestStub func(*sqs.TagQueueInput) (*request.Request, *sqs.TagQueueOutput) + tagQueueRequestMutex sync.RWMutex + tagQueueRequestArgsForCall []struct { + arg1 *sqs.TagQueueInput + } + tagQueueRequestReturns struct { + result1 *request.Request + result2 *sqs.TagQueueOutput + } + tagQueueRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.TagQueueOutput + } + UntagQueueStub func(*sqs.UntagQueueInput) (*sqs.UntagQueueOutput, error) + untagQueueMutex sync.RWMutex + untagQueueArgsForCall []struct { + arg1 *sqs.UntagQueueInput + } + untagQueueReturns struct { + result1 *sqs.UntagQueueOutput + result2 error + } + untagQueueReturnsOnCall map[int]struct { + result1 *sqs.UntagQueueOutput + result2 error + } + UntagQueueWithContextStub func(aws.Context, *sqs.UntagQueueInput, ...request.Option) (*sqs.UntagQueueOutput, error) + untagQueueWithContextMutex sync.RWMutex + untagQueueWithContextArgsForCall []struct { + arg1 aws.Context + arg2 *sqs.UntagQueueInput + arg3 []request.Option + } + untagQueueWithContextReturns struct { + result1 *sqs.UntagQueueOutput + result2 error + } + untagQueueWithContextReturnsOnCall map[int]struct { + result1 *sqs.UntagQueueOutput + result2 error + } + UntagQueueRequestStub func(*sqs.UntagQueueInput) (*request.Request, *sqs.UntagQueueOutput) + untagQueueRequestMutex sync.RWMutex + untagQueueRequestArgsForCall []struct { + arg1 *sqs.UntagQueueInput + } + untagQueueRequestReturns struct { + result1 *request.Request + result2 *sqs.UntagQueueOutput + } + untagQueueRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *sqs.UntagQueueOutput + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeSQSAPI) AddPermission(arg1 *sqs.AddPermissionInput) (*sqs.AddPermissionOutput, error) { + fake.addPermissionMutex.Lock() + ret, specificReturn := fake.addPermissionReturnsOnCall[len(fake.addPermissionArgsForCall)] + fake.addPermissionArgsForCall = append(fake.addPermissionArgsForCall, struct { + arg1 *sqs.AddPermissionInput + }{arg1}) + fake.recordInvocation("AddPermission", []interface{}{arg1}) + fake.addPermissionMutex.Unlock() + if fake.AddPermissionStub != nil { + return fake.AddPermissionStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.addPermissionReturns.result1, fake.addPermissionReturns.result2 +} + +func (fake *FakeSQSAPI) AddPermissionCallCount() int { + fake.addPermissionMutex.RLock() + defer fake.addPermissionMutex.RUnlock() + return len(fake.addPermissionArgsForCall) +} + +func (fake *FakeSQSAPI) AddPermissionArgsForCall(i int) *sqs.AddPermissionInput { + fake.addPermissionMutex.RLock() + defer fake.addPermissionMutex.RUnlock() + return fake.addPermissionArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) AddPermissionReturns(result1 *sqs.AddPermissionOutput, result2 error) { + fake.AddPermissionStub = nil + fake.addPermissionReturns = struct { + result1 *sqs.AddPermissionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) AddPermissionReturnsOnCall(i int, result1 *sqs.AddPermissionOutput, result2 error) { + fake.AddPermissionStub = nil + if fake.addPermissionReturnsOnCall == nil { + fake.addPermissionReturnsOnCall = make(map[int]struct { + result1 *sqs.AddPermissionOutput + result2 error + }) + } + fake.addPermissionReturnsOnCall[i] = struct { + result1 *sqs.AddPermissionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) AddPermissionWithContext(arg1 aws.Context, arg2 *sqs.AddPermissionInput, arg3 ...request.Option) (*sqs.AddPermissionOutput, error) { + fake.addPermissionWithContextMutex.Lock() + ret, specificReturn := fake.addPermissionWithContextReturnsOnCall[len(fake.addPermissionWithContextArgsForCall)] + fake.addPermissionWithContextArgsForCall = append(fake.addPermissionWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.AddPermissionInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("AddPermissionWithContext", []interface{}{arg1, arg2, arg3}) + fake.addPermissionWithContextMutex.Unlock() + if fake.AddPermissionWithContextStub != nil { + return fake.AddPermissionWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.addPermissionWithContextReturns.result1, fake.addPermissionWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) AddPermissionWithContextCallCount() int { + fake.addPermissionWithContextMutex.RLock() + defer fake.addPermissionWithContextMutex.RUnlock() + return len(fake.addPermissionWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) AddPermissionWithContextArgsForCall(i int) (aws.Context, *sqs.AddPermissionInput, []request.Option) { + fake.addPermissionWithContextMutex.RLock() + defer fake.addPermissionWithContextMutex.RUnlock() + return fake.addPermissionWithContextArgsForCall[i].arg1, fake.addPermissionWithContextArgsForCall[i].arg2, fake.addPermissionWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) AddPermissionWithContextReturns(result1 *sqs.AddPermissionOutput, result2 error) { + fake.AddPermissionWithContextStub = nil + fake.addPermissionWithContextReturns = struct { + result1 *sqs.AddPermissionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) AddPermissionWithContextReturnsOnCall(i int, result1 *sqs.AddPermissionOutput, result2 error) { + fake.AddPermissionWithContextStub = nil + if fake.addPermissionWithContextReturnsOnCall == nil { + fake.addPermissionWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.AddPermissionOutput + result2 error + }) + } + fake.addPermissionWithContextReturnsOnCall[i] = struct { + result1 *sqs.AddPermissionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) AddPermissionRequest(arg1 *sqs.AddPermissionInput) (*request.Request, *sqs.AddPermissionOutput) { + fake.addPermissionRequestMutex.Lock() + ret, specificReturn := fake.addPermissionRequestReturnsOnCall[len(fake.addPermissionRequestArgsForCall)] + fake.addPermissionRequestArgsForCall = append(fake.addPermissionRequestArgsForCall, struct { + arg1 *sqs.AddPermissionInput + }{arg1}) + fake.recordInvocation("AddPermissionRequest", []interface{}{arg1}) + fake.addPermissionRequestMutex.Unlock() + if fake.AddPermissionRequestStub != nil { + return fake.AddPermissionRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.addPermissionRequestReturns.result1, fake.addPermissionRequestReturns.result2 +} + +func (fake *FakeSQSAPI) AddPermissionRequestCallCount() int { + fake.addPermissionRequestMutex.RLock() + defer fake.addPermissionRequestMutex.RUnlock() + return len(fake.addPermissionRequestArgsForCall) +} + +func (fake *FakeSQSAPI) AddPermissionRequestArgsForCall(i int) *sqs.AddPermissionInput { + fake.addPermissionRequestMutex.RLock() + defer fake.addPermissionRequestMutex.RUnlock() + return fake.addPermissionRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) AddPermissionRequestReturns(result1 *request.Request, result2 *sqs.AddPermissionOutput) { + fake.AddPermissionRequestStub = nil + fake.addPermissionRequestReturns = struct { + result1 *request.Request + result2 *sqs.AddPermissionOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) AddPermissionRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.AddPermissionOutput) { + fake.AddPermissionRequestStub = nil + if fake.addPermissionRequestReturnsOnCall == nil { + fake.addPermissionRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.AddPermissionOutput + }) + } + fake.addPermissionRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.AddPermissionOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibility(arg1 *sqs.ChangeMessageVisibilityInput) (*sqs.ChangeMessageVisibilityOutput, error) { + fake.changeMessageVisibilityMutex.Lock() + ret, specificReturn := fake.changeMessageVisibilityReturnsOnCall[len(fake.changeMessageVisibilityArgsForCall)] + fake.changeMessageVisibilityArgsForCall = append(fake.changeMessageVisibilityArgsForCall, struct { + arg1 *sqs.ChangeMessageVisibilityInput + }{arg1}) + fake.recordInvocation("ChangeMessageVisibility", []interface{}{arg1}) + fake.changeMessageVisibilityMutex.Unlock() + if fake.ChangeMessageVisibilityStub != nil { + return fake.ChangeMessageVisibilityStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.changeMessageVisibilityReturns.result1, fake.changeMessageVisibilityReturns.result2 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityCallCount() int { + fake.changeMessageVisibilityMutex.RLock() + defer fake.changeMessageVisibilityMutex.RUnlock() + return len(fake.changeMessageVisibilityArgsForCall) +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityArgsForCall(i int) *sqs.ChangeMessageVisibilityInput { + fake.changeMessageVisibilityMutex.RLock() + defer fake.changeMessageVisibilityMutex.RUnlock() + return fake.changeMessageVisibilityArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityReturns(result1 *sqs.ChangeMessageVisibilityOutput, result2 error) { + fake.ChangeMessageVisibilityStub = nil + fake.changeMessageVisibilityReturns = struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityReturnsOnCall(i int, result1 *sqs.ChangeMessageVisibilityOutput, result2 error) { + fake.ChangeMessageVisibilityStub = nil + if fake.changeMessageVisibilityReturnsOnCall == nil { + fake.changeMessageVisibilityReturnsOnCall = make(map[int]struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + }) + } + fake.changeMessageVisibilityReturnsOnCall[i] = struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityWithContext(arg1 aws.Context, arg2 *sqs.ChangeMessageVisibilityInput, arg3 ...request.Option) (*sqs.ChangeMessageVisibilityOutput, error) { + fake.changeMessageVisibilityWithContextMutex.Lock() + ret, specificReturn := fake.changeMessageVisibilityWithContextReturnsOnCall[len(fake.changeMessageVisibilityWithContextArgsForCall)] + fake.changeMessageVisibilityWithContextArgsForCall = append(fake.changeMessageVisibilityWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.ChangeMessageVisibilityInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("ChangeMessageVisibilityWithContext", []interface{}{arg1, arg2, arg3}) + fake.changeMessageVisibilityWithContextMutex.Unlock() + if fake.ChangeMessageVisibilityWithContextStub != nil { + return fake.ChangeMessageVisibilityWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.changeMessageVisibilityWithContextReturns.result1, fake.changeMessageVisibilityWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityWithContextCallCount() int { + fake.changeMessageVisibilityWithContextMutex.RLock() + defer fake.changeMessageVisibilityWithContextMutex.RUnlock() + return len(fake.changeMessageVisibilityWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityWithContextArgsForCall(i int) (aws.Context, *sqs.ChangeMessageVisibilityInput, []request.Option) { + fake.changeMessageVisibilityWithContextMutex.RLock() + defer fake.changeMessageVisibilityWithContextMutex.RUnlock() + return fake.changeMessageVisibilityWithContextArgsForCall[i].arg1, fake.changeMessageVisibilityWithContextArgsForCall[i].arg2, fake.changeMessageVisibilityWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityWithContextReturns(result1 *sqs.ChangeMessageVisibilityOutput, result2 error) { + fake.ChangeMessageVisibilityWithContextStub = nil + fake.changeMessageVisibilityWithContextReturns = struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityWithContextReturnsOnCall(i int, result1 *sqs.ChangeMessageVisibilityOutput, result2 error) { + fake.ChangeMessageVisibilityWithContextStub = nil + if fake.changeMessageVisibilityWithContextReturnsOnCall == nil { + fake.changeMessageVisibilityWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + }) + } + fake.changeMessageVisibilityWithContextReturnsOnCall[i] = struct { + result1 *sqs.ChangeMessageVisibilityOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityRequest(arg1 *sqs.ChangeMessageVisibilityInput) (*request.Request, *sqs.ChangeMessageVisibilityOutput) { + fake.changeMessageVisibilityRequestMutex.Lock() + ret, specificReturn := fake.changeMessageVisibilityRequestReturnsOnCall[len(fake.changeMessageVisibilityRequestArgsForCall)] + fake.changeMessageVisibilityRequestArgsForCall = append(fake.changeMessageVisibilityRequestArgsForCall, struct { + arg1 *sqs.ChangeMessageVisibilityInput + }{arg1}) + fake.recordInvocation("ChangeMessageVisibilityRequest", []interface{}{arg1}) + fake.changeMessageVisibilityRequestMutex.Unlock() + if fake.ChangeMessageVisibilityRequestStub != nil { + return fake.ChangeMessageVisibilityRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.changeMessageVisibilityRequestReturns.result1, fake.changeMessageVisibilityRequestReturns.result2 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityRequestCallCount() int { + fake.changeMessageVisibilityRequestMutex.RLock() + defer fake.changeMessageVisibilityRequestMutex.RUnlock() + return len(fake.changeMessageVisibilityRequestArgsForCall) +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityRequestArgsForCall(i int) *sqs.ChangeMessageVisibilityInput { + fake.changeMessageVisibilityRequestMutex.RLock() + defer fake.changeMessageVisibilityRequestMutex.RUnlock() + return fake.changeMessageVisibilityRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityRequestReturns(result1 *request.Request, result2 *sqs.ChangeMessageVisibilityOutput) { + fake.ChangeMessageVisibilityRequestStub = nil + fake.changeMessageVisibilityRequestReturns = struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.ChangeMessageVisibilityOutput) { + fake.ChangeMessageVisibilityRequestStub = nil + if fake.changeMessageVisibilityRequestReturnsOnCall == nil { + fake.changeMessageVisibilityRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityOutput + }) + } + fake.changeMessageVisibilityRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatch(arg1 *sqs.ChangeMessageVisibilityBatchInput) (*sqs.ChangeMessageVisibilityBatchOutput, error) { + fake.changeMessageVisibilityBatchMutex.Lock() + ret, specificReturn := fake.changeMessageVisibilityBatchReturnsOnCall[len(fake.changeMessageVisibilityBatchArgsForCall)] + fake.changeMessageVisibilityBatchArgsForCall = append(fake.changeMessageVisibilityBatchArgsForCall, struct { + arg1 *sqs.ChangeMessageVisibilityBatchInput + }{arg1}) + fake.recordInvocation("ChangeMessageVisibilityBatch", []interface{}{arg1}) + fake.changeMessageVisibilityBatchMutex.Unlock() + if fake.ChangeMessageVisibilityBatchStub != nil { + return fake.ChangeMessageVisibilityBatchStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.changeMessageVisibilityBatchReturns.result1, fake.changeMessageVisibilityBatchReturns.result2 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchCallCount() int { + fake.changeMessageVisibilityBatchMutex.RLock() + defer fake.changeMessageVisibilityBatchMutex.RUnlock() + return len(fake.changeMessageVisibilityBatchArgsForCall) +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchArgsForCall(i int) *sqs.ChangeMessageVisibilityBatchInput { + fake.changeMessageVisibilityBatchMutex.RLock() + defer fake.changeMessageVisibilityBatchMutex.RUnlock() + return fake.changeMessageVisibilityBatchArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchReturns(result1 *sqs.ChangeMessageVisibilityBatchOutput, result2 error) { + fake.ChangeMessageVisibilityBatchStub = nil + fake.changeMessageVisibilityBatchReturns = struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchReturnsOnCall(i int, result1 *sqs.ChangeMessageVisibilityBatchOutput, result2 error) { + fake.ChangeMessageVisibilityBatchStub = nil + if fake.changeMessageVisibilityBatchReturnsOnCall == nil { + fake.changeMessageVisibilityBatchReturnsOnCall = make(map[int]struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + }) + } + fake.changeMessageVisibilityBatchReturnsOnCall[i] = struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchWithContext(arg1 aws.Context, arg2 *sqs.ChangeMessageVisibilityBatchInput, arg3 ...request.Option) (*sqs.ChangeMessageVisibilityBatchOutput, error) { + fake.changeMessageVisibilityBatchWithContextMutex.Lock() + ret, specificReturn := fake.changeMessageVisibilityBatchWithContextReturnsOnCall[len(fake.changeMessageVisibilityBatchWithContextArgsForCall)] + fake.changeMessageVisibilityBatchWithContextArgsForCall = append(fake.changeMessageVisibilityBatchWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.ChangeMessageVisibilityBatchInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("ChangeMessageVisibilityBatchWithContext", []interface{}{arg1, arg2, arg3}) + fake.changeMessageVisibilityBatchWithContextMutex.Unlock() + if fake.ChangeMessageVisibilityBatchWithContextStub != nil { + return fake.ChangeMessageVisibilityBatchWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.changeMessageVisibilityBatchWithContextReturns.result1, fake.changeMessageVisibilityBatchWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchWithContextCallCount() int { + fake.changeMessageVisibilityBatchWithContextMutex.RLock() + defer fake.changeMessageVisibilityBatchWithContextMutex.RUnlock() + return len(fake.changeMessageVisibilityBatchWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchWithContextArgsForCall(i int) (aws.Context, *sqs.ChangeMessageVisibilityBatchInput, []request.Option) { + fake.changeMessageVisibilityBatchWithContextMutex.RLock() + defer fake.changeMessageVisibilityBatchWithContextMutex.RUnlock() + return fake.changeMessageVisibilityBatchWithContextArgsForCall[i].arg1, fake.changeMessageVisibilityBatchWithContextArgsForCall[i].arg2, fake.changeMessageVisibilityBatchWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchWithContextReturns(result1 *sqs.ChangeMessageVisibilityBatchOutput, result2 error) { + fake.ChangeMessageVisibilityBatchWithContextStub = nil + fake.changeMessageVisibilityBatchWithContextReturns = struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchWithContextReturnsOnCall(i int, result1 *sqs.ChangeMessageVisibilityBatchOutput, result2 error) { + fake.ChangeMessageVisibilityBatchWithContextStub = nil + if fake.changeMessageVisibilityBatchWithContextReturnsOnCall == nil { + fake.changeMessageVisibilityBatchWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + }) + } + fake.changeMessageVisibilityBatchWithContextReturnsOnCall[i] = struct { + result1 *sqs.ChangeMessageVisibilityBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchRequest(arg1 *sqs.ChangeMessageVisibilityBatchInput) (*request.Request, *sqs.ChangeMessageVisibilityBatchOutput) { + fake.changeMessageVisibilityBatchRequestMutex.Lock() + ret, specificReturn := fake.changeMessageVisibilityBatchRequestReturnsOnCall[len(fake.changeMessageVisibilityBatchRequestArgsForCall)] + fake.changeMessageVisibilityBatchRequestArgsForCall = append(fake.changeMessageVisibilityBatchRequestArgsForCall, struct { + arg1 *sqs.ChangeMessageVisibilityBatchInput + }{arg1}) + fake.recordInvocation("ChangeMessageVisibilityBatchRequest", []interface{}{arg1}) + fake.changeMessageVisibilityBatchRequestMutex.Unlock() + if fake.ChangeMessageVisibilityBatchRequestStub != nil { + return fake.ChangeMessageVisibilityBatchRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.changeMessageVisibilityBatchRequestReturns.result1, fake.changeMessageVisibilityBatchRequestReturns.result2 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchRequestCallCount() int { + fake.changeMessageVisibilityBatchRequestMutex.RLock() + defer fake.changeMessageVisibilityBatchRequestMutex.RUnlock() + return len(fake.changeMessageVisibilityBatchRequestArgsForCall) +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchRequestArgsForCall(i int) *sqs.ChangeMessageVisibilityBatchInput { + fake.changeMessageVisibilityBatchRequestMutex.RLock() + defer fake.changeMessageVisibilityBatchRequestMutex.RUnlock() + return fake.changeMessageVisibilityBatchRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchRequestReturns(result1 *request.Request, result2 *sqs.ChangeMessageVisibilityBatchOutput) { + fake.ChangeMessageVisibilityBatchRequestStub = nil + fake.changeMessageVisibilityBatchRequestReturns = struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityBatchOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ChangeMessageVisibilityBatchRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.ChangeMessageVisibilityBatchOutput) { + fake.ChangeMessageVisibilityBatchRequestStub = nil + if fake.changeMessageVisibilityBatchRequestReturnsOnCall == nil { + fake.changeMessageVisibilityBatchRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityBatchOutput + }) + } + fake.changeMessageVisibilityBatchRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.ChangeMessageVisibilityBatchOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) CreateQueue(arg1 *sqs.CreateQueueInput) (*sqs.CreateQueueOutput, error) { + fake.createQueueMutex.Lock() + ret, specificReturn := fake.createQueueReturnsOnCall[len(fake.createQueueArgsForCall)] + fake.createQueueArgsForCall = append(fake.createQueueArgsForCall, struct { + arg1 *sqs.CreateQueueInput + }{arg1}) + fake.recordInvocation("CreateQueue", []interface{}{arg1}) + fake.createQueueMutex.Unlock() + if fake.CreateQueueStub != nil { + return fake.CreateQueueStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createQueueReturns.result1, fake.createQueueReturns.result2 +} + +func (fake *FakeSQSAPI) CreateQueueCallCount() int { + fake.createQueueMutex.RLock() + defer fake.createQueueMutex.RUnlock() + return len(fake.createQueueArgsForCall) +} + +func (fake *FakeSQSAPI) CreateQueueArgsForCall(i int) *sqs.CreateQueueInput { + fake.createQueueMutex.RLock() + defer fake.createQueueMutex.RUnlock() + return fake.createQueueArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) CreateQueueReturns(result1 *sqs.CreateQueueOutput, result2 error) { + fake.CreateQueueStub = nil + fake.createQueueReturns = struct { + result1 *sqs.CreateQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) CreateQueueReturnsOnCall(i int, result1 *sqs.CreateQueueOutput, result2 error) { + fake.CreateQueueStub = nil + if fake.createQueueReturnsOnCall == nil { + fake.createQueueReturnsOnCall = make(map[int]struct { + result1 *sqs.CreateQueueOutput + result2 error + }) + } + fake.createQueueReturnsOnCall[i] = struct { + result1 *sqs.CreateQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) CreateQueueWithContext(arg1 aws.Context, arg2 *sqs.CreateQueueInput, arg3 ...request.Option) (*sqs.CreateQueueOutput, error) { + fake.createQueueWithContextMutex.Lock() + ret, specificReturn := fake.createQueueWithContextReturnsOnCall[len(fake.createQueueWithContextArgsForCall)] + fake.createQueueWithContextArgsForCall = append(fake.createQueueWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.CreateQueueInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("CreateQueueWithContext", []interface{}{arg1, arg2, arg3}) + fake.createQueueWithContextMutex.Unlock() + if fake.CreateQueueWithContextStub != nil { + return fake.CreateQueueWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createQueueWithContextReturns.result1, fake.createQueueWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) CreateQueueWithContextCallCount() int { + fake.createQueueWithContextMutex.RLock() + defer fake.createQueueWithContextMutex.RUnlock() + return len(fake.createQueueWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) CreateQueueWithContextArgsForCall(i int) (aws.Context, *sqs.CreateQueueInput, []request.Option) { + fake.createQueueWithContextMutex.RLock() + defer fake.createQueueWithContextMutex.RUnlock() + return fake.createQueueWithContextArgsForCall[i].arg1, fake.createQueueWithContextArgsForCall[i].arg2, fake.createQueueWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) CreateQueueWithContextReturns(result1 *sqs.CreateQueueOutput, result2 error) { + fake.CreateQueueWithContextStub = nil + fake.createQueueWithContextReturns = struct { + result1 *sqs.CreateQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) CreateQueueWithContextReturnsOnCall(i int, result1 *sqs.CreateQueueOutput, result2 error) { + fake.CreateQueueWithContextStub = nil + if fake.createQueueWithContextReturnsOnCall == nil { + fake.createQueueWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.CreateQueueOutput + result2 error + }) + } + fake.createQueueWithContextReturnsOnCall[i] = struct { + result1 *sqs.CreateQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) CreateQueueRequest(arg1 *sqs.CreateQueueInput) (*request.Request, *sqs.CreateQueueOutput) { + fake.createQueueRequestMutex.Lock() + ret, specificReturn := fake.createQueueRequestReturnsOnCall[len(fake.createQueueRequestArgsForCall)] + fake.createQueueRequestArgsForCall = append(fake.createQueueRequestArgsForCall, struct { + arg1 *sqs.CreateQueueInput + }{arg1}) + fake.recordInvocation("CreateQueueRequest", []interface{}{arg1}) + fake.createQueueRequestMutex.Unlock() + if fake.CreateQueueRequestStub != nil { + return fake.CreateQueueRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createQueueRequestReturns.result1, fake.createQueueRequestReturns.result2 +} + +func (fake *FakeSQSAPI) CreateQueueRequestCallCount() int { + fake.createQueueRequestMutex.RLock() + defer fake.createQueueRequestMutex.RUnlock() + return len(fake.createQueueRequestArgsForCall) +} + +func (fake *FakeSQSAPI) CreateQueueRequestArgsForCall(i int) *sqs.CreateQueueInput { + fake.createQueueRequestMutex.RLock() + defer fake.createQueueRequestMutex.RUnlock() + return fake.createQueueRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) CreateQueueRequestReturns(result1 *request.Request, result2 *sqs.CreateQueueOutput) { + fake.CreateQueueRequestStub = nil + fake.createQueueRequestReturns = struct { + result1 *request.Request + result2 *sqs.CreateQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) CreateQueueRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.CreateQueueOutput) { + fake.CreateQueueRequestStub = nil + if fake.createQueueRequestReturnsOnCall == nil { + fake.createQueueRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.CreateQueueOutput + }) + } + fake.createQueueRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.CreateQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessage(arg1 *sqs.DeleteMessageInput) (*sqs.DeleteMessageOutput, error) { + fake.deleteMessageMutex.Lock() + ret, specificReturn := fake.deleteMessageReturnsOnCall[len(fake.deleteMessageArgsForCall)] + fake.deleteMessageArgsForCall = append(fake.deleteMessageArgsForCall, struct { + arg1 *sqs.DeleteMessageInput + }{arg1}) + fake.recordInvocation("DeleteMessage", []interface{}{arg1}) + fake.deleteMessageMutex.Unlock() + if fake.DeleteMessageStub != nil { + return fake.DeleteMessageStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteMessageReturns.result1, fake.deleteMessageReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteMessageCallCount() int { + fake.deleteMessageMutex.RLock() + defer fake.deleteMessageMutex.RUnlock() + return len(fake.deleteMessageArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteMessageArgsForCall(i int) *sqs.DeleteMessageInput { + fake.deleteMessageMutex.RLock() + defer fake.deleteMessageMutex.RUnlock() + return fake.deleteMessageArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) DeleteMessageReturns(result1 *sqs.DeleteMessageOutput, result2 error) { + fake.DeleteMessageStub = nil + fake.deleteMessageReturns = struct { + result1 *sqs.DeleteMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageReturnsOnCall(i int, result1 *sqs.DeleteMessageOutput, result2 error) { + fake.DeleteMessageStub = nil + if fake.deleteMessageReturnsOnCall == nil { + fake.deleteMessageReturnsOnCall = make(map[int]struct { + result1 *sqs.DeleteMessageOutput + result2 error + }) + } + fake.deleteMessageReturnsOnCall[i] = struct { + result1 *sqs.DeleteMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageWithContext(arg1 aws.Context, arg2 *sqs.DeleteMessageInput, arg3 ...request.Option) (*sqs.DeleteMessageOutput, error) { + fake.deleteMessageWithContextMutex.Lock() + ret, specificReturn := fake.deleteMessageWithContextReturnsOnCall[len(fake.deleteMessageWithContextArgsForCall)] + fake.deleteMessageWithContextArgsForCall = append(fake.deleteMessageWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.DeleteMessageInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("DeleteMessageWithContext", []interface{}{arg1, arg2, arg3}) + fake.deleteMessageWithContextMutex.Unlock() + if fake.DeleteMessageWithContextStub != nil { + return fake.DeleteMessageWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteMessageWithContextReturns.result1, fake.deleteMessageWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteMessageWithContextCallCount() int { + fake.deleteMessageWithContextMutex.RLock() + defer fake.deleteMessageWithContextMutex.RUnlock() + return len(fake.deleteMessageWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteMessageWithContextArgsForCall(i int) (aws.Context, *sqs.DeleteMessageInput, []request.Option) { + fake.deleteMessageWithContextMutex.RLock() + defer fake.deleteMessageWithContextMutex.RUnlock() + return fake.deleteMessageWithContextArgsForCall[i].arg1, fake.deleteMessageWithContextArgsForCall[i].arg2, fake.deleteMessageWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) DeleteMessageWithContextReturns(result1 *sqs.DeleteMessageOutput, result2 error) { + fake.DeleteMessageWithContextStub = nil + fake.deleteMessageWithContextReturns = struct { + result1 *sqs.DeleteMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageWithContextReturnsOnCall(i int, result1 *sqs.DeleteMessageOutput, result2 error) { + fake.DeleteMessageWithContextStub = nil + if fake.deleteMessageWithContextReturnsOnCall == nil { + fake.deleteMessageWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.DeleteMessageOutput + result2 error + }) + } + fake.deleteMessageWithContextReturnsOnCall[i] = struct { + result1 *sqs.DeleteMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageRequest(arg1 *sqs.DeleteMessageInput) (*request.Request, *sqs.DeleteMessageOutput) { + fake.deleteMessageRequestMutex.Lock() + ret, specificReturn := fake.deleteMessageRequestReturnsOnCall[len(fake.deleteMessageRequestArgsForCall)] + fake.deleteMessageRequestArgsForCall = append(fake.deleteMessageRequestArgsForCall, struct { + arg1 *sqs.DeleteMessageInput + }{arg1}) + fake.recordInvocation("DeleteMessageRequest", []interface{}{arg1}) + fake.deleteMessageRequestMutex.Unlock() + if fake.DeleteMessageRequestStub != nil { + return fake.DeleteMessageRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteMessageRequestReturns.result1, fake.deleteMessageRequestReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteMessageRequestCallCount() int { + fake.deleteMessageRequestMutex.RLock() + defer fake.deleteMessageRequestMutex.RUnlock() + return len(fake.deleteMessageRequestArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteMessageRequestArgsForCall(i int) *sqs.DeleteMessageInput { + fake.deleteMessageRequestMutex.RLock() + defer fake.deleteMessageRequestMutex.RUnlock() + return fake.deleteMessageRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) DeleteMessageRequestReturns(result1 *request.Request, result2 *sqs.DeleteMessageOutput) { + fake.DeleteMessageRequestStub = nil + fake.deleteMessageRequestReturns = struct { + result1 *request.Request + result2 *sqs.DeleteMessageOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.DeleteMessageOutput) { + fake.DeleteMessageRequestStub = nil + if fake.deleteMessageRequestReturnsOnCall == nil { + fake.deleteMessageRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.DeleteMessageOutput + }) + } + fake.deleteMessageRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.DeleteMessageOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageBatch(arg1 *sqs.DeleteMessageBatchInput) (*sqs.DeleteMessageBatchOutput, error) { + fake.deleteMessageBatchMutex.Lock() + ret, specificReturn := fake.deleteMessageBatchReturnsOnCall[len(fake.deleteMessageBatchArgsForCall)] + fake.deleteMessageBatchArgsForCall = append(fake.deleteMessageBatchArgsForCall, struct { + arg1 *sqs.DeleteMessageBatchInput + }{arg1}) + fake.recordInvocation("DeleteMessageBatch", []interface{}{arg1}) + fake.deleteMessageBatchMutex.Unlock() + if fake.DeleteMessageBatchStub != nil { + return fake.DeleteMessageBatchStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteMessageBatchReturns.result1, fake.deleteMessageBatchReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteMessageBatchCallCount() int { + fake.deleteMessageBatchMutex.RLock() + defer fake.deleteMessageBatchMutex.RUnlock() + return len(fake.deleteMessageBatchArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteMessageBatchArgsForCall(i int) *sqs.DeleteMessageBatchInput { + fake.deleteMessageBatchMutex.RLock() + defer fake.deleteMessageBatchMutex.RUnlock() + return fake.deleteMessageBatchArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) DeleteMessageBatchReturns(result1 *sqs.DeleteMessageBatchOutput, result2 error) { + fake.DeleteMessageBatchStub = nil + fake.deleteMessageBatchReturns = struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageBatchReturnsOnCall(i int, result1 *sqs.DeleteMessageBatchOutput, result2 error) { + fake.DeleteMessageBatchStub = nil + if fake.deleteMessageBatchReturnsOnCall == nil { + fake.deleteMessageBatchReturnsOnCall = make(map[int]struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + }) + } + fake.deleteMessageBatchReturnsOnCall[i] = struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageBatchWithContext(arg1 aws.Context, arg2 *sqs.DeleteMessageBatchInput, arg3 ...request.Option) (*sqs.DeleteMessageBatchOutput, error) { + fake.deleteMessageBatchWithContextMutex.Lock() + ret, specificReturn := fake.deleteMessageBatchWithContextReturnsOnCall[len(fake.deleteMessageBatchWithContextArgsForCall)] + fake.deleteMessageBatchWithContextArgsForCall = append(fake.deleteMessageBatchWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.DeleteMessageBatchInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("DeleteMessageBatchWithContext", []interface{}{arg1, arg2, arg3}) + fake.deleteMessageBatchWithContextMutex.Unlock() + if fake.DeleteMessageBatchWithContextStub != nil { + return fake.DeleteMessageBatchWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteMessageBatchWithContextReturns.result1, fake.deleteMessageBatchWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteMessageBatchWithContextCallCount() int { + fake.deleteMessageBatchWithContextMutex.RLock() + defer fake.deleteMessageBatchWithContextMutex.RUnlock() + return len(fake.deleteMessageBatchWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteMessageBatchWithContextArgsForCall(i int) (aws.Context, *sqs.DeleteMessageBatchInput, []request.Option) { + fake.deleteMessageBatchWithContextMutex.RLock() + defer fake.deleteMessageBatchWithContextMutex.RUnlock() + return fake.deleteMessageBatchWithContextArgsForCall[i].arg1, fake.deleteMessageBatchWithContextArgsForCall[i].arg2, fake.deleteMessageBatchWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) DeleteMessageBatchWithContextReturns(result1 *sqs.DeleteMessageBatchOutput, result2 error) { + fake.DeleteMessageBatchWithContextStub = nil + fake.deleteMessageBatchWithContextReturns = struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageBatchWithContextReturnsOnCall(i int, result1 *sqs.DeleteMessageBatchOutput, result2 error) { + fake.DeleteMessageBatchWithContextStub = nil + if fake.deleteMessageBatchWithContextReturnsOnCall == nil { + fake.deleteMessageBatchWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + }) + } + fake.deleteMessageBatchWithContextReturnsOnCall[i] = struct { + result1 *sqs.DeleteMessageBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageBatchRequest(arg1 *sqs.DeleteMessageBatchInput) (*request.Request, *sqs.DeleteMessageBatchOutput) { + fake.deleteMessageBatchRequestMutex.Lock() + ret, specificReturn := fake.deleteMessageBatchRequestReturnsOnCall[len(fake.deleteMessageBatchRequestArgsForCall)] + fake.deleteMessageBatchRequestArgsForCall = append(fake.deleteMessageBatchRequestArgsForCall, struct { + arg1 *sqs.DeleteMessageBatchInput + }{arg1}) + fake.recordInvocation("DeleteMessageBatchRequest", []interface{}{arg1}) + fake.deleteMessageBatchRequestMutex.Unlock() + if fake.DeleteMessageBatchRequestStub != nil { + return fake.DeleteMessageBatchRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteMessageBatchRequestReturns.result1, fake.deleteMessageBatchRequestReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteMessageBatchRequestCallCount() int { + fake.deleteMessageBatchRequestMutex.RLock() + defer fake.deleteMessageBatchRequestMutex.RUnlock() + return len(fake.deleteMessageBatchRequestArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteMessageBatchRequestArgsForCall(i int) *sqs.DeleteMessageBatchInput { + fake.deleteMessageBatchRequestMutex.RLock() + defer fake.deleteMessageBatchRequestMutex.RUnlock() + return fake.deleteMessageBatchRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) DeleteMessageBatchRequestReturns(result1 *request.Request, result2 *sqs.DeleteMessageBatchOutput) { + fake.DeleteMessageBatchRequestStub = nil + fake.deleteMessageBatchRequestReturns = struct { + result1 *request.Request + result2 *sqs.DeleteMessageBatchOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteMessageBatchRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.DeleteMessageBatchOutput) { + fake.DeleteMessageBatchRequestStub = nil + if fake.deleteMessageBatchRequestReturnsOnCall == nil { + fake.deleteMessageBatchRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.DeleteMessageBatchOutput + }) + } + fake.deleteMessageBatchRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.DeleteMessageBatchOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteQueue(arg1 *sqs.DeleteQueueInput) (*sqs.DeleteQueueOutput, error) { + fake.deleteQueueMutex.Lock() + ret, specificReturn := fake.deleteQueueReturnsOnCall[len(fake.deleteQueueArgsForCall)] + fake.deleteQueueArgsForCall = append(fake.deleteQueueArgsForCall, struct { + arg1 *sqs.DeleteQueueInput + }{arg1}) + fake.recordInvocation("DeleteQueue", []interface{}{arg1}) + fake.deleteQueueMutex.Unlock() + if fake.DeleteQueueStub != nil { + return fake.DeleteQueueStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteQueueReturns.result1, fake.deleteQueueReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteQueueCallCount() int { + fake.deleteQueueMutex.RLock() + defer fake.deleteQueueMutex.RUnlock() + return len(fake.deleteQueueArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteQueueArgsForCall(i int) *sqs.DeleteQueueInput { + fake.deleteQueueMutex.RLock() + defer fake.deleteQueueMutex.RUnlock() + return fake.deleteQueueArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) DeleteQueueReturns(result1 *sqs.DeleteQueueOutput, result2 error) { + fake.DeleteQueueStub = nil + fake.deleteQueueReturns = struct { + result1 *sqs.DeleteQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteQueueReturnsOnCall(i int, result1 *sqs.DeleteQueueOutput, result2 error) { + fake.DeleteQueueStub = nil + if fake.deleteQueueReturnsOnCall == nil { + fake.deleteQueueReturnsOnCall = make(map[int]struct { + result1 *sqs.DeleteQueueOutput + result2 error + }) + } + fake.deleteQueueReturnsOnCall[i] = struct { + result1 *sqs.DeleteQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteQueueWithContext(arg1 aws.Context, arg2 *sqs.DeleteQueueInput, arg3 ...request.Option) (*sqs.DeleteQueueOutput, error) { + fake.deleteQueueWithContextMutex.Lock() + ret, specificReturn := fake.deleteQueueWithContextReturnsOnCall[len(fake.deleteQueueWithContextArgsForCall)] + fake.deleteQueueWithContextArgsForCall = append(fake.deleteQueueWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.DeleteQueueInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("DeleteQueueWithContext", []interface{}{arg1, arg2, arg3}) + fake.deleteQueueWithContextMutex.Unlock() + if fake.DeleteQueueWithContextStub != nil { + return fake.DeleteQueueWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteQueueWithContextReturns.result1, fake.deleteQueueWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteQueueWithContextCallCount() int { + fake.deleteQueueWithContextMutex.RLock() + defer fake.deleteQueueWithContextMutex.RUnlock() + return len(fake.deleteQueueWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteQueueWithContextArgsForCall(i int) (aws.Context, *sqs.DeleteQueueInput, []request.Option) { + fake.deleteQueueWithContextMutex.RLock() + defer fake.deleteQueueWithContextMutex.RUnlock() + return fake.deleteQueueWithContextArgsForCall[i].arg1, fake.deleteQueueWithContextArgsForCall[i].arg2, fake.deleteQueueWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) DeleteQueueWithContextReturns(result1 *sqs.DeleteQueueOutput, result2 error) { + fake.DeleteQueueWithContextStub = nil + fake.deleteQueueWithContextReturns = struct { + result1 *sqs.DeleteQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteQueueWithContextReturnsOnCall(i int, result1 *sqs.DeleteQueueOutput, result2 error) { + fake.DeleteQueueWithContextStub = nil + if fake.deleteQueueWithContextReturnsOnCall == nil { + fake.deleteQueueWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.DeleteQueueOutput + result2 error + }) + } + fake.deleteQueueWithContextReturnsOnCall[i] = struct { + result1 *sqs.DeleteQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteQueueRequest(arg1 *sqs.DeleteQueueInput) (*request.Request, *sqs.DeleteQueueOutput) { + fake.deleteQueueRequestMutex.Lock() + ret, specificReturn := fake.deleteQueueRequestReturnsOnCall[len(fake.deleteQueueRequestArgsForCall)] + fake.deleteQueueRequestArgsForCall = append(fake.deleteQueueRequestArgsForCall, struct { + arg1 *sqs.DeleteQueueInput + }{arg1}) + fake.recordInvocation("DeleteQueueRequest", []interface{}{arg1}) + fake.deleteQueueRequestMutex.Unlock() + if fake.DeleteQueueRequestStub != nil { + return fake.DeleteQueueRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.deleteQueueRequestReturns.result1, fake.deleteQueueRequestReturns.result2 +} + +func (fake *FakeSQSAPI) DeleteQueueRequestCallCount() int { + fake.deleteQueueRequestMutex.RLock() + defer fake.deleteQueueRequestMutex.RUnlock() + return len(fake.deleteQueueRequestArgsForCall) +} + +func (fake *FakeSQSAPI) DeleteQueueRequestArgsForCall(i int) *sqs.DeleteQueueInput { + fake.deleteQueueRequestMutex.RLock() + defer fake.deleteQueueRequestMutex.RUnlock() + return fake.deleteQueueRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) DeleteQueueRequestReturns(result1 *request.Request, result2 *sqs.DeleteQueueOutput) { + fake.DeleteQueueRequestStub = nil + fake.deleteQueueRequestReturns = struct { + result1 *request.Request + result2 *sqs.DeleteQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) DeleteQueueRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.DeleteQueueOutput) { + fake.DeleteQueueRequestStub = nil + if fake.deleteQueueRequestReturnsOnCall == nil { + fake.deleteQueueRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.DeleteQueueOutput + }) + } + fake.deleteQueueRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.DeleteQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueAttributes(arg1 *sqs.GetQueueAttributesInput) (*sqs.GetQueueAttributesOutput, error) { + fake.getQueueAttributesMutex.Lock() + ret, specificReturn := fake.getQueueAttributesReturnsOnCall[len(fake.getQueueAttributesArgsForCall)] + fake.getQueueAttributesArgsForCall = append(fake.getQueueAttributesArgsForCall, struct { + arg1 *sqs.GetQueueAttributesInput + }{arg1}) + fake.recordInvocation("GetQueueAttributes", []interface{}{arg1}) + fake.getQueueAttributesMutex.Unlock() + if fake.GetQueueAttributesStub != nil { + return fake.GetQueueAttributesStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getQueueAttributesReturns.result1, fake.getQueueAttributesReturns.result2 +} + +func (fake *FakeSQSAPI) GetQueueAttributesCallCount() int { + fake.getQueueAttributesMutex.RLock() + defer fake.getQueueAttributesMutex.RUnlock() + return len(fake.getQueueAttributesArgsForCall) +} + +func (fake *FakeSQSAPI) GetQueueAttributesArgsForCall(i int) *sqs.GetQueueAttributesInput { + fake.getQueueAttributesMutex.RLock() + defer fake.getQueueAttributesMutex.RUnlock() + return fake.getQueueAttributesArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) GetQueueAttributesReturns(result1 *sqs.GetQueueAttributesOutput, result2 error) { + fake.GetQueueAttributesStub = nil + fake.getQueueAttributesReturns = struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueAttributesReturnsOnCall(i int, result1 *sqs.GetQueueAttributesOutput, result2 error) { + fake.GetQueueAttributesStub = nil + if fake.getQueueAttributesReturnsOnCall == nil { + fake.getQueueAttributesReturnsOnCall = make(map[int]struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + }) + } + fake.getQueueAttributesReturnsOnCall[i] = struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueAttributesWithContext(arg1 aws.Context, arg2 *sqs.GetQueueAttributesInput, arg3 ...request.Option) (*sqs.GetQueueAttributesOutput, error) { + fake.getQueueAttributesWithContextMutex.Lock() + ret, specificReturn := fake.getQueueAttributesWithContextReturnsOnCall[len(fake.getQueueAttributesWithContextArgsForCall)] + fake.getQueueAttributesWithContextArgsForCall = append(fake.getQueueAttributesWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.GetQueueAttributesInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("GetQueueAttributesWithContext", []interface{}{arg1, arg2, arg3}) + fake.getQueueAttributesWithContextMutex.Unlock() + if fake.GetQueueAttributesWithContextStub != nil { + return fake.GetQueueAttributesWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getQueueAttributesWithContextReturns.result1, fake.getQueueAttributesWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) GetQueueAttributesWithContextCallCount() int { + fake.getQueueAttributesWithContextMutex.RLock() + defer fake.getQueueAttributesWithContextMutex.RUnlock() + return len(fake.getQueueAttributesWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) GetQueueAttributesWithContextArgsForCall(i int) (aws.Context, *sqs.GetQueueAttributesInput, []request.Option) { + fake.getQueueAttributesWithContextMutex.RLock() + defer fake.getQueueAttributesWithContextMutex.RUnlock() + return fake.getQueueAttributesWithContextArgsForCall[i].arg1, fake.getQueueAttributesWithContextArgsForCall[i].arg2, fake.getQueueAttributesWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) GetQueueAttributesWithContextReturns(result1 *sqs.GetQueueAttributesOutput, result2 error) { + fake.GetQueueAttributesWithContextStub = nil + fake.getQueueAttributesWithContextReturns = struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueAttributesWithContextReturnsOnCall(i int, result1 *sqs.GetQueueAttributesOutput, result2 error) { + fake.GetQueueAttributesWithContextStub = nil + if fake.getQueueAttributesWithContextReturnsOnCall == nil { + fake.getQueueAttributesWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + }) + } + fake.getQueueAttributesWithContextReturnsOnCall[i] = struct { + result1 *sqs.GetQueueAttributesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueAttributesRequest(arg1 *sqs.GetQueueAttributesInput) (*request.Request, *sqs.GetQueueAttributesOutput) { + fake.getQueueAttributesRequestMutex.Lock() + ret, specificReturn := fake.getQueueAttributesRequestReturnsOnCall[len(fake.getQueueAttributesRequestArgsForCall)] + fake.getQueueAttributesRequestArgsForCall = append(fake.getQueueAttributesRequestArgsForCall, struct { + arg1 *sqs.GetQueueAttributesInput + }{arg1}) + fake.recordInvocation("GetQueueAttributesRequest", []interface{}{arg1}) + fake.getQueueAttributesRequestMutex.Unlock() + if fake.GetQueueAttributesRequestStub != nil { + return fake.GetQueueAttributesRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getQueueAttributesRequestReturns.result1, fake.getQueueAttributesRequestReturns.result2 +} + +func (fake *FakeSQSAPI) GetQueueAttributesRequestCallCount() int { + fake.getQueueAttributesRequestMutex.RLock() + defer fake.getQueueAttributesRequestMutex.RUnlock() + return len(fake.getQueueAttributesRequestArgsForCall) +} + +func (fake *FakeSQSAPI) GetQueueAttributesRequestArgsForCall(i int) *sqs.GetQueueAttributesInput { + fake.getQueueAttributesRequestMutex.RLock() + defer fake.getQueueAttributesRequestMutex.RUnlock() + return fake.getQueueAttributesRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) GetQueueAttributesRequestReturns(result1 *request.Request, result2 *sqs.GetQueueAttributesOutput) { + fake.GetQueueAttributesRequestStub = nil + fake.getQueueAttributesRequestReturns = struct { + result1 *request.Request + result2 *sqs.GetQueueAttributesOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueAttributesRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.GetQueueAttributesOutput) { + fake.GetQueueAttributesRequestStub = nil + if fake.getQueueAttributesRequestReturnsOnCall == nil { + fake.getQueueAttributesRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.GetQueueAttributesOutput + }) + } + fake.getQueueAttributesRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.GetQueueAttributesOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueUrl(arg1 *sqs.GetQueueUrlInput) (*sqs.GetQueueUrlOutput, error) { + fake.getQueueUrlMutex.Lock() + ret, specificReturn := fake.getQueueUrlReturnsOnCall[len(fake.getQueueUrlArgsForCall)] + fake.getQueueUrlArgsForCall = append(fake.getQueueUrlArgsForCall, struct { + arg1 *sqs.GetQueueUrlInput + }{arg1}) + fake.recordInvocation("GetQueueUrl", []interface{}{arg1}) + fake.getQueueUrlMutex.Unlock() + if fake.GetQueueUrlStub != nil { + return fake.GetQueueUrlStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getQueueUrlReturns.result1, fake.getQueueUrlReturns.result2 +} + +func (fake *FakeSQSAPI) GetQueueUrlCallCount() int { + fake.getQueueUrlMutex.RLock() + defer fake.getQueueUrlMutex.RUnlock() + return len(fake.getQueueUrlArgsForCall) +} + +func (fake *FakeSQSAPI) GetQueueUrlArgsForCall(i int) *sqs.GetQueueUrlInput { + fake.getQueueUrlMutex.RLock() + defer fake.getQueueUrlMutex.RUnlock() + return fake.getQueueUrlArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) GetQueueUrlReturns(result1 *sqs.GetQueueUrlOutput, result2 error) { + fake.GetQueueUrlStub = nil + fake.getQueueUrlReturns = struct { + result1 *sqs.GetQueueUrlOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueUrlReturnsOnCall(i int, result1 *sqs.GetQueueUrlOutput, result2 error) { + fake.GetQueueUrlStub = nil + if fake.getQueueUrlReturnsOnCall == nil { + fake.getQueueUrlReturnsOnCall = make(map[int]struct { + result1 *sqs.GetQueueUrlOutput + result2 error + }) + } + fake.getQueueUrlReturnsOnCall[i] = struct { + result1 *sqs.GetQueueUrlOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueUrlWithContext(arg1 aws.Context, arg2 *sqs.GetQueueUrlInput, arg3 ...request.Option) (*sqs.GetQueueUrlOutput, error) { + fake.getQueueUrlWithContextMutex.Lock() + ret, specificReturn := fake.getQueueUrlWithContextReturnsOnCall[len(fake.getQueueUrlWithContextArgsForCall)] + fake.getQueueUrlWithContextArgsForCall = append(fake.getQueueUrlWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.GetQueueUrlInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("GetQueueUrlWithContext", []interface{}{arg1, arg2, arg3}) + fake.getQueueUrlWithContextMutex.Unlock() + if fake.GetQueueUrlWithContextStub != nil { + return fake.GetQueueUrlWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getQueueUrlWithContextReturns.result1, fake.getQueueUrlWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) GetQueueUrlWithContextCallCount() int { + fake.getQueueUrlWithContextMutex.RLock() + defer fake.getQueueUrlWithContextMutex.RUnlock() + return len(fake.getQueueUrlWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) GetQueueUrlWithContextArgsForCall(i int) (aws.Context, *sqs.GetQueueUrlInput, []request.Option) { + fake.getQueueUrlWithContextMutex.RLock() + defer fake.getQueueUrlWithContextMutex.RUnlock() + return fake.getQueueUrlWithContextArgsForCall[i].arg1, fake.getQueueUrlWithContextArgsForCall[i].arg2, fake.getQueueUrlWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) GetQueueUrlWithContextReturns(result1 *sqs.GetQueueUrlOutput, result2 error) { + fake.GetQueueUrlWithContextStub = nil + fake.getQueueUrlWithContextReturns = struct { + result1 *sqs.GetQueueUrlOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueUrlWithContextReturnsOnCall(i int, result1 *sqs.GetQueueUrlOutput, result2 error) { + fake.GetQueueUrlWithContextStub = nil + if fake.getQueueUrlWithContextReturnsOnCall == nil { + fake.getQueueUrlWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.GetQueueUrlOutput + result2 error + }) + } + fake.getQueueUrlWithContextReturnsOnCall[i] = struct { + result1 *sqs.GetQueueUrlOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueUrlRequest(arg1 *sqs.GetQueueUrlInput) (*request.Request, *sqs.GetQueueUrlOutput) { + fake.getQueueUrlRequestMutex.Lock() + ret, specificReturn := fake.getQueueUrlRequestReturnsOnCall[len(fake.getQueueUrlRequestArgsForCall)] + fake.getQueueUrlRequestArgsForCall = append(fake.getQueueUrlRequestArgsForCall, struct { + arg1 *sqs.GetQueueUrlInput + }{arg1}) + fake.recordInvocation("GetQueueUrlRequest", []interface{}{arg1}) + fake.getQueueUrlRequestMutex.Unlock() + if fake.GetQueueUrlRequestStub != nil { + return fake.GetQueueUrlRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getQueueUrlRequestReturns.result1, fake.getQueueUrlRequestReturns.result2 +} + +func (fake *FakeSQSAPI) GetQueueUrlRequestCallCount() int { + fake.getQueueUrlRequestMutex.RLock() + defer fake.getQueueUrlRequestMutex.RUnlock() + return len(fake.getQueueUrlRequestArgsForCall) +} + +func (fake *FakeSQSAPI) GetQueueUrlRequestArgsForCall(i int) *sqs.GetQueueUrlInput { + fake.getQueueUrlRequestMutex.RLock() + defer fake.getQueueUrlRequestMutex.RUnlock() + return fake.getQueueUrlRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) GetQueueUrlRequestReturns(result1 *request.Request, result2 *sqs.GetQueueUrlOutput) { + fake.GetQueueUrlRequestStub = nil + fake.getQueueUrlRequestReturns = struct { + result1 *request.Request + result2 *sqs.GetQueueUrlOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) GetQueueUrlRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.GetQueueUrlOutput) { + fake.GetQueueUrlRequestStub = nil + if fake.getQueueUrlRequestReturnsOnCall == nil { + fake.getQueueUrlRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.GetQueueUrlOutput + }) + } + fake.getQueueUrlRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.GetQueueUrlOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueues(arg1 *sqs.ListDeadLetterSourceQueuesInput) (*sqs.ListDeadLetterSourceQueuesOutput, error) { + fake.listDeadLetterSourceQueuesMutex.Lock() + ret, specificReturn := fake.listDeadLetterSourceQueuesReturnsOnCall[len(fake.listDeadLetterSourceQueuesArgsForCall)] + fake.listDeadLetterSourceQueuesArgsForCall = append(fake.listDeadLetterSourceQueuesArgsForCall, struct { + arg1 *sqs.ListDeadLetterSourceQueuesInput + }{arg1}) + fake.recordInvocation("ListDeadLetterSourceQueues", []interface{}{arg1}) + fake.listDeadLetterSourceQueuesMutex.Unlock() + if fake.ListDeadLetterSourceQueuesStub != nil { + return fake.ListDeadLetterSourceQueuesStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listDeadLetterSourceQueuesReturns.result1, fake.listDeadLetterSourceQueuesReturns.result2 +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesCallCount() int { + fake.listDeadLetterSourceQueuesMutex.RLock() + defer fake.listDeadLetterSourceQueuesMutex.RUnlock() + return len(fake.listDeadLetterSourceQueuesArgsForCall) +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesArgsForCall(i int) *sqs.ListDeadLetterSourceQueuesInput { + fake.listDeadLetterSourceQueuesMutex.RLock() + defer fake.listDeadLetterSourceQueuesMutex.RUnlock() + return fake.listDeadLetterSourceQueuesArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesReturns(result1 *sqs.ListDeadLetterSourceQueuesOutput, result2 error) { + fake.ListDeadLetterSourceQueuesStub = nil + fake.listDeadLetterSourceQueuesReturns = struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesReturnsOnCall(i int, result1 *sqs.ListDeadLetterSourceQueuesOutput, result2 error) { + fake.ListDeadLetterSourceQueuesStub = nil + if fake.listDeadLetterSourceQueuesReturnsOnCall == nil { + fake.listDeadLetterSourceQueuesReturnsOnCall = make(map[int]struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + }) + } + fake.listDeadLetterSourceQueuesReturnsOnCall[i] = struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesWithContext(arg1 aws.Context, arg2 *sqs.ListDeadLetterSourceQueuesInput, arg3 ...request.Option) (*sqs.ListDeadLetterSourceQueuesOutput, error) { + fake.listDeadLetterSourceQueuesWithContextMutex.Lock() + ret, specificReturn := fake.listDeadLetterSourceQueuesWithContextReturnsOnCall[len(fake.listDeadLetterSourceQueuesWithContextArgsForCall)] + fake.listDeadLetterSourceQueuesWithContextArgsForCall = append(fake.listDeadLetterSourceQueuesWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.ListDeadLetterSourceQueuesInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("ListDeadLetterSourceQueuesWithContext", []interface{}{arg1, arg2, arg3}) + fake.listDeadLetterSourceQueuesWithContextMutex.Unlock() + if fake.ListDeadLetterSourceQueuesWithContextStub != nil { + return fake.ListDeadLetterSourceQueuesWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listDeadLetterSourceQueuesWithContextReturns.result1, fake.listDeadLetterSourceQueuesWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesWithContextCallCount() int { + fake.listDeadLetterSourceQueuesWithContextMutex.RLock() + defer fake.listDeadLetterSourceQueuesWithContextMutex.RUnlock() + return len(fake.listDeadLetterSourceQueuesWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesWithContextArgsForCall(i int) (aws.Context, *sqs.ListDeadLetterSourceQueuesInput, []request.Option) { + fake.listDeadLetterSourceQueuesWithContextMutex.RLock() + defer fake.listDeadLetterSourceQueuesWithContextMutex.RUnlock() + return fake.listDeadLetterSourceQueuesWithContextArgsForCall[i].arg1, fake.listDeadLetterSourceQueuesWithContextArgsForCall[i].arg2, fake.listDeadLetterSourceQueuesWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesWithContextReturns(result1 *sqs.ListDeadLetterSourceQueuesOutput, result2 error) { + fake.ListDeadLetterSourceQueuesWithContextStub = nil + fake.listDeadLetterSourceQueuesWithContextReturns = struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesWithContextReturnsOnCall(i int, result1 *sqs.ListDeadLetterSourceQueuesOutput, result2 error) { + fake.ListDeadLetterSourceQueuesWithContextStub = nil + if fake.listDeadLetterSourceQueuesWithContextReturnsOnCall == nil { + fake.listDeadLetterSourceQueuesWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + }) + } + fake.listDeadLetterSourceQueuesWithContextReturnsOnCall[i] = struct { + result1 *sqs.ListDeadLetterSourceQueuesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesRequest(arg1 *sqs.ListDeadLetterSourceQueuesInput) (*request.Request, *sqs.ListDeadLetterSourceQueuesOutput) { + fake.listDeadLetterSourceQueuesRequestMutex.Lock() + ret, specificReturn := fake.listDeadLetterSourceQueuesRequestReturnsOnCall[len(fake.listDeadLetterSourceQueuesRequestArgsForCall)] + fake.listDeadLetterSourceQueuesRequestArgsForCall = append(fake.listDeadLetterSourceQueuesRequestArgsForCall, struct { + arg1 *sqs.ListDeadLetterSourceQueuesInput + }{arg1}) + fake.recordInvocation("ListDeadLetterSourceQueuesRequest", []interface{}{arg1}) + fake.listDeadLetterSourceQueuesRequestMutex.Unlock() + if fake.ListDeadLetterSourceQueuesRequestStub != nil { + return fake.ListDeadLetterSourceQueuesRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listDeadLetterSourceQueuesRequestReturns.result1, fake.listDeadLetterSourceQueuesRequestReturns.result2 +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesRequestCallCount() int { + fake.listDeadLetterSourceQueuesRequestMutex.RLock() + defer fake.listDeadLetterSourceQueuesRequestMutex.RUnlock() + return len(fake.listDeadLetterSourceQueuesRequestArgsForCall) +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesRequestArgsForCall(i int) *sqs.ListDeadLetterSourceQueuesInput { + fake.listDeadLetterSourceQueuesRequestMutex.RLock() + defer fake.listDeadLetterSourceQueuesRequestMutex.RUnlock() + return fake.listDeadLetterSourceQueuesRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesRequestReturns(result1 *request.Request, result2 *sqs.ListDeadLetterSourceQueuesOutput) { + fake.ListDeadLetterSourceQueuesRequestStub = nil + fake.listDeadLetterSourceQueuesRequestReturns = struct { + result1 *request.Request + result2 *sqs.ListDeadLetterSourceQueuesOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListDeadLetterSourceQueuesRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.ListDeadLetterSourceQueuesOutput) { + fake.ListDeadLetterSourceQueuesRequestStub = nil + if fake.listDeadLetterSourceQueuesRequestReturnsOnCall == nil { + fake.listDeadLetterSourceQueuesRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.ListDeadLetterSourceQueuesOutput + }) + } + fake.listDeadLetterSourceQueuesRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.ListDeadLetterSourceQueuesOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueueTags(arg1 *sqs.ListQueueTagsInput) (*sqs.ListQueueTagsOutput, error) { + fake.listQueueTagsMutex.Lock() + ret, specificReturn := fake.listQueueTagsReturnsOnCall[len(fake.listQueueTagsArgsForCall)] + fake.listQueueTagsArgsForCall = append(fake.listQueueTagsArgsForCall, struct { + arg1 *sqs.ListQueueTagsInput + }{arg1}) + fake.recordInvocation("ListQueueTags", []interface{}{arg1}) + fake.listQueueTagsMutex.Unlock() + if fake.ListQueueTagsStub != nil { + return fake.ListQueueTagsStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listQueueTagsReturns.result1, fake.listQueueTagsReturns.result2 +} + +func (fake *FakeSQSAPI) ListQueueTagsCallCount() int { + fake.listQueueTagsMutex.RLock() + defer fake.listQueueTagsMutex.RUnlock() + return len(fake.listQueueTagsArgsForCall) +} + +func (fake *FakeSQSAPI) ListQueueTagsArgsForCall(i int) *sqs.ListQueueTagsInput { + fake.listQueueTagsMutex.RLock() + defer fake.listQueueTagsMutex.RUnlock() + return fake.listQueueTagsArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ListQueueTagsReturns(result1 *sqs.ListQueueTagsOutput, result2 error) { + fake.ListQueueTagsStub = nil + fake.listQueueTagsReturns = struct { + result1 *sqs.ListQueueTagsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueueTagsReturnsOnCall(i int, result1 *sqs.ListQueueTagsOutput, result2 error) { + fake.ListQueueTagsStub = nil + if fake.listQueueTagsReturnsOnCall == nil { + fake.listQueueTagsReturnsOnCall = make(map[int]struct { + result1 *sqs.ListQueueTagsOutput + result2 error + }) + } + fake.listQueueTagsReturnsOnCall[i] = struct { + result1 *sqs.ListQueueTagsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueueTagsWithContext(arg1 aws.Context, arg2 *sqs.ListQueueTagsInput, arg3 ...request.Option) (*sqs.ListQueueTagsOutput, error) { + fake.listQueueTagsWithContextMutex.Lock() + ret, specificReturn := fake.listQueueTagsWithContextReturnsOnCall[len(fake.listQueueTagsWithContextArgsForCall)] + fake.listQueueTagsWithContextArgsForCall = append(fake.listQueueTagsWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.ListQueueTagsInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("ListQueueTagsWithContext", []interface{}{arg1, arg2, arg3}) + fake.listQueueTagsWithContextMutex.Unlock() + if fake.ListQueueTagsWithContextStub != nil { + return fake.ListQueueTagsWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listQueueTagsWithContextReturns.result1, fake.listQueueTagsWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) ListQueueTagsWithContextCallCount() int { + fake.listQueueTagsWithContextMutex.RLock() + defer fake.listQueueTagsWithContextMutex.RUnlock() + return len(fake.listQueueTagsWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) ListQueueTagsWithContextArgsForCall(i int) (aws.Context, *sqs.ListQueueTagsInput, []request.Option) { + fake.listQueueTagsWithContextMutex.RLock() + defer fake.listQueueTagsWithContextMutex.RUnlock() + return fake.listQueueTagsWithContextArgsForCall[i].arg1, fake.listQueueTagsWithContextArgsForCall[i].arg2, fake.listQueueTagsWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) ListQueueTagsWithContextReturns(result1 *sqs.ListQueueTagsOutput, result2 error) { + fake.ListQueueTagsWithContextStub = nil + fake.listQueueTagsWithContextReturns = struct { + result1 *sqs.ListQueueTagsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueueTagsWithContextReturnsOnCall(i int, result1 *sqs.ListQueueTagsOutput, result2 error) { + fake.ListQueueTagsWithContextStub = nil + if fake.listQueueTagsWithContextReturnsOnCall == nil { + fake.listQueueTagsWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.ListQueueTagsOutput + result2 error + }) + } + fake.listQueueTagsWithContextReturnsOnCall[i] = struct { + result1 *sqs.ListQueueTagsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueueTagsRequest(arg1 *sqs.ListQueueTagsInput) (*request.Request, *sqs.ListQueueTagsOutput) { + fake.listQueueTagsRequestMutex.Lock() + ret, specificReturn := fake.listQueueTagsRequestReturnsOnCall[len(fake.listQueueTagsRequestArgsForCall)] + fake.listQueueTagsRequestArgsForCall = append(fake.listQueueTagsRequestArgsForCall, struct { + arg1 *sqs.ListQueueTagsInput + }{arg1}) + fake.recordInvocation("ListQueueTagsRequest", []interface{}{arg1}) + fake.listQueueTagsRequestMutex.Unlock() + if fake.ListQueueTagsRequestStub != nil { + return fake.ListQueueTagsRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listQueueTagsRequestReturns.result1, fake.listQueueTagsRequestReturns.result2 +} + +func (fake *FakeSQSAPI) ListQueueTagsRequestCallCount() int { + fake.listQueueTagsRequestMutex.RLock() + defer fake.listQueueTagsRequestMutex.RUnlock() + return len(fake.listQueueTagsRequestArgsForCall) +} + +func (fake *FakeSQSAPI) ListQueueTagsRequestArgsForCall(i int) *sqs.ListQueueTagsInput { + fake.listQueueTagsRequestMutex.RLock() + defer fake.listQueueTagsRequestMutex.RUnlock() + return fake.listQueueTagsRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ListQueueTagsRequestReturns(result1 *request.Request, result2 *sqs.ListQueueTagsOutput) { + fake.ListQueueTagsRequestStub = nil + fake.listQueueTagsRequestReturns = struct { + result1 *request.Request + result2 *sqs.ListQueueTagsOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueueTagsRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.ListQueueTagsOutput) { + fake.ListQueueTagsRequestStub = nil + if fake.listQueueTagsRequestReturnsOnCall == nil { + fake.listQueueTagsRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.ListQueueTagsOutput + }) + } + fake.listQueueTagsRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.ListQueueTagsOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueues(arg1 *sqs.ListQueuesInput) (*sqs.ListQueuesOutput, error) { + fake.listQueuesMutex.Lock() + ret, specificReturn := fake.listQueuesReturnsOnCall[len(fake.listQueuesArgsForCall)] + fake.listQueuesArgsForCall = append(fake.listQueuesArgsForCall, struct { + arg1 *sqs.ListQueuesInput + }{arg1}) + fake.recordInvocation("ListQueues", []interface{}{arg1}) + fake.listQueuesMutex.Unlock() + if fake.ListQueuesStub != nil { + return fake.ListQueuesStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listQueuesReturns.result1, fake.listQueuesReturns.result2 +} + +func (fake *FakeSQSAPI) ListQueuesCallCount() int { + fake.listQueuesMutex.RLock() + defer fake.listQueuesMutex.RUnlock() + return len(fake.listQueuesArgsForCall) +} + +func (fake *FakeSQSAPI) ListQueuesArgsForCall(i int) *sqs.ListQueuesInput { + fake.listQueuesMutex.RLock() + defer fake.listQueuesMutex.RUnlock() + return fake.listQueuesArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ListQueuesReturns(result1 *sqs.ListQueuesOutput, result2 error) { + fake.ListQueuesStub = nil + fake.listQueuesReturns = struct { + result1 *sqs.ListQueuesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueuesReturnsOnCall(i int, result1 *sqs.ListQueuesOutput, result2 error) { + fake.ListQueuesStub = nil + if fake.listQueuesReturnsOnCall == nil { + fake.listQueuesReturnsOnCall = make(map[int]struct { + result1 *sqs.ListQueuesOutput + result2 error + }) + } + fake.listQueuesReturnsOnCall[i] = struct { + result1 *sqs.ListQueuesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueuesWithContext(arg1 aws.Context, arg2 *sqs.ListQueuesInput, arg3 ...request.Option) (*sqs.ListQueuesOutput, error) { + fake.listQueuesWithContextMutex.Lock() + ret, specificReturn := fake.listQueuesWithContextReturnsOnCall[len(fake.listQueuesWithContextArgsForCall)] + fake.listQueuesWithContextArgsForCall = append(fake.listQueuesWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.ListQueuesInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("ListQueuesWithContext", []interface{}{arg1, arg2, arg3}) + fake.listQueuesWithContextMutex.Unlock() + if fake.ListQueuesWithContextStub != nil { + return fake.ListQueuesWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listQueuesWithContextReturns.result1, fake.listQueuesWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) ListQueuesWithContextCallCount() int { + fake.listQueuesWithContextMutex.RLock() + defer fake.listQueuesWithContextMutex.RUnlock() + return len(fake.listQueuesWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) ListQueuesWithContextArgsForCall(i int) (aws.Context, *sqs.ListQueuesInput, []request.Option) { + fake.listQueuesWithContextMutex.RLock() + defer fake.listQueuesWithContextMutex.RUnlock() + return fake.listQueuesWithContextArgsForCall[i].arg1, fake.listQueuesWithContextArgsForCall[i].arg2, fake.listQueuesWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) ListQueuesWithContextReturns(result1 *sqs.ListQueuesOutput, result2 error) { + fake.ListQueuesWithContextStub = nil + fake.listQueuesWithContextReturns = struct { + result1 *sqs.ListQueuesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueuesWithContextReturnsOnCall(i int, result1 *sqs.ListQueuesOutput, result2 error) { + fake.ListQueuesWithContextStub = nil + if fake.listQueuesWithContextReturnsOnCall == nil { + fake.listQueuesWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.ListQueuesOutput + result2 error + }) + } + fake.listQueuesWithContextReturnsOnCall[i] = struct { + result1 *sqs.ListQueuesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueuesRequest(arg1 *sqs.ListQueuesInput) (*request.Request, *sqs.ListQueuesOutput) { + fake.listQueuesRequestMutex.Lock() + ret, specificReturn := fake.listQueuesRequestReturnsOnCall[len(fake.listQueuesRequestArgsForCall)] + fake.listQueuesRequestArgsForCall = append(fake.listQueuesRequestArgsForCall, struct { + arg1 *sqs.ListQueuesInput + }{arg1}) + fake.recordInvocation("ListQueuesRequest", []interface{}{arg1}) + fake.listQueuesRequestMutex.Unlock() + if fake.ListQueuesRequestStub != nil { + return fake.ListQueuesRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listQueuesRequestReturns.result1, fake.listQueuesRequestReturns.result2 +} + +func (fake *FakeSQSAPI) ListQueuesRequestCallCount() int { + fake.listQueuesRequestMutex.RLock() + defer fake.listQueuesRequestMutex.RUnlock() + return len(fake.listQueuesRequestArgsForCall) +} + +func (fake *FakeSQSAPI) ListQueuesRequestArgsForCall(i int) *sqs.ListQueuesInput { + fake.listQueuesRequestMutex.RLock() + defer fake.listQueuesRequestMutex.RUnlock() + return fake.listQueuesRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ListQueuesRequestReturns(result1 *request.Request, result2 *sqs.ListQueuesOutput) { + fake.ListQueuesRequestStub = nil + fake.listQueuesRequestReturns = struct { + result1 *request.Request + result2 *sqs.ListQueuesOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ListQueuesRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.ListQueuesOutput) { + fake.ListQueuesRequestStub = nil + if fake.listQueuesRequestReturnsOnCall == nil { + fake.listQueuesRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.ListQueuesOutput + }) + } + fake.listQueuesRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.ListQueuesOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) PurgeQueue(arg1 *sqs.PurgeQueueInput) (*sqs.PurgeQueueOutput, error) { + fake.purgeQueueMutex.Lock() + ret, specificReturn := fake.purgeQueueReturnsOnCall[len(fake.purgeQueueArgsForCall)] + fake.purgeQueueArgsForCall = append(fake.purgeQueueArgsForCall, struct { + arg1 *sqs.PurgeQueueInput + }{arg1}) + fake.recordInvocation("PurgeQueue", []interface{}{arg1}) + fake.purgeQueueMutex.Unlock() + if fake.PurgeQueueStub != nil { + return fake.PurgeQueueStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.purgeQueueReturns.result1, fake.purgeQueueReturns.result2 +} + +func (fake *FakeSQSAPI) PurgeQueueCallCount() int { + fake.purgeQueueMutex.RLock() + defer fake.purgeQueueMutex.RUnlock() + return len(fake.purgeQueueArgsForCall) +} + +func (fake *FakeSQSAPI) PurgeQueueArgsForCall(i int) *sqs.PurgeQueueInput { + fake.purgeQueueMutex.RLock() + defer fake.purgeQueueMutex.RUnlock() + return fake.purgeQueueArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) PurgeQueueReturns(result1 *sqs.PurgeQueueOutput, result2 error) { + fake.PurgeQueueStub = nil + fake.purgeQueueReturns = struct { + result1 *sqs.PurgeQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) PurgeQueueReturnsOnCall(i int, result1 *sqs.PurgeQueueOutput, result2 error) { + fake.PurgeQueueStub = nil + if fake.purgeQueueReturnsOnCall == nil { + fake.purgeQueueReturnsOnCall = make(map[int]struct { + result1 *sqs.PurgeQueueOutput + result2 error + }) + } + fake.purgeQueueReturnsOnCall[i] = struct { + result1 *sqs.PurgeQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) PurgeQueueWithContext(arg1 aws.Context, arg2 *sqs.PurgeQueueInput, arg3 ...request.Option) (*sqs.PurgeQueueOutput, error) { + fake.purgeQueueWithContextMutex.Lock() + ret, specificReturn := fake.purgeQueueWithContextReturnsOnCall[len(fake.purgeQueueWithContextArgsForCall)] + fake.purgeQueueWithContextArgsForCall = append(fake.purgeQueueWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.PurgeQueueInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("PurgeQueueWithContext", []interface{}{arg1, arg2, arg3}) + fake.purgeQueueWithContextMutex.Unlock() + if fake.PurgeQueueWithContextStub != nil { + return fake.PurgeQueueWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.purgeQueueWithContextReturns.result1, fake.purgeQueueWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) PurgeQueueWithContextCallCount() int { + fake.purgeQueueWithContextMutex.RLock() + defer fake.purgeQueueWithContextMutex.RUnlock() + return len(fake.purgeQueueWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) PurgeQueueWithContextArgsForCall(i int) (aws.Context, *sqs.PurgeQueueInput, []request.Option) { + fake.purgeQueueWithContextMutex.RLock() + defer fake.purgeQueueWithContextMutex.RUnlock() + return fake.purgeQueueWithContextArgsForCall[i].arg1, fake.purgeQueueWithContextArgsForCall[i].arg2, fake.purgeQueueWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) PurgeQueueWithContextReturns(result1 *sqs.PurgeQueueOutput, result2 error) { + fake.PurgeQueueWithContextStub = nil + fake.purgeQueueWithContextReturns = struct { + result1 *sqs.PurgeQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) PurgeQueueWithContextReturnsOnCall(i int, result1 *sqs.PurgeQueueOutput, result2 error) { + fake.PurgeQueueWithContextStub = nil + if fake.purgeQueueWithContextReturnsOnCall == nil { + fake.purgeQueueWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.PurgeQueueOutput + result2 error + }) + } + fake.purgeQueueWithContextReturnsOnCall[i] = struct { + result1 *sqs.PurgeQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) PurgeQueueRequest(arg1 *sqs.PurgeQueueInput) (*request.Request, *sqs.PurgeQueueOutput) { + fake.purgeQueueRequestMutex.Lock() + ret, specificReturn := fake.purgeQueueRequestReturnsOnCall[len(fake.purgeQueueRequestArgsForCall)] + fake.purgeQueueRequestArgsForCall = append(fake.purgeQueueRequestArgsForCall, struct { + arg1 *sqs.PurgeQueueInput + }{arg1}) + fake.recordInvocation("PurgeQueueRequest", []interface{}{arg1}) + fake.purgeQueueRequestMutex.Unlock() + if fake.PurgeQueueRequestStub != nil { + return fake.PurgeQueueRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.purgeQueueRequestReturns.result1, fake.purgeQueueRequestReturns.result2 +} + +func (fake *FakeSQSAPI) PurgeQueueRequestCallCount() int { + fake.purgeQueueRequestMutex.RLock() + defer fake.purgeQueueRequestMutex.RUnlock() + return len(fake.purgeQueueRequestArgsForCall) +} + +func (fake *FakeSQSAPI) PurgeQueueRequestArgsForCall(i int) *sqs.PurgeQueueInput { + fake.purgeQueueRequestMutex.RLock() + defer fake.purgeQueueRequestMutex.RUnlock() + return fake.purgeQueueRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) PurgeQueueRequestReturns(result1 *request.Request, result2 *sqs.PurgeQueueOutput) { + fake.PurgeQueueRequestStub = nil + fake.purgeQueueRequestReturns = struct { + result1 *request.Request + result2 *sqs.PurgeQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) PurgeQueueRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.PurgeQueueOutput) { + fake.PurgeQueueRequestStub = nil + if fake.purgeQueueRequestReturnsOnCall == nil { + fake.purgeQueueRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.PurgeQueueOutput + }) + } + fake.purgeQueueRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.PurgeQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ReceiveMessage(arg1 *sqs.ReceiveMessageInput) (*sqs.ReceiveMessageOutput, error) { + fake.receiveMessageMutex.Lock() + ret, specificReturn := fake.receiveMessageReturnsOnCall[len(fake.receiveMessageArgsForCall)] + fake.receiveMessageArgsForCall = append(fake.receiveMessageArgsForCall, struct { + arg1 *sqs.ReceiveMessageInput + }{arg1}) + fake.recordInvocation("ReceiveMessage", []interface{}{arg1}) + fake.receiveMessageMutex.Unlock() + if fake.ReceiveMessageStub != nil { + return fake.ReceiveMessageStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.receiveMessageReturns.result1, fake.receiveMessageReturns.result2 +} + +func (fake *FakeSQSAPI) ReceiveMessageCallCount() int { + fake.receiveMessageMutex.RLock() + defer fake.receiveMessageMutex.RUnlock() + return len(fake.receiveMessageArgsForCall) +} + +func (fake *FakeSQSAPI) ReceiveMessageArgsForCall(i int) *sqs.ReceiveMessageInput { + fake.receiveMessageMutex.RLock() + defer fake.receiveMessageMutex.RUnlock() + return fake.receiveMessageArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ReceiveMessageReturns(result1 *sqs.ReceiveMessageOutput, result2 error) { + fake.ReceiveMessageStub = nil + fake.receiveMessageReturns = struct { + result1 *sqs.ReceiveMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ReceiveMessageReturnsOnCall(i int, result1 *sqs.ReceiveMessageOutput, result2 error) { + fake.ReceiveMessageStub = nil + if fake.receiveMessageReturnsOnCall == nil { + fake.receiveMessageReturnsOnCall = make(map[int]struct { + result1 *sqs.ReceiveMessageOutput + result2 error + }) + } + fake.receiveMessageReturnsOnCall[i] = struct { + result1 *sqs.ReceiveMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ReceiveMessageWithContext(arg1 aws.Context, arg2 *sqs.ReceiveMessageInput, arg3 ...request.Option) (*sqs.ReceiveMessageOutput, error) { + fake.receiveMessageWithContextMutex.Lock() + ret, specificReturn := fake.receiveMessageWithContextReturnsOnCall[len(fake.receiveMessageWithContextArgsForCall)] + fake.receiveMessageWithContextArgsForCall = append(fake.receiveMessageWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.ReceiveMessageInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("ReceiveMessageWithContext", []interface{}{arg1, arg2, arg3}) + fake.receiveMessageWithContextMutex.Unlock() + if fake.ReceiveMessageWithContextStub != nil { + return fake.ReceiveMessageWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.receiveMessageWithContextReturns.result1, fake.receiveMessageWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) ReceiveMessageWithContextCallCount() int { + fake.receiveMessageWithContextMutex.RLock() + defer fake.receiveMessageWithContextMutex.RUnlock() + return len(fake.receiveMessageWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) ReceiveMessageWithContextArgsForCall(i int) (aws.Context, *sqs.ReceiveMessageInput, []request.Option) { + fake.receiveMessageWithContextMutex.RLock() + defer fake.receiveMessageWithContextMutex.RUnlock() + return fake.receiveMessageWithContextArgsForCall[i].arg1, fake.receiveMessageWithContextArgsForCall[i].arg2, fake.receiveMessageWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) ReceiveMessageWithContextReturns(result1 *sqs.ReceiveMessageOutput, result2 error) { + fake.ReceiveMessageWithContextStub = nil + fake.receiveMessageWithContextReturns = struct { + result1 *sqs.ReceiveMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ReceiveMessageWithContextReturnsOnCall(i int, result1 *sqs.ReceiveMessageOutput, result2 error) { + fake.ReceiveMessageWithContextStub = nil + if fake.receiveMessageWithContextReturnsOnCall == nil { + fake.receiveMessageWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.ReceiveMessageOutput + result2 error + }) + } + fake.receiveMessageWithContextReturnsOnCall[i] = struct { + result1 *sqs.ReceiveMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) ReceiveMessageRequest(arg1 *sqs.ReceiveMessageInput) (*request.Request, *sqs.ReceiveMessageOutput) { + fake.receiveMessageRequestMutex.Lock() + ret, specificReturn := fake.receiveMessageRequestReturnsOnCall[len(fake.receiveMessageRequestArgsForCall)] + fake.receiveMessageRequestArgsForCall = append(fake.receiveMessageRequestArgsForCall, struct { + arg1 *sqs.ReceiveMessageInput + }{arg1}) + fake.recordInvocation("ReceiveMessageRequest", []interface{}{arg1}) + fake.receiveMessageRequestMutex.Unlock() + if fake.ReceiveMessageRequestStub != nil { + return fake.ReceiveMessageRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.receiveMessageRequestReturns.result1, fake.receiveMessageRequestReturns.result2 +} + +func (fake *FakeSQSAPI) ReceiveMessageRequestCallCount() int { + fake.receiveMessageRequestMutex.RLock() + defer fake.receiveMessageRequestMutex.RUnlock() + return len(fake.receiveMessageRequestArgsForCall) +} + +func (fake *FakeSQSAPI) ReceiveMessageRequestArgsForCall(i int) *sqs.ReceiveMessageInput { + fake.receiveMessageRequestMutex.RLock() + defer fake.receiveMessageRequestMutex.RUnlock() + return fake.receiveMessageRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) ReceiveMessageRequestReturns(result1 *request.Request, result2 *sqs.ReceiveMessageOutput) { + fake.ReceiveMessageRequestStub = nil + fake.receiveMessageRequestReturns = struct { + result1 *request.Request + result2 *sqs.ReceiveMessageOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) ReceiveMessageRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.ReceiveMessageOutput) { + fake.ReceiveMessageRequestStub = nil + if fake.receiveMessageRequestReturnsOnCall == nil { + fake.receiveMessageRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.ReceiveMessageOutput + }) + } + fake.receiveMessageRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.ReceiveMessageOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) RemovePermission(arg1 *sqs.RemovePermissionInput) (*sqs.RemovePermissionOutput, error) { + fake.removePermissionMutex.Lock() + ret, specificReturn := fake.removePermissionReturnsOnCall[len(fake.removePermissionArgsForCall)] + fake.removePermissionArgsForCall = append(fake.removePermissionArgsForCall, struct { + arg1 *sqs.RemovePermissionInput + }{arg1}) + fake.recordInvocation("RemovePermission", []interface{}{arg1}) + fake.removePermissionMutex.Unlock() + if fake.RemovePermissionStub != nil { + return fake.RemovePermissionStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.removePermissionReturns.result1, fake.removePermissionReturns.result2 +} + +func (fake *FakeSQSAPI) RemovePermissionCallCount() int { + fake.removePermissionMutex.RLock() + defer fake.removePermissionMutex.RUnlock() + return len(fake.removePermissionArgsForCall) +} + +func (fake *FakeSQSAPI) RemovePermissionArgsForCall(i int) *sqs.RemovePermissionInput { + fake.removePermissionMutex.RLock() + defer fake.removePermissionMutex.RUnlock() + return fake.removePermissionArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) RemovePermissionReturns(result1 *sqs.RemovePermissionOutput, result2 error) { + fake.RemovePermissionStub = nil + fake.removePermissionReturns = struct { + result1 *sqs.RemovePermissionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) RemovePermissionReturnsOnCall(i int, result1 *sqs.RemovePermissionOutput, result2 error) { + fake.RemovePermissionStub = nil + if fake.removePermissionReturnsOnCall == nil { + fake.removePermissionReturnsOnCall = make(map[int]struct { + result1 *sqs.RemovePermissionOutput + result2 error + }) + } + fake.removePermissionReturnsOnCall[i] = struct { + result1 *sqs.RemovePermissionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) RemovePermissionWithContext(arg1 aws.Context, arg2 *sqs.RemovePermissionInput, arg3 ...request.Option) (*sqs.RemovePermissionOutput, error) { + fake.removePermissionWithContextMutex.Lock() + ret, specificReturn := fake.removePermissionWithContextReturnsOnCall[len(fake.removePermissionWithContextArgsForCall)] + fake.removePermissionWithContextArgsForCall = append(fake.removePermissionWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.RemovePermissionInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("RemovePermissionWithContext", []interface{}{arg1, arg2, arg3}) + fake.removePermissionWithContextMutex.Unlock() + if fake.RemovePermissionWithContextStub != nil { + return fake.RemovePermissionWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.removePermissionWithContextReturns.result1, fake.removePermissionWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) RemovePermissionWithContextCallCount() int { + fake.removePermissionWithContextMutex.RLock() + defer fake.removePermissionWithContextMutex.RUnlock() + return len(fake.removePermissionWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) RemovePermissionWithContextArgsForCall(i int) (aws.Context, *sqs.RemovePermissionInput, []request.Option) { + fake.removePermissionWithContextMutex.RLock() + defer fake.removePermissionWithContextMutex.RUnlock() + return fake.removePermissionWithContextArgsForCall[i].arg1, fake.removePermissionWithContextArgsForCall[i].arg2, fake.removePermissionWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) RemovePermissionWithContextReturns(result1 *sqs.RemovePermissionOutput, result2 error) { + fake.RemovePermissionWithContextStub = nil + fake.removePermissionWithContextReturns = struct { + result1 *sqs.RemovePermissionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) RemovePermissionWithContextReturnsOnCall(i int, result1 *sqs.RemovePermissionOutput, result2 error) { + fake.RemovePermissionWithContextStub = nil + if fake.removePermissionWithContextReturnsOnCall == nil { + fake.removePermissionWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.RemovePermissionOutput + result2 error + }) + } + fake.removePermissionWithContextReturnsOnCall[i] = struct { + result1 *sqs.RemovePermissionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) RemovePermissionRequest(arg1 *sqs.RemovePermissionInput) (*request.Request, *sqs.RemovePermissionOutput) { + fake.removePermissionRequestMutex.Lock() + ret, specificReturn := fake.removePermissionRequestReturnsOnCall[len(fake.removePermissionRequestArgsForCall)] + fake.removePermissionRequestArgsForCall = append(fake.removePermissionRequestArgsForCall, struct { + arg1 *sqs.RemovePermissionInput + }{arg1}) + fake.recordInvocation("RemovePermissionRequest", []interface{}{arg1}) + fake.removePermissionRequestMutex.Unlock() + if fake.RemovePermissionRequestStub != nil { + return fake.RemovePermissionRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.removePermissionRequestReturns.result1, fake.removePermissionRequestReturns.result2 +} + +func (fake *FakeSQSAPI) RemovePermissionRequestCallCount() int { + fake.removePermissionRequestMutex.RLock() + defer fake.removePermissionRequestMutex.RUnlock() + return len(fake.removePermissionRequestArgsForCall) +} + +func (fake *FakeSQSAPI) RemovePermissionRequestArgsForCall(i int) *sqs.RemovePermissionInput { + fake.removePermissionRequestMutex.RLock() + defer fake.removePermissionRequestMutex.RUnlock() + return fake.removePermissionRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) RemovePermissionRequestReturns(result1 *request.Request, result2 *sqs.RemovePermissionOutput) { + fake.RemovePermissionRequestStub = nil + fake.removePermissionRequestReturns = struct { + result1 *request.Request + result2 *sqs.RemovePermissionOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) RemovePermissionRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.RemovePermissionOutput) { + fake.RemovePermissionRequestStub = nil + if fake.removePermissionRequestReturnsOnCall == nil { + fake.removePermissionRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.RemovePermissionOutput + }) + } + fake.removePermissionRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.RemovePermissionOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessage(arg1 *sqs.SendMessageInput) (*sqs.SendMessageOutput, error) { + fake.sendMessageMutex.Lock() + ret, specificReturn := fake.sendMessageReturnsOnCall[len(fake.sendMessageArgsForCall)] + fake.sendMessageArgsForCall = append(fake.sendMessageArgsForCall, struct { + arg1 *sqs.SendMessageInput + }{arg1}) + fake.recordInvocation("SendMessage", []interface{}{arg1}) + fake.sendMessageMutex.Unlock() + if fake.SendMessageStub != nil { + return fake.SendMessageStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.sendMessageReturns.result1, fake.sendMessageReturns.result2 +} + +func (fake *FakeSQSAPI) SendMessageCallCount() int { + fake.sendMessageMutex.RLock() + defer fake.sendMessageMutex.RUnlock() + return len(fake.sendMessageArgsForCall) +} + +func (fake *FakeSQSAPI) SendMessageArgsForCall(i int) *sqs.SendMessageInput { + fake.sendMessageMutex.RLock() + defer fake.sendMessageMutex.RUnlock() + return fake.sendMessageArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) SendMessageReturns(result1 *sqs.SendMessageOutput, result2 error) { + fake.SendMessageStub = nil + fake.sendMessageReturns = struct { + result1 *sqs.SendMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageReturnsOnCall(i int, result1 *sqs.SendMessageOutput, result2 error) { + fake.SendMessageStub = nil + if fake.sendMessageReturnsOnCall == nil { + fake.sendMessageReturnsOnCall = make(map[int]struct { + result1 *sqs.SendMessageOutput + result2 error + }) + } + fake.sendMessageReturnsOnCall[i] = struct { + result1 *sqs.SendMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageWithContext(arg1 aws.Context, arg2 *sqs.SendMessageInput, arg3 ...request.Option) (*sqs.SendMessageOutput, error) { + fake.sendMessageWithContextMutex.Lock() + ret, specificReturn := fake.sendMessageWithContextReturnsOnCall[len(fake.sendMessageWithContextArgsForCall)] + fake.sendMessageWithContextArgsForCall = append(fake.sendMessageWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.SendMessageInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("SendMessageWithContext", []interface{}{arg1, arg2, arg3}) + fake.sendMessageWithContextMutex.Unlock() + if fake.SendMessageWithContextStub != nil { + return fake.SendMessageWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.sendMessageWithContextReturns.result1, fake.sendMessageWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) SendMessageWithContextCallCount() int { + fake.sendMessageWithContextMutex.RLock() + defer fake.sendMessageWithContextMutex.RUnlock() + return len(fake.sendMessageWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) SendMessageWithContextArgsForCall(i int) (aws.Context, *sqs.SendMessageInput, []request.Option) { + fake.sendMessageWithContextMutex.RLock() + defer fake.sendMessageWithContextMutex.RUnlock() + return fake.sendMessageWithContextArgsForCall[i].arg1, fake.sendMessageWithContextArgsForCall[i].arg2, fake.sendMessageWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) SendMessageWithContextReturns(result1 *sqs.SendMessageOutput, result2 error) { + fake.SendMessageWithContextStub = nil + fake.sendMessageWithContextReturns = struct { + result1 *sqs.SendMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageWithContextReturnsOnCall(i int, result1 *sqs.SendMessageOutput, result2 error) { + fake.SendMessageWithContextStub = nil + if fake.sendMessageWithContextReturnsOnCall == nil { + fake.sendMessageWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.SendMessageOutput + result2 error + }) + } + fake.sendMessageWithContextReturnsOnCall[i] = struct { + result1 *sqs.SendMessageOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageRequest(arg1 *sqs.SendMessageInput) (*request.Request, *sqs.SendMessageOutput) { + fake.sendMessageRequestMutex.Lock() + ret, specificReturn := fake.sendMessageRequestReturnsOnCall[len(fake.sendMessageRequestArgsForCall)] + fake.sendMessageRequestArgsForCall = append(fake.sendMessageRequestArgsForCall, struct { + arg1 *sqs.SendMessageInput + }{arg1}) + fake.recordInvocation("SendMessageRequest", []interface{}{arg1}) + fake.sendMessageRequestMutex.Unlock() + if fake.SendMessageRequestStub != nil { + return fake.SendMessageRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.sendMessageRequestReturns.result1, fake.sendMessageRequestReturns.result2 +} + +func (fake *FakeSQSAPI) SendMessageRequestCallCount() int { + fake.sendMessageRequestMutex.RLock() + defer fake.sendMessageRequestMutex.RUnlock() + return len(fake.sendMessageRequestArgsForCall) +} + +func (fake *FakeSQSAPI) SendMessageRequestArgsForCall(i int) *sqs.SendMessageInput { + fake.sendMessageRequestMutex.RLock() + defer fake.sendMessageRequestMutex.RUnlock() + return fake.sendMessageRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) SendMessageRequestReturns(result1 *request.Request, result2 *sqs.SendMessageOutput) { + fake.SendMessageRequestStub = nil + fake.sendMessageRequestReturns = struct { + result1 *request.Request + result2 *sqs.SendMessageOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.SendMessageOutput) { + fake.SendMessageRequestStub = nil + if fake.sendMessageRequestReturnsOnCall == nil { + fake.sendMessageRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.SendMessageOutput + }) + } + fake.sendMessageRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.SendMessageOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageBatch(arg1 *sqs.SendMessageBatchInput) (*sqs.SendMessageBatchOutput, error) { + fake.sendMessageBatchMutex.Lock() + ret, specificReturn := fake.sendMessageBatchReturnsOnCall[len(fake.sendMessageBatchArgsForCall)] + fake.sendMessageBatchArgsForCall = append(fake.sendMessageBatchArgsForCall, struct { + arg1 *sqs.SendMessageBatchInput + }{arg1}) + fake.recordInvocation("SendMessageBatch", []interface{}{arg1}) + fake.sendMessageBatchMutex.Unlock() + if fake.SendMessageBatchStub != nil { + return fake.SendMessageBatchStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.sendMessageBatchReturns.result1, fake.sendMessageBatchReturns.result2 +} + +func (fake *FakeSQSAPI) SendMessageBatchCallCount() int { + fake.sendMessageBatchMutex.RLock() + defer fake.sendMessageBatchMutex.RUnlock() + return len(fake.sendMessageBatchArgsForCall) +} + +func (fake *FakeSQSAPI) SendMessageBatchArgsForCall(i int) *sqs.SendMessageBatchInput { + fake.sendMessageBatchMutex.RLock() + defer fake.sendMessageBatchMutex.RUnlock() + return fake.sendMessageBatchArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) SendMessageBatchReturns(result1 *sqs.SendMessageBatchOutput, result2 error) { + fake.SendMessageBatchStub = nil + fake.sendMessageBatchReturns = struct { + result1 *sqs.SendMessageBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageBatchReturnsOnCall(i int, result1 *sqs.SendMessageBatchOutput, result2 error) { + fake.SendMessageBatchStub = nil + if fake.sendMessageBatchReturnsOnCall == nil { + fake.sendMessageBatchReturnsOnCall = make(map[int]struct { + result1 *sqs.SendMessageBatchOutput + result2 error + }) + } + fake.sendMessageBatchReturnsOnCall[i] = struct { + result1 *sqs.SendMessageBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageBatchWithContext(arg1 aws.Context, arg2 *sqs.SendMessageBatchInput, arg3 ...request.Option) (*sqs.SendMessageBatchOutput, error) { + fake.sendMessageBatchWithContextMutex.Lock() + ret, specificReturn := fake.sendMessageBatchWithContextReturnsOnCall[len(fake.sendMessageBatchWithContextArgsForCall)] + fake.sendMessageBatchWithContextArgsForCall = append(fake.sendMessageBatchWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.SendMessageBatchInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("SendMessageBatchWithContext", []interface{}{arg1, arg2, arg3}) + fake.sendMessageBatchWithContextMutex.Unlock() + if fake.SendMessageBatchWithContextStub != nil { + return fake.SendMessageBatchWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.sendMessageBatchWithContextReturns.result1, fake.sendMessageBatchWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) SendMessageBatchWithContextCallCount() int { + fake.sendMessageBatchWithContextMutex.RLock() + defer fake.sendMessageBatchWithContextMutex.RUnlock() + return len(fake.sendMessageBatchWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) SendMessageBatchWithContextArgsForCall(i int) (aws.Context, *sqs.SendMessageBatchInput, []request.Option) { + fake.sendMessageBatchWithContextMutex.RLock() + defer fake.sendMessageBatchWithContextMutex.RUnlock() + return fake.sendMessageBatchWithContextArgsForCall[i].arg1, fake.sendMessageBatchWithContextArgsForCall[i].arg2, fake.sendMessageBatchWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) SendMessageBatchWithContextReturns(result1 *sqs.SendMessageBatchOutput, result2 error) { + fake.SendMessageBatchWithContextStub = nil + fake.sendMessageBatchWithContextReturns = struct { + result1 *sqs.SendMessageBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageBatchWithContextReturnsOnCall(i int, result1 *sqs.SendMessageBatchOutput, result2 error) { + fake.SendMessageBatchWithContextStub = nil + if fake.sendMessageBatchWithContextReturnsOnCall == nil { + fake.sendMessageBatchWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.SendMessageBatchOutput + result2 error + }) + } + fake.sendMessageBatchWithContextReturnsOnCall[i] = struct { + result1 *sqs.SendMessageBatchOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageBatchRequest(arg1 *sqs.SendMessageBatchInput) (*request.Request, *sqs.SendMessageBatchOutput) { + fake.sendMessageBatchRequestMutex.Lock() + ret, specificReturn := fake.sendMessageBatchRequestReturnsOnCall[len(fake.sendMessageBatchRequestArgsForCall)] + fake.sendMessageBatchRequestArgsForCall = append(fake.sendMessageBatchRequestArgsForCall, struct { + arg1 *sqs.SendMessageBatchInput + }{arg1}) + fake.recordInvocation("SendMessageBatchRequest", []interface{}{arg1}) + fake.sendMessageBatchRequestMutex.Unlock() + if fake.SendMessageBatchRequestStub != nil { + return fake.SendMessageBatchRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.sendMessageBatchRequestReturns.result1, fake.sendMessageBatchRequestReturns.result2 +} + +func (fake *FakeSQSAPI) SendMessageBatchRequestCallCount() int { + fake.sendMessageBatchRequestMutex.RLock() + defer fake.sendMessageBatchRequestMutex.RUnlock() + return len(fake.sendMessageBatchRequestArgsForCall) +} + +func (fake *FakeSQSAPI) SendMessageBatchRequestArgsForCall(i int) *sqs.SendMessageBatchInput { + fake.sendMessageBatchRequestMutex.RLock() + defer fake.sendMessageBatchRequestMutex.RUnlock() + return fake.sendMessageBatchRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) SendMessageBatchRequestReturns(result1 *request.Request, result2 *sqs.SendMessageBatchOutput) { + fake.SendMessageBatchRequestStub = nil + fake.sendMessageBatchRequestReturns = struct { + result1 *request.Request + result2 *sqs.SendMessageBatchOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) SendMessageBatchRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.SendMessageBatchOutput) { + fake.SendMessageBatchRequestStub = nil + if fake.sendMessageBatchRequestReturnsOnCall == nil { + fake.sendMessageBatchRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.SendMessageBatchOutput + }) + } + fake.sendMessageBatchRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.SendMessageBatchOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) SetQueueAttributes(arg1 *sqs.SetQueueAttributesInput) (*sqs.SetQueueAttributesOutput, error) { + fake.setQueueAttributesMutex.Lock() + ret, specificReturn := fake.setQueueAttributesReturnsOnCall[len(fake.setQueueAttributesArgsForCall)] + fake.setQueueAttributesArgsForCall = append(fake.setQueueAttributesArgsForCall, struct { + arg1 *sqs.SetQueueAttributesInput + }{arg1}) + fake.recordInvocation("SetQueueAttributes", []interface{}{arg1}) + fake.setQueueAttributesMutex.Unlock() + if fake.SetQueueAttributesStub != nil { + return fake.SetQueueAttributesStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.setQueueAttributesReturns.result1, fake.setQueueAttributesReturns.result2 +} + +func (fake *FakeSQSAPI) SetQueueAttributesCallCount() int { + fake.setQueueAttributesMutex.RLock() + defer fake.setQueueAttributesMutex.RUnlock() + return len(fake.setQueueAttributesArgsForCall) +} + +func (fake *FakeSQSAPI) SetQueueAttributesArgsForCall(i int) *sqs.SetQueueAttributesInput { + fake.setQueueAttributesMutex.RLock() + defer fake.setQueueAttributesMutex.RUnlock() + return fake.setQueueAttributesArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) SetQueueAttributesReturns(result1 *sqs.SetQueueAttributesOutput, result2 error) { + fake.SetQueueAttributesStub = nil + fake.setQueueAttributesReturns = struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SetQueueAttributesReturnsOnCall(i int, result1 *sqs.SetQueueAttributesOutput, result2 error) { + fake.SetQueueAttributesStub = nil + if fake.setQueueAttributesReturnsOnCall == nil { + fake.setQueueAttributesReturnsOnCall = make(map[int]struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + }) + } + fake.setQueueAttributesReturnsOnCall[i] = struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SetQueueAttributesWithContext(arg1 aws.Context, arg2 *sqs.SetQueueAttributesInput, arg3 ...request.Option) (*sqs.SetQueueAttributesOutput, error) { + fake.setQueueAttributesWithContextMutex.Lock() + ret, specificReturn := fake.setQueueAttributesWithContextReturnsOnCall[len(fake.setQueueAttributesWithContextArgsForCall)] + fake.setQueueAttributesWithContextArgsForCall = append(fake.setQueueAttributesWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.SetQueueAttributesInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("SetQueueAttributesWithContext", []interface{}{arg1, arg2, arg3}) + fake.setQueueAttributesWithContextMutex.Unlock() + if fake.SetQueueAttributesWithContextStub != nil { + return fake.SetQueueAttributesWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.setQueueAttributesWithContextReturns.result1, fake.setQueueAttributesWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) SetQueueAttributesWithContextCallCount() int { + fake.setQueueAttributesWithContextMutex.RLock() + defer fake.setQueueAttributesWithContextMutex.RUnlock() + return len(fake.setQueueAttributesWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) SetQueueAttributesWithContextArgsForCall(i int) (aws.Context, *sqs.SetQueueAttributesInput, []request.Option) { + fake.setQueueAttributesWithContextMutex.RLock() + defer fake.setQueueAttributesWithContextMutex.RUnlock() + return fake.setQueueAttributesWithContextArgsForCall[i].arg1, fake.setQueueAttributesWithContextArgsForCall[i].arg2, fake.setQueueAttributesWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) SetQueueAttributesWithContextReturns(result1 *sqs.SetQueueAttributesOutput, result2 error) { + fake.SetQueueAttributesWithContextStub = nil + fake.setQueueAttributesWithContextReturns = struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SetQueueAttributesWithContextReturnsOnCall(i int, result1 *sqs.SetQueueAttributesOutput, result2 error) { + fake.SetQueueAttributesWithContextStub = nil + if fake.setQueueAttributesWithContextReturnsOnCall == nil { + fake.setQueueAttributesWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + }) + } + fake.setQueueAttributesWithContextReturnsOnCall[i] = struct { + result1 *sqs.SetQueueAttributesOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) SetQueueAttributesRequest(arg1 *sqs.SetQueueAttributesInput) (*request.Request, *sqs.SetQueueAttributesOutput) { + fake.setQueueAttributesRequestMutex.Lock() + ret, specificReturn := fake.setQueueAttributesRequestReturnsOnCall[len(fake.setQueueAttributesRequestArgsForCall)] + fake.setQueueAttributesRequestArgsForCall = append(fake.setQueueAttributesRequestArgsForCall, struct { + arg1 *sqs.SetQueueAttributesInput + }{arg1}) + fake.recordInvocation("SetQueueAttributesRequest", []interface{}{arg1}) + fake.setQueueAttributesRequestMutex.Unlock() + if fake.SetQueueAttributesRequestStub != nil { + return fake.SetQueueAttributesRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.setQueueAttributesRequestReturns.result1, fake.setQueueAttributesRequestReturns.result2 +} + +func (fake *FakeSQSAPI) SetQueueAttributesRequestCallCount() int { + fake.setQueueAttributesRequestMutex.RLock() + defer fake.setQueueAttributesRequestMutex.RUnlock() + return len(fake.setQueueAttributesRequestArgsForCall) +} + +func (fake *FakeSQSAPI) SetQueueAttributesRequestArgsForCall(i int) *sqs.SetQueueAttributesInput { + fake.setQueueAttributesRequestMutex.RLock() + defer fake.setQueueAttributesRequestMutex.RUnlock() + return fake.setQueueAttributesRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) SetQueueAttributesRequestReturns(result1 *request.Request, result2 *sqs.SetQueueAttributesOutput) { + fake.SetQueueAttributesRequestStub = nil + fake.setQueueAttributesRequestReturns = struct { + result1 *request.Request + result2 *sqs.SetQueueAttributesOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) SetQueueAttributesRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.SetQueueAttributesOutput) { + fake.SetQueueAttributesRequestStub = nil + if fake.setQueueAttributesRequestReturnsOnCall == nil { + fake.setQueueAttributesRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.SetQueueAttributesOutput + }) + } + fake.setQueueAttributesRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.SetQueueAttributesOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) TagQueue(arg1 *sqs.TagQueueInput) (*sqs.TagQueueOutput, error) { + fake.tagQueueMutex.Lock() + ret, specificReturn := fake.tagQueueReturnsOnCall[len(fake.tagQueueArgsForCall)] + fake.tagQueueArgsForCall = append(fake.tagQueueArgsForCall, struct { + arg1 *sqs.TagQueueInput + }{arg1}) + fake.recordInvocation("TagQueue", []interface{}{arg1}) + fake.tagQueueMutex.Unlock() + if fake.TagQueueStub != nil { + return fake.TagQueueStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.tagQueueReturns.result1, fake.tagQueueReturns.result2 +} + +func (fake *FakeSQSAPI) TagQueueCallCount() int { + fake.tagQueueMutex.RLock() + defer fake.tagQueueMutex.RUnlock() + return len(fake.tagQueueArgsForCall) +} + +func (fake *FakeSQSAPI) TagQueueArgsForCall(i int) *sqs.TagQueueInput { + fake.tagQueueMutex.RLock() + defer fake.tagQueueMutex.RUnlock() + return fake.tagQueueArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) TagQueueReturns(result1 *sqs.TagQueueOutput, result2 error) { + fake.TagQueueStub = nil + fake.tagQueueReturns = struct { + result1 *sqs.TagQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) TagQueueReturnsOnCall(i int, result1 *sqs.TagQueueOutput, result2 error) { + fake.TagQueueStub = nil + if fake.tagQueueReturnsOnCall == nil { + fake.tagQueueReturnsOnCall = make(map[int]struct { + result1 *sqs.TagQueueOutput + result2 error + }) + } + fake.tagQueueReturnsOnCall[i] = struct { + result1 *sqs.TagQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) TagQueueWithContext(arg1 aws.Context, arg2 *sqs.TagQueueInput, arg3 ...request.Option) (*sqs.TagQueueOutput, error) { + fake.tagQueueWithContextMutex.Lock() + ret, specificReturn := fake.tagQueueWithContextReturnsOnCall[len(fake.tagQueueWithContextArgsForCall)] + fake.tagQueueWithContextArgsForCall = append(fake.tagQueueWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.TagQueueInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("TagQueueWithContext", []interface{}{arg1, arg2, arg3}) + fake.tagQueueWithContextMutex.Unlock() + if fake.TagQueueWithContextStub != nil { + return fake.TagQueueWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.tagQueueWithContextReturns.result1, fake.tagQueueWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) TagQueueWithContextCallCount() int { + fake.tagQueueWithContextMutex.RLock() + defer fake.tagQueueWithContextMutex.RUnlock() + return len(fake.tagQueueWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) TagQueueWithContextArgsForCall(i int) (aws.Context, *sqs.TagQueueInput, []request.Option) { + fake.tagQueueWithContextMutex.RLock() + defer fake.tagQueueWithContextMutex.RUnlock() + return fake.tagQueueWithContextArgsForCall[i].arg1, fake.tagQueueWithContextArgsForCall[i].arg2, fake.tagQueueWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) TagQueueWithContextReturns(result1 *sqs.TagQueueOutput, result2 error) { + fake.TagQueueWithContextStub = nil + fake.tagQueueWithContextReturns = struct { + result1 *sqs.TagQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) TagQueueWithContextReturnsOnCall(i int, result1 *sqs.TagQueueOutput, result2 error) { + fake.TagQueueWithContextStub = nil + if fake.tagQueueWithContextReturnsOnCall == nil { + fake.tagQueueWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.TagQueueOutput + result2 error + }) + } + fake.tagQueueWithContextReturnsOnCall[i] = struct { + result1 *sqs.TagQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) TagQueueRequest(arg1 *sqs.TagQueueInput) (*request.Request, *sqs.TagQueueOutput) { + fake.tagQueueRequestMutex.Lock() + ret, specificReturn := fake.tagQueueRequestReturnsOnCall[len(fake.tagQueueRequestArgsForCall)] + fake.tagQueueRequestArgsForCall = append(fake.tagQueueRequestArgsForCall, struct { + arg1 *sqs.TagQueueInput + }{arg1}) + fake.recordInvocation("TagQueueRequest", []interface{}{arg1}) + fake.tagQueueRequestMutex.Unlock() + if fake.TagQueueRequestStub != nil { + return fake.TagQueueRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.tagQueueRequestReturns.result1, fake.tagQueueRequestReturns.result2 +} + +func (fake *FakeSQSAPI) TagQueueRequestCallCount() int { + fake.tagQueueRequestMutex.RLock() + defer fake.tagQueueRequestMutex.RUnlock() + return len(fake.tagQueueRequestArgsForCall) +} + +func (fake *FakeSQSAPI) TagQueueRequestArgsForCall(i int) *sqs.TagQueueInput { + fake.tagQueueRequestMutex.RLock() + defer fake.tagQueueRequestMutex.RUnlock() + return fake.tagQueueRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) TagQueueRequestReturns(result1 *request.Request, result2 *sqs.TagQueueOutput) { + fake.TagQueueRequestStub = nil + fake.tagQueueRequestReturns = struct { + result1 *request.Request + result2 *sqs.TagQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) TagQueueRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.TagQueueOutput) { + fake.TagQueueRequestStub = nil + if fake.tagQueueRequestReturnsOnCall == nil { + fake.tagQueueRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.TagQueueOutput + }) + } + fake.tagQueueRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.TagQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) UntagQueue(arg1 *sqs.UntagQueueInput) (*sqs.UntagQueueOutput, error) { + fake.untagQueueMutex.Lock() + ret, specificReturn := fake.untagQueueReturnsOnCall[len(fake.untagQueueArgsForCall)] + fake.untagQueueArgsForCall = append(fake.untagQueueArgsForCall, struct { + arg1 *sqs.UntagQueueInput + }{arg1}) + fake.recordInvocation("UntagQueue", []interface{}{arg1}) + fake.untagQueueMutex.Unlock() + if fake.UntagQueueStub != nil { + return fake.UntagQueueStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.untagQueueReturns.result1, fake.untagQueueReturns.result2 +} + +func (fake *FakeSQSAPI) UntagQueueCallCount() int { + fake.untagQueueMutex.RLock() + defer fake.untagQueueMutex.RUnlock() + return len(fake.untagQueueArgsForCall) +} + +func (fake *FakeSQSAPI) UntagQueueArgsForCall(i int) *sqs.UntagQueueInput { + fake.untagQueueMutex.RLock() + defer fake.untagQueueMutex.RUnlock() + return fake.untagQueueArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) UntagQueueReturns(result1 *sqs.UntagQueueOutput, result2 error) { + fake.UntagQueueStub = nil + fake.untagQueueReturns = struct { + result1 *sqs.UntagQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) UntagQueueReturnsOnCall(i int, result1 *sqs.UntagQueueOutput, result2 error) { + fake.UntagQueueStub = nil + if fake.untagQueueReturnsOnCall == nil { + fake.untagQueueReturnsOnCall = make(map[int]struct { + result1 *sqs.UntagQueueOutput + result2 error + }) + } + fake.untagQueueReturnsOnCall[i] = struct { + result1 *sqs.UntagQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) UntagQueueWithContext(arg1 aws.Context, arg2 *sqs.UntagQueueInput, arg3 ...request.Option) (*sqs.UntagQueueOutput, error) { + fake.untagQueueWithContextMutex.Lock() + ret, specificReturn := fake.untagQueueWithContextReturnsOnCall[len(fake.untagQueueWithContextArgsForCall)] + fake.untagQueueWithContextArgsForCall = append(fake.untagQueueWithContextArgsForCall, struct { + arg1 aws.Context + arg2 *sqs.UntagQueueInput + arg3 []request.Option + }{arg1, arg2, arg3}) + fake.recordInvocation("UntagQueueWithContext", []interface{}{arg1, arg2, arg3}) + fake.untagQueueWithContextMutex.Unlock() + if fake.UntagQueueWithContextStub != nil { + return fake.UntagQueueWithContextStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.untagQueueWithContextReturns.result1, fake.untagQueueWithContextReturns.result2 +} + +func (fake *FakeSQSAPI) UntagQueueWithContextCallCount() int { + fake.untagQueueWithContextMutex.RLock() + defer fake.untagQueueWithContextMutex.RUnlock() + return len(fake.untagQueueWithContextArgsForCall) +} + +func (fake *FakeSQSAPI) UntagQueueWithContextArgsForCall(i int) (aws.Context, *sqs.UntagQueueInput, []request.Option) { + fake.untagQueueWithContextMutex.RLock() + defer fake.untagQueueWithContextMutex.RUnlock() + return fake.untagQueueWithContextArgsForCall[i].arg1, fake.untagQueueWithContextArgsForCall[i].arg2, fake.untagQueueWithContextArgsForCall[i].arg3 +} + +func (fake *FakeSQSAPI) UntagQueueWithContextReturns(result1 *sqs.UntagQueueOutput, result2 error) { + fake.UntagQueueWithContextStub = nil + fake.untagQueueWithContextReturns = struct { + result1 *sqs.UntagQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) UntagQueueWithContextReturnsOnCall(i int, result1 *sqs.UntagQueueOutput, result2 error) { + fake.UntagQueueWithContextStub = nil + if fake.untagQueueWithContextReturnsOnCall == nil { + fake.untagQueueWithContextReturnsOnCall = make(map[int]struct { + result1 *sqs.UntagQueueOutput + result2 error + }) + } + fake.untagQueueWithContextReturnsOnCall[i] = struct { + result1 *sqs.UntagQueueOutput + result2 error + }{result1, result2} +} + +func (fake *FakeSQSAPI) UntagQueueRequest(arg1 *sqs.UntagQueueInput) (*request.Request, *sqs.UntagQueueOutput) { + fake.untagQueueRequestMutex.Lock() + ret, specificReturn := fake.untagQueueRequestReturnsOnCall[len(fake.untagQueueRequestArgsForCall)] + fake.untagQueueRequestArgsForCall = append(fake.untagQueueRequestArgsForCall, struct { + arg1 *sqs.UntagQueueInput + }{arg1}) + fake.recordInvocation("UntagQueueRequest", []interface{}{arg1}) + fake.untagQueueRequestMutex.Unlock() + if fake.UntagQueueRequestStub != nil { + return fake.UntagQueueRequestStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.untagQueueRequestReturns.result1, fake.untagQueueRequestReturns.result2 +} + +func (fake *FakeSQSAPI) UntagQueueRequestCallCount() int { + fake.untagQueueRequestMutex.RLock() + defer fake.untagQueueRequestMutex.RUnlock() + return len(fake.untagQueueRequestArgsForCall) +} + +func (fake *FakeSQSAPI) UntagQueueRequestArgsForCall(i int) *sqs.UntagQueueInput { + fake.untagQueueRequestMutex.RLock() + defer fake.untagQueueRequestMutex.RUnlock() + return fake.untagQueueRequestArgsForCall[i].arg1 +} + +func (fake *FakeSQSAPI) UntagQueueRequestReturns(result1 *request.Request, result2 *sqs.UntagQueueOutput) { + fake.UntagQueueRequestStub = nil + fake.untagQueueRequestReturns = struct { + result1 *request.Request + result2 *sqs.UntagQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) UntagQueueRequestReturnsOnCall(i int, result1 *request.Request, result2 *sqs.UntagQueueOutput) { + fake.UntagQueueRequestStub = nil + if fake.untagQueueRequestReturnsOnCall == nil { + fake.untagQueueRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *sqs.UntagQueueOutput + }) + } + fake.untagQueueRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *sqs.UntagQueueOutput + }{result1, result2} +} + +func (fake *FakeSQSAPI) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.addPermissionMutex.RLock() + defer fake.addPermissionMutex.RUnlock() + fake.addPermissionWithContextMutex.RLock() + defer fake.addPermissionWithContextMutex.RUnlock() + fake.addPermissionRequestMutex.RLock() + defer fake.addPermissionRequestMutex.RUnlock() + fake.changeMessageVisibilityMutex.RLock() + defer fake.changeMessageVisibilityMutex.RUnlock() + fake.changeMessageVisibilityWithContextMutex.RLock() + defer fake.changeMessageVisibilityWithContextMutex.RUnlock() + fake.changeMessageVisibilityRequestMutex.RLock() + defer fake.changeMessageVisibilityRequestMutex.RUnlock() + fake.changeMessageVisibilityBatchMutex.RLock() + defer fake.changeMessageVisibilityBatchMutex.RUnlock() + fake.changeMessageVisibilityBatchWithContextMutex.RLock() + defer fake.changeMessageVisibilityBatchWithContextMutex.RUnlock() + fake.changeMessageVisibilityBatchRequestMutex.RLock() + defer fake.changeMessageVisibilityBatchRequestMutex.RUnlock() + fake.createQueueMutex.RLock() + defer fake.createQueueMutex.RUnlock() + fake.createQueueWithContextMutex.RLock() + defer fake.createQueueWithContextMutex.RUnlock() + fake.createQueueRequestMutex.RLock() + defer fake.createQueueRequestMutex.RUnlock() + fake.deleteMessageMutex.RLock() + defer fake.deleteMessageMutex.RUnlock() + fake.deleteMessageWithContextMutex.RLock() + defer fake.deleteMessageWithContextMutex.RUnlock() + fake.deleteMessageRequestMutex.RLock() + defer fake.deleteMessageRequestMutex.RUnlock() + fake.deleteMessageBatchMutex.RLock() + defer fake.deleteMessageBatchMutex.RUnlock() + fake.deleteMessageBatchWithContextMutex.RLock() + defer fake.deleteMessageBatchWithContextMutex.RUnlock() + fake.deleteMessageBatchRequestMutex.RLock() + defer fake.deleteMessageBatchRequestMutex.RUnlock() + fake.deleteQueueMutex.RLock() + defer fake.deleteQueueMutex.RUnlock() + fake.deleteQueueWithContextMutex.RLock() + defer fake.deleteQueueWithContextMutex.RUnlock() + fake.deleteQueueRequestMutex.RLock() + defer fake.deleteQueueRequestMutex.RUnlock() + fake.getQueueAttributesMutex.RLock() + defer fake.getQueueAttributesMutex.RUnlock() + fake.getQueueAttributesWithContextMutex.RLock() + defer fake.getQueueAttributesWithContextMutex.RUnlock() + fake.getQueueAttributesRequestMutex.RLock() + defer fake.getQueueAttributesRequestMutex.RUnlock() + fake.getQueueUrlMutex.RLock() + defer fake.getQueueUrlMutex.RUnlock() + fake.getQueueUrlWithContextMutex.RLock() + defer fake.getQueueUrlWithContextMutex.RUnlock() + fake.getQueueUrlRequestMutex.RLock() + defer fake.getQueueUrlRequestMutex.RUnlock() + fake.listDeadLetterSourceQueuesMutex.RLock() + defer fake.listDeadLetterSourceQueuesMutex.RUnlock() + fake.listDeadLetterSourceQueuesWithContextMutex.RLock() + defer fake.listDeadLetterSourceQueuesWithContextMutex.RUnlock() + fake.listDeadLetterSourceQueuesRequestMutex.RLock() + defer fake.listDeadLetterSourceQueuesRequestMutex.RUnlock() + fake.listQueueTagsMutex.RLock() + defer fake.listQueueTagsMutex.RUnlock() + fake.listQueueTagsWithContextMutex.RLock() + defer fake.listQueueTagsWithContextMutex.RUnlock() + fake.listQueueTagsRequestMutex.RLock() + defer fake.listQueueTagsRequestMutex.RUnlock() + fake.listQueuesMutex.RLock() + defer fake.listQueuesMutex.RUnlock() + fake.listQueuesWithContextMutex.RLock() + defer fake.listQueuesWithContextMutex.RUnlock() + fake.listQueuesRequestMutex.RLock() + defer fake.listQueuesRequestMutex.RUnlock() + fake.purgeQueueMutex.RLock() + defer fake.purgeQueueMutex.RUnlock() + fake.purgeQueueWithContextMutex.RLock() + defer fake.purgeQueueWithContextMutex.RUnlock() + fake.purgeQueueRequestMutex.RLock() + defer fake.purgeQueueRequestMutex.RUnlock() + fake.receiveMessageMutex.RLock() + defer fake.receiveMessageMutex.RUnlock() + fake.receiveMessageWithContextMutex.RLock() + defer fake.receiveMessageWithContextMutex.RUnlock() + fake.receiveMessageRequestMutex.RLock() + defer fake.receiveMessageRequestMutex.RUnlock() + fake.removePermissionMutex.RLock() + defer fake.removePermissionMutex.RUnlock() + fake.removePermissionWithContextMutex.RLock() + defer fake.removePermissionWithContextMutex.RUnlock() + fake.removePermissionRequestMutex.RLock() + defer fake.removePermissionRequestMutex.RUnlock() + fake.sendMessageMutex.RLock() + defer fake.sendMessageMutex.RUnlock() + fake.sendMessageWithContextMutex.RLock() + defer fake.sendMessageWithContextMutex.RUnlock() + fake.sendMessageRequestMutex.RLock() + defer fake.sendMessageRequestMutex.RUnlock() + fake.sendMessageBatchMutex.RLock() + defer fake.sendMessageBatchMutex.RUnlock() + fake.sendMessageBatchWithContextMutex.RLock() + defer fake.sendMessageBatchWithContextMutex.RUnlock() + fake.sendMessageBatchRequestMutex.RLock() + defer fake.sendMessageBatchRequestMutex.RUnlock() + fake.setQueueAttributesMutex.RLock() + defer fake.setQueueAttributesMutex.RUnlock() + fake.setQueueAttributesWithContextMutex.RLock() + defer fake.setQueueAttributesWithContextMutex.RUnlock() + fake.setQueueAttributesRequestMutex.RLock() + defer fake.setQueueAttributesRequestMutex.RUnlock() + fake.tagQueueMutex.RLock() + defer fake.tagQueueMutex.RUnlock() + fake.tagQueueWithContextMutex.RLock() + defer fake.tagQueueWithContextMutex.RUnlock() + fake.tagQueueRequestMutex.RLock() + defer fake.tagQueueRequestMutex.RUnlock() + fake.untagQueueMutex.RLock() + defer fake.untagQueueMutex.RUnlock() + fake.untagQueueWithContextMutex.RLock() + defer fake.untagQueueWithContextMutex.RUnlock() + fake.untagQueueRequestMutex.RLock() + defer fake.untagQueueRequestMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeSQSAPI) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ sqsiface.SQSAPI = new(FakeSQSAPI) From 594a09c91f175fd2e16b3121b1f43e0912602e73 Mon Sep 17 00:00:00 2001 From: jsteenb2 Date: Thu, 21 Jun 2018 09:43:51 -0700 Subject: [PATCH 2/2] add mutli writer for sqs publishing --- queues/sqs/multi_writer.go | 384 ++++++++++++++++++++++++++++++++ queues/sqs/multi_writer_test.go | 129 +++++++++++ 2 files changed, 513 insertions(+) create mode 100644 queues/sqs/multi_writer.go create mode 100644 queues/sqs/multi_writer_test.go diff --git a/queues/sqs/multi_writer.go b/queues/sqs/multi_writer.go new file mode 100644 index 0000000..9d20630 --- /dev/null +++ b/queues/sqs/multi_writer.go @@ -0,0 +1,384 @@ +package sqs + +import ( + "fmt" + "sync" + "time" + + "github.com/matryer/vice" + + "github.com/aws/aws-sdk-go/aws" + "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" +) + +// MultiTransport is a vice.Transport for Amazon's SQS +type MultiTransport struct { + writers int + batchSize int + batchInterval time.Duration + + wg sync.WaitGroup + + sm sync.Mutex + sendChans map[string]chan []byte + + rm sync.Mutex + receiveChans map[string]chan []byte + + errChan chan error + stopchan chan struct{} + stopPubChan chan struct{} + stopSubChan chan struct{} + + NewService func(region string) (sqsiface.SQSAPI, error) +} + +var _ vice.Transport = (*MultiTransport)(nil) + +// NewMulti returns a new transport with multiple sqs writers +// Credentials are automatically sourced using the AWS SDK credential chain, +// for more info see the AWS SDK docs: +// https://godoc.org/github.com/aws/aws-sdk-go#hdr-Configuring_Credentials +func NewMulti(writers, batchSize int, batchInterval time.Duration) *MultiTransport { + const defaultWriter = 2 + if writers == 0 { + writers = defaultWriter + } + + const maxBatchSize = 10 + if batchSize > 10 { + batchSize = maxBatchSize + } + + const defaultInterval = 200 * time.Millisecond + if batchInterval == 0 { + batchInterval = defaultInterval + } + + return &MultiTransport{ + writers: writers, + batchSize: batchSize, + batchInterval: batchInterval, + sendChans: make(map[string]chan []byte), + receiveChans: make(map[string]chan []byte), + errChan: make(chan error, 10), + stopchan: make(chan struct{}), + stopPubChan: make(chan struct{}), + stopSubChan: make(chan struct{}), + + NewService: func(region string) (sqsiface.SQSAPI, error) { + awsConfig := aws.NewConfig().WithRegion(region) + s, err := session.NewSession(awsConfig) + if err != nil { + return nil, err + } + return sqs.New(s), nil + }, + } +} + +// Receive gets a channel on which to receive messages +// with the specified name. The name is the queue's url +func (t *MultiTransport) Receive(name string) <-chan []byte { + t.rm.Lock() + defer t.rm.Unlock() + + ch, ok := t.receiveChans[name] + if ok { + return ch + } + + ch, err := t.makeSubscriber(name) + if err != nil { + t.errChan <- vice.Err{Name: name, Err: err} + return make(chan []byte) + } + + t.receiveChans[name] = ch + return ch +} + +func (t *MultiTransport) makeSubscriber(name string) (chan []byte, error) { + region := RegionFromURL(name) + svc, err := t.NewService(region) + if err != nil { + return nil, err + } + + ch := make(chan []byte, 1024) + + params := &sqs.ReceiveMessageInput{ + QueueUrl: aws.String(name), + MaxNumberOfMessages: aws.Int64(1), + VisibilityTimeout: aws.Int64(1), + WaitTimeSeconds: aws.Int64(1), + } + + go func() { + for { + select { + case <-t.stopSubChan: + return + default: + resp, err := svc.ReceiveMessage(params) + if err != nil { + t.errChan <- vice.Err{Name: name, Err: err} + continue + } + + if len(resp.Messages) > 0 { + for _, m := range resp.Messages { + if m.ReceiptHandle != nil { + delParams := &sqs.DeleteMessageInput{ + QueueUrl: aws.String(name), + ReceiptHandle: aws.String(*m.ReceiptHandle), + } + _, err := svc.DeleteMessage(delParams) + if err != nil { + t.errChan <- vice.Err{Name: name, Err: err} + continue + } + } + ch <- []byte(*m.Body) + } + } + } + } + }() + return ch, nil +} + +// Send gets a channel on which messages with the +// specified name may be sent. The name is the queue's +// URL +func (t *MultiTransport) Send(name string) chan<- []byte { + t.sm.Lock() + defer t.sm.Unlock() + + ch, ok := t.sendChans[name] + if ok { + return ch + } + + ch, err := t.makePublishers(name) + if err != nil { + t.errChan <- vice.Err{Name: name, Err: err} + return make(chan []byte) + } + + t.sendChans[name] = ch + return ch +} + +// makePublishers creates t.writers of writers to make outgoing requests to the +// SQS queue. This scales horizontally as doing single publisher is very limited. +// This method will create the publishers and use the first available publisher +// that is not making a send to SQS. If all are active then it will fallback block. +// The sends to SQS are now done concurrently as well to remove the sends from the +// critical path. This is ideal as we are able to increase throughput and still +// maintain the error channel to share errors with downstream components. +func (t *MultiTransport) makePublishers(name string) (chan []byte, error) { + region := RegionFromURL(name) + + queue := make(chan writerMsg) + err := newWriterGroup(t.writers, t.stopchan, t.errChan, queue, t.NewService, region) + if err != nil { + return nil, err + } + + ch := make(chan []byte, 1024) + + t.wg.Add(1) + go func() { + defer t.wg.Done() + var accum sendMsgBatch + + defer func() { + if len(accum) == 0 { + return + } + queue <- writerMsg{batch: accum, name: name} + time.Sleep(50 * time.Millisecond) + }() + + for { + select { + case <-t.stopPubChan: + if len(ch) != 0 { + continue + } + return + case msg := <-ch: + id := fmt.Sprintf("%d", time.Now().UnixNano()) + accum = append(accum, sqs.SendMessageBatchRequestEntry{ + MessageBody: aws.String(string(msg)), + Id: aws.String(id), + }) + + if t.batchSize == 0 { + tmp := make(sendMsgBatch, len(accum)) + copy(tmp, accum) + queue <- writerMsg{batch: tmp, name: name} + accum = make(sendMsgBatch, 0, t.batchSize) + continue + } + + if len(accum) < t.batchSize { + continue + } + + tmp := make(sendMsgBatch, len(accum)) + copy(tmp, accum) + queue <- writerMsg{batch: tmp, name: name} + accum = make(sendMsgBatch, 0, t.batchSize) + case <-time.After(t.batchInterval): + if t.batchSize == 0 || len(accum) == 0 { + continue + } + + tmp := make(sendMsgBatch, len(accum)) + copy(tmp, accum) + queue <- writerMsg{batch: tmp, name: name} + accum = make(sendMsgBatch, 0, t.batchSize) + } + } + }() + + return ch, nil +} + +// ErrChan gets the channel on which errors are sent. +func (t *MultiTransport) ErrChan() <-chan error { + return t.errChan +} + +// Stop stops the transport. +// The channel returned from Done() will be closed +// when the transport has stopped. +func (t *MultiTransport) Stop() { + close(t.stopSubChan) + close(t.stopPubChan) + t.wg.Wait() + close(t.stopchan) +} + +// Done gets a channel which is closed when the +// transport has successfully stopped. +func (t *MultiTransport) Done() chan struct{} { + return t.stopchan +} + +type sendMsgBatch []sqs.SendMessageBatchRequestEntry + +type writerMsg struct { + batch sendMsgBatch + name string +} + +type newServiceFn func(region string) (sqsiface.SQSAPI, error) + +func newWriterGroup(n int, done <-chan struct{}, errChan chan<- error, queue <-chan writerMsg, newSVCFn newServiceFn, region string) error { + var svcs []sqsiface.SQSAPI + for i := 0; i < n; i++ { + svc, err := newSVCFn(region) + if err != nil { + return err + } + svcs = append(svcs, svc) + } + + workerQueue := make(chan chan writerMsg, n) + for i := range svcs { + w := newWriter(svcs[i], done, errChan, workerQueue) + w.Start() + } + + go func() { + for work := range queue { + select { + case <-done: + return + default: + worker := <-workerQueue + worker <- work + } + } + }() + + return nil +} + +type svcWriter struct { + svc sqsiface.SQSAPI + work chan writerMsg + workerQueue chan chan writerMsg + done <-chan struct{} + errChan chan<- error +} + +func newWriter(svc sqsiface.SQSAPI, done <-chan struct{}, errChan chan<- error, workerQueue chan chan writerMsg) *svcWriter { + return &svcWriter{ + svc: svc, + work: make(chan writerMsg), + workerQueue: workerQueue, + done: done, + errChan: errChan, + } +} + +func (s *svcWriter) Start() { + go func() { + for { + s.workerQueue <- s.work + + select { + case <-s.done: + return + case w := <-s.work: + if len(w.batch) == 1 { + s.sendMessage(w.name, w.batch[0]) + continue + } + s.sendBatch(w.name, w.batch) + } + } + }() +} + +func (s *svcWriter) sendMessage(name string, msg sqs.SendMessageBatchRequestEntry) { + _, err := s.svc.SendMessage(&sqs.SendMessageInput{ + MessageBody: msg.MessageBody, + QueueUrl: aws.String(name), + }) + if err != nil { + s.errChan <- vice.Err{Message: []byte(*msg.MessageBody), Name: name, Err: err} + } +} + +func (s *svcWriter) sendBatch(name string, batch sendMsgBatch) { + if len(batch) == 0 { + return + } + + entryPtrs := make([]*sqs.SendMessageBatchRequestEntry, len(batch)) + for i := range batch { + entryPtrs[i] = &batch[i] + } + + batchParams := &sqs.SendMessageBatchInput{ + Entries: entryPtrs, + QueueUrl: aws.String(name), + } + + resp, err := s.svc.SendMessageBatch(batchParams) + if err != nil { + s.errChan <- vice.Err{Name: name, Err: err} + return + } + + for _, v := range resp.Failed { + s.errChan <- vice.Err{Name: name, Err: fmt.Errorf("%s", *v.Message)} + } +} diff --git a/queues/sqs/multi_writer_test.go b/queues/sqs/multi_writer_test.go new file mode 100644 index 0000000..212ad38 --- /dev/null +++ b/queues/sqs/multi_writer_test.go @@ -0,0 +1,129 @@ +package sqs + +import ( + "strconv" + "testing" + "time" + + "github.com/matryer/vice" + "github.com/matryer/vice/queues/sqs/sqsfakes" + "github.com/matryer/vice/vicetest" + + "github.com/aws/aws-sdk-go/service/sqs" + "github.com/aws/aws-sdk-go/service/sqs/sqsiface" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestMultiTransport(t *testing.T) { + svc := &mockSQSClient{ + chs: make(map[string]chan string), + finish: make(chan bool), + } + + newT := func() vice.Transport { + transport := NewMulti(1, 0, 10*time.Second) + transport.NewService = func(region string) (sqsiface.SQSAPI, error) { + return svc, nil + } + + return transport + } + + vicetest.Transport(t, newT) + close(svc.finish) +} + +func Test_MultiTransport_SingleWriterBatchesWrites(t *testing.T) { + newTransport := NewMulti(1, 10, 1000*time.Millisecond) + svc := new(sqsfakes.FakeSQSAPI) + svc.SendMessageBatchReturns(&sqs.SendMessageBatchOutput{}, nil) + newTransport.NewService = func(region string) (sqsiface.SQSAPI, error) { return svc, nil } + + stream := newTransport.Send("svcWriter") + for i := 0; i < 30; i++ { + stream <- []byte(strconv.Itoa(i)) + } + time.Sleep(100 * time.Millisecond) + require.Equal(t, 3, svc.SendMessageBatchCallCount()) + + batch0 := svc.SendMessageBatchArgsForCall(0) + require.Equal(t, 10, len(batch0.Entries)) + for i := 0; i < 10; i++ { + assert.Contains(t, *batch0.Entries[i].MessageBody, strconv.Itoa(i)) + } + + batch1 := svc.SendMessageBatchArgsForCall(1) + require.Equal(t, 10, len(batch1.Entries)) + for i := 0; i < 10; i++ { + assert.Contains(t, *batch1.Entries[i].MessageBody, strconv.Itoa(i)) + } + + batch2 := svc.SendMessageBatchArgsForCall(2) + require.Equal(t, 10, len(batch2.Entries)) + for i := 0; i < 10; i++ { + assert.Contains(t, *batch2.Entries[i].MessageBody, strconv.Itoa(i)) + } +} + +func Test_MultiTransport_SingleWriterBatchFlushesOnReturn(t *testing.T) { + newTransport := NewMulti(1, 10, 1000*time.Millisecond) + svc := new(sqsfakes.FakeSQSAPI) + svc.SendMessageBatchReturns(&sqs.SendMessageBatchOutput{}, nil) + newTransport.NewService = func(region string) (sqsiface.SQSAPI, error) { return svc, nil } + + stream := newTransport.Send("svcWriter") + for i := 0; i < 9; i++ { + stream <- []byte(strconv.Itoa(i)) + } + time.Sleep(100 * time.Millisecond) + newTransport.Stop() + + time.Sleep(200 * time.Millisecond) + + require.Equal(t, 1, svc.SendMessageBatchCallCount()) + + batch0 := svc.SendMessageBatchArgsForCall(0) + require.Equal(t, 9, len(batch0.Entries)) + for i := 0; i < 9; i++ { + assert.Equal(t, strconv.Itoa(i), *batch0.Entries[i].MessageBody) + } +} + +func Test_MultiTransport_MultipleWritersBatchesWrites(t *testing.T) { + newTransport := NewMulti(3, 10, 1000*time.Millisecond) + var svcs []*sqsfakes.FakeSQSAPI + for i := 0; i < 3; i++ { + svc := new(sqsfakes.FakeSQSAPI) + svc.SendMessageBatchStub = func(input *sqs.SendMessageBatchInput) (*sqs.SendMessageBatchOutput, error) { + time.Sleep(200 * time.Millisecond) + return &sqs.SendMessageBatchOutput{}, nil + } + svcs = append(svcs, svc) + } + + var numWriters int + newTransport.NewService = func(region string) (sqsiface.SQSAPI, error) { + svc := svcs[numWriters] + numWriters++ + return svc, nil + } + + stream := newTransport.Send("svcWriter") + for i := 0; i < 30; i++ { + stream <- []byte(strconv.Itoa(i)) + } + time.Sleep(100 * time.Millisecond) + + require.Equal(t, 3, numWriters) + + for i := 0; i < 3; i++ { + svc := svcs[i] + require.Equal(t, 1, svc.SendMessageBatchCallCount()) + batch := svc.SendMessageBatchArgsForCall(0) + require.Equal(t, 10, len(batch.Entries)) + for j := 0; j < 10; j++ { + assert.Contains(t, *batch.Entries[j].MessageBody, strconv.Itoa(j)) + } + } +}