sarama.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/Shopify/sarama (interfaces: Client,Consumer,PartitionConsumer)

// Package mock is a generated GoMock package.
package mock

import (
	sarama "github.com/Shopify/sarama"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockClient is a mock of Client interface
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockClient) EXPECT() *MockClientMockRecorder {
	return m.recorder
}

// Brokers mocks base method
func (m *MockClient) Brokers() []*sarama.Broker {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Brokers")
	ret0, _ := ret[0].([]*sarama.Broker)
	return ret0
}

// Brokers indicates an expected call of Brokers
func (mr *MockClientMockRecorder) Brokers() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Brokers", reflect.TypeOf((*MockClient)(nil).Brokers))
}

// Close mocks base method
func (m *MockClient) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockClientMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close))
}

// Closed mocks base method
func (m *MockClient) Closed() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Closed")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Closed indicates an expected call of Closed
func (mr *MockClientMockRecorder) Closed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Closed", reflect.TypeOf((*MockClient)(nil).Closed))
}

// Config mocks base method
func (m *MockClient) Config() *sarama.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Config")
	ret0, _ := ret[0].(*sarama.Config)
	return ret0
}

// Config indicates an expected call of Config
func (mr *MockClientMockRecorder) Config() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Config", reflect.TypeOf((*MockClient)(nil).Config))
}

// Controller mocks base method
func (m *MockClient) Controller() (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Controller")
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Controller indicates an expected call of Controller
func (mr *MockClientMockRecorder) Controller() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Controller", reflect.TypeOf((*MockClient)(nil).Controller))
}

// Coordinator mocks base method
func (m *MockClient) Coordinator(arg0 string) (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Coordinator", arg0)
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Coordinator indicates an expected call of Coordinator
func (mr *MockClientMockRecorder) Coordinator(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Coordinator", reflect.TypeOf((*MockClient)(nil).Coordinator), arg0)
}

// GetOffset mocks base method
func (m *MockClient) GetOffset(arg0 string, arg1 int32, arg2 int64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOffset", arg0, arg1, arg2)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOffset indicates an expected call of GetOffset
func (mr *MockClientMockRecorder) GetOffset(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOffset", reflect.TypeOf((*MockClient)(nil).GetOffset), arg0, arg1, arg2)
}

// InSyncReplicas mocks base method
func (m *MockClient) InSyncReplicas(arg0 string, arg1 int32) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InSyncReplicas", arg0, arg1)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InSyncReplicas indicates an expected call of InSyncReplicas
func (mr *MockClientMockRecorder) InSyncReplicas(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InSyncReplicas", reflect.TypeOf((*MockClient)(nil).InSyncReplicas), arg0, arg1)
}

// InitProducerID mocks base method
func (m *MockClient) InitProducerID() (*sarama.InitProducerIDResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitProducerID")
	ret0, _ := ret[0].(*sarama.InitProducerIDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InitProducerID indicates an expected call of InitProducerID
func (mr *MockClientMockRecorder) InitProducerID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitProducerID", reflect.TypeOf((*MockClient)(nil).InitProducerID))
}

// Leader mocks base method
func (m *MockClient) Leader(arg0 string, arg1 int32) (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Leader", arg0, arg1)
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Leader indicates an expected call of Leader
func (mr *MockClientMockRecorder) Leader(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Leader", reflect.TypeOf((*MockClient)(nil).Leader), arg0, arg1)
}

// OfflineReplicas mocks base method
func (m *MockClient) OfflineReplicas(arg0 string, arg1 int32) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OfflineReplicas", arg0, arg1)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OfflineReplicas indicates an expected call of OfflineReplicas
func (mr *MockClientMockRecorder) OfflineReplicas(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OfflineReplicas", reflect.TypeOf((*MockClient)(nil).OfflineReplicas), arg0, arg1)
}

// Partitions mocks base method
func (m *MockClient) Partitions(arg0 string) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Partitions", arg0)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Partitions indicates an expected call of Partitions
func (mr *MockClientMockRecorder) Partitions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Partitions", reflect.TypeOf((*MockClient)(nil).Partitions), arg0)
}

// RefreshCoordinator mocks base method
func (m *MockClient) RefreshCoordinator(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshCoordinator", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshCoordinator indicates an expected call of RefreshCoordinator
func (mr *MockClientMockRecorder) RefreshCoordinator(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshCoordinator", reflect.TypeOf((*MockClient)(nil).RefreshCoordinator), arg0)
}

// RefreshMetadata mocks base method
func (m *MockClient) RefreshMetadata(arg0 ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RefreshMetadata", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshMetadata indicates an expected call of RefreshMetadata
func (mr *MockClientMockRecorder) RefreshMetadata(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshMetadata", reflect.TypeOf((*MockClient)(nil).RefreshMetadata), arg0...)
}

// Replicas mocks base method
func (m *MockClient) Replicas(arg0 string, arg1 int32) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Replicas", arg0, arg1)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Replicas indicates an expected call of Replicas
func (mr *MockClientMockRecorder) Replicas(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replicas", reflect.TypeOf((*MockClient)(nil).Replicas), arg0, arg1)
}

// Topics mocks base method
func (m *MockClient) Topics() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Topics")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Topics indicates an expected call of Topics
func (mr *MockClientMockRecorder) Topics() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Topics", reflect.TypeOf((*MockClient)(nil).Topics))
}

// WritablePartitions mocks base method
func (m *MockClient) WritablePartitions(arg0 string) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WritablePartitions", arg0)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WritablePartitions indicates an expected call of WritablePartitions
func (mr *MockClientMockRecorder) WritablePartitions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WritablePartitions", reflect.TypeOf((*MockClient)(nil).WritablePartitions), arg0)
}

// MockConsumer is a mock of Consumer interface
type MockConsumer struct {
	ctrl     *gomock.Controller
	recorder *MockConsumerMockRecorder
}

// MockConsumerMockRecorder is the mock recorder for MockConsumer
type MockConsumerMockRecorder struct {
	mock *MockConsumer
}

// NewMockConsumer creates a new mock instance
func NewMockConsumer(ctrl *gomock.Controller) *MockConsumer {
	mock := &MockConsumer{ctrl: ctrl}
	mock.recorder = &MockConsumerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockConsumer) EXPECT() *MockConsumerMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockConsumer) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockConsumerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConsumer)(nil).Close))
}

