mirror of
https://gitee.com/milvus-io/milvus.git
synced 2025-12-06 17:18:35 +08:00
c02892e9fb
issue: #37651 this PR enable to balance the collection with largest row count first, to avoid temporary migration of small table data to new nodes during their onboarding, only to be moved out again after the large table balance, which would cause unnecessary load. --------- Signed-off-by: Wei Liu <wei.liu@zilliz.com>
1150 lines
44 KiB
Go
1150 lines
44 KiB
Go
// Code generated by mockery v2.46.0. DO NOT EDIT.
|
|
|
|
package meta
|
|
|
|
import (
|
|
context "context"
|
|
|
|
metastore "github.com/milvus-io/milvus/internal/metastore"
|
|
datapb "github.com/milvus-io/milvus/pkg/v2/proto/datapb"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
typeutil "github.com/milvus-io/milvus/pkg/v2/util/typeutil"
|
|
)
|
|
|
|
// MockTargetManager is an autogenerated mock type for the TargetManagerInterface type
|
|
type MockTargetManager struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockTargetManager_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockTargetManager) EXPECT() *MockTargetManager_Expecter {
|
|
return &MockTargetManager_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// CanSegmentBeMoved provides a mock function with given fields: ctx, collectionID, segmentID
|
|
func (_m *MockTargetManager) CanSegmentBeMoved(ctx context.Context, collectionID int64, segmentID int64) bool {
|
|
ret := _m.Called(ctx, collectionID, segmentID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CanSegmentBeMoved")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int64) bool); ok {
|
|
r0 = rf(ctx, collectionID, segmentID)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_CanSegmentBeMoved_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanSegmentBeMoved'
|
|
type MockTargetManager_CanSegmentBeMoved_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CanSegmentBeMoved is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - segmentID int64
|
|
func (_e *MockTargetManager_Expecter) CanSegmentBeMoved(ctx interface{}, collectionID interface{}, segmentID interface{}) *MockTargetManager_CanSegmentBeMoved_Call {
|
|
return &MockTargetManager_CanSegmentBeMoved_Call{Call: _e.mock.On("CanSegmentBeMoved", ctx, collectionID, segmentID)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_CanSegmentBeMoved_Call) Run(run func(ctx context.Context, collectionID int64, segmentID int64)) *MockTargetManager_CanSegmentBeMoved_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_CanSegmentBeMoved_Call) Return(_a0 bool) *MockTargetManager_CanSegmentBeMoved_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_CanSegmentBeMoved_Call) RunAndReturn(run func(context.Context, int64, int64) bool) *MockTargetManager_CanSegmentBeMoved_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCollectionRowCount provides a mock function with given fields: ctx, collectionID, scope
|
|
func (_m *MockTargetManager) GetCollectionRowCount(ctx context.Context, collectionID int64, scope int32) int64 {
|
|
ret := _m.Called(ctx, collectionID, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCollectionRowCount")
|
|
}
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int32) int64); ok {
|
|
r0 = rf(ctx, collectionID, scope)
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetCollectionRowCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCollectionRowCount'
|
|
type MockTargetManager_GetCollectionRowCount_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCollectionRowCount is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetCollectionRowCount(ctx interface{}, collectionID interface{}, scope interface{}) *MockTargetManager_GetCollectionRowCount_Call {
|
|
return &MockTargetManager_GetCollectionRowCount_Call{Call: _e.mock.On("GetCollectionRowCount", ctx, collectionID, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetCollectionRowCount_Call) Run(run func(ctx context.Context, collectionID int64, scope int32)) *MockTargetManager_GetCollectionRowCount_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetCollectionRowCount_Call) Return(_a0 int64) *MockTargetManager_GetCollectionRowCount_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetCollectionRowCount_Call) RunAndReturn(run func(context.Context, int64, int32) int64) *MockTargetManager_GetCollectionRowCount_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCollectionTargetVersion provides a mock function with given fields: ctx, collectionID, scope
|
|
func (_m *MockTargetManager) GetCollectionTargetVersion(ctx context.Context, collectionID int64, scope int32) int64 {
|
|
ret := _m.Called(ctx, collectionID, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCollectionTargetVersion")
|
|
}
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int32) int64); ok {
|
|
r0 = rf(ctx, collectionID, scope)
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetCollectionTargetVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCollectionTargetVersion'
|
|
type MockTargetManager_GetCollectionTargetVersion_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCollectionTargetVersion is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetCollectionTargetVersion(ctx interface{}, collectionID interface{}, scope interface{}) *MockTargetManager_GetCollectionTargetVersion_Call {
|
|
return &MockTargetManager_GetCollectionTargetVersion_Call{Call: _e.mock.On("GetCollectionTargetVersion", ctx, collectionID, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetCollectionTargetVersion_Call) Run(run func(ctx context.Context, collectionID int64, scope int32)) *MockTargetManager_GetCollectionTargetVersion_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetCollectionTargetVersion_Call) Return(_a0 int64) *MockTargetManager_GetCollectionTargetVersion_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetCollectionTargetVersion_Call) RunAndReturn(run func(context.Context, int64, int32) int64) *MockTargetManager_GetCollectionTargetVersion_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetDmChannel provides a mock function with given fields: ctx, collectionID, channel, scope
|
|
func (_m *MockTargetManager) GetDmChannel(ctx context.Context, collectionID int64, channel string, scope int32) *DmChannel {
|
|
ret := _m.Called(ctx, collectionID, channel, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetDmChannel")
|
|
}
|
|
|
|
var r0 *DmChannel
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, string, int32) *DmChannel); ok {
|
|
r0 = rf(ctx, collectionID, channel, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*DmChannel)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetDmChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDmChannel'
|
|
type MockTargetManager_GetDmChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetDmChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - channel string
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetDmChannel(ctx interface{}, collectionID interface{}, channel interface{}, scope interface{}) *MockTargetManager_GetDmChannel_Call {
|
|
return &MockTargetManager_GetDmChannel_Call{Call: _e.mock.On("GetDmChannel", ctx, collectionID, channel, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDmChannel_Call) Run(run func(ctx context.Context, collectionID int64, channel string, scope int32)) *MockTargetManager_GetDmChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDmChannel_Call) Return(_a0 *DmChannel) *MockTargetManager_GetDmChannel_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDmChannel_Call) RunAndReturn(run func(context.Context, int64, string, int32) *DmChannel) *MockTargetManager_GetDmChannel_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetDmChannelsByCollection provides a mock function with given fields: ctx, collectionID, scope
|
|
func (_m *MockTargetManager) GetDmChannelsByCollection(ctx context.Context, collectionID int64, scope int32) map[string]*DmChannel {
|
|
ret := _m.Called(ctx, collectionID, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetDmChannelsByCollection")
|
|
}
|
|
|
|
var r0 map[string]*DmChannel
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int32) map[string]*DmChannel); ok {
|
|
r0 = rf(ctx, collectionID, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[string]*DmChannel)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetDmChannelsByCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDmChannelsByCollection'
|
|
type MockTargetManager_GetDmChannelsByCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetDmChannelsByCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetDmChannelsByCollection(ctx interface{}, collectionID interface{}, scope interface{}) *MockTargetManager_GetDmChannelsByCollection_Call {
|
|
return &MockTargetManager_GetDmChannelsByCollection_Call{Call: _e.mock.On("GetDmChannelsByCollection", ctx, collectionID, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDmChannelsByCollection_Call) Run(run func(ctx context.Context, collectionID int64, scope int32)) *MockTargetManager_GetDmChannelsByCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDmChannelsByCollection_Call) Return(_a0 map[string]*DmChannel) *MockTargetManager_GetDmChannelsByCollection_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDmChannelsByCollection_Call) RunAndReturn(run func(context.Context, int64, int32) map[string]*DmChannel) *MockTargetManager_GetDmChannelsByCollection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetDroppedSegmentsByChannel provides a mock function with given fields: ctx, collectionID, channelName, scope
|
|
func (_m *MockTargetManager) GetDroppedSegmentsByChannel(ctx context.Context, collectionID int64, channelName string, scope int32) []int64 {
|
|
ret := _m.Called(ctx, collectionID, channelName, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetDroppedSegmentsByChannel")
|
|
}
|
|
|
|
var r0 []int64
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, string, int32) []int64); ok {
|
|
r0 = rf(ctx, collectionID, channelName, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]int64)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetDroppedSegmentsByChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDroppedSegmentsByChannel'
|
|
type MockTargetManager_GetDroppedSegmentsByChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetDroppedSegmentsByChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - channelName string
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetDroppedSegmentsByChannel(ctx interface{}, collectionID interface{}, channelName interface{}, scope interface{}) *MockTargetManager_GetDroppedSegmentsByChannel_Call {
|
|
return &MockTargetManager_GetDroppedSegmentsByChannel_Call{Call: _e.mock.On("GetDroppedSegmentsByChannel", ctx, collectionID, channelName, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDroppedSegmentsByChannel_Call) Run(run func(ctx context.Context, collectionID int64, channelName string, scope int32)) *MockTargetManager_GetDroppedSegmentsByChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDroppedSegmentsByChannel_Call) Return(_a0 []int64) *MockTargetManager_GetDroppedSegmentsByChannel_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetDroppedSegmentsByChannel_Call) RunAndReturn(run func(context.Context, int64, string, int32) []int64) *MockTargetManager_GetDroppedSegmentsByChannel_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetGrowingSegmentsByChannel provides a mock function with given fields: ctx, collectionID, channelName, scope
|
|
func (_m *MockTargetManager) GetGrowingSegmentsByChannel(ctx context.Context, collectionID int64, channelName string, scope int32) typeutil.Set[int64] {
|
|
ret := _m.Called(ctx, collectionID, channelName, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGrowingSegmentsByChannel")
|
|
}
|
|
|
|
var r0 typeutil.Set[int64]
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, string, int32) typeutil.Set[int64]); ok {
|
|
r0 = rf(ctx, collectionID, channelName, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(typeutil.Set[int64])
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetGrowingSegmentsByChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGrowingSegmentsByChannel'
|
|
type MockTargetManager_GetGrowingSegmentsByChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetGrowingSegmentsByChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - channelName string
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetGrowingSegmentsByChannel(ctx interface{}, collectionID interface{}, channelName interface{}, scope interface{}) *MockTargetManager_GetGrowingSegmentsByChannel_Call {
|
|
return &MockTargetManager_GetGrowingSegmentsByChannel_Call{Call: _e.mock.On("GetGrowingSegmentsByChannel", ctx, collectionID, channelName, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetGrowingSegmentsByChannel_Call) Run(run func(ctx context.Context, collectionID int64, channelName string, scope int32)) *MockTargetManager_GetGrowingSegmentsByChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetGrowingSegmentsByChannel_Call) Return(_a0 typeutil.Set[int64]) *MockTargetManager_GetGrowingSegmentsByChannel_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetGrowingSegmentsByChannel_Call) RunAndReturn(run func(context.Context, int64, string, int32) typeutil.Set[int64]) *MockTargetManager_GetGrowingSegmentsByChannel_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetGrowingSegmentsByCollection provides a mock function with given fields: ctx, collectionID, scope
|
|
func (_m *MockTargetManager) GetGrowingSegmentsByCollection(ctx context.Context, collectionID int64, scope int32) typeutil.Set[int64] {
|
|
ret := _m.Called(ctx, collectionID, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGrowingSegmentsByCollection")
|
|
}
|
|
|
|
var r0 typeutil.Set[int64]
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int32) typeutil.Set[int64]); ok {
|
|
r0 = rf(ctx, collectionID, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(typeutil.Set[int64])
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetGrowingSegmentsByCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGrowingSegmentsByCollection'
|
|
type MockTargetManager_GetGrowingSegmentsByCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetGrowingSegmentsByCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetGrowingSegmentsByCollection(ctx interface{}, collectionID interface{}, scope interface{}) *MockTargetManager_GetGrowingSegmentsByCollection_Call {
|
|
return &MockTargetManager_GetGrowingSegmentsByCollection_Call{Call: _e.mock.On("GetGrowingSegmentsByCollection", ctx, collectionID, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetGrowingSegmentsByCollection_Call) Run(run func(ctx context.Context, collectionID int64, scope int32)) *MockTargetManager_GetGrowingSegmentsByCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetGrowingSegmentsByCollection_Call) Return(_a0 typeutil.Set[int64]) *MockTargetManager_GetGrowingSegmentsByCollection_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetGrowingSegmentsByCollection_Call) RunAndReturn(run func(context.Context, int64, int32) typeutil.Set[int64]) *MockTargetManager_GetGrowingSegmentsByCollection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetPartitions provides a mock function with given fields: ctx, collectionID, scope
|
|
func (_m *MockTargetManager) GetPartitions(ctx context.Context, collectionID int64, scope int32) ([]int64, error) {
|
|
ret := _m.Called(ctx, collectionID, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPartitions")
|
|
}
|
|
|
|
var r0 []int64
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int32) ([]int64, error)); ok {
|
|
return rf(ctx, collectionID, scope)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int32) []int64); ok {
|
|
r0 = rf(ctx, collectionID, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]int64)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int64, int32) error); ok {
|
|
r1 = rf(ctx, collectionID, scope)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockTargetManager_GetPartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPartitions'
|
|
type MockTargetManager_GetPartitions_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetPartitions is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetPartitions(ctx interface{}, collectionID interface{}, scope interface{}) *MockTargetManager_GetPartitions_Call {
|
|
return &MockTargetManager_GetPartitions_Call{Call: _e.mock.On("GetPartitions", ctx, collectionID, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetPartitions_Call) Run(run func(ctx context.Context, collectionID int64, scope int32)) *MockTargetManager_GetPartitions_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetPartitions_Call) Return(_a0 []int64, _a1 error) *MockTargetManager_GetPartitions_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetPartitions_Call) RunAndReturn(run func(context.Context, int64, int32) ([]int64, error)) *MockTargetManager_GetPartitions_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSealedSegment provides a mock function with given fields: ctx, collectionID, id, scope
|
|
func (_m *MockTargetManager) GetSealedSegment(ctx context.Context, collectionID int64, id int64, scope int32) *datapb.SegmentInfo {
|
|
ret := _m.Called(ctx, collectionID, id, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSealedSegment")
|
|
}
|
|
|
|
var r0 *datapb.SegmentInfo
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int64, int32) *datapb.SegmentInfo); ok {
|
|
r0 = rf(ctx, collectionID, id, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*datapb.SegmentInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetSealedSegment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSealedSegment'
|
|
type MockTargetManager_GetSealedSegment_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSealedSegment is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - id int64
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetSealedSegment(ctx interface{}, collectionID interface{}, id interface{}, scope interface{}) *MockTargetManager_GetSealedSegment_Call {
|
|
return &MockTargetManager_GetSealedSegment_Call{Call: _e.mock.On("GetSealedSegment", ctx, collectionID, id, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegment_Call) Run(run func(ctx context.Context, collectionID int64, id int64, scope int32)) *MockTargetManager_GetSealedSegment_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int64), args[3].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegment_Call) Return(_a0 *datapb.SegmentInfo) *MockTargetManager_GetSealedSegment_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegment_Call) RunAndReturn(run func(context.Context, int64, int64, int32) *datapb.SegmentInfo) *MockTargetManager_GetSealedSegment_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSealedSegmentsByChannel provides a mock function with given fields: ctx, collectionID, channelName, scope
|
|
func (_m *MockTargetManager) GetSealedSegmentsByChannel(ctx context.Context, collectionID int64, channelName string, scope int32) map[int64]*datapb.SegmentInfo {
|
|
ret := _m.Called(ctx, collectionID, channelName, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSealedSegmentsByChannel")
|
|
}
|
|
|
|
var r0 map[int64]*datapb.SegmentInfo
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, string, int32) map[int64]*datapb.SegmentInfo); ok {
|
|
r0 = rf(ctx, collectionID, channelName, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[int64]*datapb.SegmentInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetSealedSegmentsByChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSealedSegmentsByChannel'
|
|
type MockTargetManager_GetSealedSegmentsByChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSealedSegmentsByChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - channelName string
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetSealedSegmentsByChannel(ctx interface{}, collectionID interface{}, channelName interface{}, scope interface{}) *MockTargetManager_GetSealedSegmentsByChannel_Call {
|
|
return &MockTargetManager_GetSealedSegmentsByChannel_Call{Call: _e.mock.On("GetSealedSegmentsByChannel", ctx, collectionID, channelName, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByChannel_Call) Run(run func(ctx context.Context, collectionID int64, channelName string, scope int32)) *MockTargetManager_GetSealedSegmentsByChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByChannel_Call) Return(_a0 map[int64]*datapb.SegmentInfo) *MockTargetManager_GetSealedSegmentsByChannel_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByChannel_Call) RunAndReturn(run func(context.Context, int64, string, int32) map[int64]*datapb.SegmentInfo) *MockTargetManager_GetSealedSegmentsByChannel_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSealedSegmentsByCollection provides a mock function with given fields: ctx, collectionID, scope
|
|
func (_m *MockTargetManager) GetSealedSegmentsByCollection(ctx context.Context, collectionID int64, scope int32) map[int64]*datapb.SegmentInfo {
|
|
ret := _m.Called(ctx, collectionID, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSealedSegmentsByCollection")
|
|
}
|
|
|
|
var r0 map[int64]*datapb.SegmentInfo
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int32) map[int64]*datapb.SegmentInfo); ok {
|
|
r0 = rf(ctx, collectionID, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[int64]*datapb.SegmentInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetSealedSegmentsByCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSealedSegmentsByCollection'
|
|
type MockTargetManager_GetSealedSegmentsByCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSealedSegmentsByCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetSealedSegmentsByCollection(ctx interface{}, collectionID interface{}, scope interface{}) *MockTargetManager_GetSealedSegmentsByCollection_Call {
|
|
return &MockTargetManager_GetSealedSegmentsByCollection_Call{Call: _e.mock.On("GetSealedSegmentsByCollection", ctx, collectionID, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByCollection_Call) Run(run func(ctx context.Context, collectionID int64, scope int32)) *MockTargetManager_GetSealedSegmentsByCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByCollection_Call) Return(_a0 map[int64]*datapb.SegmentInfo) *MockTargetManager_GetSealedSegmentsByCollection_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByCollection_Call) RunAndReturn(run func(context.Context, int64, int32) map[int64]*datapb.SegmentInfo) *MockTargetManager_GetSealedSegmentsByCollection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSealedSegmentsByPartition provides a mock function with given fields: ctx, collectionID, partitionID, scope
|
|
func (_m *MockTargetManager) GetSealedSegmentsByPartition(ctx context.Context, collectionID int64, partitionID int64, scope int32) map[int64]*datapb.SegmentInfo {
|
|
ret := _m.Called(ctx, collectionID, partitionID, scope)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSealedSegmentsByPartition")
|
|
}
|
|
|
|
var r0 map[int64]*datapb.SegmentInfo
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int64, int32) map[int64]*datapb.SegmentInfo); ok {
|
|
r0 = rf(ctx, collectionID, partitionID, scope)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[int64]*datapb.SegmentInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetSealedSegmentsByPartition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSealedSegmentsByPartition'
|
|
type MockTargetManager_GetSealedSegmentsByPartition_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSealedSegmentsByPartition is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - partitionID int64
|
|
// - scope int32
|
|
func (_e *MockTargetManager_Expecter) GetSealedSegmentsByPartition(ctx interface{}, collectionID interface{}, partitionID interface{}, scope interface{}) *MockTargetManager_GetSealedSegmentsByPartition_Call {
|
|
return &MockTargetManager_GetSealedSegmentsByPartition_Call{Call: _e.mock.On("GetSealedSegmentsByPartition", ctx, collectionID, partitionID, scope)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByPartition_Call) Run(run func(ctx context.Context, collectionID int64, partitionID int64, scope int32)) *MockTargetManager_GetSealedSegmentsByPartition_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int64), args[3].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByPartition_Call) Return(_a0 map[int64]*datapb.SegmentInfo) *MockTargetManager_GetSealedSegmentsByPartition_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetSealedSegmentsByPartition_Call) RunAndReturn(run func(context.Context, int64, int64, int32) map[int64]*datapb.SegmentInfo) *MockTargetManager_GetSealedSegmentsByPartition_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTargetJSON provides a mock function with given fields: ctx, scope, collectionID
|
|
func (_m *MockTargetManager) GetTargetJSON(ctx context.Context, scope int32, collectionID int64) string {
|
|
ret := _m.Called(ctx, scope, collectionID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTargetJSON")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32, int64) string); ok {
|
|
r0 = rf(ctx, scope, collectionID)
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_GetTargetJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTargetJSON'
|
|
type MockTargetManager_GetTargetJSON_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTargetJSON is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - scope int32
|
|
// - collectionID int64
|
|
func (_e *MockTargetManager_Expecter) GetTargetJSON(ctx interface{}, scope interface{}, collectionID interface{}) *MockTargetManager_GetTargetJSON_Call {
|
|
return &MockTargetManager_GetTargetJSON_Call{Call: _e.mock.On("GetTargetJSON", ctx, scope, collectionID)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetTargetJSON_Call) Run(run func(ctx context.Context, scope int32, collectionID int64)) *MockTargetManager_GetTargetJSON_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int32), args[2].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetTargetJSON_Call) Return(_a0 string) *MockTargetManager_GetTargetJSON_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_GetTargetJSON_Call) RunAndReturn(run func(context.Context, int32, int64) string) *MockTargetManager_GetTargetJSON_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// IsCurrentTargetExist provides a mock function with given fields: ctx, collectionID, partitionID
|
|
func (_m *MockTargetManager) IsCurrentTargetExist(ctx context.Context, collectionID int64, partitionID int64) bool {
|
|
ret := _m.Called(ctx, collectionID, partitionID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for IsCurrentTargetExist")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, int64) bool); ok {
|
|
r0 = rf(ctx, collectionID, partitionID)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_IsCurrentTargetExist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsCurrentTargetExist'
|
|
type MockTargetManager_IsCurrentTargetExist_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// IsCurrentTargetExist is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - partitionID int64
|
|
func (_e *MockTargetManager_Expecter) IsCurrentTargetExist(ctx interface{}, collectionID interface{}, partitionID interface{}) *MockTargetManager_IsCurrentTargetExist_Call {
|
|
return &MockTargetManager_IsCurrentTargetExist_Call{Call: _e.mock.On("IsCurrentTargetExist", ctx, collectionID, partitionID)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsCurrentTargetExist_Call) Run(run func(ctx context.Context, collectionID int64, partitionID int64)) *MockTargetManager_IsCurrentTargetExist_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64), args[2].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsCurrentTargetExist_Call) Return(_a0 bool) *MockTargetManager_IsCurrentTargetExist_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsCurrentTargetExist_Call) RunAndReturn(run func(context.Context, int64, int64) bool) *MockTargetManager_IsCurrentTargetExist_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// IsCurrentTargetReady provides a mock function with given fields: ctx, collectionID
|
|
func (_m *MockTargetManager) IsCurrentTargetReady(ctx context.Context, collectionID int64) bool {
|
|
ret := _m.Called(ctx, collectionID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for IsCurrentTargetReady")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) bool); ok {
|
|
r0 = rf(ctx, collectionID)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_IsCurrentTargetReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsCurrentTargetReady'
|
|
type MockTargetManager_IsCurrentTargetReady_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// IsCurrentTargetReady is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
func (_e *MockTargetManager_Expecter) IsCurrentTargetReady(ctx interface{}, collectionID interface{}) *MockTargetManager_IsCurrentTargetReady_Call {
|
|
return &MockTargetManager_IsCurrentTargetReady_Call{Call: _e.mock.On("IsCurrentTargetReady", ctx, collectionID)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsCurrentTargetReady_Call) Run(run func(ctx context.Context, collectionID int64)) *MockTargetManager_IsCurrentTargetReady_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsCurrentTargetReady_Call) Return(_a0 bool) *MockTargetManager_IsCurrentTargetReady_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsCurrentTargetReady_Call) RunAndReturn(run func(context.Context, int64) bool) *MockTargetManager_IsCurrentTargetReady_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// IsNextTargetExist provides a mock function with given fields: ctx, collectionID
|
|
func (_m *MockTargetManager) IsNextTargetExist(ctx context.Context, collectionID int64) bool {
|
|
ret := _m.Called(ctx, collectionID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for IsNextTargetExist")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) bool); ok {
|
|
r0 = rf(ctx, collectionID)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_IsNextTargetExist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsNextTargetExist'
|
|
type MockTargetManager_IsNextTargetExist_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// IsNextTargetExist is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
func (_e *MockTargetManager_Expecter) IsNextTargetExist(ctx interface{}, collectionID interface{}) *MockTargetManager_IsNextTargetExist_Call {
|
|
return &MockTargetManager_IsNextTargetExist_Call{Call: _e.mock.On("IsNextTargetExist", ctx, collectionID)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsNextTargetExist_Call) Run(run func(ctx context.Context, collectionID int64)) *MockTargetManager_IsNextTargetExist_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsNextTargetExist_Call) Return(_a0 bool) *MockTargetManager_IsNextTargetExist_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_IsNextTargetExist_Call) RunAndReturn(run func(context.Context, int64) bool) *MockTargetManager_IsNextTargetExist_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Recover provides a mock function with given fields: ctx, catalog
|
|
func (_m *MockTargetManager) Recover(ctx context.Context, catalog metastore.QueryCoordCatalog) error {
|
|
ret := _m.Called(ctx, catalog)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Recover")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, metastore.QueryCoordCatalog) error); ok {
|
|
r0 = rf(ctx, catalog)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_Recover_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recover'
|
|
type MockTargetManager_Recover_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Recover is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - catalog metastore.QueryCoordCatalog
|
|
func (_e *MockTargetManager_Expecter) Recover(ctx interface{}, catalog interface{}) *MockTargetManager_Recover_Call {
|
|
return &MockTargetManager_Recover_Call{Call: _e.mock.On("Recover", ctx, catalog)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_Recover_Call) Run(run func(ctx context.Context, catalog metastore.QueryCoordCatalog)) *MockTargetManager_Recover_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(metastore.QueryCoordCatalog))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_Recover_Call) Return(_a0 error) *MockTargetManager_Recover_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_Recover_Call) RunAndReturn(run func(context.Context, metastore.QueryCoordCatalog) error) *MockTargetManager_Recover_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemoveCollection provides a mock function with given fields: ctx, collectionID
|
|
func (_m *MockTargetManager) RemoveCollection(ctx context.Context, collectionID int64) {
|
|
_m.Called(ctx, collectionID)
|
|
}
|
|
|
|
// MockTargetManager_RemoveCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCollection'
|
|
type MockTargetManager_RemoveCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemoveCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
func (_e *MockTargetManager_Expecter) RemoveCollection(ctx interface{}, collectionID interface{}) *MockTargetManager_RemoveCollection_Call {
|
|
return &MockTargetManager_RemoveCollection_Call{Call: _e.mock.On("RemoveCollection", ctx, collectionID)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_RemoveCollection_Call) Run(run func(ctx context.Context, collectionID int64)) *MockTargetManager_RemoveCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_RemoveCollection_Call) Return() *MockTargetManager_RemoveCollection_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_RemoveCollection_Call) RunAndReturn(run func(context.Context, int64)) *MockTargetManager_RemoveCollection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemovePartition provides a mock function with given fields: ctx, collectionID, partitionIDs
|
|
func (_m *MockTargetManager) RemovePartition(ctx context.Context, collectionID int64, partitionIDs ...int64) {
|
|
_va := make([]interface{}, len(partitionIDs))
|
|
for _i := range partitionIDs {
|
|
_va[_i] = partitionIDs[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, collectionID)
|
|
_ca = append(_ca, _va...)
|
|
_m.Called(_ca...)
|
|
}
|
|
|
|
// MockTargetManager_RemovePartition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePartition'
|
|
type MockTargetManager_RemovePartition_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemovePartition is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
// - partitionIDs ...int64
|
|
func (_e *MockTargetManager_Expecter) RemovePartition(ctx interface{}, collectionID interface{}, partitionIDs ...interface{}) *MockTargetManager_RemovePartition_Call {
|
|
return &MockTargetManager_RemovePartition_Call{Call: _e.mock.On("RemovePartition",
|
|
append([]interface{}{ctx, collectionID}, partitionIDs...)...)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_RemovePartition_Call) Run(run func(ctx context.Context, collectionID int64, partitionIDs ...int64)) *MockTargetManager_RemovePartition_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]int64, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(int64)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(int64), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_RemovePartition_Call) Return() *MockTargetManager_RemovePartition_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_RemovePartition_Call) RunAndReturn(run func(context.Context, int64, ...int64)) *MockTargetManager_RemovePartition_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SaveCurrentTarget provides a mock function with given fields: ctx, catalog
|
|
func (_m *MockTargetManager) SaveCurrentTarget(ctx context.Context, catalog metastore.QueryCoordCatalog) {
|
|
_m.Called(ctx, catalog)
|
|
}
|
|
|
|
// MockTargetManager_SaveCurrentTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveCurrentTarget'
|
|
type MockTargetManager_SaveCurrentTarget_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SaveCurrentTarget is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - catalog metastore.QueryCoordCatalog
|
|
func (_e *MockTargetManager_Expecter) SaveCurrentTarget(ctx interface{}, catalog interface{}) *MockTargetManager_SaveCurrentTarget_Call {
|
|
return &MockTargetManager_SaveCurrentTarget_Call{Call: _e.mock.On("SaveCurrentTarget", ctx, catalog)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_SaveCurrentTarget_Call) Run(run func(ctx context.Context, catalog metastore.QueryCoordCatalog)) *MockTargetManager_SaveCurrentTarget_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(metastore.QueryCoordCatalog))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_SaveCurrentTarget_Call) Return() *MockTargetManager_SaveCurrentTarget_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_SaveCurrentTarget_Call) RunAndReturn(run func(context.Context, metastore.QueryCoordCatalog)) *MockTargetManager_SaveCurrentTarget_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateCollectionCurrentTarget provides a mock function with given fields: ctx, collectionID
|
|
func (_m *MockTargetManager) UpdateCollectionCurrentTarget(ctx context.Context, collectionID int64) bool {
|
|
ret := _m.Called(ctx, collectionID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateCollectionCurrentTarget")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) bool); ok {
|
|
r0 = rf(ctx, collectionID)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_UpdateCollectionCurrentTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCollectionCurrentTarget'
|
|
type MockTargetManager_UpdateCollectionCurrentTarget_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateCollectionCurrentTarget is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
func (_e *MockTargetManager_Expecter) UpdateCollectionCurrentTarget(ctx interface{}, collectionID interface{}) *MockTargetManager_UpdateCollectionCurrentTarget_Call {
|
|
return &MockTargetManager_UpdateCollectionCurrentTarget_Call{Call: _e.mock.On("UpdateCollectionCurrentTarget", ctx, collectionID)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_UpdateCollectionCurrentTarget_Call) Run(run func(ctx context.Context, collectionID int64)) *MockTargetManager_UpdateCollectionCurrentTarget_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_UpdateCollectionCurrentTarget_Call) Return(_a0 bool) *MockTargetManager_UpdateCollectionCurrentTarget_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_UpdateCollectionCurrentTarget_Call) RunAndReturn(run func(context.Context, int64) bool) *MockTargetManager_UpdateCollectionCurrentTarget_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateCollectionNextTarget provides a mock function with given fields: ctx, collectionID
|
|
func (_m *MockTargetManager) UpdateCollectionNextTarget(ctx context.Context, collectionID int64) error {
|
|
ret := _m.Called(ctx, collectionID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateCollectionNextTarget")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok {
|
|
r0 = rf(ctx, collectionID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockTargetManager_UpdateCollectionNextTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCollectionNextTarget'
|
|
type MockTargetManager_UpdateCollectionNextTarget_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateCollectionNextTarget is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - collectionID int64
|
|
func (_e *MockTargetManager_Expecter) UpdateCollectionNextTarget(ctx interface{}, collectionID interface{}) *MockTargetManager_UpdateCollectionNextTarget_Call {
|
|
return &MockTargetManager_UpdateCollectionNextTarget_Call{Call: _e.mock.On("UpdateCollectionNextTarget", ctx, collectionID)}
|
|
}
|
|
|
|
func (_c *MockTargetManager_UpdateCollectionNextTarget_Call) Run(run func(ctx context.Context, collectionID int64)) *MockTargetManager_UpdateCollectionNextTarget_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_UpdateCollectionNextTarget_Call) Return(_a0 error) *MockTargetManager_UpdateCollectionNextTarget_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockTargetManager_UpdateCollectionNextTarget_Call) RunAndReturn(run func(context.Context, int64) error) *MockTargetManager_UpdateCollectionNextTarget_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockTargetManager creates a new instance of MockTargetManager. 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 NewMockTargetManager(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockTargetManager {
|
|
mock := &MockTargetManager{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|