From e016b54f7baa21ed3d3cf086d74f883a120b3813 Mon Sep 17 00:00:00 2001 From: frairon Date: Fri, 26 Apr 2019 14:47:02 +0200 Subject: [PATCH] update mocks --- kafka/mock/cluster_consumer.go | 80 ++++--- kafka/mock/kazoo.go | 144 +++++++----- kafka/mock/sarama.go | 385 ++++++++++++++++++++++----------- 3 files changed, 401 insertions(+), 208 deletions(-) diff --git a/kafka/mock/cluster_consumer.go b/kafka/mock/cluster_consumer.go index 64d40250..7eec3e6c 100644 --- a/kafka/mock/cluster_consumer.go +++ b/kafka/mock/cluster_consumer.go @@ -1,79 +1,103 @@ -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: group_consumer.go +// Package mock is a generated GoMock package. package mock import ( sarama "github.com/Shopify/sarama" sarama_cluster "github.com/bsm/sarama-cluster" gomock "github.com/golang/mock/gomock" + reflect "reflect" ) -// Mock of clusterConsumer interface +// MockclusterConsumer is a mock of clusterConsumer interface type MockclusterConsumer struct { ctrl *gomock.Controller - recorder *_MockclusterConsumerRecorder + recorder *MockclusterConsumerMockRecorder } -// Recorder for MockclusterConsumer (not exported) -type _MockclusterConsumerRecorder struct { +// MockclusterConsumerMockRecorder is the mock recorder for MockclusterConsumer +type MockclusterConsumerMockRecorder struct { mock *MockclusterConsumer } +// NewMockclusterConsumer creates a new mock instance func NewMockclusterConsumer(ctrl *gomock.Controller) *MockclusterConsumer { mock := &MockclusterConsumer{ctrl: ctrl} - mock.recorder = &_MockclusterConsumerRecorder{mock} + mock.recorder = &MockclusterConsumerMockRecorder{mock} return mock } -func (_m *MockclusterConsumer) EXPECT() *_MockclusterConsumerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockclusterConsumer) EXPECT() *MockclusterConsumerMockRecorder { + return m.recorder } -func (_m *MockclusterConsumer) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// Close mocks base method +func (m *MockclusterConsumer) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockclusterConsumerRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// Close indicates an expected call of Close +func (mr *MockclusterConsumerMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockclusterConsumer)(nil).Close)) } -func (_m *MockclusterConsumer) MarkPartitionOffset(topic string, partition int32, offset int64, metadata string) { - _m.ctrl.Call(_m, "MarkPartitionOffset", topic, partition, offset, metadata) +// MarkPartitionOffset mocks base method +func (m *MockclusterConsumer) MarkPartitionOffset(topic string, partition int32, offset int64, metadata string) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "MarkPartitionOffset", topic, partition, offset, metadata) } -func (_mr *_MockclusterConsumerRecorder) MarkPartitionOffset(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "MarkPartitionOffset", arg0, arg1, arg2, arg3) +// MarkPartitionOffset indicates an expected call of MarkPartitionOffset +func (mr *MockclusterConsumerMockRecorder) MarkPartitionOffset(topic, partition, offset, metadata interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkPartitionOffset", reflect.TypeOf((*MockclusterConsumer)(nil).MarkPartitionOffset), topic, partition, offset, metadata) } -func (_m *MockclusterConsumer) Notifications() <-chan *sarama_cluster.Notification { - ret := _m.ctrl.Call(_m, "Notifications") +// Notifications mocks base method +func (m *MockclusterConsumer) Notifications() <-chan *sarama_cluster.Notification { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Notifications") ret0, _ := ret[0].(<-chan *sarama_cluster.Notification) return ret0 } -func (_mr *_MockclusterConsumerRecorder) Notifications() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Notifications") +// Notifications indicates an expected call of Notifications +func (mr *MockclusterConsumerMockRecorder) Notifications() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notifications", reflect.TypeOf((*MockclusterConsumer)(nil).Notifications)) } -func (_m *MockclusterConsumer) Messages() <-chan *sarama.ConsumerMessage { - ret := _m.ctrl.Call(_m, "Messages") +// Messages mocks base method +func (m *MockclusterConsumer) Messages() <-chan *sarama.ConsumerMessage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Messages") ret0, _ := ret[0].(<-chan *sarama.ConsumerMessage) return ret0 } -func (_mr *_MockclusterConsumerRecorder) Messages() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Messages") +// Messages indicates an expected call of Messages +func (mr *MockclusterConsumerMockRecorder) Messages() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Messages", reflect.TypeOf((*MockclusterConsumer)(nil).Messages)) } -func (_m *MockclusterConsumer) Errors() <-chan error { - ret := _m.ctrl.Call(_m, "Errors") +// Errors mocks base method +func (m *MockclusterConsumer) Errors() <-chan error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Errors") ret0, _ := ret[0].(<-chan error) return ret0 } -func (_mr *_MockclusterConsumerRecorder) Errors() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Errors") +// Errors indicates an expected call of Errors +func (mr *MockclusterConsumerMockRecorder) Errors() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errors", reflect.TypeOf((*MockclusterConsumer)(nil).Errors)) } diff --git a/kafka/mock/kazoo.go b/kafka/mock/kazoo.go index f2b4798a..49649b39 100644 --- a/kafka/mock/kazoo.go +++ b/kafka/mock/kazoo.go @@ -1,143 +1,185 @@ -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: topic_manager.go +// Package mock is a generated GoMock package. package mock import ( gomock "github.com/golang/mock/gomock" kazoo_go "github.com/wvanbergen/kazoo-go" + reflect "reflect" ) -// Mock of TopicManager interface +// MockTopicManager is a mock of TopicManager interface type MockTopicManager struct { ctrl *gomock.Controller - recorder *_MockTopicManagerRecorder + recorder *MockTopicManagerMockRecorder } -// Recorder for MockTopicManager (not exported) -type _MockTopicManagerRecorder struct { +// MockTopicManagerMockRecorder is the mock recorder for MockTopicManager +type MockTopicManagerMockRecorder struct { mock *MockTopicManager } +// NewMockTopicManager creates a new mock instance func NewMockTopicManager(ctrl *gomock.Controller) *MockTopicManager { mock := &MockTopicManager{ctrl: ctrl} - mock.recorder = &_MockTopicManagerRecorder{mock} + mock.recorder = &MockTopicManagerMockRecorder{mock} return mock } -func (_m *MockTopicManager) EXPECT() *_MockTopicManagerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTopicManager) EXPECT() *MockTopicManagerMockRecorder { + return m.recorder } -func (_m *MockTopicManager) EnsureTableExists(topic string, npar int) error { - ret := _m.ctrl.Call(_m, "EnsureTableExists", topic, npar) +// EnsureTableExists mocks base method +func (m *MockTopicManager) EnsureTableExists(topic string, npar int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnsureTableExists", topic, npar) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTopicManagerRecorder) EnsureTableExists(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnsureTableExists", arg0, arg1) +// EnsureTableExists indicates an expected call of EnsureTableExists +func (mr *MockTopicManagerMockRecorder) EnsureTableExists(topic, npar interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureTableExists", reflect.TypeOf((*MockTopicManager)(nil).EnsureTableExists), topic, npar) } -func (_m *MockTopicManager) EnsureStreamExists(topic string, npar int) error { - ret := _m.ctrl.Call(_m, "EnsureStreamExists", topic, npar) +// EnsureStreamExists mocks base method +func (m *MockTopicManager) EnsureStreamExists(topic string, npar int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnsureStreamExists", topic, npar) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTopicManagerRecorder) EnsureStreamExists(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnsureStreamExists", arg0, arg1) +// EnsureStreamExists indicates an expected call of EnsureStreamExists +func (mr *MockTopicManagerMockRecorder) EnsureStreamExists(topic, npar interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureStreamExists", reflect.TypeOf((*MockTopicManager)(nil).EnsureStreamExists), topic, npar) } -func (_m *MockTopicManager) EnsureTopicExists(topic string, npar int, rfactor int, config map[string]string) error { - ret := _m.ctrl.Call(_m, "EnsureTopicExists", topic, npar, rfactor, config) +// EnsureTopicExists mocks base method +func (m *MockTopicManager) EnsureTopicExists(topic string, npar, rfactor int, config map[string]string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnsureTopicExists", topic, npar, rfactor, config) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTopicManagerRecorder) EnsureTopicExists(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "EnsureTopicExists", arg0, arg1, arg2, arg3) +// EnsureTopicExists indicates an expected call of EnsureTopicExists +func (mr *MockTopicManagerMockRecorder) EnsureTopicExists(topic, npar, rfactor, config interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureTopicExists", reflect.TypeOf((*MockTopicManager)(nil).EnsureTopicExists), topic, npar, rfactor, config) } -func (_m *MockTopicManager) Partitions(topic string) ([]int32, error) { - ret := _m.ctrl.Call(_m, "Partitions", topic) +// Partitions mocks base method +func (m *MockTopicManager) Partitions(topic string) ([]int32, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Partitions", topic) ret0, _ := ret[0].([]int32) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockTopicManagerRecorder) Partitions(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Partitions", arg0) +// Partitions indicates an expected call of Partitions +func (mr *MockTopicManagerMockRecorder) Partitions(topic interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Partitions", reflect.TypeOf((*MockTopicManager)(nil).Partitions), topic) } -func (_m *MockTopicManager) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// Close mocks base method +func (m *MockTopicManager) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTopicManagerRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// Close indicates an expected call of Close +func (mr *MockTopicManagerMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTopicManager)(nil).Close)) } -// Mock of kzoo interface +// Mockkzoo is a mock of kzoo interface type Mockkzoo struct { ctrl *gomock.Controller - recorder *_MockkzooRecorder + recorder *MockkzooMockRecorder } -// Recorder for Mockkzoo (not exported) -type _MockkzooRecorder struct { +// MockkzooMockRecorder is the mock recorder for Mockkzoo +type MockkzooMockRecorder struct { mock *Mockkzoo } +// NewMockkzoo creates a new mock instance func NewMockkzoo(ctrl *gomock.Controller) *Mockkzoo { mock := &Mockkzoo{ctrl: ctrl} - mock.recorder = &_MockkzooRecorder{mock} + mock.recorder = &MockkzooMockRecorder{mock} return mock } -func (_m *Mockkzoo) EXPECT() *_MockkzooRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *Mockkzoo) EXPECT() *MockkzooMockRecorder { + return m.recorder } -func (_m *Mockkzoo) Topic(topic string) *kazoo_go.Topic { - ret := _m.ctrl.Call(_m, "Topic", topic) +// Topic mocks base method +func (m *Mockkzoo) Topic(topic string) *kazoo_go.Topic { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Topic", topic) ret0, _ := ret[0].(*kazoo_go.Topic) return ret0 } -func (_mr *_MockkzooRecorder) Topic(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Topic", arg0) +// Topic indicates an expected call of Topic +func (mr *MockkzooMockRecorder) Topic(topic interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Topic", reflect.TypeOf((*Mockkzoo)(nil).Topic), topic) } -func (_m *Mockkzoo) Topics() (kazoo_go.TopicList, error) { - ret := _m.ctrl.Call(_m, "Topics") +// Topics mocks base method +func (m *Mockkzoo) Topics() (kazoo_go.TopicList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Topics") ret0, _ := ret[0].(kazoo_go.TopicList) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockkzooRecorder) Topics() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Topics") +// Topics indicates an expected call of Topics +func (mr *MockkzooMockRecorder) Topics() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Topics", reflect.TypeOf((*Mockkzoo)(nil).Topics)) } -func (_m *Mockkzoo) CreateTopic(topic string, npar int, rep int, config map[string]string) error { - ret := _m.ctrl.Call(_m, "CreateTopic", topic, npar, rep, config) +// CreateTopic mocks base method +func (m *Mockkzoo) CreateTopic(topic string, npar, rep int, config map[string]string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTopic", topic, npar, rep, config) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockkzooRecorder) CreateTopic(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTopic", arg0, arg1, arg2, arg3) +// CreateTopic indicates an expected call of CreateTopic +func (mr *MockkzooMockRecorder) CreateTopic(topic, npar, rep, config interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTopic", reflect.TypeOf((*Mockkzoo)(nil).CreateTopic), topic, npar, rep, config) } -func (_m *Mockkzoo) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// Close mocks base method +func (m *Mockkzoo) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockkzooRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// Close indicates an expected call of Close +func (mr *MockkzooMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*Mockkzoo)(nil).Close)) } diff --git a/kafka/mock/sarama.go b/kafka/mock/sarama.go index 86632663..97c75465 100644 --- a/kafka/mock/sarama.go +++ b/kafka/mock/sarama.go @@ -1,347 +1,474 @@ -// Automatically generated by MockGen. DO NOT EDIT! +// 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" ) -// Mock of Client interface +// MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller - recorder *_MockClientRecorder + recorder *MockClientMockRecorder } -// Recorder for MockClient (not exported) -type _MockClientRecorder struct { +// 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 = &_MockClientRecorder{mock} + mock.recorder = &MockClientMockRecorder{mock} return mock } -func (_m *MockClient) EXPECT() *_MockClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder } -func (_m *MockClient) Brokers() []*sarama.Broker { - ret := _m.ctrl.Call(_m, "Brokers") +// 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 } -func (_mr *_MockClientRecorder) Brokers() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Brokers") +// 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)) } -func (_m *MockClient) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// 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 } -func (_mr *_MockClientRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// 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)) } -func (_m *MockClient) Closed() bool { - ret := _m.ctrl.Call(_m, "Closed") +// 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 } -func (_mr *_MockClientRecorder) Closed() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Closed") +// 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)) } -func (_m *MockClient) Config() *sarama.Config { - ret := _m.ctrl.Call(_m, "Config") +// 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 } -func (_mr *_MockClientRecorder) Config() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Config") +// 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)) } -func (_m *MockClient) Controller() (*sarama.Broker, error) { - ret := _m.ctrl.Call(_m, "Controller") +// 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 } -func (_mr *_MockClientRecorder) Controller() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Controller") +// 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)) } -func (_m *MockClient) Coordinator(_param0 string) (*sarama.Broker, error) { - ret := _m.ctrl.Call(_m, "Coordinator", _param0) +// 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 } -func (_mr *_MockClientRecorder) Coordinator(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Coordinator", arg0) +// 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) } -func (_m *MockClient) GetOffset(_param0 string, _param1 int32, _param2 int64) (int64, error) { - ret := _m.ctrl.Call(_m, "GetOffset", _param0, _param1, _param2) +// 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 } -func (_mr *_MockClientRecorder) GetOffset(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetOffset", arg0, arg1, arg2) +// 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) } -func (_m *MockClient) InSyncReplicas(_param0 string, _param1 int32) ([]int32, error) { - ret := _m.ctrl.Call(_m, "InSyncReplicas", _param0, _param1) +// 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 } -func (_mr *_MockClientRecorder) InSyncReplicas(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InSyncReplicas", arg0, arg1) +// 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) } -func (_m *MockClient) InitProducerID() (*sarama.InitProducerIDResponse, error) { - ret := _m.ctrl.Call(_m, "InitProducerID") +// 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 } -func (_mr *_MockClientRecorder) InitProducerID() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InitProducerID") +// 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)) } -func (_m *MockClient) Leader(_param0 string, _param1 int32) (*sarama.Broker, error) { - ret := _m.ctrl.Call(_m, "Leader", _param0, _param1) +// 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 } -func (_mr *_MockClientRecorder) Leader(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Leader", arg0, arg1) +// 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) } -func (_m *MockClient) Partitions(_param0 string) ([]int32, error) { - ret := _m.ctrl.Call(_m, "Partitions", _param0) +// 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 } -func (_mr *_MockClientRecorder) Partitions(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Partitions", arg0) +// 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) } -func (_m *MockClient) RefreshCoordinator(_param0 string) error { - ret := _m.ctrl.Call(_m, "RefreshCoordinator", _param0) +// 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 } -func (_mr *_MockClientRecorder) RefreshCoordinator(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RefreshCoordinator", arg0) +// 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) } -func (_m *MockClient) RefreshMetadata(_param0 ...string) error { - _s := []interface{}{} - for _, _x := range _param0 { - _s = append(_s, _x) +// 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", _s...) + ret := m.ctrl.Call(m, "RefreshMetadata", varargs...) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) RefreshMetadata(arg0 ...interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RefreshMetadata", arg0...) +// 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...) } -func (_m *MockClient) Replicas(_param0 string, _param1 int32) ([]int32, error) { - ret := _m.ctrl.Call(_m, "Replicas", _param0, _param1) +// 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 } -func (_mr *_MockClientRecorder) Replicas(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Replicas", arg0, arg1) +// 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) } -func (_m *MockClient) Topics() ([]string, error) { - ret := _m.ctrl.Call(_m, "Topics") +// 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 } -func (_mr *_MockClientRecorder) Topics() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Topics") +// 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)) } -func (_m *MockClient) WritablePartitions(_param0 string) ([]int32, error) { - ret := _m.ctrl.Call(_m, "WritablePartitions", _param0) +// 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 } -func (_mr *_MockClientRecorder) WritablePartitions(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "WritablePartitions", arg0) +// 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) } -// Mock of Consumer interface +// MockConsumer is a mock of Consumer interface type MockConsumer struct { ctrl *gomock.Controller - recorder *_MockConsumerRecorder + recorder *MockConsumerMockRecorder } -// Recorder for MockConsumer (not exported) -type _MockConsumerRecorder struct { +// 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 = &_MockConsumerRecorder{mock} + mock.recorder = &MockConsumerMockRecorder{mock} return mock } -func (_m *MockConsumer) EXPECT() *_MockConsumerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockConsumer) EXPECT() *MockConsumerMockRecorder { + return m.recorder } -func (_m *MockConsumer) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// 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 } -func (_mr *_MockConsumerRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// 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)) } -func (_m *MockConsumer) ConsumePartition(_param0 string, _param1 int32, _param2 int64) (sarama.PartitionConsumer, error) { - ret := _m.ctrl.Call(_m, "ConsumePartition", _param0, _param1, _param2) +// 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 } -func (_mr *_MockConsumerRecorder) ConsumePartition(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ConsumePartition", arg0, arg1, arg2) +// 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) } -func (_m *MockConsumer) HighWaterMarks() map[string]map[int32]int64 { - ret := _m.ctrl.Call(_m, "HighWaterMarks") +// 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 } -func (_mr *_MockConsumerRecorder) HighWaterMarks() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "HighWaterMarks") +// 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)) } -func (_m *MockConsumer) Partitions(_param0 string) ([]int32, error) { - ret := _m.ctrl.Call(_m, "Partitions", _param0) +// 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 } -func (_mr *_MockConsumerRecorder) Partitions(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Partitions", arg0) +// 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) } -func (_m *MockConsumer) Topics() ([]string, error) { - ret := _m.ctrl.Call(_m, "Topics") +// 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 } -func (_mr *_MockConsumerRecorder) Topics() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Topics") +// 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)) } -// Mock of PartitionConsumer interface +// MockPartitionConsumer is a mock of PartitionConsumer interface type MockPartitionConsumer struct { ctrl *gomock.Controller - recorder *_MockPartitionConsumerRecorder + recorder *MockPartitionConsumerMockRecorder } -// Recorder for MockPartitionConsumer (not exported) -type _MockPartitionConsumerRecorder struct { +// 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 = &_MockPartitionConsumerRecorder{mock} + mock.recorder = &MockPartitionConsumerMockRecorder{mock} return mock } -func (_m *MockPartitionConsumer) EXPECT() *_MockPartitionConsumerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockPartitionConsumer) EXPECT() *MockPartitionConsumerMockRecorder { + return m.recorder } -func (_m *MockPartitionConsumer) AsyncClose() { - _m.ctrl.Call(_m, "AsyncClose") +// AsyncClose mocks base method +func (m *MockPartitionConsumer) AsyncClose() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "AsyncClose") } -func (_mr *_MockPartitionConsumerRecorder) AsyncClose() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "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)) } -func (_m *MockPartitionConsumer) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// 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 } -func (_mr *_MockPartitionConsumerRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// 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)) } -func (_m *MockPartitionConsumer) Errors() <-chan *sarama.ConsumerError { - ret := _m.ctrl.Call(_m, "Errors") +// 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 } -func (_mr *_MockPartitionConsumerRecorder) Errors() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Errors") +// 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)) } -func (_m *MockPartitionConsumer) HighWaterMarkOffset() int64 { - ret := _m.ctrl.Call(_m, "HighWaterMarkOffset") +// 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 } -func (_mr *_MockPartitionConsumerRecorder) HighWaterMarkOffset() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "HighWaterMarkOffset") +// 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)) } -func (_m *MockPartitionConsumer) Messages() <-chan *sarama.ConsumerMessage { - ret := _m.ctrl.Call(_m, "Messages") +// 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 } -func (_mr *_MockPartitionConsumerRecorder) Messages() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Messages") +// 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)) }