mirror of
https://gitee.com/milvus-io/milvus.git
synced 2024-12-02 20:09:57 +08:00
59bcbf0cf6
Signed-off-by: yun.zhang <yun.zhang@zilliz.com> Signed-off-by: yun.zhang <yun.zhang@zilliz.com>
1737 lines
58 KiB
Go
1737 lines
58 KiB
Go
// Code generated by mockery v2.14.0. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
commonpb "github.com/milvus-io/milvus-proto/go-api/commonpb"
|
|
|
|
datapb "github.com/milvus-io/milvus/internal/proto/datapb"
|
|
|
|
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
|
|
|
|
milvuspb "github.com/milvus-io/milvus-proto/go-api/milvuspb"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// DataCoord is an autogenerated mock type for the DataCoord type
|
|
type DataCoord struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type DataCoord_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *DataCoord) EXPECT() *DataCoord_Expecter {
|
|
return &DataCoord_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// AcquireSegmentLock provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) AcquireSegmentLock(ctx context.Context, req *datapb.AcquireSegmentLockRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AcquireSegmentLockRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.AcquireSegmentLockRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_AcquireSegmentLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcquireSegmentLock'
|
|
type DataCoord_AcquireSegmentLock_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AcquireSegmentLock is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.AcquireSegmentLockRequest
|
|
func (_e *DataCoord_Expecter) AcquireSegmentLock(ctx interface{}, req interface{}) *DataCoord_AcquireSegmentLock_Call {
|
|
return &DataCoord_AcquireSegmentLock_Call{Call: _e.mock.On("AcquireSegmentLock", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_AcquireSegmentLock_Call) Run(run func(ctx context.Context, req *datapb.AcquireSegmentLockRequest)) *DataCoord_AcquireSegmentLock_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.AcquireSegmentLockRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_AcquireSegmentLock_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_AcquireSegmentLock_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// AssignSegmentID provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) AssignSegmentID(ctx context.Context, req *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.AssignSegmentIDResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AssignSegmentIDRequest) *datapb.AssignSegmentIDResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.AssignSegmentIDResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.AssignSegmentIDRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_AssignSegmentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignSegmentID'
|
|
type DataCoord_AssignSegmentID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AssignSegmentID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.AssignSegmentIDRequest
|
|
func (_e *DataCoord_Expecter) AssignSegmentID(ctx interface{}, req interface{}) *DataCoord_AssignSegmentID_Call {
|
|
return &DataCoord_AssignSegmentID_Call{Call: _e.mock.On("AssignSegmentID", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_AssignSegmentID_Call) Run(run func(ctx context.Context, req *datapb.AssignSegmentIDRequest)) *DataCoord_AssignSegmentID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.AssignSegmentIDRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_AssignSegmentID_Call) Return(_a0 *datapb.AssignSegmentIDResponse, _a1 error) *DataCoord_AssignSegmentID_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// BroadcastAlteredCollection provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_BroadcastAlteredCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastAlteredCollection'
|
|
type DataCoord_BroadcastAlteredCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// BroadcastAlteredCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.AlterCollectionRequest
|
|
func (_e *DataCoord_Expecter) BroadcastAlteredCollection(ctx interface{}, req interface{}) *DataCoord_BroadcastAlteredCollection_Call {
|
|
return &DataCoord_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_BroadcastAlteredCollection_Call) Run(run func(ctx context.Context, req *milvuspb.AlterCollectionRequest)) *DataCoord_BroadcastAlteredCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_BroadcastAlteredCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_BroadcastAlteredCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// CheckHealth provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.CheckHealthResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) *milvuspb.CheckHealthResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.CheckHealthResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CheckHealthRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'
|
|
type DataCoord_CheckHealth_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CheckHealth is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.CheckHealthRequest
|
|
func (_e *DataCoord_Expecter) CheckHealth(ctx interface{}, req interface{}) *DataCoord_CheckHealth_Call {
|
|
return &DataCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_CheckHealth_Call) Run(run func(ctx context.Context, req *milvuspb.CheckHealthRequest)) *DataCoord_CheckHealth_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *DataCoord_CheckHealth_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// DropVirtualChannel provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.DropVirtualChannelResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropVirtualChannelRequest) *datapb.DropVirtualChannelResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.DropVirtualChannelResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.DropVirtualChannelRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_DropVirtualChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropVirtualChannel'
|
|
type DataCoord_DropVirtualChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropVirtualChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.DropVirtualChannelRequest
|
|
func (_e *DataCoord_Expecter) DropVirtualChannel(ctx interface{}, req interface{}) *DataCoord_DropVirtualChannel_Call {
|
|
return &DataCoord_DropVirtualChannel_Call{Call: _e.mock.On("DropVirtualChannel", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_DropVirtualChannel_Call) Run(run func(ctx context.Context, req *datapb.DropVirtualChannelRequest)) *DataCoord_DropVirtualChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.DropVirtualChannelRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_DropVirtualChannel_Call) Return(_a0 *datapb.DropVirtualChannelResponse, _a1 error) *DataCoord_DropVirtualChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Flush provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) Flush(ctx context.Context, req *datapb.FlushRequest) (*datapb.FlushResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.FlushResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushRequest) *datapb.FlushResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.FlushResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.FlushRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
|
|
type DataCoord_Flush_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Flush is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.FlushRequest
|
|
func (_e *DataCoord_Expecter) Flush(ctx interface{}, req interface{}) *DataCoord_Flush_Call {
|
|
return &DataCoord_Flush_Call{Call: _e.mock.On("Flush", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_Flush_Call) Run(run func(ctx context.Context, req *datapb.FlushRequest)) *DataCoord_Flush_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.FlushRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_Flush_Call) Return(_a0 *datapb.FlushResponse, _a1 error) *DataCoord_Flush_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetCollectionStatistics provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetCollectionStatistics(ctx context.Context, req *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.GetCollectionStatisticsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetCollectionStatisticsRequest) *datapb.GetCollectionStatisticsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetCollectionStatisticsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetCollectionStatisticsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetCollectionStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCollectionStatistics'
|
|
type DataCoord_GetCollectionStatistics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCollectionStatistics is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.GetCollectionStatisticsRequest
|
|
func (_e *DataCoord_Expecter) GetCollectionStatistics(ctx interface{}, req interface{}) *DataCoord_GetCollectionStatistics_Call {
|
|
return &DataCoord_GetCollectionStatistics_Call{Call: _e.mock.On("GetCollectionStatistics", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetCollectionStatistics_Call) Run(run func(ctx context.Context, req *datapb.GetCollectionStatisticsRequest)) *DataCoord_GetCollectionStatistics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetCollectionStatisticsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetCollectionStatistics_Call) Return(_a0 *datapb.GetCollectionStatisticsResponse, _a1 error) *DataCoord_GetCollectionStatistics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetCompactionState provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetCompactionState(ctx context.Context, req *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.GetCompactionStateResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionStateRequest) *milvuspb.GetCompactionStateResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetCompactionStateResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetCompactionStateRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetCompactionState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionState'
|
|
type DataCoord_GetCompactionState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCompactionState is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.GetCompactionStateRequest
|
|
func (_e *DataCoord_Expecter) GetCompactionState(ctx interface{}, req interface{}) *DataCoord_GetCompactionState_Call {
|
|
return &DataCoord_GetCompactionState_Call{Call: _e.mock.On("GetCompactionState", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetCompactionState_Call) Run(run func(ctx context.Context, req *milvuspb.GetCompactionStateRequest)) *DataCoord_GetCompactionState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetCompactionStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetCompactionState_Call) Return(_a0 *milvuspb.GetCompactionStateResponse, _a1 error) *DataCoord_GetCompactionState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetCompactionStateWithPlans provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetCompactionStateWithPlans(ctx context.Context, req *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.GetCompactionPlansResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionPlansRequest) *milvuspb.GetCompactionPlansResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetCompactionPlansResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetCompactionPlansRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetCompactionStateWithPlans_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionStateWithPlans'
|
|
type DataCoord_GetCompactionStateWithPlans_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCompactionStateWithPlans is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.GetCompactionPlansRequest
|
|
func (_e *DataCoord_Expecter) GetCompactionStateWithPlans(ctx interface{}, req interface{}) *DataCoord_GetCompactionStateWithPlans_Call {
|
|
return &DataCoord_GetCompactionStateWithPlans_Call{Call: _e.mock.On("GetCompactionStateWithPlans", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetCompactionStateWithPlans_Call) Run(run func(ctx context.Context, req *milvuspb.GetCompactionPlansRequest)) *DataCoord_GetCompactionStateWithPlans_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetCompactionPlansRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetCompactionStateWithPlans_Call) Return(_a0 *milvuspb.GetCompactionPlansResponse, _a1 error) *DataCoord_GetCompactionStateWithPlans_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetComponentStates provides a mock function with given fields: ctx
|
|
func (_m *DataCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 *milvuspb.ComponentStates
|
|
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.ComponentStates); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ComponentStates)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetComponentStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComponentStates'
|
|
type DataCoord_GetComponentStates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetComponentStates is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *DataCoord_Expecter) GetComponentStates(ctx interface{}) *DataCoord_GetComponentStates_Call {
|
|
return &DataCoord_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", ctx)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetComponentStates_Call) Run(run func(ctx context.Context)) *DataCoord_GetComponentStates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *DataCoord_GetComponentStates_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetFlushState provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.GetFlushStateResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetFlushStateRequest) *milvuspb.GetFlushStateResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetFlushStateResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetFlushStateRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetFlushState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushState'
|
|
type DataCoord_GetFlushState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFlushState is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.GetFlushStateRequest
|
|
func (_e *DataCoord_Expecter) GetFlushState(ctx interface{}, req interface{}) *DataCoord_GetFlushState_Call {
|
|
return &DataCoord_GetFlushState_Call{Call: _e.mock.On("GetFlushState", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetFlushState_Call) Run(run func(ctx context.Context, req *milvuspb.GetFlushStateRequest)) *DataCoord_GetFlushState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetFlushStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetFlushState_Call) Return(_a0 *milvuspb.GetFlushStateResponse, _a1 error) *DataCoord_GetFlushState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetFlushedSegments provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetFlushedSegments(ctx context.Context, req *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.GetFlushedSegmentsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushedSegmentsRequest) *datapb.GetFlushedSegmentsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetFlushedSegmentsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetFlushedSegmentsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetFlushedSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushedSegments'
|
|
type DataCoord_GetFlushedSegments_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFlushedSegments is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.GetFlushedSegmentsRequest
|
|
func (_e *DataCoord_Expecter) GetFlushedSegments(ctx interface{}, req interface{}) *DataCoord_GetFlushedSegments_Call {
|
|
return &DataCoord_GetFlushedSegments_Call{Call: _e.mock.On("GetFlushedSegments", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetFlushedSegments_Call) Run(run func(ctx context.Context, req *datapb.GetFlushedSegmentsRequest)) *DataCoord_GetFlushedSegments_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetFlushedSegmentsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetFlushedSegments_Call) Return(_a0 *datapb.GetFlushedSegmentsResponse, _a1 error) *DataCoord_GetFlushedSegments_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetInsertBinlogPaths provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetInsertBinlogPaths(ctx context.Context, req *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.GetInsertBinlogPathsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetInsertBinlogPathsRequest) *datapb.GetInsertBinlogPathsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetInsertBinlogPathsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetInsertBinlogPathsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetInsertBinlogPaths_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInsertBinlogPaths'
|
|
type DataCoord_GetInsertBinlogPaths_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetInsertBinlogPaths is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.GetInsertBinlogPathsRequest
|
|
func (_e *DataCoord_Expecter) GetInsertBinlogPaths(ctx interface{}, req interface{}) *DataCoord_GetInsertBinlogPaths_Call {
|
|
return &DataCoord_GetInsertBinlogPaths_Call{Call: _e.mock.On("GetInsertBinlogPaths", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetInsertBinlogPaths_Call) Run(run func(ctx context.Context, req *datapb.GetInsertBinlogPathsRequest)) *DataCoord_GetInsertBinlogPaths_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetInsertBinlogPathsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetInsertBinlogPaths_Call) Return(_a0 *datapb.GetInsertBinlogPathsResponse, _a1 error) *DataCoord_GetInsertBinlogPaths_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetMetrics provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.GetMetricsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetMetricsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetMetricsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetrics'
|
|
type DataCoord_GetMetrics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetMetrics is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.GetMetricsRequest
|
|
func (_e *DataCoord_Expecter) GetMetrics(ctx interface{}, req interface{}) *DataCoord_GetMetrics_Call {
|
|
return &DataCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetMetrics_Call) Run(run func(ctx context.Context, req *milvuspb.GetMetricsRequest)) *DataCoord_GetMetrics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetMetricsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetMetrics_Call) Return(_a0 *milvuspb.GetMetricsResponse, _a1 error) *DataCoord_GetMetrics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetPartitionStatistics provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetPartitionStatistics(ctx context.Context, req *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.GetPartitionStatisticsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetPartitionStatisticsRequest) *datapb.GetPartitionStatisticsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetPartitionStatisticsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetPartitionStatisticsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetPartitionStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPartitionStatistics'
|
|
type DataCoord_GetPartitionStatistics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetPartitionStatistics is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.GetPartitionStatisticsRequest
|
|
func (_e *DataCoord_Expecter) GetPartitionStatistics(ctx interface{}, req interface{}) *DataCoord_GetPartitionStatistics_Call {
|
|
return &DataCoord_GetPartitionStatistics_Call{Call: _e.mock.On("GetPartitionStatistics", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetPartitionStatistics_Call) Run(run func(ctx context.Context, req *datapb.GetPartitionStatisticsRequest)) *DataCoord_GetPartitionStatistics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetPartitionStatisticsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetPartitionStatistics_Call) Return(_a0 *datapb.GetPartitionStatisticsResponse, _a1 error) *DataCoord_GetPartitionStatistics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetRecoveryInfo provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetRecoveryInfo(ctx context.Context, req *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.GetRecoveryInfoResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequest) *datapb.GetRecoveryInfoResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetRecoveryInfoResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetRecoveryInfoRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetRecoveryInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecoveryInfo'
|
|
type DataCoord_GetRecoveryInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRecoveryInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.GetRecoveryInfoRequest
|
|
func (_e *DataCoord_Expecter) GetRecoveryInfo(ctx interface{}, req interface{}) *DataCoord_GetRecoveryInfo_Call {
|
|
return &DataCoord_GetRecoveryInfo_Call{Call: _e.mock.On("GetRecoveryInfo", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetRecoveryInfo_Call) Run(run func(ctx context.Context, req *datapb.GetRecoveryInfoRequest)) *DataCoord_GetRecoveryInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetRecoveryInfoRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetRecoveryInfo_Call) Return(_a0 *datapb.GetRecoveryInfoResponse, _a1 error) *DataCoord_GetRecoveryInfo_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentInfo provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetSegmentInfo(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.GetSegmentInfoResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoRequest) *datapb.GetSegmentInfoResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetSegmentInfoResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentInfoRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetSegmentInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentInfo'
|
|
type DataCoord_GetSegmentInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.GetSegmentInfoRequest
|
|
func (_e *DataCoord_Expecter) GetSegmentInfo(ctx interface{}, req interface{}) *DataCoord_GetSegmentInfo_Call {
|
|
return &DataCoord_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetSegmentInfo_Call) Run(run func(ctx context.Context, req *datapb.GetSegmentInfoRequest)) *DataCoord_GetSegmentInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetSegmentInfoRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetSegmentInfo_Call) Return(_a0 *datapb.GetSegmentInfoResponse, _a1 error) *DataCoord_GetSegmentInfo_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentInfoChannel provides a mock function with given fields: ctx
|
|
func (_m *DataCoord) GetSegmentInfoChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 *milvuspb.StringResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.StringResponse); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.StringResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetSegmentInfoChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentInfoChannel'
|
|
type DataCoord_GetSegmentInfoChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentInfoChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *DataCoord_Expecter) GetSegmentInfoChannel(ctx interface{}) *DataCoord_GetSegmentInfoChannel_Call {
|
|
return &DataCoord_GetSegmentInfoChannel_Call{Call: _e.mock.On("GetSegmentInfoChannel", ctx)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetSegmentInfoChannel_Call) Run(run func(ctx context.Context)) *DataCoord_GetSegmentInfoChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetSegmentInfoChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *DataCoord_GetSegmentInfoChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentStates provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetSegmentStates(ctx context.Context, req *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.GetSegmentStatesResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentStatesRequest) *datapb.GetSegmentStatesResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetSegmentStatesResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentStatesRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetSegmentStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentStates'
|
|
type DataCoord_GetSegmentStates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentStates is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.GetSegmentStatesRequest
|
|
func (_e *DataCoord_Expecter) GetSegmentStates(ctx interface{}, req interface{}) *DataCoord_GetSegmentStates_Call {
|
|
return &DataCoord_GetSegmentStates_Call{Call: _e.mock.On("GetSegmentStates", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetSegmentStates_Call) Run(run func(ctx context.Context, req *datapb.GetSegmentStatesRequest)) *DataCoord_GetSegmentStates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetSegmentStatesRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetSegmentStates_Call) Return(_a0 *datapb.GetSegmentStatesResponse, _a1 error) *DataCoord_GetSegmentStates_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentsByStates provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) GetSegmentsByStates(ctx context.Context, req *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.GetSegmentsByStatesResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentsByStatesRequest) *datapb.GetSegmentsByStatesResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetSegmentsByStatesResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentsByStatesRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetSegmentsByStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentsByStates'
|
|
type DataCoord_GetSegmentsByStates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentsByStates is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.GetSegmentsByStatesRequest
|
|
func (_e *DataCoord_Expecter) GetSegmentsByStates(ctx interface{}, req interface{}) *DataCoord_GetSegmentsByStates_Call {
|
|
return &DataCoord_GetSegmentsByStates_Call{Call: _e.mock.On("GetSegmentsByStates", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetSegmentsByStates_Call) Run(run func(ctx context.Context, req *datapb.GetSegmentsByStatesRequest)) *DataCoord_GetSegmentsByStates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetSegmentsByStatesRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetSegmentsByStates_Call) Return(_a0 *datapb.GetSegmentsByStatesResponse, _a1 error) *DataCoord_GetSegmentsByStates_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetStatisticsChannel provides a mock function with given fields: ctx
|
|
func (_m *DataCoord) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 *milvuspb.StringResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.StringResponse); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.StringResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetStatisticsChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatisticsChannel'
|
|
type DataCoord_GetStatisticsChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetStatisticsChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *DataCoord_Expecter) GetStatisticsChannel(ctx interface{}) *DataCoord_GetStatisticsChannel_Call {
|
|
return &DataCoord_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", ctx)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetStatisticsChannel_Call) Run(run func(ctx context.Context)) *DataCoord_GetStatisticsChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetStatisticsChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *DataCoord_GetStatisticsChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetTimeTickChannel provides a mock function with given fields: ctx
|
|
func (_m *DataCoord) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 *milvuspb.StringResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.StringResponse); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.StringResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_GetTimeTickChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTimeTickChannel'
|
|
type DataCoord_GetTimeTickChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTimeTickChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *DataCoord_Expecter) GetTimeTickChannel(ctx interface{}) *DataCoord_GetTimeTickChannel_Call {
|
|
return &DataCoord_GetTimeTickChannel_Call{Call: _e.mock.On("GetTimeTickChannel", ctx)}
|
|
}
|
|
|
|
func (_c *DataCoord_GetTimeTickChannel_Call) Run(run func(ctx context.Context)) *DataCoord_GetTimeTickChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_GetTimeTickChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *DataCoord_GetTimeTickChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Import provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.ImportTaskResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportTaskRequest) *datapb.ImportTaskResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.ImportTaskResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.ImportTaskRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_Import_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Import'
|
|
type DataCoord_Import_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Import is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.ImportTaskRequest
|
|
func (_e *DataCoord_Expecter) Import(ctx interface{}, req interface{}) *DataCoord_Import_Call {
|
|
return &DataCoord_Import_Call{Call: _e.mock.On("Import", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_Import_Call) Run(run func(ctx context.Context, req *datapb.ImportTaskRequest)) *DataCoord_Import_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.ImportTaskRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_Import_Call) Return(_a0 *datapb.ImportTaskResponse, _a1 error) *DataCoord_Import_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Init provides a mock function with given fields:
|
|
func (_m *DataCoord) Init() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DataCoord_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init'
|
|
type DataCoord_Init_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Init is a helper method to define mock.On call
|
|
func (_e *DataCoord_Expecter) Init() *DataCoord_Init_Call {
|
|
return &DataCoord_Init_Call{Call: _e.mock.On("Init")}
|
|
}
|
|
|
|
func (_c *DataCoord_Init_Call) Run(run func()) *DataCoord_Init_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_Init_Call) Return(_a0 error) *DataCoord_Init_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// ManualCompaction provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) ManualCompaction(ctx context.Context, req *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.ManualCompactionResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ManualCompactionRequest) *milvuspb.ManualCompactionResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ManualCompactionResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ManualCompactionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_ManualCompaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManualCompaction'
|
|
type DataCoord_ManualCompaction_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ManualCompaction is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.ManualCompactionRequest
|
|
func (_e *DataCoord_Expecter) ManualCompaction(ctx interface{}, req interface{}) *DataCoord_ManualCompaction_Call {
|
|
return &DataCoord_ManualCompaction_Call{Call: _e.mock.On("ManualCompaction", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_ManualCompaction_Call) Run(run func(ctx context.Context, req *milvuspb.ManualCompactionRequest)) *DataCoord_ManualCompaction_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ManualCompactionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_ManualCompaction_Call) Return(_a0 *milvuspb.ManualCompactionResponse, _a1 error) *DataCoord_ManualCompaction_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// MarkSegmentsDropped provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) MarkSegmentsDropped(ctx context.Context, req *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_MarkSegmentsDropped_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkSegmentsDropped'
|
|
type DataCoord_MarkSegmentsDropped_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// MarkSegmentsDropped is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.MarkSegmentsDroppedRequest
|
|
func (_e *DataCoord_Expecter) MarkSegmentsDropped(ctx interface{}, req interface{}) *DataCoord_MarkSegmentsDropped_Call {
|
|
return &DataCoord_MarkSegmentsDropped_Call{Call: _e.mock.On("MarkSegmentsDropped", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_MarkSegmentsDropped_Call) Run(run func(ctx context.Context, req *datapb.MarkSegmentsDroppedRequest)) *DataCoord_MarkSegmentsDropped_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.MarkSegmentsDroppedRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_MarkSegmentsDropped_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_MarkSegmentsDropped_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Register provides a mock function with given fields:
|
|
func (_m *DataCoord) Register() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DataCoord_Register_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Register'
|
|
type DataCoord_Register_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Register is a helper method to define mock.On call
|
|
func (_e *DataCoord_Expecter) Register() *DataCoord_Register_Call {
|
|
return &DataCoord_Register_Call{Call: _e.mock.On("Register")}
|
|
}
|
|
|
|
func (_c *DataCoord_Register_Call) Run(run func()) *DataCoord_Register_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_Register_Call) Return(_a0 error) *DataCoord_Register_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// ReleaseSegmentLock provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) ReleaseSegmentLock(ctx context.Context, req *datapb.ReleaseSegmentLockRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.ReleaseSegmentLockRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.ReleaseSegmentLockRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_ReleaseSegmentLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseSegmentLock'
|
|
type DataCoord_ReleaseSegmentLock_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ReleaseSegmentLock is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.ReleaseSegmentLockRequest
|
|
func (_e *DataCoord_Expecter) ReleaseSegmentLock(ctx interface{}, req interface{}) *DataCoord_ReleaseSegmentLock_Call {
|
|
return &DataCoord_ReleaseSegmentLock_Call{Call: _e.mock.On("ReleaseSegmentLock", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_ReleaseSegmentLock_Call) Run(run func(ctx context.Context, req *datapb.ReleaseSegmentLockRequest)) *DataCoord_ReleaseSegmentLock_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.ReleaseSegmentLockRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_ReleaseSegmentLock_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_ReleaseSegmentLock_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// SaveBinlogPaths provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveBinlogPathsRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.SaveBinlogPathsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_SaveBinlogPaths_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveBinlogPaths'
|
|
type DataCoord_SaveBinlogPaths_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SaveBinlogPaths is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.SaveBinlogPathsRequest
|
|
func (_e *DataCoord_Expecter) SaveBinlogPaths(ctx interface{}, req interface{}) *DataCoord_SaveBinlogPaths_Call {
|
|
return &DataCoord_SaveBinlogPaths_Call{Call: _e.mock.On("SaveBinlogPaths", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_SaveBinlogPaths_Call) Run(run func(ctx context.Context, req *datapb.SaveBinlogPathsRequest)) *DataCoord_SaveBinlogPaths_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.SaveBinlogPathsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_SaveBinlogPaths_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_SaveBinlogPaths_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// SaveImportSegment provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) SaveImportSegment(ctx context.Context, req *datapb.SaveImportSegmentRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveImportSegmentRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.SaveImportSegmentRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_SaveImportSegment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveImportSegment'
|
|
type DataCoord_SaveImportSegment_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SaveImportSegment is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.SaveImportSegmentRequest
|
|
func (_e *DataCoord_Expecter) SaveImportSegment(ctx interface{}, req interface{}) *DataCoord_SaveImportSegment_Call {
|
|
return &DataCoord_SaveImportSegment_Call{Call: _e.mock.On("SaveImportSegment", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_SaveImportSegment_Call) Run(run func(ctx context.Context, req *datapb.SaveImportSegmentRequest)) *DataCoord_SaveImportSegment_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.SaveImportSegmentRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_SaveImportSegment_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_SaveImportSegment_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// SetSegmentState provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.SetSegmentStateResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.SetSegmentStateRequest) *datapb.SetSegmentStateResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.SetSegmentStateResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.SetSegmentStateRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_SetSegmentState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSegmentState'
|
|
type DataCoord_SetSegmentState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetSegmentState is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.SetSegmentStateRequest
|
|
func (_e *DataCoord_Expecter) SetSegmentState(ctx interface{}, req interface{}) *DataCoord_SetSegmentState_Call {
|
|
return &DataCoord_SetSegmentState_Call{Call: _e.mock.On("SetSegmentState", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_SetSegmentState_Call) Run(run func(ctx context.Context, req *datapb.SetSegmentStateRequest)) *DataCoord_SetSegmentState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.SetSegmentStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_SetSegmentState_Call) Return(_a0 *datapb.SetSegmentStateResponse, _a1 error) *DataCoord_SetSegmentState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ShowConfigurations provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *internalpb.ShowConfigurationsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) *internalpb.ShowConfigurationsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*internalpb.ShowConfigurationsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ShowConfigurationsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_ShowConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowConfigurations'
|
|
type DataCoord_ShowConfigurations_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowConfigurations is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *internalpb.ShowConfigurationsRequest
|
|
func (_e *DataCoord_Expecter) ShowConfigurations(ctx interface{}, req interface{}) *DataCoord_ShowConfigurations_Call {
|
|
return &DataCoord_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_ShowConfigurations_Call) Run(run func(ctx context.Context, req *internalpb.ShowConfigurationsRequest)) *DataCoord_ShowConfigurations_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.ShowConfigurationsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_ShowConfigurations_Call) Return(_a0 *internalpb.ShowConfigurationsResponse, _a1 error) *DataCoord_ShowConfigurations_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Start provides a mock function with given fields:
|
|
func (_m *DataCoord) Start() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DataCoord_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
|
type DataCoord_Start_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Start is a helper method to define mock.On call
|
|
func (_e *DataCoord_Expecter) Start() *DataCoord_Start_Call {
|
|
return &DataCoord_Start_Call{Call: _e.mock.On("Start")}
|
|
}
|
|
|
|
func (_c *DataCoord_Start_Call) Run(run func()) *DataCoord_Start_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_Start_Call) Return(_a0 error) *DataCoord_Start_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// Stop provides a mock function with given fields:
|
|
func (_m *DataCoord) Stop() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DataCoord_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
|
|
type DataCoord_Stop_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Stop is a helper method to define mock.On call
|
|
func (_e *DataCoord_Expecter) Stop() *DataCoord_Stop_Call {
|
|
return &DataCoord_Stop_Call{Call: _e.mock.On("Stop")}
|
|
}
|
|
|
|
func (_c *DataCoord_Stop_Call) Run(run func()) *DataCoord_Stop_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_Stop_Call) Return(_a0 error) *DataCoord_Stop_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// UnsetIsImportingState provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) UnsetIsImportingState(ctx context.Context, req *datapb.UnsetIsImportingStateRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.UnsetIsImportingStateRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.UnsetIsImportingStateRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_UnsetIsImportingState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnsetIsImportingState'
|
|
type DataCoord_UnsetIsImportingState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UnsetIsImportingState is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.UnsetIsImportingStateRequest
|
|
func (_e *DataCoord_Expecter) UnsetIsImportingState(ctx interface{}, req interface{}) *DataCoord_UnsetIsImportingState_Call {
|
|
return &DataCoord_UnsetIsImportingState_Call{Call: _e.mock.On("UnsetIsImportingState", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_UnsetIsImportingState_Call) Run(run func(ctx context.Context, req *datapb.UnsetIsImportingStateRequest)) *DataCoord_UnsetIsImportingState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.UnsetIsImportingStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_UnsetIsImportingState_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_UnsetIsImportingState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// UpdateSegmentStatistics provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) UpdateSegmentStatistics(ctx context.Context, req *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_UpdateSegmentStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSegmentStatistics'
|
|
type DataCoord_UpdateSegmentStatistics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateSegmentStatistics is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.UpdateSegmentStatisticsRequest
|
|
func (_e *DataCoord_Expecter) UpdateSegmentStatistics(ctx interface{}, req interface{}) *DataCoord_UpdateSegmentStatistics_Call {
|
|
return &DataCoord_UpdateSegmentStatistics_Call{Call: _e.mock.On("UpdateSegmentStatistics", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_UpdateSegmentStatistics_Call) Run(run func(ctx context.Context, req *datapb.UpdateSegmentStatisticsRequest)) *DataCoord_UpdateSegmentStatistics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.UpdateSegmentStatisticsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_UpdateSegmentStatistics_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_UpdateSegmentStatistics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// WatchChannels provides a mock function with given fields: ctx, req
|
|
func (_m *DataCoord) WatchChannels(ctx context.Context, req *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *datapb.WatchChannelsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.WatchChannelsRequest) *datapb.WatchChannelsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.WatchChannelsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.WatchChannelsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DataCoord_WatchChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchChannels'
|
|
type DataCoord_WatchChannels_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// WatchChannels is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *datapb.WatchChannelsRequest
|
|
func (_e *DataCoord_Expecter) WatchChannels(ctx interface{}, req interface{}) *DataCoord_WatchChannels_Call {
|
|
return &DataCoord_WatchChannels_Call{Call: _e.mock.On("WatchChannels", ctx, req)}
|
|
}
|
|
|
|
func (_c *DataCoord_WatchChannels_Call) Run(run func(ctx context.Context, req *datapb.WatchChannelsRequest)) *DataCoord_WatchChannels_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.WatchChannelsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *DataCoord_WatchChannels_Call) Return(_a0 *datapb.WatchChannelsResponse, _a1 error) *DataCoord_WatchChannels_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
type mockConstructorTestingTNewDataCoord interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}
|
|
|
|
// NewDataCoord creates a new instance of DataCoord. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
func NewDataCoord(t mockConstructorTestingTNewDataCoord) *DataCoord {
|
|
mock := &DataCoord{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|