fake_producer.go

// Code generated by counterfeiter. DO NOT EDIT.
package pulsarfakes

import (
	"context"
	"sync"

	"github.com/apache/pulsar-client-go/pulsar"
)

type FakeProducer struct {
	CloseStub        func()
	closeMutex       sync.RWMutex
	closeArgsForCall []struct {
	}
	FlushStub        func() error
	flushMutex       sync.RWMutex
	flushArgsForCall []struct {
	}
	flushReturns struct {
		result1 error
	}
	flushReturnsOnCall map[int]struct {
		result1 error
	}
	LastSequenceIDStub        func() int64
	lastSequenceIDMutex       sync.RWMutex
	lastSequenceIDArgsForCall []struct {
	}
	lastSequenceIDReturns struct {
		result1 int64
	}
	lastSequenceIDReturnsOnCall map[int]struct {
		result1 int64
	}
	NameStub        func() string
	nameMutex       sync.RWMutex
	nameArgsForCall []struct {
	}
	nameReturns struct {
		result1 string
	}
	nameReturnsOnCall map[int]struct {
		result1 string
	}
	SendStub        func(context.Context, *pulsar.ProducerMessage) (pulsar.MessageID, error)
	sendMutex       sync.RWMutex
	sendArgsForCall []struct {
		arg1 context.Context
		arg2 *pulsar.ProducerMessage
	}
	sendReturns struct {
		result1 pulsar.MessageID
		result2 error
	}
	sendReturnsOnCall map[int]struct {
		result1 pulsar.MessageID
		result2 error
	}
	SendAsyncStub        func(context.Context, *pulsar.ProducerMessage, func(pulsar.MessageID, *pulsar.ProducerMessage, error))
	sendAsyncMutex       sync.RWMutex
	sendAsyncArgsForCall []struct {
		arg1 context.Context
		arg2 *pulsar.ProducerMessage
		arg3 func(pulsar.MessageID, *pulsar.ProducerMessage, error)
	}
	TopicStub        func() string
	topicMutex       sync.RWMutex
	topicArgsForCall []struct {
	}
	topicReturns struct {
		result1 string
	}
	topicReturnsOnCall map[int]struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeProducer) Close() {
	fake.closeMutex.Lock()
	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
	}{})
	stub := fake.CloseStub
	fake.recordInvocation("Close", []interface{}{})
	fake.closeMutex.Unlock()
	if stub != nil {
		fake.CloseStub()
	}
}

func (fake *FakeProducer) CloseCallCount() int {
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	return len(fake.closeArgsForCall)
}

func (fake *FakeProducer) CloseCalls(stub func()) {
	fake.closeMutex.Lock()
	defer fake.closeMutex.Unlock()
	fake.CloseStub = stub
}

func (fake *FakeProducer) Flush() error {
	fake.flushMutex.Lock()
	ret, specificReturn := fake.flushReturnsOnCall[len(fake.flushArgsForCall)]
	fake.flushArgsForCall = append(fake.flushArgsForCall, struct {
	}{})
	stub := fake.FlushStub
	fakeReturns := fake.flushReturns
	fake.recordInvocation("Flush", []interface{}{})
	fake.flushMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProducer) FlushCallCount() int {
	fake.flushMutex.RLock()
	defer fake.flushMutex.RUnlock()
	return len(fake.flushArgsForCall)
}

func (fake *FakeProducer) FlushCalls(stub func() error) {
	fake.flushMutex.Lock()
	defer fake.flushMutex.Unlock()
	fake.FlushStub = stub
}