// ConsumePartition mocks base method
func (m *MockConsumer) ConsumePartition(arg0 string, arg1 int32, arg2 int64) (sarama.PartitionConsumer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConsumePartition", arg0, arg1, arg2)
	ret0, _ := ret[0].(sarama.PartitionConsumer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConsumePartition indicates an expected call of ConsumePartition
func (mr *MockConsumerMockRecorder) ConsumePartition(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsumePartition", reflect.TypeOf((*MockConsumer)(nil).ConsumePartition), arg0, arg1, arg2)
}

// HighWaterMarks mocks base method
func (m *MockConsumer) HighWaterMarks() map[string]map[int32]int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HighWaterMarks")
	ret0, _ := ret[0].(map[string]map[int32]int64)
	return ret0
}

// HighWaterMarks indicates an expected call of HighWaterMarks
func (mr *MockConsumerMockRecorder) HighWaterMarks() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HighWaterMarks", reflect.TypeOf((*MockConsumer)(nil).HighWaterMarks))
}

// Partitions mocks base method
func (m *MockConsumer) Partitions(arg0 string) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Partitions", arg0)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Partitions indicates an expected call of Partitions
func (mr *MockConsumerMockRecorder) Partitions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Partitions", reflect.TypeOf((*MockConsumer)(nil).Partitions), arg0)
}

// Topics mocks base method
func (m *MockConsumer) Topics() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Topics")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Topics indicates an expected call of Topics
func (mr *MockConsumerMockRecorder) Topics() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Topics", reflect.TypeOf((*MockConsumer)(nil).Topics))
}

// MockPartitionConsumer is a mock of PartitionConsumer interface
type MockPartitionConsumer struct {
	ctrl     *gomock.Controller
	recorder *MockPartitionConsumerMockRecorder
}

// MockPartitionConsumerMockRecorder is the mock recorder for MockPartitionConsumer
type MockPartitionConsumerMockRecorder struct {
	mock *MockPartitionConsumer
}

// NewMockPartitionConsumer creates a new mock instance
func NewMockPartitionConsumer(ctrl *gomock.Controller) *MockPartitionConsumer {
	mock := &MockPartitionConsumer{ctrl: ctrl}
	mock.recorder = &MockPartitionConsumerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockPartitionConsumer) EXPECT() *MockPartitionConsumerMockRecorder {
	return m.recorder
}

// AsyncClose mocks base method
func (m *MockPartitionConsumer) AsyncClose() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AsyncClose")
}

// AsyncClose indicates an expected call of AsyncClose
func (mr *MockPartitionConsumerMockRecorder) AsyncClose() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncClose", reflect.TypeOf((*MockPartitionConsumer)(nil).AsyncClose))
}

// Close mocks base method
func (m *MockPartitionConsumer) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockPartitionConsumerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPartitionConsumer)(nil).Close))
}

// Errors mocks base method
func (m *MockPartitionConsumer) Errors() <-chan *sarama.ConsumerError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Errors")
	ret0, _ := ret[0].(<-chan *sarama.ConsumerError)
	return ret0
}

// Errors indicates an expected call of Errors
func (mr *MockPartitionConsumerMockRecorder) Errors() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errors", reflect.TypeOf((*MockPartitionConsumer)(nil).Errors))
}

// HighWaterMarkOffset mocks base method
func (m *MockPartitionConsumer) HighWaterMarkOffset() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HighWaterMarkOffset")
	ret0, _ := ret[0].(int64)
	return ret0
}

// HighWaterMarkOffset indicates an expected call of HighWaterMarkOffset
func (mr *MockPartitionConsumerMockRecorder) HighWaterMarkOffset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HighWaterMarkOffset", reflect.TypeOf((*MockPartitionConsumer)(nil).HighWaterMarkOffset))
}

// Messages mocks base method
func (m *MockPartitionConsumer) Messages() <-chan *sarama.ConsumerMessage {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Messages")
	ret0, _ := ret[0].(<-chan *sarama.ConsumerMessage)
	return ret0
}

// Messages indicates an expected call of Messages
func (mr *MockPartitionConsumerMockRecorder) Messages() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Messages", reflect.TypeOf((*MockPartitionConsumer)(nil).Messages))
}