From ce0fd27e4ee4a114629b39c961b155c847f77c76 Mon Sep 17 00:00:00 2001 From: ldechoux <34473609+ldechoux@users.noreply.github.com> Date: Fri, 29 Mar 2024 14:55:48 +0100 Subject: [PATCH] update mocks --- internal/kafka/client_mock.go | 39 +++--- internal/kafka/producer_mock.go | 31 ++--- internal/metrics/kafka_mock.go | 47 +++---- internal/mongo/collection_mock.go | 211 +++++++++++++++--------------- 4 files changed, 166 insertions(+), 162 deletions(-) diff --git a/internal/kafka/client_mock.go b/internal/kafka/client_mock.go index ea4f5525..13c47e54 100644 --- a/internal/kafka/client_mock.go +++ b/internal/kafka/client_mock.go @@ -5,47 +5,48 @@ package kafka import ( + reflect "reflect" + kafka "github.com/confluentinc/confluent-kafka-go/v2/kafka" gomock "github.com/golang/mock/gomock" - reflect "reflect" ) -// MockClient is a mock of Client interface +// MockClient is a mock of Client interface. type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient +// MockClientMockRecorder is the mock recorder for MockClient. type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// Produce mocks base method -func (m *MockClient) Produce(messages chan *Message) { +// Close mocks base method. +func (m *MockClient) Close() { m.ctrl.T.Helper() - m.ctrl.Call(m, "Produce", messages) + m.ctrl.Call(m, "Close") } -// Produce indicates an expected call of Produce -func (mr *MockClientMockRecorder) Produce(messages interface{}) *gomock.Call { +// 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, "Produce", reflect.TypeOf((*MockClient)(nil).Produce), messages) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close)) } -// Events mocks base method +// Events mocks base method. func (m *MockClient) Events() chan kafka.Event { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Events") @@ -53,20 +54,20 @@ func (m *MockClient) Events() chan kafka.Event { return ret0 } -// Events indicates an expected call of Events +// Events indicates an expected call of Events. func (mr *MockClientMockRecorder) Events() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Events", reflect.TypeOf((*MockClient)(nil).Events)) } -// Close mocks base method -func (m *MockClient) Close() { +// Produce mocks base method. +func (m *MockClient) Produce(messages chan *Message) { m.ctrl.T.Helper() - m.ctrl.Call(m, "Close") + m.ctrl.Call(m, "Produce", messages) } -// Close indicates an expected call of Close -func (mr *MockClientMockRecorder) Close() *gomock.Call { +// Produce indicates an expected call of Produce. +func (mr *MockClientMockRecorder) Produce(messages interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Produce", reflect.TypeOf((*MockClient)(nil).Produce), messages) } diff --git a/internal/kafka/producer_mock.go b/internal/kafka/producer_mock.go index a65ed21e..83ec4741 100644 --- a/internal/kafka/producer_mock.go +++ b/internal/kafka/producer_mock.go @@ -5,47 +5,48 @@ package kafka import ( + reflect "reflect" + kafka "github.com/confluentinc/confluent-kafka-go/v2/kafka" gomock "github.com/golang/mock/gomock" - reflect "reflect" ) -// MockKafkaProducer is a mock of KafkaProducer interface +// MockKafkaProducer is a mock of KafkaProducer interface. type MockKafkaProducer struct { ctrl *gomock.Controller recorder *MockKafkaProducerMockRecorder } -// MockKafkaProducerMockRecorder is the mock recorder for MockKafkaProducer +// MockKafkaProducerMockRecorder is the mock recorder for MockKafkaProducer. type MockKafkaProducerMockRecorder struct { mock *MockKafkaProducer } -// NewMockKafkaProducer creates a new mock instance +// NewMockKafkaProducer creates a new mock instance. func NewMockKafkaProducer(ctrl *gomock.Controller) *MockKafkaProducer { mock := &MockKafkaProducer{ctrl: ctrl} mock.recorder = &MockKafkaProducerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockKafkaProducer) EXPECT() *MockKafkaProducerMockRecorder { return m.recorder } -// Close mocks base method +// Close mocks base method. func (m *MockKafkaProducer) Close() { m.ctrl.T.Helper() m.ctrl.Call(m, "Close") } -// Close indicates an expected call of Close +// Close indicates an expected call of Close. func (mr *MockKafkaProducerMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockKafkaProducer)(nil).Close)) } -// Events mocks base method +// Events mocks base method. func (m *MockKafkaProducer) Events() chan kafka.Event { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Events") @@ -53,13 +54,13 @@ func (m *MockKafkaProducer) Events() chan kafka.Event { return ret0 } -// Events indicates an expected call of Events +// Events indicates an expected call of Events. func (mr *MockKafkaProducerMockRecorder) Events() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Events", reflect.TypeOf((*MockKafkaProducer)(nil).Events)) } -// Len mocks base method +// Len mocks base method. func (m *MockKafkaProducer) Len() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Len") @@ -67,13 +68,13 @@ func (m *MockKafkaProducer) Len() int { return ret0 } -// Len indicates an expected call of Len +// Len indicates an expected call of Len. func (mr *MockKafkaProducerMockRecorder) Len() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockKafkaProducer)(nil).Len)) } -// Produce mocks base method +// Produce mocks base method. func (m *MockKafkaProducer) Produce(msg *kafka.Message, deliveryChan chan kafka.Event) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Produce", msg, deliveryChan) @@ -81,13 +82,13 @@ func (m *MockKafkaProducer) Produce(msg *kafka.Message, deliveryChan chan kafka. return ret0 } -// Produce indicates an expected call of Produce +// Produce indicates an expected call of Produce. func (mr *MockKafkaProducerMockRecorder) Produce(msg, deliveryChan interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Produce", reflect.TypeOf((*MockKafkaProducer)(nil).Produce), msg, deliveryChan) } -// ProduceChannel mocks base method +// ProduceChannel mocks base method. func (m *MockKafkaProducer) ProduceChannel() chan *kafka.Message { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ProduceChannel") @@ -95,7 +96,7 @@ func (m *MockKafkaProducer) ProduceChannel() chan *kafka.Message { return ret0 } -// ProduceChannel indicates an expected call of ProduceChannel +// ProduceChannel indicates an expected call of ProduceChannel. func (mr *MockKafkaProducerMockRecorder) ProduceChannel() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProduceChannel", reflect.TypeOf((*MockKafkaProducer)(nil).ProduceChannel)) diff --git a/internal/metrics/kafka_mock.go b/internal/metrics/kafka_mock.go index 3dfcade5..4c5d99bb 100644 --- a/internal/metrics/kafka_mock.go +++ b/internal/metrics/kafka_mock.go @@ -5,71 +5,72 @@ package metrics import ( + reflect "reflect" + gomock "github.com/golang/mock/gomock" prometheus "github.com/prometheus/client_golang/prometheus" - reflect "reflect" ) -// MockKafkaRecorder is a mock of KafkaRecorder interface +// MockKafkaRecorder is a mock of KafkaRecorder interface. type MockKafkaRecorder struct { ctrl *gomock.Controller recorder *MockKafkaRecorderMockRecorder } -// MockKafkaRecorderMockRecorder is the mock recorder for MockKafkaRecorder +// MockKafkaRecorderMockRecorder is the mock recorder for MockKafkaRecorder. type MockKafkaRecorderMockRecorder struct { mock *MockKafkaRecorder } -// NewMockKafkaRecorder creates a new mock instance +// NewMockKafkaRecorder creates a new mock instance. func NewMockKafkaRecorder(ctrl *gomock.Controller) *MockKafkaRecorder { mock := &MockKafkaRecorder{ctrl: ctrl} mock.recorder = &MockKafkaRecorderMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockKafkaRecorder) EXPECT() *MockKafkaRecorderMockRecorder { return m.recorder } -// IncKafkaClientProduceCounter mocks base method +// IncKafkaClientProduceCounter mocks base method. func (m *MockKafkaRecorder) IncKafkaClientProduceCounter(topic string) { m.ctrl.T.Helper() m.ctrl.Call(m, "IncKafkaClientProduceCounter", topic) } -// IncKafkaClientProduceCounter indicates an expected call of IncKafkaClientProduceCounter +// IncKafkaClientProduceCounter indicates an expected call of IncKafkaClientProduceCounter. func (mr *MockKafkaRecorderMockRecorder) IncKafkaClientProduceCounter(topic interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncKafkaClientProduceCounter", reflect.TypeOf((*MockKafkaRecorder)(nil).IncKafkaClientProduceCounter), topic) } -// IncKafkaProducerSuccessCounter mocks base method -func (m *MockKafkaRecorder) IncKafkaProducerSuccessCounter(topic string) { +// IncKafkaProducerErrorCounter mocks base method. +func (m *MockKafkaRecorder) IncKafkaProducerErrorCounter(topic string) { m.ctrl.T.Helper() - m.ctrl.Call(m, "IncKafkaProducerSuccessCounter", topic) + m.ctrl.Call(m, "IncKafkaProducerErrorCounter", topic) } -// IncKafkaProducerSuccessCounter indicates an expected call of IncKafkaProducerSuccessCounter -func (mr *MockKafkaRecorderMockRecorder) IncKafkaProducerSuccessCounter(topic interface{}) *gomock.Call { +// IncKafkaProducerErrorCounter indicates an expected call of IncKafkaProducerErrorCounter. +func (mr *MockKafkaRecorderMockRecorder) IncKafkaProducerErrorCounter(topic interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncKafkaProducerSuccessCounter", reflect.TypeOf((*MockKafkaRecorder)(nil).IncKafkaProducerSuccessCounter), topic) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncKafkaProducerErrorCounter", reflect.TypeOf((*MockKafkaRecorder)(nil).IncKafkaProducerErrorCounter), topic) } -// IncKafkaProducerErrorCounter mocks base method -func (m *MockKafkaRecorder) IncKafkaProducerErrorCounter(topic string) { +// IncKafkaProducerSuccessCounter mocks base method. +func (m *MockKafkaRecorder) IncKafkaProducerSuccessCounter(topic string) { m.ctrl.T.Helper() - m.ctrl.Call(m, "IncKafkaProducerErrorCounter", topic) + m.ctrl.Call(m, "IncKafkaProducerSuccessCounter", topic) } -// IncKafkaProducerErrorCounter indicates an expected call of IncKafkaProducerErrorCounter -func (mr *MockKafkaRecorderMockRecorder) IncKafkaProducerErrorCounter(topic interface{}) *gomock.Call { +// IncKafkaProducerSuccessCounter indicates an expected call of IncKafkaProducerSuccessCounter. +func (mr *MockKafkaRecorderMockRecorder) IncKafkaProducerSuccessCounter(topic interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncKafkaProducerErrorCounter", reflect.TypeOf((*MockKafkaRecorder)(nil).IncKafkaProducerErrorCounter), topic) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncKafkaProducerSuccessCounter", reflect.TypeOf((*MockKafkaRecorder)(nil).IncKafkaProducerSuccessCounter), topic) } -// RegisterOn mocks base method +// RegisterOn mocks base method. func (m *MockKafkaRecorder) RegisterOn(registry prometheus.Registerer) KafkaRecorder { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RegisterOn", registry) @@ -77,13 +78,13 @@ func (m *MockKafkaRecorder) RegisterOn(registry prometheus.Registerer) KafkaReco return ret0 } -// RegisterOn indicates an expected call of RegisterOn +// RegisterOn indicates an expected call of RegisterOn. func (mr *MockKafkaRecorderMockRecorder) RegisterOn(registry interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterOn", reflect.TypeOf((*MockKafkaRecorder)(nil).RegisterOn), registry) } -// Unregister mocks base method +// Unregister mocks base method. func (m *MockKafkaRecorder) Unregister(registry prometheus.Registerer) KafkaRecorder { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Unregister", registry) @@ -91,7 +92,7 @@ func (m *MockKafkaRecorder) Unregister(registry prometheus.Registerer) KafkaReco return ret0 } -// Unregister indicates an expected call of Unregister +// Unregister indicates an expected call of Unregister. func (mr *MockKafkaRecorderMockRecorder) Unregister(registry interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unregister", reflect.TypeOf((*MockKafkaRecorder)(nil).Unregister), registry) diff --git a/internal/mongo/collection_mock.go b/internal/mongo/collection_mock.go index b163dc38..e504687c 100644 --- a/internal/mongo/collection_mock.go +++ b/internal/mongo/collection_mock.go @@ -6,36 +6,51 @@ package mongo import ( context "context" + reflect "reflect" + gomock "github.com/golang/mock/gomock" bson "go.mongodb.org/mongo-driver/bson" options "go.mongodb.org/mongo-driver/mongo/options" - reflect "reflect" ) -// MockAggregateCursor is a mock of AggregateCursor interface +// MockAggregateCursor is a mock of AggregateCursor interface. type MockAggregateCursor struct { ctrl *gomock.Controller recorder *MockAggregateCursorMockRecorder } -// MockAggregateCursorMockRecorder is the mock recorder for MockAggregateCursor +// MockAggregateCursorMockRecorder is the mock recorder for MockAggregateCursor. type MockAggregateCursorMockRecorder struct { mock *MockAggregateCursor } -// NewMockAggregateCursor creates a new mock instance +// NewMockAggregateCursor creates a new mock instance. func NewMockAggregateCursor(ctrl *gomock.Controller) *MockAggregateCursor { mock := &MockAggregateCursor{ctrl: ctrl} mock.recorder = &MockAggregateCursorMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockAggregateCursor) EXPECT() *MockAggregateCursorMockRecorder { return m.recorder } -// Decode mocks base method +// Close mocks base method. +func (m *MockAggregateCursor) Close(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockAggregateCursorMockRecorder) Close(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAggregateCursor)(nil).Close), ctx) +} + +// Decode mocks base method. func (m *MockAggregateCursor) Decode(val interface{}) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Decode", val) @@ -43,13 +58,13 @@ func (m *MockAggregateCursor) Decode(val interface{}) error { return ret0 } -// Decode indicates an expected call of Decode +// Decode indicates an expected call of Decode. func (mr *MockAggregateCursorMockRecorder) Decode(val interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockAggregateCursor)(nil).Decode), val) } -// Next mocks base method +// Next mocks base method. func (m *MockAggregateCursor) Next(ctx context.Context) bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Next", ctx) @@ -57,13 +72,13 @@ func (m *MockAggregateCursor) Next(ctx context.Context) bool { return ret0 } -// Next indicates an expected call of Next +// Next indicates an expected call of Next. func (mr *MockAggregateCursorMockRecorder) Next(ctx interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockAggregateCursor)(nil).Next), ctx) } -// TryNext mocks base method +// TryNext mocks base method. func (m *MockAggregateCursor) TryNext(ctx context.Context) bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "TryNext", ctx) @@ -71,106 +86,64 @@ func (m *MockAggregateCursor) TryNext(ctx context.Context) bool { return ret0 } -// TryNext indicates an expected call of TryNext +// TryNext indicates an expected call of TryNext. func (mr *MockAggregateCursorMockRecorder) TryNext(ctx interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryNext", reflect.TypeOf((*MockAggregateCursor)(nil).TryNext), ctx) } -// Close mocks base method -func (m *MockAggregateCursor) Close(ctx context.Context) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close", ctx) - ret0, _ := ret[0].(error) - return ret0 -} - -// Close indicates an expected call of Close -func (mr *MockAggregateCursorMockRecorder) Close(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAggregateCursor)(nil).Close), ctx) -} - -// MockStreamCursor is a mock of StreamCursor interface +// MockStreamCursor is a mock of StreamCursor interface. type MockStreamCursor struct { ctrl *gomock.Controller recorder *MockStreamCursorMockRecorder } -// MockStreamCursorMockRecorder is the mock recorder for MockStreamCursor +// MockStreamCursorMockRecorder is the mock recorder for MockStreamCursor. type MockStreamCursorMockRecorder struct { mock *MockStreamCursor } -// NewMockStreamCursor creates a new mock instance +// NewMockStreamCursor creates a new mock instance. func NewMockStreamCursor(ctrl *gomock.Controller) *MockStreamCursor { mock := &MockStreamCursor{ctrl: ctrl} mock.recorder = &MockStreamCursorMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStreamCursor) EXPECT() *MockStreamCursorMockRecorder { return m.recorder } -// Decode mocks base method -func (m *MockStreamCursor) Decode(val interface{}) error { +// Close mocks base method. +func (m *MockStreamCursor) Close(ctx context.Context) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Decode", val) + ret := m.ctrl.Call(m, "Close", ctx) ret0, _ := ret[0].(error) return ret0 } -// Decode indicates an expected call of Decode -func (mr *MockStreamCursorMockRecorder) Decode(val interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockStreamCursor)(nil).Decode), val) -} - -// Next mocks base method -func (m *MockStreamCursor) Next(ctx context.Context) bool { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Next", ctx) - ret0, _ := ret[0].(bool) - return ret0 -} - -// Next indicates an expected call of Next -func (mr *MockStreamCursorMockRecorder) Next(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockStreamCursor)(nil).Next), ctx) -} - -// TryNext mocks base method -func (m *MockStreamCursor) TryNext(ctx context.Context) bool { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TryNext", ctx) - ret0, _ := ret[0].(bool) - return ret0 -} - -// TryNext indicates an expected call of TryNext -func (mr *MockStreamCursorMockRecorder) TryNext(ctx interface{}) *gomock.Call { +// Close indicates an expected call of Close. +func (mr *MockStreamCursorMockRecorder) Close(ctx interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryNext", reflect.TypeOf((*MockStreamCursor)(nil).TryNext), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStreamCursor)(nil).Close), ctx) } -// Close mocks base method -func (m *MockStreamCursor) Close(ctx context.Context) error { +// Decode mocks base method. +func (m *MockStreamCursor) Decode(val interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close", ctx) + ret := m.ctrl.Call(m, "Decode", val) ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close -func (mr *MockStreamCursorMockRecorder) Close(ctx interface{}) *gomock.Call { +// Decode indicates an expected call of Decode. +func (mr *MockStreamCursorMockRecorder) Decode(val interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStreamCursor)(nil).Close), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockStreamCursor)(nil).Decode), val) } -// Err mocks base method +// Err mocks base method. func (m *MockStreamCursor) Err() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Err") @@ -178,13 +151,13 @@ func (m *MockStreamCursor) Err() error { return ret0 } -// Err indicates an expected call of Err +// Err indicates an expected call of Err. func (mr *MockStreamCursorMockRecorder) Err() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockStreamCursor)(nil).Err)) } -// ID mocks base method +// ID mocks base method. func (m *MockStreamCursor) ID() int64 { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ID") @@ -192,13 +165,27 @@ func (m *MockStreamCursor) ID() int64 { return ret0 } -// ID indicates an expected call of ID +// ID indicates an expected call of ID. func (mr *MockStreamCursorMockRecorder) ID() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockStreamCursor)(nil).ID)) } -// ResumeToken mocks base method +// Next mocks base method. +func (m *MockStreamCursor) Next(ctx context.Context) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Next", ctx) + ret0, _ := ret[0].(bool) + return ret0 +} + +// Next indicates an expected call of Next. +func (mr *MockStreamCursorMockRecorder) Next(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockStreamCursor)(nil).Next), ctx) +} + +// ResumeToken mocks base method. func (m *MockStreamCursor) ResumeToken() bson.Raw { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ResumeToken") @@ -206,36 +193,50 @@ func (m *MockStreamCursor) ResumeToken() bson.Raw { return ret0 } -// ResumeToken indicates an expected call of ResumeToken +// ResumeToken indicates an expected call of ResumeToken. func (mr *MockStreamCursorMockRecorder) ResumeToken() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeToken", reflect.TypeOf((*MockStreamCursor)(nil).ResumeToken)) } -// MockDriverDatabase is a mock of DriverDatabase interface +// TryNext mocks base method. +func (m *MockStreamCursor) TryNext(ctx context.Context) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TryNext", ctx) + ret0, _ := ret[0].(bool) + return ret0 +} + +// TryNext indicates an expected call of TryNext. +func (mr *MockStreamCursorMockRecorder) TryNext(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryNext", reflect.TypeOf((*MockStreamCursor)(nil).TryNext), ctx) +} + +// MockDriverDatabase is a mock of DriverDatabase interface. type MockDriverDatabase struct { ctrl *gomock.Controller recorder *MockDriverDatabaseMockRecorder } -// MockDriverDatabaseMockRecorder is the mock recorder for MockDriverDatabase +// MockDriverDatabaseMockRecorder is the mock recorder for MockDriverDatabase. type MockDriverDatabaseMockRecorder struct { mock *MockDriverDatabase } -// NewMockDriverDatabase creates a new mock instance +// NewMockDriverDatabase creates a new mock instance. func NewMockDriverDatabase(ctrl *gomock.Controller) *MockDriverDatabase { mock := &MockDriverDatabase{ctrl: ctrl} mock.recorder = &MockDriverDatabaseMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockDriverDatabase) EXPECT() *MockDriverDatabaseMockRecorder { return m.recorder } -// Name mocks base method +// Name mocks base method. func (m *MockDriverDatabase) Name() string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Name") @@ -243,36 +244,36 @@ func (m *MockDriverDatabase) Name() string { return ret0 } -// Name indicates an expected call of Name +// Name indicates an expected call of Name. func (mr *MockDriverDatabaseMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockDriverDatabase)(nil).Name)) } -// MockCollectionAdapter is a mock of CollectionAdapter interface +// MockCollectionAdapter is a mock of CollectionAdapter interface. type MockCollectionAdapter struct { ctrl *gomock.Controller recorder *MockCollectionAdapterMockRecorder } -// MockCollectionAdapterMockRecorder is the mock recorder for MockCollectionAdapter +// MockCollectionAdapterMockRecorder is the mock recorder for MockCollectionAdapter. type MockCollectionAdapterMockRecorder struct { mock *MockCollectionAdapter } -// NewMockCollectionAdapter creates a new mock instance +// NewMockCollectionAdapter creates a new mock instance. func NewMockCollectionAdapter(ctrl *gomock.Controller) *MockCollectionAdapter { mock := &MockCollectionAdapter{ctrl: ctrl} mock.recorder = &MockCollectionAdapterMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockCollectionAdapter) EXPECT() *MockCollectionAdapterMockRecorder { return m.recorder } -// Aggregate mocks base method +// Aggregate mocks base method. func (m *MockCollectionAdapter) Aggregate(ctx context.Context, pipeline interface{}, opts ...*options.AggregateOptions) (AggregateCursor, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, pipeline} @@ -285,14 +286,14 @@ func (m *MockCollectionAdapter) Aggregate(ctx context.Context, pipeline interfac return ret0, ret1 } -// Aggregate indicates an expected call of Aggregate +// Aggregate indicates an expected call of Aggregate. func (mr *MockCollectionAdapterMockRecorder) Aggregate(ctx, pipeline interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{ctx, pipeline}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockCollectionAdapter)(nil).Aggregate), varargs...) } -// Database mocks base method +// Database mocks base method. func (m *MockCollectionAdapter) Database() DriverDatabase { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Database") @@ -300,13 +301,27 @@ func (m *MockCollectionAdapter) Database() DriverDatabase { return ret0 } -// Database indicates an expected call of Database +// Database indicates an expected call of Database. func (mr *MockCollectionAdapterMockRecorder) Database() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Database", reflect.TypeOf((*MockCollectionAdapter)(nil).Database)) } -// Watch mocks base method +// Name mocks base method. +func (m *MockCollectionAdapter) Name() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) + return ret0 +} + +// Name indicates an expected call of Name. +func (mr *MockCollectionAdapterMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCollectionAdapter)(nil).Name)) +} + +// Watch mocks base method. func (m *MockCollectionAdapter) Watch(ctx context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (StreamCursor, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, pipeline} @@ -319,23 +334,9 @@ func (m *MockCollectionAdapter) Watch(ctx context.Context, pipeline interface{}, return ret0, ret1 } -// Watch indicates an expected call of Watch +// Watch indicates an expected call of Watch. func (mr *MockCollectionAdapterMockRecorder) Watch(ctx, pipeline interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{ctx, pipeline}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockCollectionAdapter)(nil).Watch), varargs...) } - -// Name mocks base method -func (m *MockCollectionAdapter) Name() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 -} - -// Name indicates an expected call of Name -func (mr *MockCollectionAdapterMockRecorder) Name() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCollectionAdapter)(nil).Name)) -}