func (fake *FakeProducer) FlushReturns(result1 error) {
	fake.flushMutex.Lock()
	defer fake.flushMutex.Unlock()
	fake.FlushStub = nil
	fake.flushReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeProducer) FlushReturnsOnCall(i int, result1 error) {
	fake.flushMutex.Lock()
	defer fake.flushMutex.Unlock()
	fake.FlushStub = nil
	if fake.flushReturnsOnCall == nil {
		fake.flushReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.flushReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeProducer) LastSequenceID() int64 {
	fake.lastSequenceIDMutex.Lock()
	ret, specificReturn := fake.lastSequenceIDReturnsOnCall[len(fake.lastSequenceIDArgsForCall)]
	fake.lastSequenceIDArgsForCall = append(fake.lastSequenceIDArgsForCall, struct {
	}{})
	stub := fake.LastSequenceIDStub
	fakeReturns := fake.lastSequenceIDReturns
	fake.recordInvocation("LastSequenceID", []interface{}{})
	fake.lastSequenceIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProducer) LastSequenceIDCallCount() int {
	fake.lastSequenceIDMutex.RLock()
	defer fake.lastSequenceIDMutex.RUnlock()
	return len(fake.lastSequenceIDArgsForCall)
}

func (fake *FakeProducer) LastSequenceIDCalls(stub func() int64) {
	fake.lastSequenceIDMutex.Lock()
	defer fake.lastSequenceIDMutex.Unlock()
	fake.LastSequenceIDStub = stub
}

func (fake *FakeProducer) LastSequenceIDReturns(result1 int64) {
	fake.lastSequenceIDMutex.Lock()
	defer fake.lastSequenceIDMutex.Unlock()
	fake.LastSequenceIDStub = nil
	fake.lastSequenceIDReturns = struct {
		result1 int64
	}{result1}
}

func (fake *FakeProducer) LastSequenceIDReturnsOnCall(i int, result1 int64) {
	fake.lastSequenceIDMutex.Lock()
	defer fake.lastSequenceIDMutex.Unlock()
	fake.LastSequenceIDStub = nil
	if fake.lastSequenceIDReturnsOnCall == nil {
		fake.lastSequenceIDReturnsOnCall = make(map[int]struct {
			result1 int64
		})
	}
	fake.lastSequenceIDReturnsOnCall[i] = struct {
		result1 int64
	}{result1}
}

func (fake *FakeProducer) Name() string {
	fake.nameMutex.Lock()
	ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)]
	fake.nameArgsForCall = append(fake.nameArgsForCall, struct {
	}{})
	stub := fake.NameStub
	fakeReturns := fake.nameReturns
	fake.recordInvocation("Name", []interface{}{})
	fake.nameMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProducer) NameCallCount() int {
	fake.nameMutex.RLock()
	defer fake.nameMutex.RUnlock()
	return len(fake.nameArgsForCall)
}

func (fake *FakeProducer) NameCalls(stub func() string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = stub
}

