mirror of
https://gitee.com/milvus-io/milvus.git
synced 2025-12-07 01:28:27 +08:00
b6532d3e44
issue: https://github.com/milvus-io/milvus/issues/45691 Add persistent task management for external collections with automatic detection of external_source and external_spec changes. When source changes, the system aborts running tasks and creates new ones, ensuring only one active task per collection. Tasks validate their source on completion to prevent superseded tasks from committing results. --------- Signed-off-by: sunby <sunbingyi1992@gmail.com>
3408 lines
120 KiB
Go
3408 lines
120 KiB
Go
// Code generated by mockery v2.53.3. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
commonpb "github.com/milvus-io/milvus-proto/go-api/v2/commonpb"
|
|
clientv3 "go.etcd.io/etcd/client/v3"
|
|
|
|
datapb "github.com/milvus-io/milvus/pkg/v2/proto/datapb"
|
|
|
|
indexpb "github.com/milvus-io/milvus/pkg/v2/proto/indexpb"
|
|
|
|
internalpb "github.com/milvus-io/milvus/pkg/v2/proto/internalpb"
|
|
|
|
milvuspb "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
msgpb "github.com/milvus-io/milvus-proto/go-api/v2/msgpb"
|
|
|
|
txnkv "github.com/tikv/client-go/v2/txnkv"
|
|
|
|
types "github.com/milvus-io/milvus/internal/types"
|
|
)
|
|
|
|
// MockDataCoord is an autogenerated mock type for the DataCoordComponent type
|
|
type MockDataCoord struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockDataCoord_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockDataCoord) EXPECT() *MockDataCoord_Expecter {
|
|
return &MockDataCoord_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// AddFileResource provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) AddFileResource(_a0 context.Context, _a1 *milvuspb.AddFileResourceRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddFileResource")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddFileResourceRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddFileResourceRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddFileResourceRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_AddFileResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFileResource'
|
|
type MockDataCoord_AddFileResource_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddFileResource is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.AddFileResourceRequest
|
|
func (_e *MockDataCoord_Expecter) AddFileResource(_a0 interface{}, _a1 interface{}) *MockDataCoord_AddFileResource_Call {
|
|
return &MockDataCoord_AddFileResource_Call{Call: _e.mock.On("AddFileResource", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_AddFileResource_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AddFileResourceRequest)) *MockDataCoord_AddFileResource_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.AddFileResourceRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_AddFileResource_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_AddFileResource_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_AddFileResource_Call) RunAndReturn(run func(context.Context, *milvuspb.AddFileResourceRequest) (*commonpb.Status, error)) *MockDataCoord_AddFileResource_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// AllocSegment provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) AllocSegment(_a0 context.Context, _a1 *datapb.AllocSegmentRequest) (*datapb.AllocSegmentResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AllocSegment")
|
|
}
|
|
|
|
var r0 *datapb.AllocSegmentResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AllocSegmentRequest) (*datapb.AllocSegmentResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AllocSegmentRequest) *datapb.AllocSegmentResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.AllocSegmentResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.AllocSegmentRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_AllocSegment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllocSegment'
|
|
type MockDataCoord_AllocSegment_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AllocSegment is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.AllocSegmentRequest
|
|
func (_e *MockDataCoord_Expecter) AllocSegment(_a0 interface{}, _a1 interface{}) *MockDataCoord_AllocSegment_Call {
|
|
return &MockDataCoord_AllocSegment_Call{Call: _e.mock.On("AllocSegment", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_AllocSegment_Call) Run(run func(_a0 context.Context, _a1 *datapb.AllocSegmentRequest)) *MockDataCoord_AllocSegment_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.AllocSegmentRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_AllocSegment_Call) Return(_a0 *datapb.AllocSegmentResponse, _a1 error) *MockDataCoord_AllocSegment_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_AllocSegment_Call) RunAndReturn(run func(context.Context, *datapb.AllocSegmentRequest) (*datapb.AllocSegmentResponse, error)) *MockDataCoord_AllocSegment_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// AlterIndex provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) AlterIndex(_a0 context.Context, _a1 *indexpb.AlterIndexRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AlterIndex")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.AlterIndexRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.AlterIndexRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.AlterIndexRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_AlterIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterIndex'
|
|
type MockDataCoord_AlterIndex_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AlterIndex is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.AlterIndexRequest
|
|
func (_e *MockDataCoord_Expecter) AlterIndex(_a0 interface{}, _a1 interface{}) *MockDataCoord_AlterIndex_Call {
|
|
return &MockDataCoord_AlterIndex_Call{Call: _e.mock.On("AlterIndex", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_AlterIndex_Call) Run(run func(_a0 context.Context, _a1 *indexpb.AlterIndexRequest)) *MockDataCoord_AlterIndex_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.AlterIndexRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_AlterIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_AlterIndex_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_AlterIndex_Call) RunAndReturn(run func(context.Context, *indexpb.AlterIndexRequest) (*commonpb.Status, error)) *MockDataCoord_AlterIndex_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// AssignSegmentID provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) AssignSegmentID(_a0 context.Context, _a1 *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AssignSegmentID")
|
|
}
|
|
|
|
var r0 *datapb.AssignSegmentIDResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AssignSegmentIDRequest) *datapb.AssignSegmentIDResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.AssignSegmentIDResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.AssignSegmentIDRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_AssignSegmentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignSegmentID'
|
|
type MockDataCoord_AssignSegmentID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AssignSegmentID is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.AssignSegmentIDRequest
|
|
func (_e *MockDataCoord_Expecter) AssignSegmentID(_a0 interface{}, _a1 interface{}) *MockDataCoord_AssignSegmentID_Call {
|
|
return &MockDataCoord_AssignSegmentID_Call{Call: _e.mock.On("AssignSegmentID", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_AssignSegmentID_Call) Run(run func(_a0 context.Context, _a1 *datapb.AssignSegmentIDRequest)) *MockDataCoord_AssignSegmentID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.AssignSegmentIDRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_AssignSegmentID_Call) Return(_a0 *datapb.AssignSegmentIDResponse, _a1 error) *MockDataCoord_AssignSegmentID_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_AssignSegmentID_Call) RunAndReturn(run func(context.Context, *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error)) *MockDataCoord_AssignSegmentID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// BroadcastAlteredCollection provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) BroadcastAlteredCollection(_a0 context.Context, _a1 *datapb.AlterCollectionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for BroadcastAlteredCollection")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.AlterCollectionRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_BroadcastAlteredCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastAlteredCollection'
|
|
type MockDataCoord_BroadcastAlteredCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// BroadcastAlteredCollection is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.AlterCollectionRequest
|
|
func (_e *MockDataCoord_Expecter) BroadcastAlteredCollection(_a0 interface{}, _a1 interface{}) *MockDataCoord_BroadcastAlteredCollection_Call {
|
|
return &MockDataCoord_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_BroadcastAlteredCollection_Call) Run(run func(_a0 context.Context, _a1 *datapb.AlterCollectionRequest)) *MockDataCoord_BroadcastAlteredCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.AlterCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_BroadcastAlteredCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_BroadcastAlteredCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_BroadcastAlteredCollection_Call) RunAndReturn(run func(context.Context, *datapb.AlterCollectionRequest) (*commonpb.Status, error)) *MockDataCoord_BroadcastAlteredCollection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CheckHealth provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) CheckHealth(_a0 context.Context, _a1 *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CheckHealth")
|
|
}
|
|
|
|
var r0 *milvuspb.CheckHealthResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) *milvuspb.CheckHealthResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.CheckHealthResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CheckHealthRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'
|
|
type MockDataCoord_CheckHealth_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CheckHealth is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.CheckHealthRequest
|
|
func (_e *MockDataCoord_Expecter) CheckHealth(_a0 interface{}, _a1 interface{}) *MockDataCoord_CheckHealth_Call {
|
|
return &MockDataCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_CheckHealth_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.CheckHealthRequest)) *MockDataCoord_CheckHealth_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *MockDataCoord_CheckHealth_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_CheckHealth_Call) RunAndReturn(run func(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)) *MockDataCoord_CheckHealth_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateExternalCollection provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) CreateExternalCollection(_a0 context.Context, _a1 *msgpb.CreateCollectionRequest) (*datapb.CreateExternalCollectionResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateExternalCollection")
|
|
}
|
|
|
|
var r0 *datapb.CreateExternalCollectionResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *msgpb.CreateCollectionRequest) (*datapb.CreateExternalCollectionResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *msgpb.CreateCollectionRequest) *datapb.CreateExternalCollectionResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.CreateExternalCollectionResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *msgpb.CreateCollectionRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_CreateExternalCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateExternalCollection'
|
|
type MockDataCoord_CreateExternalCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateExternalCollection is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *msgpb.CreateCollectionRequest
|
|
func (_e *MockDataCoord_Expecter) CreateExternalCollection(_a0 interface{}, _a1 interface{}) *MockDataCoord_CreateExternalCollection_Call {
|
|
return &MockDataCoord_CreateExternalCollection_Call{Call: _e.mock.On("CreateExternalCollection", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_CreateExternalCollection_Call) Run(run func(_a0 context.Context, _a1 *msgpb.CreateCollectionRequest)) *MockDataCoord_CreateExternalCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*msgpb.CreateCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_CreateExternalCollection_Call) Return(_a0 *datapb.CreateExternalCollectionResponse, _a1 error) *MockDataCoord_CreateExternalCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_CreateExternalCollection_Call) RunAndReturn(run func(context.Context, *msgpb.CreateCollectionRequest) (*datapb.CreateExternalCollectionResponse, error)) *MockDataCoord_CreateExternalCollection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateIndex provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) CreateIndex(_a0 context.Context, _a1 *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateIndex")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.CreateIndexRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex'
|
|
type MockDataCoord_CreateIndex_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateIndex is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.CreateIndexRequest
|
|
func (_e *MockDataCoord_Expecter) CreateIndex(_a0 interface{}, _a1 interface{}) *MockDataCoord_CreateIndex_Call {
|
|
return &MockDataCoord_CreateIndex_Call{Call: _e.mock.On("CreateIndex", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_CreateIndex_Call) Run(run func(_a0 context.Context, _a1 *indexpb.CreateIndexRequest)) *MockDataCoord_CreateIndex_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.CreateIndexRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_CreateIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_CreateIndex_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_CreateIndex_Call) RunAndReturn(run func(context.Context, *indexpb.CreateIndexRequest) (*commonpb.Status, error)) *MockDataCoord_CreateIndex_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DescribeIndex provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) DescribeIndex(_a0 context.Context, _a1 *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DescribeIndex")
|
|
}
|
|
|
|
var r0 *indexpb.DescribeIndexResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DescribeIndexRequest) *indexpb.DescribeIndexResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*indexpb.DescribeIndexResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DescribeIndexRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_DescribeIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIndex'
|
|
type MockDataCoord_DescribeIndex_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DescribeIndex is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.DescribeIndexRequest
|
|
func (_e *MockDataCoord_Expecter) DescribeIndex(_a0 interface{}, _a1 interface{}) *MockDataCoord_DescribeIndex_Call {
|
|
return &MockDataCoord_DescribeIndex_Call{Call: _e.mock.On("DescribeIndex", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_DescribeIndex_Call) Run(run func(_a0 context.Context, _a1 *indexpb.DescribeIndexRequest)) *MockDataCoord_DescribeIndex_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.DescribeIndexRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_DescribeIndex_Call) Return(_a0 *indexpb.DescribeIndexResponse, _a1 error) *MockDataCoord_DescribeIndex_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_DescribeIndex_Call) RunAndReturn(run func(context.Context, *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)) *MockDataCoord_DescribeIndex_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DropIndex provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) DropIndex(_a0 context.Context, _a1 *indexpb.DropIndexRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DropIndex")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DropIndexRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_DropIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropIndex'
|
|
type MockDataCoord_DropIndex_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropIndex is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.DropIndexRequest
|
|
func (_e *MockDataCoord_Expecter) DropIndex(_a0 interface{}, _a1 interface{}) *MockDataCoord_DropIndex_Call {
|
|
return &MockDataCoord_DropIndex_Call{Call: _e.mock.On("DropIndex", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_DropIndex_Call) Run(run func(_a0 context.Context, _a1 *indexpb.DropIndexRequest)) *MockDataCoord_DropIndex_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.DropIndexRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_DropIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_DropIndex_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_DropIndex_Call) RunAndReturn(run func(context.Context, *indexpb.DropIndexRequest) (*commonpb.Status, error)) *MockDataCoord_DropIndex_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DropVirtualChannel provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) DropVirtualChannel(_a0 context.Context, _a1 *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DropVirtualChannel")
|
|
}
|
|
|
|
var r0 *datapb.DropVirtualChannelResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropVirtualChannelRequest) *datapb.DropVirtualChannelResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.DropVirtualChannelResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.DropVirtualChannelRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_DropVirtualChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropVirtualChannel'
|
|
type MockDataCoord_DropVirtualChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropVirtualChannel is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.DropVirtualChannelRequest
|
|
func (_e *MockDataCoord_Expecter) DropVirtualChannel(_a0 interface{}, _a1 interface{}) *MockDataCoord_DropVirtualChannel_Call {
|
|
return &MockDataCoord_DropVirtualChannel_Call{Call: _e.mock.On("DropVirtualChannel", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_DropVirtualChannel_Call) Run(run func(_a0 context.Context, _a1 *datapb.DropVirtualChannelRequest)) *MockDataCoord_DropVirtualChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.DropVirtualChannelRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_DropVirtualChannel_Call) Return(_a0 *datapb.DropVirtualChannelResponse, _a1 error) *MockDataCoord_DropVirtualChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_DropVirtualChannel_Call) RunAndReturn(run func(context.Context, *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error)) *MockDataCoord_DropVirtualChannel_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Flush provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) Flush(_a0 context.Context, _a1 *datapb.FlushRequest) (*datapb.FlushResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Flush")
|
|
}
|
|
|
|
var r0 *datapb.FlushResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushRequest) (*datapb.FlushResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushRequest) *datapb.FlushResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.FlushResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.FlushRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
|
|
type MockDataCoord_Flush_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Flush is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.FlushRequest
|
|
func (_e *MockDataCoord_Expecter) Flush(_a0 interface{}, _a1 interface{}) *MockDataCoord_Flush_Call {
|
|
return &MockDataCoord_Flush_Call{Call: _e.mock.On("Flush", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_Flush_Call) Run(run func(_a0 context.Context, _a1 *datapb.FlushRequest)) *MockDataCoord_Flush_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.FlushRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Flush_Call) Return(_a0 *datapb.FlushResponse, _a1 error) *MockDataCoord_Flush_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Flush_Call) RunAndReturn(run func(context.Context, *datapb.FlushRequest) (*datapb.FlushResponse, error)) *MockDataCoord_Flush_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// FlushAll provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) FlushAll(_a0 context.Context, _a1 *datapb.FlushAllRequest) (*datapb.FlushAllResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for FlushAll")
|
|
}
|
|
|
|
var r0 *datapb.FlushAllResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushAllRequest) (*datapb.FlushAllResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushAllRequest) *datapb.FlushAllResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.FlushAllResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.FlushAllRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_FlushAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlushAll'
|
|
type MockDataCoord_FlushAll_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// FlushAll is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.FlushAllRequest
|
|
func (_e *MockDataCoord_Expecter) FlushAll(_a0 interface{}, _a1 interface{}) *MockDataCoord_FlushAll_Call {
|
|
return &MockDataCoord_FlushAll_Call{Call: _e.mock.On("FlushAll", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_FlushAll_Call) Run(run func(_a0 context.Context, _a1 *datapb.FlushAllRequest)) *MockDataCoord_FlushAll_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.FlushAllRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_FlushAll_Call) Return(_a0 *datapb.FlushAllResponse, _a1 error) *MockDataCoord_FlushAll_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_FlushAll_Call) RunAndReturn(run func(context.Context, *datapb.FlushAllRequest) (*datapb.FlushAllResponse, error)) *MockDataCoord_FlushAll_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GcConfirm provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GcConfirm(_a0 context.Context, _a1 *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GcConfirm")
|
|
}
|
|
|
|
var r0 *datapb.GcConfirmResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcConfirmRequest) *datapb.GcConfirmResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GcConfirmResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GcConfirmRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GcConfirm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GcConfirm'
|
|
type MockDataCoord_GcConfirm_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GcConfirm is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GcConfirmRequest
|
|
func (_e *MockDataCoord_Expecter) GcConfirm(_a0 interface{}, _a1 interface{}) *MockDataCoord_GcConfirm_Call {
|
|
return &MockDataCoord_GcConfirm_Call{Call: _e.mock.On("GcConfirm", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GcConfirm_Call) Run(run func(_a0 context.Context, _a1 *datapb.GcConfirmRequest)) *MockDataCoord_GcConfirm_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GcConfirmRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GcConfirm_Call) Return(_a0 *datapb.GcConfirmResponse, _a1 error) *MockDataCoord_GcConfirm_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GcConfirm_Call) RunAndReturn(run func(context.Context, *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error)) *MockDataCoord_GcConfirm_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GcControl provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GcControl(_a0 context.Context, _a1 *datapb.GcControlRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GcControl")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcControlRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcControlRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GcControlRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GcControl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GcControl'
|
|
type MockDataCoord_GcControl_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GcControl is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GcControlRequest
|
|
func (_e *MockDataCoord_Expecter) GcControl(_a0 interface{}, _a1 interface{}) *MockDataCoord_GcControl_Call {
|
|
return &MockDataCoord_GcControl_Call{Call: _e.mock.On("GcControl", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GcControl_Call) Run(run func(_a0 context.Context, _a1 *datapb.GcControlRequest)) *MockDataCoord_GcControl_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GcControlRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GcControl_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_GcControl_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GcControl_Call) RunAndReturn(run func(context.Context, *datapb.GcControlRequest) (*commonpb.Status, error)) *MockDataCoord_GcControl_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetChannelRecoveryInfo provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetChannelRecoveryInfo(_a0 context.Context, _a1 *datapb.GetChannelRecoveryInfoRequest) (*datapb.GetChannelRecoveryInfoResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetChannelRecoveryInfo")
|
|
}
|
|
|
|
var r0 *datapb.GetChannelRecoveryInfoResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetChannelRecoveryInfoRequest) (*datapb.GetChannelRecoveryInfoResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetChannelRecoveryInfoRequest) *datapb.GetChannelRecoveryInfoResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetChannelRecoveryInfoResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetChannelRecoveryInfoRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetChannelRecoveryInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChannelRecoveryInfo'
|
|
type MockDataCoord_GetChannelRecoveryInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetChannelRecoveryInfo is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetChannelRecoveryInfoRequest
|
|
func (_e *MockDataCoord_Expecter) GetChannelRecoveryInfo(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetChannelRecoveryInfo_Call {
|
|
return &MockDataCoord_GetChannelRecoveryInfo_Call{Call: _e.mock.On("GetChannelRecoveryInfo", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetChannelRecoveryInfo_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetChannelRecoveryInfoRequest)) *MockDataCoord_GetChannelRecoveryInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetChannelRecoveryInfoRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetChannelRecoveryInfo_Call) Return(_a0 *datapb.GetChannelRecoveryInfoResponse, _a1 error) *MockDataCoord_GetChannelRecoveryInfo_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetChannelRecoveryInfo_Call) RunAndReturn(run func(context.Context, *datapb.GetChannelRecoveryInfoRequest) (*datapb.GetChannelRecoveryInfoResponse, error)) *MockDataCoord_GetChannelRecoveryInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCollectionStatistics provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetCollectionStatistics(_a0 context.Context, _a1 *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCollectionStatistics")
|
|
}
|
|
|
|
var r0 *datapb.GetCollectionStatisticsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetCollectionStatisticsRequest) *datapb.GetCollectionStatisticsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetCollectionStatisticsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetCollectionStatisticsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetCollectionStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCollectionStatistics'
|
|
type MockDataCoord_GetCollectionStatistics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCollectionStatistics is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetCollectionStatisticsRequest
|
|
func (_e *MockDataCoord_Expecter) GetCollectionStatistics(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetCollectionStatistics_Call {
|
|
return &MockDataCoord_GetCollectionStatistics_Call{Call: _e.mock.On("GetCollectionStatistics", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCollectionStatistics_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetCollectionStatisticsRequest)) *MockDataCoord_GetCollectionStatistics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetCollectionStatisticsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCollectionStatistics_Call) Return(_a0 *datapb.GetCollectionStatisticsResponse, _a1 error) *MockDataCoord_GetCollectionStatistics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCollectionStatistics_Call) RunAndReturn(run func(context.Context, *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error)) *MockDataCoord_GetCollectionStatistics_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCompactionState provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetCompactionState(_a0 context.Context, _a1 *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCompactionState")
|
|
}
|
|
|
|
var r0 *milvuspb.GetCompactionStateResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionStateRequest) *milvuspb.GetCompactionStateResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetCompactionStateResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetCompactionStateRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetCompactionState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionState'
|
|
type MockDataCoord_GetCompactionState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCompactionState is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.GetCompactionStateRequest
|
|
func (_e *MockDataCoord_Expecter) GetCompactionState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetCompactionState_Call {
|
|
return &MockDataCoord_GetCompactionState_Call{Call: _e.mock.On("GetCompactionState", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCompactionState_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.GetCompactionStateRequest)) *MockDataCoord_GetCompactionState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetCompactionStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCompactionState_Call) Return(_a0 *milvuspb.GetCompactionStateResponse, _a1 error) *MockDataCoord_GetCompactionState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCompactionState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error)) *MockDataCoord_GetCompactionState_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCompactionStateWithPlans provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetCompactionStateWithPlans(_a0 context.Context, _a1 *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCompactionStateWithPlans")
|
|
}
|
|
|
|
var r0 *milvuspb.GetCompactionPlansResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionPlansRequest) *milvuspb.GetCompactionPlansResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetCompactionPlansResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetCompactionPlansRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetCompactionStateWithPlans_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionStateWithPlans'
|
|
type MockDataCoord_GetCompactionStateWithPlans_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCompactionStateWithPlans is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.GetCompactionPlansRequest
|
|
func (_e *MockDataCoord_Expecter) GetCompactionStateWithPlans(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetCompactionStateWithPlans_Call {
|
|
return &MockDataCoord_GetCompactionStateWithPlans_Call{Call: _e.mock.On("GetCompactionStateWithPlans", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCompactionStateWithPlans_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.GetCompactionPlansRequest)) *MockDataCoord_GetCompactionStateWithPlans_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetCompactionPlansRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCompactionStateWithPlans_Call) Return(_a0 *milvuspb.GetCompactionPlansResponse, _a1 error) *MockDataCoord_GetCompactionStateWithPlans_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetCompactionStateWithPlans_Call) RunAndReturn(run func(context.Context, *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error)) *MockDataCoord_GetCompactionStateWithPlans_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetFlushAllState provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetFlushAllState(_a0 context.Context, _a1 *milvuspb.GetFlushAllStateRequest) (*milvuspb.GetFlushAllStateResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetFlushAllState")
|
|
}
|
|
|
|
var r0 *milvuspb.GetFlushAllStateResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetFlushAllStateRequest) (*milvuspb.GetFlushAllStateResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetFlushAllStateRequest) *milvuspb.GetFlushAllStateResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetFlushAllStateResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetFlushAllStateRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetFlushAllState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushAllState'
|
|
type MockDataCoord_GetFlushAllState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFlushAllState is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.GetFlushAllStateRequest
|
|
func (_e *MockDataCoord_Expecter) GetFlushAllState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetFlushAllState_Call {
|
|
return &MockDataCoord_GetFlushAllState_Call{Call: _e.mock.On("GetFlushAllState", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushAllState_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.GetFlushAllStateRequest)) *MockDataCoord_GetFlushAllState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetFlushAllStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushAllState_Call) Return(_a0 *milvuspb.GetFlushAllStateResponse, _a1 error) *MockDataCoord_GetFlushAllState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushAllState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetFlushAllStateRequest) (*milvuspb.GetFlushAllStateResponse, error)) *MockDataCoord_GetFlushAllState_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetFlushState provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetFlushState(_a0 context.Context, _a1 *datapb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetFlushState")
|
|
}
|
|
|
|
var r0 *milvuspb.GetFlushStateResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushStateRequest) *milvuspb.GetFlushStateResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetFlushStateResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetFlushStateRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetFlushState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushState'
|
|
type MockDataCoord_GetFlushState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFlushState is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetFlushStateRequest
|
|
func (_e *MockDataCoord_Expecter) GetFlushState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetFlushState_Call {
|
|
return &MockDataCoord_GetFlushState_Call{Call: _e.mock.On("GetFlushState", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushState_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetFlushStateRequest)) *MockDataCoord_GetFlushState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetFlushStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushState_Call) Return(_a0 *milvuspb.GetFlushStateResponse, _a1 error) *MockDataCoord_GetFlushState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushState_Call) RunAndReturn(run func(context.Context, *datapb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)) *MockDataCoord_GetFlushState_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetFlushedSegments provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetFlushedSegments(_a0 context.Context, _a1 *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetFlushedSegments")
|
|
}
|
|
|
|
var r0 *datapb.GetFlushedSegmentsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushedSegmentsRequest) *datapb.GetFlushedSegmentsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetFlushedSegmentsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetFlushedSegmentsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetFlushedSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushedSegments'
|
|
type MockDataCoord_GetFlushedSegments_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFlushedSegments is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetFlushedSegmentsRequest
|
|
func (_e *MockDataCoord_Expecter) GetFlushedSegments(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetFlushedSegments_Call {
|
|
return &MockDataCoord_GetFlushedSegments_Call{Call: _e.mock.On("GetFlushedSegments", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushedSegments_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetFlushedSegmentsRequest)) *MockDataCoord_GetFlushedSegments_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetFlushedSegmentsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushedSegments_Call) Return(_a0 *datapb.GetFlushedSegmentsResponse, _a1 error) *MockDataCoord_GetFlushedSegments_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetFlushedSegments_Call) RunAndReturn(run func(context.Context, *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error)) *MockDataCoord_GetFlushedSegments_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetImportProgress provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetImportProgress(_a0 context.Context, _a1 *internalpb.GetImportProgressRequest) (*internalpb.GetImportProgressResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetImportProgress")
|
|
}
|
|
|
|
var r0 *internalpb.GetImportProgressResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetImportProgressRequest) (*internalpb.GetImportProgressResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetImportProgressRequest) *internalpb.GetImportProgressResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*internalpb.GetImportProgressResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetImportProgressRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetImportProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImportProgress'
|
|
type MockDataCoord_GetImportProgress_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetImportProgress is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *internalpb.GetImportProgressRequest
|
|
func (_e *MockDataCoord_Expecter) GetImportProgress(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetImportProgress_Call {
|
|
return &MockDataCoord_GetImportProgress_Call{Call: _e.mock.On("GetImportProgress", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetImportProgress_Call) Run(run func(_a0 context.Context, _a1 *internalpb.GetImportProgressRequest)) *MockDataCoord_GetImportProgress_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.GetImportProgressRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetImportProgress_Call) Return(_a0 *internalpb.GetImportProgressResponse, _a1 error) *MockDataCoord_GetImportProgress_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetImportProgress_Call) RunAndReturn(run func(context.Context, *internalpb.GetImportProgressRequest) (*internalpb.GetImportProgressResponse, error)) *MockDataCoord_GetImportProgress_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetIndexBuildProgress provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetIndexBuildProgress(_a0 context.Context, _a1 *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetIndexBuildProgress")
|
|
}
|
|
|
|
var r0 *indexpb.GetIndexBuildProgressResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) *indexpb.GetIndexBuildProgressResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*indexpb.GetIndexBuildProgressResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetIndexBuildProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexBuildProgress'
|
|
type MockDataCoord_GetIndexBuildProgress_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetIndexBuildProgress is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.GetIndexBuildProgressRequest
|
|
func (_e *MockDataCoord_Expecter) GetIndexBuildProgress(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetIndexBuildProgress_Call {
|
|
return &MockDataCoord_GetIndexBuildProgress_Call{Call: _e.mock.On("GetIndexBuildProgress", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexBuildProgress_Call) Run(run func(_a0 context.Context, _a1 *indexpb.GetIndexBuildProgressRequest)) *MockDataCoord_GetIndexBuildProgress_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.GetIndexBuildProgressRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexBuildProgress_Call) Return(_a0 *indexpb.GetIndexBuildProgressResponse, _a1 error) *MockDataCoord_GetIndexBuildProgress_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexBuildProgress_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error)) *MockDataCoord_GetIndexBuildProgress_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetIndexInfos provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetIndexInfos(_a0 context.Context, _a1 *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetIndexInfos")
|
|
}
|
|
|
|
var r0 *indexpb.GetIndexInfoResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexInfoRequest) *indexpb.GetIndexInfoResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*indexpb.GetIndexInfoResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexInfoRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetIndexInfos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexInfos'
|
|
type MockDataCoord_GetIndexInfos_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetIndexInfos is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.GetIndexInfoRequest
|
|
func (_e *MockDataCoord_Expecter) GetIndexInfos(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetIndexInfos_Call {
|
|
return &MockDataCoord_GetIndexInfos_Call{Call: _e.mock.On("GetIndexInfos", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexInfos_Call) Run(run func(_a0 context.Context, _a1 *indexpb.GetIndexInfoRequest)) *MockDataCoord_GetIndexInfos_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.GetIndexInfoRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexInfos_Call) Return(_a0 *indexpb.GetIndexInfoResponse, _a1 error) *MockDataCoord_GetIndexInfos_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexInfos_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error)) *MockDataCoord_GetIndexInfos_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetIndexState provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetIndexState(_a0 context.Context, _a1 *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetIndexState")
|
|
}
|
|
|
|
var r0 *indexpb.GetIndexStateResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStateRequest) *indexpb.GetIndexStateResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*indexpb.GetIndexStateResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexStateRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetIndexState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexState'
|
|
type MockDataCoord_GetIndexState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetIndexState is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.GetIndexStateRequest
|
|
func (_e *MockDataCoord_Expecter) GetIndexState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetIndexState_Call {
|
|
return &MockDataCoord_GetIndexState_Call{Call: _e.mock.On("GetIndexState", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexState_Call) Run(run func(_a0 context.Context, _a1 *indexpb.GetIndexStateRequest)) *MockDataCoord_GetIndexState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.GetIndexStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexState_Call) Return(_a0 *indexpb.GetIndexStateResponse, _a1 error) *MockDataCoord_GetIndexState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexState_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error)) *MockDataCoord_GetIndexState_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetIndexStatistics provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetIndexStatistics(_a0 context.Context, _a1 *indexpb.GetIndexStatisticsRequest) (*indexpb.GetIndexStatisticsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetIndexStatistics")
|
|
}
|
|
|
|
var r0 *indexpb.GetIndexStatisticsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStatisticsRequest) (*indexpb.GetIndexStatisticsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStatisticsRequest) *indexpb.GetIndexStatisticsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*indexpb.GetIndexStatisticsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexStatisticsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetIndexStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexStatistics'
|
|
type MockDataCoord_GetIndexStatistics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetIndexStatistics is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.GetIndexStatisticsRequest
|
|
func (_e *MockDataCoord_Expecter) GetIndexStatistics(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetIndexStatistics_Call {
|
|
return &MockDataCoord_GetIndexStatistics_Call{Call: _e.mock.On("GetIndexStatistics", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexStatistics_Call) Run(run func(_a0 context.Context, _a1 *indexpb.GetIndexStatisticsRequest)) *MockDataCoord_GetIndexStatistics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.GetIndexStatisticsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexStatistics_Call) Return(_a0 *indexpb.GetIndexStatisticsResponse, _a1 error) *MockDataCoord_GetIndexStatistics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetIndexStatistics_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexStatisticsRequest) (*indexpb.GetIndexStatisticsResponse, error)) *MockDataCoord_GetIndexStatistics_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetInsertBinlogPaths provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetInsertBinlogPaths(_a0 context.Context, _a1 *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetInsertBinlogPaths")
|
|
}
|
|
|
|
var r0 *datapb.GetInsertBinlogPathsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetInsertBinlogPathsRequest) *datapb.GetInsertBinlogPathsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetInsertBinlogPathsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetInsertBinlogPathsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetInsertBinlogPaths_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInsertBinlogPaths'
|
|
type MockDataCoord_GetInsertBinlogPaths_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetInsertBinlogPaths is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetInsertBinlogPathsRequest
|
|
func (_e *MockDataCoord_Expecter) GetInsertBinlogPaths(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetInsertBinlogPaths_Call {
|
|
return &MockDataCoord_GetInsertBinlogPaths_Call{Call: _e.mock.On("GetInsertBinlogPaths", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetInsertBinlogPaths_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetInsertBinlogPathsRequest)) *MockDataCoord_GetInsertBinlogPaths_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetInsertBinlogPathsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetInsertBinlogPaths_Call) Return(_a0 *datapb.GetInsertBinlogPathsResponse, _a1 error) *MockDataCoord_GetInsertBinlogPaths_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetInsertBinlogPaths_Call) RunAndReturn(run func(context.Context, *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error)) *MockDataCoord_GetInsertBinlogPaths_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetMetrics provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetMetrics(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetMetrics")
|
|
}
|
|
|
|
var r0 *milvuspb.GetMetricsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetMetricsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetMetricsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetrics'
|
|
type MockDataCoord_GetMetrics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetMetrics is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.GetMetricsRequest
|
|
func (_e *MockDataCoord_Expecter) GetMetrics(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetMetrics_Call {
|
|
return &MockDataCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetMetrics_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest)) *MockDataCoord_GetMetrics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetMetricsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetMetrics_Call) Return(_a0 *milvuspb.GetMetricsResponse, _a1 error) *MockDataCoord_GetMetrics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetMetrics_Call) RunAndReturn(run func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)) *MockDataCoord_GetMetrics_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetPartitionStatistics provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetPartitionStatistics(_a0 context.Context, _a1 *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPartitionStatistics")
|
|
}
|
|
|
|
var r0 *datapb.GetPartitionStatisticsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetPartitionStatisticsRequest) *datapb.GetPartitionStatisticsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetPartitionStatisticsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetPartitionStatisticsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetPartitionStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPartitionStatistics'
|
|
type MockDataCoord_GetPartitionStatistics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetPartitionStatistics is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetPartitionStatisticsRequest
|
|
func (_e *MockDataCoord_Expecter) GetPartitionStatistics(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetPartitionStatistics_Call {
|
|
return &MockDataCoord_GetPartitionStatistics_Call{Call: _e.mock.On("GetPartitionStatistics", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetPartitionStatistics_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetPartitionStatisticsRequest)) *MockDataCoord_GetPartitionStatistics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetPartitionStatisticsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetPartitionStatistics_Call) Return(_a0 *datapb.GetPartitionStatisticsResponse, _a1 error) *MockDataCoord_GetPartitionStatistics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetPartitionStatistics_Call) RunAndReturn(run func(context.Context, *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error)) *MockDataCoord_GetPartitionStatistics_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRecoveryInfo provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetRecoveryInfo(_a0 context.Context, _a1 *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRecoveryInfo")
|
|
}
|
|
|
|
var r0 *datapb.GetRecoveryInfoResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequest) *datapb.GetRecoveryInfoResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetRecoveryInfoResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetRecoveryInfoRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetRecoveryInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecoveryInfo'
|
|
type MockDataCoord_GetRecoveryInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRecoveryInfo is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetRecoveryInfoRequest
|
|
func (_e *MockDataCoord_Expecter) GetRecoveryInfo(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetRecoveryInfo_Call {
|
|
return &MockDataCoord_GetRecoveryInfo_Call{Call: _e.mock.On("GetRecoveryInfo", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetRecoveryInfo_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetRecoveryInfoRequest)) *MockDataCoord_GetRecoveryInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetRecoveryInfoRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetRecoveryInfo_Call) Return(_a0 *datapb.GetRecoveryInfoResponse, _a1 error) *MockDataCoord_GetRecoveryInfo_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetRecoveryInfo_Call) RunAndReturn(run func(context.Context, *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error)) *MockDataCoord_GetRecoveryInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRecoveryInfoV2 provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetRecoveryInfoV2(_a0 context.Context, _a1 *datapb.GetRecoveryInfoRequestV2) (*datapb.GetRecoveryInfoResponseV2, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRecoveryInfoV2")
|
|
}
|
|
|
|
var r0 *datapb.GetRecoveryInfoResponseV2
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequestV2) (*datapb.GetRecoveryInfoResponseV2, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequestV2) *datapb.GetRecoveryInfoResponseV2); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetRecoveryInfoResponseV2)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetRecoveryInfoRequestV2) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetRecoveryInfoV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecoveryInfoV2'
|
|
type MockDataCoord_GetRecoveryInfoV2_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRecoveryInfoV2 is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetRecoveryInfoRequestV2
|
|
func (_e *MockDataCoord_Expecter) GetRecoveryInfoV2(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetRecoveryInfoV2_Call {
|
|
return &MockDataCoord_GetRecoveryInfoV2_Call{Call: _e.mock.On("GetRecoveryInfoV2", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetRecoveryInfoV2_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetRecoveryInfoRequestV2)) *MockDataCoord_GetRecoveryInfoV2_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetRecoveryInfoRequestV2))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetRecoveryInfoV2_Call) Return(_a0 *datapb.GetRecoveryInfoResponseV2, _a1 error) *MockDataCoord_GetRecoveryInfoV2_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetRecoveryInfoV2_Call) RunAndReturn(run func(context.Context, *datapb.GetRecoveryInfoRequestV2) (*datapb.GetRecoveryInfoResponseV2, error)) *MockDataCoord_GetRecoveryInfoV2_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentIndexState provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetSegmentIndexState(_a0 context.Context, _a1 *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSegmentIndexState")
|
|
}
|
|
|
|
var r0 *indexpb.GetSegmentIndexStateResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) *indexpb.GetSegmentIndexStateResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*indexpb.GetSegmentIndexStateResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetSegmentIndexState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentIndexState'
|
|
type MockDataCoord_GetSegmentIndexState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentIndexState is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.GetSegmentIndexStateRequest
|
|
func (_e *MockDataCoord_Expecter) GetSegmentIndexState(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentIndexState_Call {
|
|
return &MockDataCoord_GetSegmentIndexState_Call{Call: _e.mock.On("GetSegmentIndexState", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentIndexState_Call) Run(run func(_a0 context.Context, _a1 *indexpb.GetSegmentIndexStateRequest)) *MockDataCoord_GetSegmentIndexState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.GetSegmentIndexStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentIndexState_Call) Return(_a0 *indexpb.GetSegmentIndexStateResponse, _a1 error) *MockDataCoord_GetSegmentIndexState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentIndexState_Call) RunAndReturn(run func(context.Context, *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error)) *MockDataCoord_GetSegmentIndexState_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentInfo provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetSegmentInfo(_a0 context.Context, _a1 *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSegmentInfo")
|
|
}
|
|
|
|
var r0 *datapb.GetSegmentInfoResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoRequest) *datapb.GetSegmentInfoResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetSegmentInfoResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentInfoRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetSegmentInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentInfo'
|
|
type MockDataCoord_GetSegmentInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentInfo is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetSegmentInfoRequest
|
|
func (_e *MockDataCoord_Expecter) GetSegmentInfo(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentInfo_Call {
|
|
return &MockDataCoord_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentInfo_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetSegmentInfoRequest)) *MockDataCoord_GetSegmentInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetSegmentInfoRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentInfo_Call) Return(_a0 *datapb.GetSegmentInfoResponse, _a1 error) *MockDataCoord_GetSegmentInfo_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentInfo_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error)) *MockDataCoord_GetSegmentInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentInfoChannel provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetSegmentInfoChannel(_a0 context.Context, _a1 *datapb.GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSegmentInfoChannel")
|
|
}
|
|
|
|
var r0 *milvuspb.StringResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoChannelRequest) *milvuspb.StringResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.StringResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentInfoChannelRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetSegmentInfoChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentInfoChannel'
|
|
type MockDataCoord_GetSegmentInfoChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentInfoChannel is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetSegmentInfoChannelRequest
|
|
func (_e *MockDataCoord_Expecter) GetSegmentInfoChannel(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentInfoChannel_Call {
|
|
return &MockDataCoord_GetSegmentInfoChannel_Call{Call: _e.mock.On("GetSegmentInfoChannel", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentInfoChannel_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetSegmentInfoChannelRequest)) *MockDataCoord_GetSegmentInfoChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetSegmentInfoChannelRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentInfoChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *MockDataCoord_GetSegmentInfoChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentInfoChannel_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error)) *MockDataCoord_GetSegmentInfoChannel_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentStates provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetSegmentStates(_a0 context.Context, _a1 *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSegmentStates")
|
|
}
|
|
|
|
var r0 *datapb.GetSegmentStatesResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentStatesRequest) *datapb.GetSegmentStatesResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetSegmentStatesResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentStatesRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetSegmentStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentStates'
|
|
type MockDataCoord_GetSegmentStates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentStates is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetSegmentStatesRequest
|
|
func (_e *MockDataCoord_Expecter) GetSegmentStates(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentStates_Call {
|
|
return &MockDataCoord_GetSegmentStates_Call{Call: _e.mock.On("GetSegmentStates", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentStates_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetSegmentStatesRequest)) *MockDataCoord_GetSegmentStates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetSegmentStatesRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentStates_Call) Return(_a0 *datapb.GetSegmentStatesResponse, _a1 error) *MockDataCoord_GetSegmentStates_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentStates_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error)) *MockDataCoord_GetSegmentStates_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentsByStates provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) GetSegmentsByStates(_a0 context.Context, _a1 *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSegmentsByStates")
|
|
}
|
|
|
|
var r0 *datapb.GetSegmentsByStatesResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentsByStatesRequest) *datapb.GetSegmentsByStatesResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.GetSegmentsByStatesResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentsByStatesRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_GetSegmentsByStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentsByStates'
|
|
type MockDataCoord_GetSegmentsByStates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentsByStates is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.GetSegmentsByStatesRequest
|
|
func (_e *MockDataCoord_Expecter) GetSegmentsByStates(_a0 interface{}, _a1 interface{}) *MockDataCoord_GetSegmentsByStates_Call {
|
|
return &MockDataCoord_GetSegmentsByStates_Call{Call: _e.mock.On("GetSegmentsByStates", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentsByStates_Call) Run(run func(_a0 context.Context, _a1 *datapb.GetSegmentsByStatesRequest)) *MockDataCoord_GetSegmentsByStates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.GetSegmentsByStatesRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentsByStates_Call) Return(_a0 *datapb.GetSegmentsByStatesResponse, _a1 error) *MockDataCoord_GetSegmentsByStates_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_GetSegmentsByStates_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error)) *MockDataCoord_GetSegmentsByStates_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ImportV2 provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) ImportV2(_a0 context.Context, _a1 *internalpb.ImportRequestInternal) (*internalpb.ImportResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ImportV2")
|
|
}
|
|
|
|
var r0 *internalpb.ImportResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ImportRequestInternal) (*internalpb.ImportResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ImportRequestInternal) *internalpb.ImportResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*internalpb.ImportResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ImportRequestInternal) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_ImportV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportV2'
|
|
type MockDataCoord_ImportV2_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ImportV2 is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *internalpb.ImportRequestInternal
|
|
func (_e *MockDataCoord_Expecter) ImportV2(_a0 interface{}, _a1 interface{}) *MockDataCoord_ImportV2_Call {
|
|
return &MockDataCoord_ImportV2_Call{Call: _e.mock.On("ImportV2", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_ImportV2_Call) Run(run func(_a0 context.Context, _a1 *internalpb.ImportRequestInternal)) *MockDataCoord_ImportV2_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.ImportRequestInternal))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ImportV2_Call) Return(_a0 *internalpb.ImportResponse, _a1 error) *MockDataCoord_ImportV2_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ImportV2_Call) RunAndReturn(run func(context.Context, *internalpb.ImportRequestInternal) (*internalpb.ImportResponse, error)) *MockDataCoord_ImportV2_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Init provides a mock function with no fields
|
|
func (_m *MockDataCoord) Init() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Init")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockDataCoord_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init'
|
|
type MockDataCoord_Init_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Init is a helper method to define mock.On call
|
|
func (_e *MockDataCoord_Expecter) Init() *MockDataCoord_Init_Call {
|
|
return &MockDataCoord_Init_Call{Call: _e.mock.On("Init")}
|
|
}
|
|
|
|
func (_c *MockDataCoord_Init_Call) Run(run func()) *MockDataCoord_Init_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Init_Call) Return(_a0 error) *MockDataCoord_Init_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Init_Call) RunAndReturn(run func() error) *MockDataCoord_Init_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListFileResources provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) ListFileResources(_a0 context.Context, _a1 *milvuspb.ListFileResourcesRequest) (*milvuspb.ListFileResourcesResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListFileResources")
|
|
}
|
|
|
|
var r0 *milvuspb.ListFileResourcesResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListFileResourcesRequest) (*milvuspb.ListFileResourcesResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListFileResourcesRequest) *milvuspb.ListFileResourcesResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ListFileResourcesResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListFileResourcesRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_ListFileResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFileResources'
|
|
type MockDataCoord_ListFileResources_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListFileResources is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.ListFileResourcesRequest
|
|
func (_e *MockDataCoord_Expecter) ListFileResources(_a0 interface{}, _a1 interface{}) *MockDataCoord_ListFileResources_Call {
|
|
return &MockDataCoord_ListFileResources_Call{Call: _e.mock.On("ListFileResources", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListFileResources_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListFileResourcesRequest)) *MockDataCoord_ListFileResources_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ListFileResourcesRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListFileResources_Call) Return(_a0 *milvuspb.ListFileResourcesResponse, _a1 error) *MockDataCoord_ListFileResources_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListFileResources_Call) RunAndReturn(run func(context.Context, *milvuspb.ListFileResourcesRequest) (*milvuspb.ListFileResourcesResponse, error)) *MockDataCoord_ListFileResources_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListImports provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) ListImports(_a0 context.Context, _a1 *internalpb.ListImportsRequestInternal) (*internalpb.ListImportsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListImports")
|
|
}
|
|
|
|
var r0 *internalpb.ListImportsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ListImportsRequestInternal) (*internalpb.ListImportsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ListImportsRequestInternal) *internalpb.ListImportsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*internalpb.ListImportsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ListImportsRequestInternal) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_ListImports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListImports'
|
|
type MockDataCoord_ListImports_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListImports is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *internalpb.ListImportsRequestInternal
|
|
func (_e *MockDataCoord_Expecter) ListImports(_a0 interface{}, _a1 interface{}) *MockDataCoord_ListImports_Call {
|
|
return &MockDataCoord_ListImports_Call{Call: _e.mock.On("ListImports", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListImports_Call) Run(run func(_a0 context.Context, _a1 *internalpb.ListImportsRequestInternal)) *MockDataCoord_ListImports_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.ListImportsRequestInternal))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListImports_Call) Return(_a0 *internalpb.ListImportsResponse, _a1 error) *MockDataCoord_ListImports_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListImports_Call) RunAndReturn(run func(context.Context, *internalpb.ListImportsRequestInternal) (*internalpb.ListImportsResponse, error)) *MockDataCoord_ListImports_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListIndexes provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) ListIndexes(_a0 context.Context, _a1 *indexpb.ListIndexesRequest) (*indexpb.ListIndexesResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListIndexes")
|
|
}
|
|
|
|
var r0 *indexpb.ListIndexesResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.ListIndexesRequest) (*indexpb.ListIndexesResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.ListIndexesRequest) *indexpb.ListIndexesResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*indexpb.ListIndexesResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.ListIndexesRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_ListIndexes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListIndexes'
|
|
type MockDataCoord_ListIndexes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListIndexes is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *indexpb.ListIndexesRequest
|
|
func (_e *MockDataCoord_Expecter) ListIndexes(_a0 interface{}, _a1 interface{}) *MockDataCoord_ListIndexes_Call {
|
|
return &MockDataCoord_ListIndexes_Call{Call: _e.mock.On("ListIndexes", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListIndexes_Call) Run(run func(_a0 context.Context, _a1 *indexpb.ListIndexesRequest)) *MockDataCoord_ListIndexes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*indexpb.ListIndexesRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListIndexes_Call) Return(_a0 *indexpb.ListIndexesResponse, _a1 error) *MockDataCoord_ListIndexes_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ListIndexes_Call) RunAndReturn(run func(context.Context, *indexpb.ListIndexesRequest) (*indexpb.ListIndexesResponse, error)) *MockDataCoord_ListIndexes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ManualCompaction provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) ManualCompaction(_a0 context.Context, _a1 *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ManualCompaction")
|
|
}
|
|
|
|
var r0 *milvuspb.ManualCompactionResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ManualCompactionRequest) *milvuspb.ManualCompactionResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ManualCompactionResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ManualCompactionRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_ManualCompaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManualCompaction'
|
|
type MockDataCoord_ManualCompaction_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ManualCompaction is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.ManualCompactionRequest
|
|
func (_e *MockDataCoord_Expecter) ManualCompaction(_a0 interface{}, _a1 interface{}) *MockDataCoord_ManualCompaction_Call {
|
|
return &MockDataCoord_ManualCompaction_Call{Call: _e.mock.On("ManualCompaction", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_ManualCompaction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ManualCompactionRequest)) *MockDataCoord_ManualCompaction_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ManualCompactionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ManualCompaction_Call) Return(_a0 *milvuspb.ManualCompactionResponse, _a1 error) *MockDataCoord_ManualCompaction_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ManualCompaction_Call) RunAndReturn(run func(context.Context, *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error)) *MockDataCoord_ManualCompaction_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// MarkSegmentsDropped provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) MarkSegmentsDropped(_a0 context.Context, _a1 *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for MarkSegmentsDropped")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_MarkSegmentsDropped_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkSegmentsDropped'
|
|
type MockDataCoord_MarkSegmentsDropped_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// MarkSegmentsDropped is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.MarkSegmentsDroppedRequest
|
|
func (_e *MockDataCoord_Expecter) MarkSegmentsDropped(_a0 interface{}, _a1 interface{}) *MockDataCoord_MarkSegmentsDropped_Call {
|
|
return &MockDataCoord_MarkSegmentsDropped_Call{Call: _e.mock.On("MarkSegmentsDropped", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_MarkSegmentsDropped_Call) Run(run func(_a0 context.Context, _a1 *datapb.MarkSegmentsDroppedRequest)) *MockDataCoord_MarkSegmentsDropped_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.MarkSegmentsDroppedRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_MarkSegmentsDropped_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_MarkSegmentsDropped_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_MarkSegmentsDropped_Call) RunAndReturn(run func(context.Context, *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)) *MockDataCoord_MarkSegmentsDropped_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Register provides a mock function with no fields
|
|
func (_m *MockDataCoord) Register() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Register")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockDataCoord_Register_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Register'
|
|
type MockDataCoord_Register_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Register is a helper method to define mock.On call
|
|
func (_e *MockDataCoord_Expecter) Register() *MockDataCoord_Register_Call {
|
|
return &MockDataCoord_Register_Call{Call: _e.mock.On("Register")}
|
|
}
|
|
|
|
func (_c *MockDataCoord_Register_Call) Run(run func()) *MockDataCoord_Register_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Register_Call) Return(_a0 error) *MockDataCoord_Register_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Register_Call) RunAndReturn(run func() error) *MockDataCoord_Register_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemoveFileResource provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) RemoveFileResource(_a0 context.Context, _a1 *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RemoveFileResource")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RemoveFileResourceRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RemoveFileResourceRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_RemoveFileResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveFileResource'
|
|
type MockDataCoord_RemoveFileResource_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemoveFileResource is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.RemoveFileResourceRequest
|
|
func (_e *MockDataCoord_Expecter) RemoveFileResource(_a0 interface{}, _a1 interface{}) *MockDataCoord_RemoveFileResource_Call {
|
|
return &MockDataCoord_RemoveFileResource_Call{Call: _e.mock.On("RemoveFileResource", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_RemoveFileResource_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.RemoveFileResourceRequest)) *MockDataCoord_RemoveFileResource_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.RemoveFileResourceRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_RemoveFileResource_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_RemoveFileResource_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_RemoveFileResource_Call) RunAndReturn(run func(context.Context, *milvuspb.RemoveFileResourceRequest) (*commonpb.Status, error)) *MockDataCoord_RemoveFileResource_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ReportDataNodeTtMsgs provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) ReportDataNodeTtMsgs(_a0 context.Context, _a1 *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ReportDataNodeTtMsgs")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_ReportDataNodeTtMsgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportDataNodeTtMsgs'
|
|
type MockDataCoord_ReportDataNodeTtMsgs_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ReportDataNodeTtMsgs is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.ReportDataNodeTtMsgsRequest
|
|
func (_e *MockDataCoord_Expecter) ReportDataNodeTtMsgs(_a0 interface{}, _a1 interface{}) *MockDataCoord_ReportDataNodeTtMsgs_Call {
|
|
return &MockDataCoord_ReportDataNodeTtMsgs_Call{Call: _e.mock.On("ReportDataNodeTtMsgs", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_ReportDataNodeTtMsgs_Call) Run(run func(_a0 context.Context, _a1 *datapb.ReportDataNodeTtMsgsRequest)) *MockDataCoord_ReportDataNodeTtMsgs_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.ReportDataNodeTtMsgsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ReportDataNodeTtMsgs_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_ReportDataNodeTtMsgs_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ReportDataNodeTtMsgs_Call) RunAndReturn(run func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error)) *MockDataCoord_ReportDataNodeTtMsgs_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SaveBinlogPaths provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) SaveBinlogPaths(_a0 context.Context, _a1 *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SaveBinlogPaths")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveBinlogPathsRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.SaveBinlogPathsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_SaveBinlogPaths_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveBinlogPaths'
|
|
type MockDataCoord_SaveBinlogPaths_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SaveBinlogPaths is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.SaveBinlogPathsRequest
|
|
func (_e *MockDataCoord_Expecter) SaveBinlogPaths(_a0 interface{}, _a1 interface{}) *MockDataCoord_SaveBinlogPaths_Call {
|
|
return &MockDataCoord_SaveBinlogPaths_Call{Call: _e.mock.On("SaveBinlogPaths", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_SaveBinlogPaths_Call) Run(run func(_a0 context.Context, _a1 *datapb.SaveBinlogPathsRequest)) *MockDataCoord_SaveBinlogPaths_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.SaveBinlogPathsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SaveBinlogPaths_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_SaveBinlogPaths_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SaveBinlogPaths_Call) RunAndReturn(run func(context.Context, *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error)) *MockDataCoord_SaveBinlogPaths_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetAddress provides a mock function with given fields: address
|
|
func (_m *MockDataCoord) SetAddress(address string) {
|
|
_m.Called(address)
|
|
}
|
|
|
|
// MockDataCoord_SetAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAddress'
|
|
type MockDataCoord_SetAddress_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetAddress is a helper method to define mock.On call
|
|
// - address string
|
|
func (_e *MockDataCoord_Expecter) SetAddress(address interface{}) *MockDataCoord_SetAddress_Call {
|
|
return &MockDataCoord_SetAddress_Call{Call: _e.mock.On("SetAddress", address)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetAddress_Call) Run(run func(address string)) *MockDataCoord_SetAddress_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetAddress_Call) Return() *MockDataCoord_SetAddress_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetAddress_Call) RunAndReturn(run func(string)) *MockDataCoord_SetAddress_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetDataNodeCreator provides a mock function with given fields: _a0
|
|
func (_m *MockDataCoord) SetDataNodeCreator(_a0 func(context.Context, string, int64) (types.DataNodeClient, error)) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// MockDataCoord_SetDataNodeCreator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDataNodeCreator'
|
|
type MockDataCoord_SetDataNodeCreator_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetDataNodeCreator is a helper method to define mock.On call
|
|
// - _a0 func(context.Context , string , int64)(types.DataNodeClient , error)
|
|
func (_e *MockDataCoord_Expecter) SetDataNodeCreator(_a0 interface{}) *MockDataCoord_SetDataNodeCreator_Call {
|
|
return &MockDataCoord_SetDataNodeCreator_Call{Call: _e.mock.On("SetDataNodeCreator", _a0)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetDataNodeCreator_Call) Run(run func(_a0 func(context.Context, string, int64) (types.DataNodeClient, error))) *MockDataCoord_SetDataNodeCreator_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(func(context.Context, string, int64) (types.DataNodeClient, error)))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetDataNodeCreator_Call) Return() *MockDataCoord_SetDataNodeCreator_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetDataNodeCreator_Call) RunAndReturn(run func(func(context.Context, string, int64) (types.DataNodeClient, error))) *MockDataCoord_SetDataNodeCreator_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetEtcdClient provides a mock function with given fields: etcdClient
|
|
func (_m *MockDataCoord) SetEtcdClient(etcdClient *clientv3.Client) {
|
|
_m.Called(etcdClient)
|
|
}
|
|
|
|
// MockDataCoord_SetEtcdClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEtcdClient'
|
|
type MockDataCoord_SetEtcdClient_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetEtcdClient is a helper method to define mock.On call
|
|
// - etcdClient *clientv3.Client
|
|
func (_e *MockDataCoord_Expecter) SetEtcdClient(etcdClient interface{}) *MockDataCoord_SetEtcdClient_Call {
|
|
return &MockDataCoord_SetEtcdClient_Call{Call: _e.mock.On("SetEtcdClient", etcdClient)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetEtcdClient_Call) Run(run func(etcdClient *clientv3.Client)) *MockDataCoord_SetEtcdClient_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*clientv3.Client))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetEtcdClient_Call) Return() *MockDataCoord_SetEtcdClient_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetEtcdClient_Call) RunAndReturn(run func(*clientv3.Client)) *MockDataCoord_SetEtcdClient_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetMixCoord provides a mock function with given fields: mixCoord
|
|
func (_m *MockDataCoord) SetMixCoord(mixCoord types.MixCoord) {
|
|
_m.Called(mixCoord)
|
|
}
|
|
|
|
// MockDataCoord_SetMixCoord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMixCoord'
|
|
type MockDataCoord_SetMixCoord_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetMixCoord is a helper method to define mock.On call
|
|
// - mixCoord types.MixCoord
|
|
func (_e *MockDataCoord_Expecter) SetMixCoord(mixCoord interface{}) *MockDataCoord_SetMixCoord_Call {
|
|
return &MockDataCoord_SetMixCoord_Call{Call: _e.mock.On("SetMixCoord", mixCoord)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetMixCoord_Call) Run(run func(mixCoord types.MixCoord)) *MockDataCoord_SetMixCoord_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(types.MixCoord))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetMixCoord_Call) Return() *MockDataCoord_SetMixCoord_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetMixCoord_Call) RunAndReturn(run func(types.MixCoord)) *MockDataCoord_SetMixCoord_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetSegmentState provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) SetSegmentState(_a0 context.Context, _a1 *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetSegmentState")
|
|
}
|
|
|
|
var r0 *datapb.SetSegmentStateResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.SetSegmentStateRequest) *datapb.SetSegmentStateResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.SetSegmentStateResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.SetSegmentStateRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_SetSegmentState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSegmentState'
|
|
type MockDataCoord_SetSegmentState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetSegmentState is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.SetSegmentStateRequest
|
|
func (_e *MockDataCoord_Expecter) SetSegmentState(_a0 interface{}, _a1 interface{}) *MockDataCoord_SetSegmentState_Call {
|
|
return &MockDataCoord_SetSegmentState_Call{Call: _e.mock.On("SetSegmentState", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetSegmentState_Call) Run(run func(_a0 context.Context, _a1 *datapb.SetSegmentStateRequest)) *MockDataCoord_SetSegmentState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.SetSegmentStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetSegmentState_Call) Return(_a0 *datapb.SetSegmentStateResponse, _a1 error) *MockDataCoord_SetSegmentState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetSegmentState_Call) RunAndReturn(run func(context.Context, *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error)) *MockDataCoord_SetSegmentState_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetTiKVClient provides a mock function with given fields: client
|
|
func (_m *MockDataCoord) SetTiKVClient(client *txnkv.Client) {
|
|
_m.Called(client)
|
|
}
|
|
|
|
// MockDataCoord_SetTiKVClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTiKVClient'
|
|
type MockDataCoord_SetTiKVClient_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetTiKVClient is a helper method to define mock.On call
|
|
// - client *txnkv.Client
|
|
func (_e *MockDataCoord_Expecter) SetTiKVClient(client interface{}) *MockDataCoord_SetTiKVClient_Call {
|
|
return &MockDataCoord_SetTiKVClient_Call{Call: _e.mock.On("SetTiKVClient", client)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetTiKVClient_Call) Run(run func(client *txnkv.Client)) *MockDataCoord_SetTiKVClient_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*txnkv.Client))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetTiKVClient_Call) Return() *MockDataCoord_SetTiKVClient_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_SetTiKVClient_Call) RunAndReturn(run func(*txnkv.Client)) *MockDataCoord_SetTiKVClient_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// ShowConfigurations provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) ShowConfigurations(_a0 context.Context, _a1 *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ShowConfigurations")
|
|
}
|
|
|
|
var r0 *internalpb.ShowConfigurationsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) *internalpb.ShowConfigurationsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*internalpb.ShowConfigurationsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ShowConfigurationsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_ShowConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowConfigurations'
|
|
type MockDataCoord_ShowConfigurations_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowConfigurations is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *internalpb.ShowConfigurationsRequest
|
|
func (_e *MockDataCoord_Expecter) ShowConfigurations(_a0 interface{}, _a1 interface{}) *MockDataCoord_ShowConfigurations_Call {
|
|
return &MockDataCoord_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_ShowConfigurations_Call) Run(run func(_a0 context.Context, _a1 *internalpb.ShowConfigurationsRequest)) *MockDataCoord_ShowConfigurations_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.ShowConfigurationsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ShowConfigurations_Call) Return(_a0 *internalpb.ShowConfigurationsResponse, _a1 error) *MockDataCoord_ShowConfigurations_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_ShowConfigurations_Call) RunAndReturn(run func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)) *MockDataCoord_ShowConfigurations_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Start provides a mock function with no fields
|
|
func (_m *MockDataCoord) Start() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Start")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockDataCoord_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
|
type MockDataCoord_Start_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Start is a helper method to define mock.On call
|
|
func (_e *MockDataCoord_Expecter) Start() *MockDataCoord_Start_Call {
|
|
return &MockDataCoord_Start_Call{Call: _e.mock.On("Start")}
|
|
}
|
|
|
|
func (_c *MockDataCoord_Start_Call) Run(run func()) *MockDataCoord_Start_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Start_Call) Return(_a0 error) *MockDataCoord_Start_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Start_Call) RunAndReturn(run func() error) *MockDataCoord_Start_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Stop provides a mock function with no fields
|
|
func (_m *MockDataCoord) Stop() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Stop")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockDataCoord_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
|
|
type MockDataCoord_Stop_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Stop is a helper method to define mock.On call
|
|
func (_e *MockDataCoord_Expecter) Stop() *MockDataCoord_Stop_Call {
|
|
return &MockDataCoord_Stop_Call{Call: _e.mock.On("Stop")}
|
|
}
|
|
|
|
func (_c *MockDataCoord_Stop_Call) Run(run func()) *MockDataCoord_Stop_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Stop_Call) Return(_a0 error) *MockDataCoord_Stop_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_Stop_Call) RunAndReturn(run func() error) *MockDataCoord_Stop_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateChannelCheckpoint provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) UpdateChannelCheckpoint(_a0 context.Context, _a1 *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateChannelCheckpoint")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_UpdateChannelCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelCheckpoint'
|
|
type MockDataCoord_UpdateChannelCheckpoint_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateChannelCheckpoint is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.UpdateChannelCheckpointRequest
|
|
func (_e *MockDataCoord_Expecter) UpdateChannelCheckpoint(_a0 interface{}, _a1 interface{}) *MockDataCoord_UpdateChannelCheckpoint_Call {
|
|
return &MockDataCoord_UpdateChannelCheckpoint_Call{Call: _e.mock.On("UpdateChannelCheckpoint", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_UpdateChannelCheckpoint_Call) Run(run func(_a0 context.Context, _a1 *datapb.UpdateChannelCheckpointRequest)) *MockDataCoord_UpdateChannelCheckpoint_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.UpdateChannelCheckpointRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_UpdateChannelCheckpoint_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_UpdateChannelCheckpoint_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_UpdateChannelCheckpoint_Call) RunAndReturn(run func(context.Context, *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error)) *MockDataCoord_UpdateChannelCheckpoint_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateSegmentStatistics provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) UpdateSegmentStatistics(_a0 context.Context, _a1 *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateSegmentStatistics")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) *commonpb.Status); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_UpdateSegmentStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSegmentStatistics'
|
|
type MockDataCoord_UpdateSegmentStatistics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateSegmentStatistics is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.UpdateSegmentStatisticsRequest
|
|
func (_e *MockDataCoord_Expecter) UpdateSegmentStatistics(_a0 interface{}, _a1 interface{}) *MockDataCoord_UpdateSegmentStatistics_Call {
|
|
return &MockDataCoord_UpdateSegmentStatistics_Call{Call: _e.mock.On("UpdateSegmentStatistics", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_UpdateSegmentStatistics_Call) Run(run func(_a0 context.Context, _a1 *datapb.UpdateSegmentStatisticsRequest)) *MockDataCoord_UpdateSegmentStatistics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.UpdateSegmentStatisticsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_UpdateSegmentStatistics_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_UpdateSegmentStatistics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_UpdateSegmentStatistics_Call) RunAndReturn(run func(context.Context, *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error)) *MockDataCoord_UpdateSegmentStatistics_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// WatchChannels provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockDataCoord) WatchChannels(_a0 context.Context, _a1 *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WatchChannels")
|
|
}
|
|
|
|
var r0 *datapb.WatchChannelsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.WatchChannelsRequest) *datapb.WatchChannelsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.WatchChannelsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.WatchChannelsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockDataCoord_WatchChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchChannels'
|
|
type MockDataCoord_WatchChannels_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// WatchChannels is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *datapb.WatchChannelsRequest
|
|
func (_e *MockDataCoord_Expecter) WatchChannels(_a0 interface{}, _a1 interface{}) *MockDataCoord_WatchChannels_Call {
|
|
return &MockDataCoord_WatchChannels_Call{Call: _e.mock.On("WatchChannels", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockDataCoord_WatchChannels_Call) Run(run func(_a0 context.Context, _a1 *datapb.WatchChannelsRequest)) *MockDataCoord_WatchChannels_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.WatchChannelsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_WatchChannels_Call) Return(_a0 *datapb.WatchChannelsResponse, _a1 error) *MockDataCoord_WatchChannels_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockDataCoord_WatchChannels_Call) RunAndReturn(run func(context.Context, *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error)) *MockDataCoord_WatchChannels_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockDataCoord creates a new instance of MockDataCoord. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockDataCoord(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockDataCoord {
|
|
mock := &MockDataCoord{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|