mirror of https://github.com/milvus-io/milvus.git
584 lines
18 KiB
Go
584 lines
18 KiB
Go
// Code generated by mockery v2.16.0. DO NOT EDIT.
|
|
|
|
package server
|
|
|
|
import mock "github.com/stretchr/testify/mock"
|
|
|
|
// MockRocksMQ is an autogenerated mock type for the RocksMQ type
|
|
type MockRocksMQ struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockRocksMQ_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockRocksMQ) EXPECT() *MockRocksMQ_Expecter {
|
|
return &MockRocksMQ_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// CheckTopicValid provides a mock function with given fields: topicName
|
|
func (_m *MockRocksMQ) CheckTopicValid(topicName string) error {
|
|
ret := _m.Called(topicName)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(topicName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockRocksMQ_CheckTopicValid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckTopicValid'
|
|
type MockRocksMQ_CheckTopicValid_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CheckTopicValid is a helper method to define mock.On call
|
|
// - topicName string
|
|
func (_e *MockRocksMQ_Expecter) CheckTopicValid(topicName interface{}) *MockRocksMQ_CheckTopicValid_Call {
|
|
return &MockRocksMQ_CheckTopicValid_Call{Call: _e.mock.On("CheckTopicValid", topicName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_CheckTopicValid_Call) Run(run func(topicName string)) *MockRocksMQ_CheckTopicValid_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_CheckTopicValid_Call) Return(_a0 error) *MockRocksMQ_CheckTopicValid_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// Close provides a mock function with given fields:
|
|
func (_m *MockRocksMQ) Close() {
|
|
_m.Called()
|
|
}
|
|
|
|
// MockRocksMQ_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
|
|
type MockRocksMQ_Close_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Close is a helper method to define mock.On call
|
|
func (_e *MockRocksMQ_Expecter) Close() *MockRocksMQ_Close_Call {
|
|
return &MockRocksMQ_Close_Call{Call: _e.mock.On("Close")}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Close_Call) Run(run func()) *MockRocksMQ_Close_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Close_Call) Return() *MockRocksMQ_Close_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
// Consume provides a mock function with given fields: topicName, groupName, n
|
|
func (_m *MockRocksMQ) Consume(topicName string, groupName string, n int) ([]ConsumerMessage, error) {
|
|
ret := _m.Called(topicName, groupName, n)
|
|
|
|
var r0 []ConsumerMessage
|
|
if rf, ok := ret.Get(0).(func(string, string, int) []ConsumerMessage); ok {
|
|
r0 = rf(topicName, groupName, n)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]ConsumerMessage)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, string, int) error); ok {
|
|
r1 = rf(topicName, groupName, n)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockRocksMQ_Consume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Consume'
|
|
type MockRocksMQ_Consume_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Consume is a helper method to define mock.On call
|
|
// - topicName string
|
|
// - groupName string
|
|
// - n int
|
|
func (_e *MockRocksMQ_Expecter) Consume(topicName interface{}, groupName interface{}, n interface{}) *MockRocksMQ_Consume_Call {
|
|
return &MockRocksMQ_Consume_Call{Call: _e.mock.On("Consume", topicName, groupName, n)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Consume_Call) Run(run func(topicName string, groupName string, n int)) *MockRocksMQ_Consume_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string), args[2].(int))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Consume_Call) Return(_a0 []ConsumerMessage, _a1 error) *MockRocksMQ_Consume_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// CreateConsumerGroup provides a mock function with given fields: topicName, groupName
|
|
func (_m *MockRocksMQ) CreateConsumerGroup(topicName string, groupName string) error {
|
|
ret := _m.Called(topicName, groupName)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, string) error); ok {
|
|
r0 = rf(topicName, groupName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockRocksMQ_CreateConsumerGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateConsumerGroup'
|
|
type MockRocksMQ_CreateConsumerGroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateConsumerGroup is a helper method to define mock.On call
|
|
// - topicName string
|
|
// - groupName string
|
|
func (_e *MockRocksMQ_Expecter) CreateConsumerGroup(topicName interface{}, groupName interface{}) *MockRocksMQ_CreateConsumerGroup_Call {
|
|
return &MockRocksMQ_CreateConsumerGroup_Call{Call: _e.mock.On("CreateConsumerGroup", topicName, groupName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_CreateConsumerGroup_Call) Run(run func(topicName string, groupName string)) *MockRocksMQ_CreateConsumerGroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_CreateConsumerGroup_Call) Return(_a0 error) *MockRocksMQ_CreateConsumerGroup_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// CreateTopic provides a mock function with given fields: topicName
|
|
func (_m *MockRocksMQ) CreateTopic(topicName string) error {
|
|
ret := _m.Called(topicName)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(topicName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockRocksMQ_CreateTopic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTopic'
|
|
type MockRocksMQ_CreateTopic_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateTopic is a helper method to define mock.On call
|
|
// - topicName string
|
|
func (_e *MockRocksMQ_Expecter) CreateTopic(topicName interface{}) *MockRocksMQ_CreateTopic_Call {
|
|
return &MockRocksMQ_CreateTopic_Call{Call: _e.mock.On("CreateTopic", topicName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_CreateTopic_Call) Run(run func(topicName string)) *MockRocksMQ_CreateTopic_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_CreateTopic_Call) Return(_a0 error) *MockRocksMQ_CreateTopic_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// DestroyConsumerGroup provides a mock function with given fields: topicName, groupName
|
|
func (_m *MockRocksMQ) DestroyConsumerGroup(topicName string, groupName string) error {
|
|
ret := _m.Called(topicName, groupName)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, string) error); ok {
|
|
r0 = rf(topicName, groupName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockRocksMQ_DestroyConsumerGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DestroyConsumerGroup'
|
|
type MockRocksMQ_DestroyConsumerGroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DestroyConsumerGroup is a helper method to define mock.On call
|
|
// - topicName string
|
|
// - groupName string
|
|
func (_e *MockRocksMQ_Expecter) DestroyConsumerGroup(topicName interface{}, groupName interface{}) *MockRocksMQ_DestroyConsumerGroup_Call {
|
|
return &MockRocksMQ_DestroyConsumerGroup_Call{Call: _e.mock.On("DestroyConsumerGroup", topicName, groupName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_DestroyConsumerGroup_Call) Run(run func(topicName string, groupName string)) *MockRocksMQ_DestroyConsumerGroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_DestroyConsumerGroup_Call) Return(_a0 error) *MockRocksMQ_DestroyConsumerGroup_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// DestroyTopic provides a mock function with given fields: topicName
|
|
func (_m *MockRocksMQ) DestroyTopic(topicName string) error {
|
|
ret := _m.Called(topicName)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(topicName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockRocksMQ_DestroyTopic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DestroyTopic'
|
|
type MockRocksMQ_DestroyTopic_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DestroyTopic is a helper method to define mock.On call
|
|
// - topicName string
|
|
func (_e *MockRocksMQ_Expecter) DestroyTopic(topicName interface{}) *MockRocksMQ_DestroyTopic_Call {
|
|
return &MockRocksMQ_DestroyTopic_Call{Call: _e.mock.On("DestroyTopic", topicName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_DestroyTopic_Call) Run(run func(topicName string)) *MockRocksMQ_DestroyTopic_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_DestroyTopic_Call) Return(_a0 error) *MockRocksMQ_DestroyTopic_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// ExistConsumerGroup provides a mock function with given fields: topicName, groupName
|
|
func (_m *MockRocksMQ) ExistConsumerGroup(topicName string, groupName string) (bool, *Consumer, error) {
|
|
ret := _m.Called(topicName, groupName)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(string, string) bool); ok {
|
|
r0 = rf(topicName, groupName)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
var r1 *Consumer
|
|
if rf, ok := ret.Get(1).(func(string, string) *Consumer); ok {
|
|
r1 = rf(topicName, groupName)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*Consumer)
|
|
}
|
|
}
|
|
|
|
var r2 error
|
|
if rf, ok := ret.Get(2).(func(string, string) error); ok {
|
|
r2 = rf(topicName, groupName)
|
|
} else {
|
|
r2 = ret.Error(2)
|
|
}
|
|
|
|
return r0, r1, r2
|
|
}
|
|
|
|
// MockRocksMQ_ExistConsumerGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExistConsumerGroup'
|
|
type MockRocksMQ_ExistConsumerGroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ExistConsumerGroup is a helper method to define mock.On call
|
|
// - topicName string
|
|
// - groupName string
|
|
func (_e *MockRocksMQ_Expecter) ExistConsumerGroup(topicName interface{}, groupName interface{}) *MockRocksMQ_ExistConsumerGroup_Call {
|
|
return &MockRocksMQ_ExistConsumerGroup_Call{Call: _e.mock.On("ExistConsumerGroup", topicName, groupName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_ExistConsumerGroup_Call) Run(run func(topicName string, groupName string)) *MockRocksMQ_ExistConsumerGroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_ExistConsumerGroup_Call) Return(_a0 bool, _a1 *Consumer, _a2 error) *MockRocksMQ_ExistConsumerGroup_Call {
|
|
_c.Call.Return(_a0, _a1, _a2)
|
|
return _c
|
|
}
|
|
|
|
// GetLatestMsg provides a mock function with given fields: topicName
|
|
func (_m *MockRocksMQ) GetLatestMsg(topicName string) (int64, error) {
|
|
ret := _m.Called(topicName)
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func(string) int64); ok {
|
|
r0 = rf(topicName)
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(topicName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockRocksMQ_GetLatestMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestMsg'
|
|
type MockRocksMQ_GetLatestMsg_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetLatestMsg is a helper method to define mock.On call
|
|
// - topicName string
|
|
func (_e *MockRocksMQ_Expecter) GetLatestMsg(topicName interface{}) *MockRocksMQ_GetLatestMsg_Call {
|
|
return &MockRocksMQ_GetLatestMsg_Call{Call: _e.mock.On("GetLatestMsg", topicName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_GetLatestMsg_Call) Run(run func(topicName string)) *MockRocksMQ_GetLatestMsg_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_GetLatestMsg_Call) Return(_a0 int64, _a1 error) *MockRocksMQ_GetLatestMsg_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Notify provides a mock function with given fields: topicName, groupName
|
|
func (_m *MockRocksMQ) Notify(topicName string, groupName string) {
|
|
_m.Called(topicName, groupName)
|
|
}
|
|
|
|
// MockRocksMQ_Notify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Notify'
|
|
type MockRocksMQ_Notify_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Notify is a helper method to define mock.On call
|
|
// - topicName string
|
|
// - groupName string
|
|
func (_e *MockRocksMQ_Expecter) Notify(topicName interface{}, groupName interface{}) *MockRocksMQ_Notify_Call {
|
|
return &MockRocksMQ_Notify_Call{Call: _e.mock.On("Notify", topicName, groupName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Notify_Call) Run(run func(topicName string, groupName string)) *MockRocksMQ_Notify_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Notify_Call) Return() *MockRocksMQ_Notify_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
// Produce provides a mock function with given fields: topicName, messages
|
|
func (_m *MockRocksMQ) Produce(topicName string, messages []ProducerMessage) ([]int64, error) {
|
|
ret := _m.Called(topicName, messages)
|
|
|
|
var r0 []int64
|
|
if rf, ok := ret.Get(0).(func(string, []ProducerMessage) []int64); ok {
|
|
r0 = rf(topicName, messages)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]int64)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, []ProducerMessage) error); ok {
|
|
r1 = rf(topicName, messages)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockRocksMQ_Produce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Produce'
|
|
type MockRocksMQ_Produce_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Produce is a helper method to define mock.On call
|
|
// - topicName string
|
|
// - messages []ProducerMessage
|
|
func (_e *MockRocksMQ_Expecter) Produce(topicName interface{}, messages interface{}) *MockRocksMQ_Produce_Call {
|
|
return &MockRocksMQ_Produce_Call{Call: _e.mock.On("Produce", topicName, messages)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Produce_Call) Run(run func(topicName string, messages []ProducerMessage)) *MockRocksMQ_Produce_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].([]ProducerMessage))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Produce_Call) Return(_a0 []int64, _a1 error) *MockRocksMQ_Produce_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// RegisterConsumer provides a mock function with given fields: consumer
|
|
func (_m *MockRocksMQ) RegisterConsumer(consumer *Consumer) error {
|
|
ret := _m.Called(consumer)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*Consumer) error); ok {
|
|
r0 = rf(consumer)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockRocksMQ_RegisterConsumer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterConsumer'
|
|
type MockRocksMQ_RegisterConsumer_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RegisterConsumer is a helper method to define mock.On call
|
|
// - consumer *Consumer
|
|
func (_e *MockRocksMQ_Expecter) RegisterConsumer(consumer interface{}) *MockRocksMQ_RegisterConsumer_Call {
|
|
return &MockRocksMQ_RegisterConsumer_Call{Call: _e.mock.On("RegisterConsumer", consumer)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_RegisterConsumer_Call) Run(run func(consumer *Consumer)) *MockRocksMQ_RegisterConsumer_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*Consumer))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_RegisterConsumer_Call) Return(_a0 error) *MockRocksMQ_RegisterConsumer_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// Seek provides a mock function with given fields: topicName, groupName, msgID
|
|
func (_m *MockRocksMQ) Seek(topicName string, groupName string, msgID int64) error {
|
|
ret := _m.Called(topicName, groupName, msgID)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, string, int64) error); ok {
|
|
r0 = rf(topicName, groupName, msgID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockRocksMQ_Seek_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Seek'
|
|
type MockRocksMQ_Seek_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Seek is a helper method to define mock.On call
|
|
// - topicName string
|
|
// - groupName string
|
|
// - msgID int64
|
|
func (_e *MockRocksMQ_Expecter) Seek(topicName interface{}, groupName interface{}, msgID interface{}) *MockRocksMQ_Seek_Call {
|
|
return &MockRocksMQ_Seek_Call{Call: _e.mock.On("Seek", topicName, groupName, msgID)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Seek_Call) Run(run func(topicName string, groupName string, msgID int64)) *MockRocksMQ_Seek_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string), args[2].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_Seek_Call) Return(_a0 error) *MockRocksMQ_Seek_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// SeekToLatest provides a mock function with given fields: topicName, groupName
|
|
func (_m *MockRocksMQ) SeekToLatest(topicName string, groupName string) error {
|
|
ret := _m.Called(topicName, groupName)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, string) error); ok {
|
|
r0 = rf(topicName, groupName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockRocksMQ_SeekToLatest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SeekToLatest'
|
|
type MockRocksMQ_SeekToLatest_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SeekToLatest is a helper method to define mock.On call
|
|
// - topicName string
|
|
// - groupName string
|
|
func (_e *MockRocksMQ_Expecter) SeekToLatest(topicName interface{}, groupName interface{}) *MockRocksMQ_SeekToLatest_Call {
|
|
return &MockRocksMQ_SeekToLatest_Call{Call: _e.mock.On("SeekToLatest", topicName, groupName)}
|
|
}
|
|
|
|
func (_c *MockRocksMQ_SeekToLatest_Call) Run(run func(topicName string, groupName string)) *MockRocksMQ_SeekToLatest_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockRocksMQ_SeekToLatest_Call) Return(_a0 error) *MockRocksMQ_SeekToLatest_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
type mockConstructorTestingTNewMockRocksMQ interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}
|
|
|
|
// NewMockRocksMQ creates a new instance of MockRocksMQ. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
func NewMockRocksMQ(t mockConstructorTestingTNewMockRocksMQ) *MockRocksMQ {
|
|
mock := &MockRocksMQ{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|