func (fake *FakeProducer) NameReturns(result1 string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = nil
	fake.nameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProducer) NameReturnsOnCall(i int, result1 string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = nil
	if fake.nameReturnsOnCall == nil {
		fake.nameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.nameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProducer) Send(arg1 context.Context, arg2 *pulsar.ProducerMessage) (pulsar.MessageID, error) {
	fake.sendMutex.Lock()
	ret, specificReturn := fake.sendReturnsOnCall[len(fake.sendArgsForCall)]
	fake.sendArgsForCall = append(fake.sendArgsForCall, struct {
		arg1 context.Context
		arg2 *pulsar.ProducerMessage
	}{arg1, arg2})
	stub := fake.SendStub
	fakeReturns := fake.sendReturns
	fake.recordInvocation("Send", []interface{}{arg1, arg2})
	fake.sendMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeProducer) SendCallCount() int {
	fake.sendMutex.RLock()
	defer fake.sendMutex.RUnlock()
	return len(fake.sendArgsForCall)
}

func (fake *FakeProducer) SendCalls(stub func(context.Context, *pulsar.ProducerMessage) (pulsar.MessageID, error)) {
	fake.sendMutex.Lock()
	defer fake.sendMutex.Unlock()
	fake.SendStub = stub
}

func (fake *FakeProducer) SendArgsForCall(i int) (context.Context, *pulsar.ProducerMessage) {
	fake.sendMutex.RLock()
	defer fake.sendMutex.RUnlock()
	argsForCall := fake.sendArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeProducer) SendReturns(result1 pulsar.MessageID, result2 error) {
	fake.sendMutex.Lock()
	defer fake.sendMutex.Unlock()
	fake.SendStub = nil
	fake.sendReturns = struct {
		result1 pulsar.MessageID
		result2 error
	}{result1, result2}
}

func (fake *FakeProducer) SendReturnsOnCall(i int, result1 pulsar.MessageID, result2 error) {
	fake.sendMutex.Lock()
	defer fake.sendMutex.Unlock()
	fake.SendStub = nil
	if fake.sendReturnsOnCall == nil {
		fake.sendReturnsOnCall = make(map[int]struct {
			result1 pulsar.MessageID
			result2 error
		})
	}
	fake.sendReturnsOnCall[i] = struct {
		result1 pulsar.MessageID
		result2 error
	}{result1, result2}
}

func (fake *FakeProducer) SendAsync(arg1 context.Context, arg2 *pulsar.ProducerMessage, arg3 func(pulsar.MessageID, *pulsar.ProducerMessage, error)) {
	fake.sendAsyncMutex.Lock()
	fake.sendAsyncArgsForCall = append(fake.sendAsyncArgsForCall, struct {
		arg1 context.Context
		arg2 *pulsar.ProducerMessage
		arg3 func(pulsar.MessageID, *pulsar.ProducerMessage, error)
	}{arg1, arg2, arg3})
	stub := fake.SendAsyncStub
	fake.recordInvocation("SendAsync", []interface{}{arg1, arg2, arg3})
	fake.sendAsyncMutex.Unlock()
	if stub != nil {
		fake.SendAsyncStub(arg1, arg2, arg3)
	}
}

func (fake *FakeProducer) SendAsyncCallCount() int {
	fake.sendAsyncMutex.RLock()
	defer fake.sendAsyncMutex.RUnlock()
	return len(fake.sendAsyncArgsForCall)
}

func (fake *FakeProducer) SendAsyncCalls(stub func(context.Context, *pulsar.ProducerMessage, func(pulsar.MessageID, *pulsar.ProducerMessage, error))) {
	fake.sendAsyncMutex.Lock()
	defer fake.sendAsyncMutex.Unlock()
	fake.SendAsyncStub = stub
}

func (fake *FakeProducer) SendAsyncArgsForCall(i int) (context.Context, *pulsar.ProducerMessage, func(pulsar.MessageID, *pulsar.ProducerMessage, error)) {
	fake.sendAsyncMutex.RLock()
	defer fake.sendAsyncMutex.RUnlock()
	argsForCall := fake.sendAsyncArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeProducer) Topic() string {
	fake.topicMutex.Lock()
	ret, specificReturn := fake.topicReturnsOnCall[len(fake.topicArgsForCall)]
	fake.topicArgsForCall = append(fake.topicArgsForCall, struct {
	}{})
	stub := fake.TopicStub
	fakeReturns := fake.topicReturns
	fake.recordInvocation("Topic", []interface{}{})
	fake.topicMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProducer) TopicCallCount() int {
	fake.topicMutex.RLock()
	defer fake.topicMutex.RUnlock()
	return len(fake.topicArgsForCall)
}

func (fake *FakeProducer) TopicCalls(stub func() string) {
	fake.topicMutex.Lock()
	defer fake.topicMutex.Unlock()
	fake.TopicStub = stub
}

func (fake *FakeProducer) TopicReturns(result1 string) {
	fake.topicMutex.Lock()
	defer fake.topicMutex.Unlock()
	fake.TopicStub = nil
	fake.topicReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProducer) TopicReturnsOnCall(i int, result1 string) {
	fake.topicMutex.Lock()
	defer fake.topicMutex.Unlock()
	fake.TopicStub = nil
	if fake.topicReturnsOnCall == nil {
		fake.topicReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.topicReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProducer) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	fake.flushMutex.RLock()
	defer fake.flushMutex.RUnlock()
	fake.lastSequenceIDMutex.RLock()
	defer fake.lastSequenceIDMutex.RUnlock()
	fake.nameMutex.RLock()
	defer fake.nameMutex.RUnlock()
	fake.sendMutex.RLock()
	defer fake.sendMutex.RUnlock()
	fake.sendAsyncMutex.RLock()
	defer fake.sendAsyncMutex.RUnlock()
	fake.topicMutex.RLock()
	defer fake.topicMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeProducer) 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 _ pulsar.Producer = new(FakeProducer)