mirror of
https://gitee.com/milvus-io/milvus.git
synced 2025-12-28 22:45:26 +08:00
ad8aba7cb4
issue: https://github.com/milvus-io/milvus/issues/45890 ComputePhraseMatchSlop accepts three pararms: 1. A string: query text 2. Some trings: data texts 3. Analyzer params, Slop will be calculated for the query text with each data text in the context of phrase match where they are tokenized with tokenizer with analyzer params. So two array will be returned: 1. is_match: is phrase match can sucess 2. slop: the related slop if phrase match can sucess, or -1 is cannot. --------- Signed-off-by: SpadeA <tangchenjie1210@gmail.com>
2788 lines
98 KiB
Go
2788 lines
98 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"
|
|
|
|
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"
|
|
|
|
querypb "github.com/milvus-io/milvus/pkg/v2/proto/querypb"
|
|
|
|
txnkv "github.com/tikv/client-go/v2/txnkv"
|
|
|
|
types "github.com/milvus-io/milvus/internal/types"
|
|
)
|
|
|
|
// MockQueryCoord is an autogenerated mock type for the QueryCoordComponent type
|
|
type MockQueryCoord struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockQueryCoord_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockQueryCoord) EXPECT() *MockQueryCoord_Expecter {
|
|
return &MockQueryCoord_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// ActivateChecker provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ActivateChecker(_a0 context.Context, _a1 *querypb.ActivateCheckerRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ActivateChecker")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ActivateCheckerRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ActivateCheckerRequest) *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, *querypb.ActivateCheckerRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ActivateChecker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateChecker'
|
|
type MockQueryCoord_ActivateChecker_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ActivateChecker is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ActivateCheckerRequest
|
|
func (_e *MockQueryCoord_Expecter) ActivateChecker(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ActivateChecker_Call {
|
|
return &MockQueryCoord_ActivateChecker_Call{Call: _e.mock.On("ActivateChecker", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ActivateChecker_Call) Run(run func(_a0 context.Context, _a1 *querypb.ActivateCheckerRequest)) *MockQueryCoord_ActivateChecker_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ActivateCheckerRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ActivateChecker_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_ActivateChecker_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ActivateChecker_Call) RunAndReturn(run func(context.Context, *querypb.ActivateCheckerRequest) (*commonpb.Status, error)) *MockQueryCoord_ActivateChecker_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CheckBalanceStatus provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) CheckBalanceStatus(_a0 context.Context, _a1 *querypb.CheckBalanceStatusRequest) (*querypb.CheckBalanceStatusResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CheckBalanceStatus")
|
|
}
|
|
|
|
var r0 *querypb.CheckBalanceStatusResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.CheckBalanceStatusRequest) (*querypb.CheckBalanceStatusResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.CheckBalanceStatusRequest) *querypb.CheckBalanceStatusResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.CheckBalanceStatusResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.CheckBalanceStatusRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_CheckBalanceStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckBalanceStatus'
|
|
type MockQueryCoord_CheckBalanceStatus_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CheckBalanceStatus is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.CheckBalanceStatusRequest
|
|
func (_e *MockQueryCoord_Expecter) CheckBalanceStatus(_a0 interface{}, _a1 interface{}) *MockQueryCoord_CheckBalanceStatus_Call {
|
|
return &MockQueryCoord_CheckBalanceStatus_Call{Call: _e.mock.On("CheckBalanceStatus", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckBalanceStatus_Call) Run(run func(_a0 context.Context, _a1 *querypb.CheckBalanceStatusRequest)) *MockQueryCoord_CheckBalanceStatus_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.CheckBalanceStatusRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckBalanceStatus_Call) Return(_a0 *querypb.CheckBalanceStatusResponse, _a1 error) *MockQueryCoord_CheckBalanceStatus_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckBalanceStatus_Call) RunAndReturn(run func(context.Context, *querypb.CheckBalanceStatusRequest) (*querypb.CheckBalanceStatusResponse, error)) *MockQueryCoord_CheckBalanceStatus_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CheckHealth provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) 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
|
|
}
|
|
|
|
// MockQueryCoord_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'
|
|
type MockQueryCoord_CheckHealth_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CheckHealth is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.CheckHealthRequest
|
|
func (_e *MockQueryCoord_Expecter) CheckHealth(_a0 interface{}, _a1 interface{}) *MockQueryCoord_CheckHealth_Call {
|
|
return &MockQueryCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckHealth_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.CheckHealthRequest)) *MockQueryCoord_CheckHealth_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *MockQueryCoord_CheckHealth_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckHealth_Call) RunAndReturn(run func(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)) *MockQueryCoord_CheckHealth_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CheckQueryNodeDistribution provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) CheckQueryNodeDistribution(_a0 context.Context, _a1 *querypb.CheckQueryNodeDistributionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CheckQueryNodeDistribution")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.CheckQueryNodeDistributionRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.CheckQueryNodeDistributionRequest) *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, *querypb.CheckQueryNodeDistributionRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_CheckQueryNodeDistribution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckQueryNodeDistribution'
|
|
type MockQueryCoord_CheckQueryNodeDistribution_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CheckQueryNodeDistribution is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.CheckQueryNodeDistributionRequest
|
|
func (_e *MockQueryCoord_Expecter) CheckQueryNodeDistribution(_a0 interface{}, _a1 interface{}) *MockQueryCoord_CheckQueryNodeDistribution_Call {
|
|
return &MockQueryCoord_CheckQueryNodeDistribution_Call{Call: _e.mock.On("CheckQueryNodeDistribution", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckQueryNodeDistribution_Call) Run(run func(_a0 context.Context, _a1 *querypb.CheckQueryNodeDistributionRequest)) *MockQueryCoord_CheckQueryNodeDistribution_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.CheckQueryNodeDistributionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckQueryNodeDistribution_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_CheckQueryNodeDistribution_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CheckQueryNodeDistribution_Call) RunAndReturn(run func(context.Context, *querypb.CheckQueryNodeDistributionRequest) (*commonpb.Status, error)) *MockQueryCoord_CheckQueryNodeDistribution_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ComputePhraseMatchSlop provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ComputePhraseMatchSlop(_a0 context.Context, _a1 *querypb.ComputePhraseMatchSlopRequest) (*querypb.ComputePhraseMatchSlopResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ComputePhraseMatchSlop")
|
|
}
|
|
|
|
var r0 *querypb.ComputePhraseMatchSlopResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ComputePhraseMatchSlopRequest) (*querypb.ComputePhraseMatchSlopResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ComputePhraseMatchSlopRequest) *querypb.ComputePhraseMatchSlopResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.ComputePhraseMatchSlopResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.ComputePhraseMatchSlopRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ComputePhraseMatchSlop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePhraseMatchSlop'
|
|
type MockQueryCoord_ComputePhraseMatchSlop_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ComputePhraseMatchSlop is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ComputePhraseMatchSlopRequest
|
|
func (_e *MockQueryCoord_Expecter) ComputePhraseMatchSlop(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ComputePhraseMatchSlop_Call {
|
|
return &MockQueryCoord_ComputePhraseMatchSlop_Call{Call: _e.mock.On("ComputePhraseMatchSlop", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ComputePhraseMatchSlop_Call) Run(run func(_a0 context.Context, _a1 *querypb.ComputePhraseMatchSlopRequest)) *MockQueryCoord_ComputePhraseMatchSlop_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ComputePhraseMatchSlopRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ComputePhraseMatchSlop_Call) Return(_a0 *querypb.ComputePhraseMatchSlopResponse, _a1 error) *MockQueryCoord_ComputePhraseMatchSlop_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ComputePhraseMatchSlop_Call) RunAndReturn(run func(context.Context, *querypb.ComputePhraseMatchSlopRequest) (*querypb.ComputePhraseMatchSlopResponse, error)) *MockQueryCoord_ComputePhraseMatchSlop_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateResourceGroup provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) CreateResourceGroup(_a0 context.Context, _a1 *milvuspb.CreateResourceGroupRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateResourceGroup")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateResourceGroupRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateResourceGroupRequest) *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.CreateResourceGroupRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_CreateResourceGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateResourceGroup'
|
|
type MockQueryCoord_CreateResourceGroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateResourceGroup is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.CreateResourceGroupRequest
|
|
func (_e *MockQueryCoord_Expecter) CreateResourceGroup(_a0 interface{}, _a1 interface{}) *MockQueryCoord_CreateResourceGroup_Call {
|
|
return &MockQueryCoord_CreateResourceGroup_Call{Call: _e.mock.On("CreateResourceGroup", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CreateResourceGroup_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.CreateResourceGroupRequest)) *MockQueryCoord_CreateResourceGroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CreateResourceGroupRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CreateResourceGroup_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_CreateResourceGroup_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_CreateResourceGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.CreateResourceGroupRequest) (*commonpb.Status, error)) *MockQueryCoord_CreateResourceGroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeactivateChecker provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) DeactivateChecker(_a0 context.Context, _a1 *querypb.DeactivateCheckerRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeactivateChecker")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeactivateCheckerRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeactivateCheckerRequest) *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, *querypb.DeactivateCheckerRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_DeactivateChecker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeactivateChecker'
|
|
type MockQueryCoord_DeactivateChecker_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeactivateChecker is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.DeactivateCheckerRequest
|
|
func (_e *MockQueryCoord_Expecter) DeactivateChecker(_a0 interface{}, _a1 interface{}) *MockQueryCoord_DeactivateChecker_Call {
|
|
return &MockQueryCoord_DeactivateChecker_Call{Call: _e.mock.On("DeactivateChecker", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DeactivateChecker_Call) Run(run func(_a0 context.Context, _a1 *querypb.DeactivateCheckerRequest)) *MockQueryCoord_DeactivateChecker_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.DeactivateCheckerRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DeactivateChecker_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_DeactivateChecker_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DeactivateChecker_Call) RunAndReturn(run func(context.Context, *querypb.DeactivateCheckerRequest) (*commonpb.Status, error)) *MockQueryCoord_DeactivateChecker_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DescribeResourceGroup provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) DescribeResourceGroup(_a0 context.Context, _a1 *querypb.DescribeResourceGroupRequest) (*querypb.DescribeResourceGroupResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DescribeResourceGroup")
|
|
}
|
|
|
|
var r0 *querypb.DescribeResourceGroupResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.DescribeResourceGroupRequest) (*querypb.DescribeResourceGroupResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.DescribeResourceGroupRequest) *querypb.DescribeResourceGroupResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.DescribeResourceGroupResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.DescribeResourceGroupRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_DescribeResourceGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeResourceGroup'
|
|
type MockQueryCoord_DescribeResourceGroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DescribeResourceGroup is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.DescribeResourceGroupRequest
|
|
func (_e *MockQueryCoord_Expecter) DescribeResourceGroup(_a0 interface{}, _a1 interface{}) *MockQueryCoord_DescribeResourceGroup_Call {
|
|
return &MockQueryCoord_DescribeResourceGroup_Call{Call: _e.mock.On("DescribeResourceGroup", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DescribeResourceGroup_Call) Run(run func(_a0 context.Context, _a1 *querypb.DescribeResourceGroupRequest)) *MockQueryCoord_DescribeResourceGroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.DescribeResourceGroupRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DescribeResourceGroup_Call) Return(_a0 *querypb.DescribeResourceGroupResponse, _a1 error) *MockQueryCoord_DescribeResourceGroup_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DescribeResourceGroup_Call) RunAndReturn(run func(context.Context, *querypb.DescribeResourceGroupRequest) (*querypb.DescribeResourceGroupResponse, error)) *MockQueryCoord_DescribeResourceGroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DropResourceGroup provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) DropResourceGroup(_a0 context.Context, _a1 *milvuspb.DropResourceGroupRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DropResourceGroup")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropResourceGroupRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropResourceGroupRequest) *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.DropResourceGroupRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_DropResourceGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropResourceGroup'
|
|
type MockQueryCoord_DropResourceGroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropResourceGroup is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.DropResourceGroupRequest
|
|
func (_e *MockQueryCoord_Expecter) DropResourceGroup(_a0 interface{}, _a1 interface{}) *MockQueryCoord_DropResourceGroup_Call {
|
|
return &MockQueryCoord_DropResourceGroup_Call{Call: _e.mock.On("DropResourceGroup", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DropResourceGroup_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.DropResourceGroupRequest)) *MockQueryCoord_DropResourceGroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.DropResourceGroupRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DropResourceGroup_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_DropResourceGroup_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_DropResourceGroup_Call) RunAndReturn(run func(context.Context, *milvuspb.DropResourceGroupRequest) (*commonpb.Status, error)) *MockQueryCoord_DropResourceGroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetLoadSegmentInfo provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) GetLoadSegmentInfo(_a0 context.Context, _a1 *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetLoadSegmentInfo")
|
|
}
|
|
|
|
var r0 *querypb.GetSegmentInfoResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetSegmentInfoRequest) *querypb.GetSegmentInfoResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.GetSegmentInfoResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetSegmentInfoRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_GetLoadSegmentInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLoadSegmentInfo'
|
|
type MockQueryCoord_GetLoadSegmentInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetLoadSegmentInfo is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.GetSegmentInfoRequest
|
|
func (_e *MockQueryCoord_Expecter) GetLoadSegmentInfo(_a0 interface{}, _a1 interface{}) *MockQueryCoord_GetLoadSegmentInfo_Call {
|
|
return &MockQueryCoord_GetLoadSegmentInfo_Call{Call: _e.mock.On("GetLoadSegmentInfo", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetLoadSegmentInfo_Call) Run(run func(_a0 context.Context, _a1 *querypb.GetSegmentInfoRequest)) *MockQueryCoord_GetLoadSegmentInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.GetSegmentInfoRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetLoadSegmentInfo_Call) Return(_a0 *querypb.GetSegmentInfoResponse, _a1 error) *MockQueryCoord_GetLoadSegmentInfo_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetLoadSegmentInfo_Call) RunAndReturn(run func(context.Context, *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)) *MockQueryCoord_GetLoadSegmentInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetMetrics provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) 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
|
|
}
|
|
|
|
// MockQueryCoord_GetMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetrics'
|
|
type MockQueryCoord_GetMetrics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetMetrics is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.GetMetricsRequest
|
|
func (_e *MockQueryCoord_Expecter) GetMetrics(_a0 interface{}, _a1 interface{}) *MockQueryCoord_GetMetrics_Call {
|
|
return &MockQueryCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetMetrics_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest)) *MockQueryCoord_GetMetrics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetMetricsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetMetrics_Call) Return(_a0 *milvuspb.GetMetricsResponse, _a1 error) *MockQueryCoord_GetMetrics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetMetrics_Call) RunAndReturn(run func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)) *MockQueryCoord_GetMetrics_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetPartitionStates provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) GetPartitionStates(_a0 context.Context, _a1 *querypb.GetPartitionStatesRequest) (*querypb.GetPartitionStatesResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPartitionStates")
|
|
}
|
|
|
|
var r0 *querypb.GetPartitionStatesResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetPartitionStatesRequest) (*querypb.GetPartitionStatesResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetPartitionStatesRequest) *querypb.GetPartitionStatesResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.GetPartitionStatesResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetPartitionStatesRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_GetPartitionStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPartitionStates'
|
|
type MockQueryCoord_GetPartitionStates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetPartitionStates is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.GetPartitionStatesRequest
|
|
func (_e *MockQueryCoord_Expecter) GetPartitionStates(_a0 interface{}, _a1 interface{}) *MockQueryCoord_GetPartitionStates_Call {
|
|
return &MockQueryCoord_GetPartitionStates_Call{Call: _e.mock.On("GetPartitionStates", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetPartitionStates_Call) Run(run func(_a0 context.Context, _a1 *querypb.GetPartitionStatesRequest)) *MockQueryCoord_GetPartitionStates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.GetPartitionStatesRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetPartitionStates_Call) Return(_a0 *querypb.GetPartitionStatesResponse, _a1 error) *MockQueryCoord_GetPartitionStates_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetPartitionStates_Call) RunAndReturn(run func(context.Context, *querypb.GetPartitionStatesRequest) (*querypb.GetPartitionStatesResponse, error)) *MockQueryCoord_GetPartitionStates_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetQueryNodeDistribution provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) GetQueryNodeDistribution(_a0 context.Context, _a1 *querypb.GetQueryNodeDistributionRequest) (*querypb.GetQueryNodeDistributionResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetQueryNodeDistribution")
|
|
}
|
|
|
|
var r0 *querypb.GetQueryNodeDistributionResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetQueryNodeDistributionRequest) (*querypb.GetQueryNodeDistributionResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetQueryNodeDistributionRequest) *querypb.GetQueryNodeDistributionResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.GetQueryNodeDistributionResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetQueryNodeDistributionRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_GetQueryNodeDistribution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueryNodeDistribution'
|
|
type MockQueryCoord_GetQueryNodeDistribution_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetQueryNodeDistribution is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.GetQueryNodeDistributionRequest
|
|
func (_e *MockQueryCoord_Expecter) GetQueryNodeDistribution(_a0 interface{}, _a1 interface{}) *MockQueryCoord_GetQueryNodeDistribution_Call {
|
|
return &MockQueryCoord_GetQueryNodeDistribution_Call{Call: _e.mock.On("GetQueryNodeDistribution", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetQueryNodeDistribution_Call) Run(run func(_a0 context.Context, _a1 *querypb.GetQueryNodeDistributionRequest)) *MockQueryCoord_GetQueryNodeDistribution_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.GetQueryNodeDistributionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetQueryNodeDistribution_Call) Return(_a0 *querypb.GetQueryNodeDistributionResponse, _a1 error) *MockQueryCoord_GetQueryNodeDistribution_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetQueryNodeDistribution_Call) RunAndReturn(run func(context.Context, *querypb.GetQueryNodeDistributionRequest) (*querypb.GetQueryNodeDistributionResponse, error)) *MockQueryCoord_GetQueryNodeDistribution_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetReplicas provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) GetReplicas(_a0 context.Context, _a1 *milvuspb.GetReplicasRequest) (*milvuspb.GetReplicasResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetReplicas")
|
|
}
|
|
|
|
var r0 *milvuspb.GetReplicasResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetReplicasRequest) (*milvuspb.GetReplicasResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetReplicasRequest) *milvuspb.GetReplicasResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetReplicasResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetReplicasRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_GetReplicas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReplicas'
|
|
type MockQueryCoord_GetReplicas_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetReplicas is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.GetReplicasRequest
|
|
func (_e *MockQueryCoord_Expecter) GetReplicas(_a0 interface{}, _a1 interface{}) *MockQueryCoord_GetReplicas_Call {
|
|
return &MockQueryCoord_GetReplicas_Call{Call: _e.mock.On("GetReplicas", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetReplicas_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.GetReplicasRequest)) *MockQueryCoord_GetReplicas_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetReplicasRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetReplicas_Call) Return(_a0 *milvuspb.GetReplicasResponse, _a1 error) *MockQueryCoord_GetReplicas_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetReplicas_Call) RunAndReturn(run func(context.Context, *milvuspb.GetReplicasRequest) (*milvuspb.GetReplicasResponse, error)) *MockQueryCoord_GetReplicas_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetShardLeaders provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) GetShardLeaders(_a0 context.Context, _a1 *querypb.GetShardLeadersRequest) (*querypb.GetShardLeadersResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetShardLeaders")
|
|
}
|
|
|
|
var r0 *querypb.GetShardLeadersResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetShardLeadersRequest) (*querypb.GetShardLeadersResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetShardLeadersRequest) *querypb.GetShardLeadersResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.GetShardLeadersResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetShardLeadersRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_GetShardLeaders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShardLeaders'
|
|
type MockQueryCoord_GetShardLeaders_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetShardLeaders is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.GetShardLeadersRequest
|
|
func (_e *MockQueryCoord_Expecter) GetShardLeaders(_a0 interface{}, _a1 interface{}) *MockQueryCoord_GetShardLeaders_Call {
|
|
return &MockQueryCoord_GetShardLeaders_Call{Call: _e.mock.On("GetShardLeaders", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetShardLeaders_Call) Run(run func(_a0 context.Context, _a1 *querypb.GetShardLeadersRequest)) *MockQueryCoord_GetShardLeaders_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.GetShardLeadersRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetShardLeaders_Call) Return(_a0 *querypb.GetShardLeadersResponse, _a1 error) *MockQueryCoord_GetShardLeaders_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_GetShardLeaders_Call) RunAndReturn(run func(context.Context, *querypb.GetShardLeadersRequest) (*querypb.GetShardLeadersResponse, error)) *MockQueryCoord_GetShardLeaders_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Init provides a mock function with no fields
|
|
func (_m *MockQueryCoord) 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
|
|
}
|
|
|
|
// MockQueryCoord_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init'
|
|
type MockQueryCoord_Init_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Init is a helper method to define mock.On call
|
|
func (_e *MockQueryCoord_Expecter) Init() *MockQueryCoord_Init_Call {
|
|
return &MockQueryCoord_Init_Call{Call: _e.mock.On("Init")}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Init_Call) Run(run func()) *MockQueryCoord_Init_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Init_Call) Return(_a0 error) *MockQueryCoord_Init_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Init_Call) RunAndReturn(run func() error) *MockQueryCoord_Init_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListCheckers provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ListCheckers(_a0 context.Context, _a1 *querypb.ListCheckersRequest) (*querypb.ListCheckersResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListCheckers")
|
|
}
|
|
|
|
var r0 *querypb.ListCheckersResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListCheckersRequest) (*querypb.ListCheckersResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListCheckersRequest) *querypb.ListCheckersResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.ListCheckersResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.ListCheckersRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ListCheckers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCheckers'
|
|
type MockQueryCoord_ListCheckers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListCheckers is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ListCheckersRequest
|
|
func (_e *MockQueryCoord_Expecter) ListCheckers(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ListCheckers_Call {
|
|
return &MockQueryCoord_ListCheckers_Call{Call: _e.mock.On("ListCheckers", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListCheckers_Call) Run(run func(_a0 context.Context, _a1 *querypb.ListCheckersRequest)) *MockQueryCoord_ListCheckers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ListCheckersRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListCheckers_Call) Return(_a0 *querypb.ListCheckersResponse, _a1 error) *MockQueryCoord_ListCheckers_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListCheckers_Call) RunAndReturn(run func(context.Context, *querypb.ListCheckersRequest) (*querypb.ListCheckersResponse, error)) *MockQueryCoord_ListCheckers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListLoadedSegments provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ListLoadedSegments(_a0 context.Context, _a1 *querypb.ListLoadedSegmentsRequest) (*querypb.ListLoadedSegmentsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListLoadedSegments")
|
|
}
|
|
|
|
var r0 *querypb.ListLoadedSegmentsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListLoadedSegmentsRequest) (*querypb.ListLoadedSegmentsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListLoadedSegmentsRequest) *querypb.ListLoadedSegmentsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.ListLoadedSegmentsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.ListLoadedSegmentsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ListLoadedSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLoadedSegments'
|
|
type MockQueryCoord_ListLoadedSegments_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListLoadedSegments is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ListLoadedSegmentsRequest
|
|
func (_e *MockQueryCoord_Expecter) ListLoadedSegments(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ListLoadedSegments_Call {
|
|
return &MockQueryCoord_ListLoadedSegments_Call{Call: _e.mock.On("ListLoadedSegments", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListLoadedSegments_Call) Run(run func(_a0 context.Context, _a1 *querypb.ListLoadedSegmentsRequest)) *MockQueryCoord_ListLoadedSegments_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ListLoadedSegmentsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListLoadedSegments_Call) Return(_a0 *querypb.ListLoadedSegmentsResponse, _a1 error) *MockQueryCoord_ListLoadedSegments_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListLoadedSegments_Call) RunAndReturn(run func(context.Context, *querypb.ListLoadedSegmentsRequest) (*querypb.ListLoadedSegmentsResponse, error)) *MockQueryCoord_ListLoadedSegments_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListQueryNode provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ListQueryNode(_a0 context.Context, _a1 *querypb.ListQueryNodeRequest) (*querypb.ListQueryNodeResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListQueryNode")
|
|
}
|
|
|
|
var r0 *querypb.ListQueryNodeResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListQueryNodeRequest) (*querypb.ListQueryNodeResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ListQueryNodeRequest) *querypb.ListQueryNodeResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.ListQueryNodeResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.ListQueryNodeRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ListQueryNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListQueryNode'
|
|
type MockQueryCoord_ListQueryNode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListQueryNode is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ListQueryNodeRequest
|
|
func (_e *MockQueryCoord_Expecter) ListQueryNode(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ListQueryNode_Call {
|
|
return &MockQueryCoord_ListQueryNode_Call{Call: _e.mock.On("ListQueryNode", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListQueryNode_Call) Run(run func(_a0 context.Context, _a1 *querypb.ListQueryNodeRequest)) *MockQueryCoord_ListQueryNode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ListQueryNodeRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListQueryNode_Call) Return(_a0 *querypb.ListQueryNodeResponse, _a1 error) *MockQueryCoord_ListQueryNode_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListQueryNode_Call) RunAndReturn(run func(context.Context, *querypb.ListQueryNodeRequest) (*querypb.ListQueryNodeResponse, error)) *MockQueryCoord_ListQueryNode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListResourceGroups provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ListResourceGroups(_a0 context.Context, _a1 *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListResourceGroups")
|
|
}
|
|
|
|
var r0 *milvuspb.ListResourceGroupsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListResourceGroupsRequest) *milvuspb.ListResourceGroupsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ListResourceGroupsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListResourceGroupsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ListResourceGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListResourceGroups'
|
|
type MockQueryCoord_ListResourceGroups_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListResourceGroups is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.ListResourceGroupsRequest
|
|
func (_e *MockQueryCoord_Expecter) ListResourceGroups(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ListResourceGroups_Call {
|
|
return &MockQueryCoord_ListResourceGroups_Call{Call: _e.mock.On("ListResourceGroups", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListResourceGroups_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListResourceGroupsRequest)) *MockQueryCoord_ListResourceGroups_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ListResourceGroupsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListResourceGroups_Call) Return(_a0 *milvuspb.ListResourceGroupsResponse, _a1 error) *MockQueryCoord_ListResourceGroups_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ListResourceGroups_Call) RunAndReturn(run func(context.Context, *milvuspb.ListResourceGroupsRequest) (*milvuspb.ListResourceGroupsResponse, error)) *MockQueryCoord_ListResourceGroups_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// LoadBalance provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) LoadBalance(_a0 context.Context, _a1 *querypb.LoadBalanceRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LoadBalance")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadBalanceRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadBalanceRequest) *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, *querypb.LoadBalanceRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_LoadBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadBalance'
|
|
type MockQueryCoord_LoadBalance_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// LoadBalance is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.LoadBalanceRequest
|
|
func (_e *MockQueryCoord_Expecter) LoadBalance(_a0 interface{}, _a1 interface{}) *MockQueryCoord_LoadBalance_Call {
|
|
return &MockQueryCoord_LoadBalance_Call{Call: _e.mock.On("LoadBalance", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadBalance_Call) Run(run func(_a0 context.Context, _a1 *querypb.LoadBalanceRequest)) *MockQueryCoord_LoadBalance_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.LoadBalanceRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadBalance_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_LoadBalance_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadBalance_Call) RunAndReturn(run func(context.Context, *querypb.LoadBalanceRequest) (*commonpb.Status, error)) *MockQueryCoord_LoadBalance_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// LoadCollection provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) LoadCollection(_a0 context.Context, _a1 *querypb.LoadCollectionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LoadCollection")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadCollectionRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadCollectionRequest) *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, *querypb.LoadCollectionRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_LoadCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadCollection'
|
|
type MockQueryCoord_LoadCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// LoadCollection is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.LoadCollectionRequest
|
|
func (_e *MockQueryCoord_Expecter) LoadCollection(_a0 interface{}, _a1 interface{}) *MockQueryCoord_LoadCollection_Call {
|
|
return &MockQueryCoord_LoadCollection_Call{Call: _e.mock.On("LoadCollection", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadCollection_Call) Run(run func(_a0 context.Context, _a1 *querypb.LoadCollectionRequest)) *MockQueryCoord_LoadCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.LoadCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_LoadCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadCollection_Call) RunAndReturn(run func(context.Context, *querypb.LoadCollectionRequest) (*commonpb.Status, error)) *MockQueryCoord_LoadCollection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// LoadPartitions provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) LoadPartitions(_a0 context.Context, _a1 *querypb.LoadPartitionsRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LoadPartitions")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) *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, *querypb.LoadPartitionsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_LoadPartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadPartitions'
|
|
type MockQueryCoord_LoadPartitions_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// LoadPartitions is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.LoadPartitionsRequest
|
|
func (_e *MockQueryCoord_Expecter) LoadPartitions(_a0 interface{}, _a1 interface{}) *MockQueryCoord_LoadPartitions_Call {
|
|
return &MockQueryCoord_LoadPartitions_Call{Call: _e.mock.On("LoadPartitions", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadPartitions_Call) Run(run func(_a0 context.Context, _a1 *querypb.LoadPartitionsRequest)) *MockQueryCoord_LoadPartitions_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.LoadPartitionsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadPartitions_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_LoadPartitions_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_LoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)) *MockQueryCoord_LoadPartitions_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Register provides a mock function with no fields
|
|
func (_m *MockQueryCoord) 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
|
|
}
|
|
|
|
// MockQueryCoord_Register_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Register'
|
|
type MockQueryCoord_Register_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Register is a helper method to define mock.On call
|
|
func (_e *MockQueryCoord_Expecter) Register() *MockQueryCoord_Register_Call {
|
|
return &MockQueryCoord_Register_Call{Call: _e.mock.On("Register")}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Register_Call) Run(run func()) *MockQueryCoord_Register_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Register_Call) Return(_a0 error) *MockQueryCoord_Register_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Register_Call) RunAndReturn(run func() error) *MockQueryCoord_Register_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ReleaseCollection provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ReleaseCollection(_a0 context.Context, _a1 *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ReleaseCollection")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) *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, *querypb.ReleaseCollectionRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ReleaseCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseCollection'
|
|
type MockQueryCoord_ReleaseCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ReleaseCollection is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ReleaseCollectionRequest
|
|
func (_e *MockQueryCoord_Expecter) ReleaseCollection(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ReleaseCollection_Call {
|
|
return &MockQueryCoord_ReleaseCollection_Call{Call: _e.mock.On("ReleaseCollection", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ReleaseCollection_Call) Run(run func(_a0 context.Context, _a1 *querypb.ReleaseCollectionRequest)) *MockQueryCoord_ReleaseCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ReleaseCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ReleaseCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_ReleaseCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ReleaseCollection_Call) RunAndReturn(run func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)) *MockQueryCoord_ReleaseCollection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ReleasePartitions provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ReleasePartitions(_a0 context.Context, _a1 *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ReleasePartitions")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) *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, *querypb.ReleasePartitionsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ReleasePartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleasePartitions'
|
|
type MockQueryCoord_ReleasePartitions_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ReleasePartitions is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ReleasePartitionsRequest
|
|
func (_e *MockQueryCoord_Expecter) ReleasePartitions(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ReleasePartitions_Call {
|
|
return &MockQueryCoord_ReleasePartitions_Call{Call: _e.mock.On("ReleasePartitions", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ReleasePartitions_Call) Run(run func(_a0 context.Context, _a1 *querypb.ReleasePartitionsRequest)) *MockQueryCoord_ReleasePartitions_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ReleasePartitionsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ReleasePartitions_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_ReleasePartitions_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ReleasePartitions_Call) RunAndReturn(run func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)) *MockQueryCoord_ReleasePartitions_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ResumeBalance provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ResumeBalance(_a0 context.Context, _a1 *querypb.ResumeBalanceRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ResumeBalance")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeBalanceRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeBalanceRequest) *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, *querypb.ResumeBalanceRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ResumeBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumeBalance'
|
|
type MockQueryCoord_ResumeBalance_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ResumeBalance is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ResumeBalanceRequest
|
|
func (_e *MockQueryCoord_Expecter) ResumeBalance(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ResumeBalance_Call {
|
|
return &MockQueryCoord_ResumeBalance_Call{Call: _e.mock.On("ResumeBalance", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ResumeBalance_Call) Run(run func(_a0 context.Context, _a1 *querypb.ResumeBalanceRequest)) *MockQueryCoord_ResumeBalance_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ResumeBalanceRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ResumeBalance_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_ResumeBalance_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ResumeBalance_Call) RunAndReturn(run func(context.Context, *querypb.ResumeBalanceRequest) (*commonpb.Status, error)) *MockQueryCoord_ResumeBalance_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ResumeNode provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ResumeNode(_a0 context.Context, _a1 *querypb.ResumeNodeRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ResumeNode")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeNodeRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ResumeNodeRequest) *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, *querypb.ResumeNodeRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ResumeNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumeNode'
|
|
type MockQueryCoord_ResumeNode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ResumeNode is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ResumeNodeRequest
|
|
func (_e *MockQueryCoord_Expecter) ResumeNode(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ResumeNode_Call {
|
|
return &MockQueryCoord_ResumeNode_Call{Call: _e.mock.On("ResumeNode", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ResumeNode_Call) Run(run func(_a0 context.Context, _a1 *querypb.ResumeNodeRequest)) *MockQueryCoord_ResumeNode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ResumeNodeRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ResumeNode_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_ResumeNode_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ResumeNode_Call) RunAndReturn(run func(context.Context, *querypb.ResumeNodeRequest) (*commonpb.Status, error)) *MockQueryCoord_ResumeNode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RunAnalyzer provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) RunAnalyzer(_a0 context.Context, _a1 *querypb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RunAnalyzer")
|
|
}
|
|
|
|
var r0 *milvuspb.RunAnalyzerResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.RunAnalyzerRequest) *milvuspb.RunAnalyzerResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.RunAnalyzerResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.RunAnalyzerRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_RunAnalyzer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunAnalyzer'
|
|
type MockQueryCoord_RunAnalyzer_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RunAnalyzer is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.RunAnalyzerRequest
|
|
func (_e *MockQueryCoord_Expecter) RunAnalyzer(_a0 interface{}, _a1 interface{}) *MockQueryCoord_RunAnalyzer_Call {
|
|
return &MockQueryCoord_RunAnalyzer_Call{Call: _e.mock.On("RunAnalyzer", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_RunAnalyzer_Call) Run(run func(_a0 context.Context, _a1 *querypb.RunAnalyzerRequest)) *MockQueryCoord_RunAnalyzer_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.RunAnalyzerRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_RunAnalyzer_Call) Return(_a0 *milvuspb.RunAnalyzerResponse, _a1 error) *MockQueryCoord_RunAnalyzer_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_RunAnalyzer_Call) RunAndReturn(run func(context.Context, *querypb.RunAnalyzerRequest) (*milvuspb.RunAnalyzerResponse, error)) *MockQueryCoord_RunAnalyzer_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetAddress provides a mock function with given fields: address
|
|
func (_m *MockQueryCoord) SetAddress(address string) {
|
|
_m.Called(address)
|
|
}
|
|
|
|
// MockQueryCoord_SetAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAddress'
|
|
type MockQueryCoord_SetAddress_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetAddress is a helper method to define mock.On call
|
|
// - address string
|
|
func (_e *MockQueryCoord_Expecter) SetAddress(address interface{}) *MockQueryCoord_SetAddress_Call {
|
|
return &MockQueryCoord_SetAddress_Call{Call: _e.mock.On("SetAddress", address)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetAddress_Call) Run(run func(address string)) *MockQueryCoord_SetAddress_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetAddress_Call) Return() *MockQueryCoord_SetAddress_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetAddress_Call) RunAndReturn(run func(string)) *MockQueryCoord_SetAddress_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetEtcdClient provides a mock function with given fields: etcdClient
|
|
func (_m *MockQueryCoord) SetEtcdClient(etcdClient *clientv3.Client) {
|
|
_m.Called(etcdClient)
|
|
}
|
|
|
|
// MockQueryCoord_SetEtcdClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEtcdClient'
|
|
type MockQueryCoord_SetEtcdClient_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetEtcdClient is a helper method to define mock.On call
|
|
// - etcdClient *clientv3.Client
|
|
func (_e *MockQueryCoord_Expecter) SetEtcdClient(etcdClient interface{}) *MockQueryCoord_SetEtcdClient_Call {
|
|
return &MockQueryCoord_SetEtcdClient_Call{Call: _e.mock.On("SetEtcdClient", etcdClient)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetEtcdClient_Call) Run(run func(etcdClient *clientv3.Client)) *MockQueryCoord_SetEtcdClient_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*clientv3.Client))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetEtcdClient_Call) Return() *MockQueryCoord_SetEtcdClient_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetEtcdClient_Call) RunAndReturn(run func(*clientv3.Client)) *MockQueryCoord_SetEtcdClient_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetMixCoord provides a mock function with given fields: mixCoord
|
|
func (_m *MockQueryCoord) SetMixCoord(mixCoord types.MixCoord) {
|
|
_m.Called(mixCoord)
|
|
}
|
|
|
|
// MockQueryCoord_SetMixCoord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMixCoord'
|
|
type MockQueryCoord_SetMixCoord_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetMixCoord is a helper method to define mock.On call
|
|
// - mixCoord types.MixCoord
|
|
func (_e *MockQueryCoord_Expecter) SetMixCoord(mixCoord interface{}) *MockQueryCoord_SetMixCoord_Call {
|
|
return &MockQueryCoord_SetMixCoord_Call{Call: _e.mock.On("SetMixCoord", mixCoord)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetMixCoord_Call) Run(run func(mixCoord types.MixCoord)) *MockQueryCoord_SetMixCoord_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(types.MixCoord))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetMixCoord_Call) Return() *MockQueryCoord_SetMixCoord_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetMixCoord_Call) RunAndReturn(run func(types.MixCoord)) *MockQueryCoord_SetMixCoord_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetQueryNodeCreator provides a mock function with given fields: _a0
|
|
func (_m *MockQueryCoord) SetQueryNodeCreator(_a0 func(context.Context, string, int64) (types.QueryNodeClient, error)) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// MockQueryCoord_SetQueryNodeCreator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetQueryNodeCreator'
|
|
type MockQueryCoord_SetQueryNodeCreator_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetQueryNodeCreator is a helper method to define mock.On call
|
|
// - _a0 func(context.Context , string , int64)(types.QueryNodeClient , error)
|
|
func (_e *MockQueryCoord_Expecter) SetQueryNodeCreator(_a0 interface{}) *MockQueryCoord_SetQueryNodeCreator_Call {
|
|
return &MockQueryCoord_SetQueryNodeCreator_Call{Call: _e.mock.On("SetQueryNodeCreator", _a0)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetQueryNodeCreator_Call) Run(run func(_a0 func(context.Context, string, int64) (types.QueryNodeClient, error))) *MockQueryCoord_SetQueryNodeCreator_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(func(context.Context, string, int64) (types.QueryNodeClient, error)))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetQueryNodeCreator_Call) Return() *MockQueryCoord_SetQueryNodeCreator_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetQueryNodeCreator_Call) RunAndReturn(run func(func(context.Context, string, int64) (types.QueryNodeClient, error))) *MockQueryCoord_SetQueryNodeCreator_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetTiKVClient provides a mock function with given fields: client
|
|
func (_m *MockQueryCoord) SetTiKVClient(client *txnkv.Client) {
|
|
_m.Called(client)
|
|
}
|
|
|
|
// MockQueryCoord_SetTiKVClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTiKVClient'
|
|
type MockQueryCoord_SetTiKVClient_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetTiKVClient is a helper method to define mock.On call
|
|
// - client *txnkv.Client
|
|
func (_e *MockQueryCoord_Expecter) SetTiKVClient(client interface{}) *MockQueryCoord_SetTiKVClient_Call {
|
|
return &MockQueryCoord_SetTiKVClient_Call{Call: _e.mock.On("SetTiKVClient", client)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetTiKVClient_Call) Run(run func(client *txnkv.Client)) *MockQueryCoord_SetTiKVClient_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*txnkv.Client))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetTiKVClient_Call) Return() *MockQueryCoord_SetTiKVClient_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SetTiKVClient_Call) RunAndReturn(run func(*txnkv.Client)) *MockQueryCoord_SetTiKVClient_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// ShowConfigurations provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) 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
|
|
}
|
|
|
|
// MockQueryCoord_ShowConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowConfigurations'
|
|
type MockQueryCoord_ShowConfigurations_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowConfigurations is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *internalpb.ShowConfigurationsRequest
|
|
func (_e *MockQueryCoord_Expecter) ShowConfigurations(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ShowConfigurations_Call {
|
|
return &MockQueryCoord_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowConfigurations_Call) Run(run func(_a0 context.Context, _a1 *internalpb.ShowConfigurationsRequest)) *MockQueryCoord_ShowConfigurations_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.ShowConfigurationsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowConfigurations_Call) Return(_a0 *internalpb.ShowConfigurationsResponse, _a1 error) *MockQueryCoord_ShowConfigurations_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowConfigurations_Call) RunAndReturn(run func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)) *MockQueryCoord_ShowConfigurations_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ShowLoadCollections provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ShowLoadCollections(_a0 context.Context, _a1 *querypb.ShowCollectionsRequest) (*querypb.ShowCollectionsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ShowLoadCollections")
|
|
}
|
|
|
|
var r0 *querypb.ShowCollectionsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ShowCollectionsRequest) (*querypb.ShowCollectionsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ShowCollectionsRequest) *querypb.ShowCollectionsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.ShowCollectionsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.ShowCollectionsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ShowLoadCollections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowLoadCollections'
|
|
type MockQueryCoord_ShowLoadCollections_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowLoadCollections is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ShowCollectionsRequest
|
|
func (_e *MockQueryCoord_Expecter) ShowLoadCollections(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ShowLoadCollections_Call {
|
|
return &MockQueryCoord_ShowLoadCollections_Call{Call: _e.mock.On("ShowLoadCollections", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowLoadCollections_Call) Run(run func(_a0 context.Context, _a1 *querypb.ShowCollectionsRequest)) *MockQueryCoord_ShowLoadCollections_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ShowCollectionsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowLoadCollections_Call) Return(_a0 *querypb.ShowCollectionsResponse, _a1 error) *MockQueryCoord_ShowLoadCollections_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowLoadCollections_Call) RunAndReturn(run func(context.Context, *querypb.ShowCollectionsRequest) (*querypb.ShowCollectionsResponse, error)) *MockQueryCoord_ShowLoadCollections_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ShowLoadPartitions provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ShowLoadPartitions(_a0 context.Context, _a1 *querypb.ShowPartitionsRequest) (*querypb.ShowPartitionsResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ShowLoadPartitions")
|
|
}
|
|
|
|
var r0 *querypb.ShowPartitionsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ShowPartitionsRequest) (*querypb.ShowPartitionsResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ShowPartitionsRequest) *querypb.ShowPartitionsResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.ShowPartitionsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.ShowPartitionsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ShowLoadPartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowLoadPartitions'
|
|
type MockQueryCoord_ShowLoadPartitions_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowLoadPartitions is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ShowPartitionsRequest
|
|
func (_e *MockQueryCoord_Expecter) ShowLoadPartitions(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ShowLoadPartitions_Call {
|
|
return &MockQueryCoord_ShowLoadPartitions_Call{Call: _e.mock.On("ShowLoadPartitions", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowLoadPartitions_Call) Run(run func(_a0 context.Context, _a1 *querypb.ShowPartitionsRequest)) *MockQueryCoord_ShowLoadPartitions_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ShowPartitionsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowLoadPartitions_Call) Return(_a0 *querypb.ShowPartitionsResponse, _a1 error) *MockQueryCoord_ShowLoadPartitions_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ShowLoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.ShowPartitionsRequest) (*querypb.ShowPartitionsResponse, error)) *MockQueryCoord_ShowLoadPartitions_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Start provides a mock function with no fields
|
|
func (_m *MockQueryCoord) 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
|
|
}
|
|
|
|
// MockQueryCoord_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
|
type MockQueryCoord_Start_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Start is a helper method to define mock.On call
|
|
func (_e *MockQueryCoord_Expecter) Start() *MockQueryCoord_Start_Call {
|
|
return &MockQueryCoord_Start_Call{Call: _e.mock.On("Start")}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Start_Call) Run(run func()) *MockQueryCoord_Start_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Start_Call) Return(_a0 error) *MockQueryCoord_Start_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Start_Call) RunAndReturn(run func() error) *MockQueryCoord_Start_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Stop provides a mock function with no fields
|
|
func (_m *MockQueryCoord) 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
|
|
}
|
|
|
|
// MockQueryCoord_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
|
|
type MockQueryCoord_Stop_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Stop is a helper method to define mock.On call
|
|
func (_e *MockQueryCoord_Expecter) Stop() *MockQueryCoord_Stop_Call {
|
|
return &MockQueryCoord_Stop_Call{Call: _e.mock.On("Stop")}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Stop_Call) Run(run func()) *MockQueryCoord_Stop_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Stop_Call) Return(_a0 error) *MockQueryCoord_Stop_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_Stop_Call) RunAndReturn(run func() error) *MockQueryCoord_Stop_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SuspendBalance provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) SuspendBalance(_a0 context.Context, _a1 *querypb.SuspendBalanceRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SuspendBalance")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendBalanceRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendBalanceRequest) *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, *querypb.SuspendBalanceRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_SuspendBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuspendBalance'
|
|
type MockQueryCoord_SuspendBalance_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SuspendBalance is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.SuspendBalanceRequest
|
|
func (_e *MockQueryCoord_Expecter) SuspendBalance(_a0 interface{}, _a1 interface{}) *MockQueryCoord_SuspendBalance_Call {
|
|
return &MockQueryCoord_SuspendBalance_Call{Call: _e.mock.On("SuspendBalance", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SuspendBalance_Call) Run(run func(_a0 context.Context, _a1 *querypb.SuspendBalanceRequest)) *MockQueryCoord_SuspendBalance_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.SuspendBalanceRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SuspendBalance_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_SuspendBalance_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SuspendBalance_Call) RunAndReturn(run func(context.Context, *querypb.SuspendBalanceRequest) (*commonpb.Status, error)) *MockQueryCoord_SuspendBalance_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SuspendNode provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) SuspendNode(_a0 context.Context, _a1 *querypb.SuspendNodeRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SuspendNode")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendNodeRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.SuspendNodeRequest) *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, *querypb.SuspendNodeRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_SuspendNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuspendNode'
|
|
type MockQueryCoord_SuspendNode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SuspendNode is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.SuspendNodeRequest
|
|
func (_e *MockQueryCoord_Expecter) SuspendNode(_a0 interface{}, _a1 interface{}) *MockQueryCoord_SuspendNode_Call {
|
|
return &MockQueryCoord_SuspendNode_Call{Call: _e.mock.On("SuspendNode", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SuspendNode_Call) Run(run func(_a0 context.Context, _a1 *querypb.SuspendNodeRequest)) *MockQueryCoord_SuspendNode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.SuspendNodeRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SuspendNode_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_SuspendNode_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SuspendNode_Call) RunAndReturn(run func(context.Context, *querypb.SuspendNodeRequest) (*commonpb.Status, error)) *MockQueryCoord_SuspendNode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SyncNewCreatedPartition provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) SyncNewCreatedPartition(_a0 context.Context, _a1 *querypb.SyncNewCreatedPartitionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SyncNewCreatedPartition")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncNewCreatedPartitionRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncNewCreatedPartitionRequest) *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, *querypb.SyncNewCreatedPartitionRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_SyncNewCreatedPartition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncNewCreatedPartition'
|
|
type MockQueryCoord_SyncNewCreatedPartition_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SyncNewCreatedPartition is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.SyncNewCreatedPartitionRequest
|
|
func (_e *MockQueryCoord_Expecter) SyncNewCreatedPartition(_a0 interface{}, _a1 interface{}) *MockQueryCoord_SyncNewCreatedPartition_Call {
|
|
return &MockQueryCoord_SyncNewCreatedPartition_Call{Call: _e.mock.On("SyncNewCreatedPartition", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SyncNewCreatedPartition_Call) Run(run func(_a0 context.Context, _a1 *querypb.SyncNewCreatedPartitionRequest)) *MockQueryCoord_SyncNewCreatedPartition_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.SyncNewCreatedPartitionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SyncNewCreatedPartition_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_SyncNewCreatedPartition_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_SyncNewCreatedPartition_Call) RunAndReturn(run func(context.Context, *querypb.SyncNewCreatedPartitionRequest) (*commonpb.Status, error)) *MockQueryCoord_SyncNewCreatedPartition_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TransferChannel provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) TransferChannel(_a0 context.Context, _a1 *querypb.TransferChannelRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TransferChannel")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferChannelRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferChannelRequest) *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, *querypb.TransferChannelRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_TransferChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransferChannel'
|
|
type MockQueryCoord_TransferChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TransferChannel is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.TransferChannelRequest
|
|
func (_e *MockQueryCoord_Expecter) TransferChannel(_a0 interface{}, _a1 interface{}) *MockQueryCoord_TransferChannel_Call {
|
|
return &MockQueryCoord_TransferChannel_Call{Call: _e.mock.On("TransferChannel", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferChannel_Call) Run(run func(_a0 context.Context, _a1 *querypb.TransferChannelRequest)) *MockQueryCoord_TransferChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.TransferChannelRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferChannel_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_TransferChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferChannel_Call) RunAndReturn(run func(context.Context, *querypb.TransferChannelRequest) (*commonpb.Status, error)) *MockQueryCoord_TransferChannel_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TransferNode provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) TransferNode(_a0 context.Context, _a1 *milvuspb.TransferNodeRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TransferNode")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.TransferNodeRequest) *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.TransferNodeRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_TransferNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransferNode'
|
|
type MockQueryCoord_TransferNode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TransferNode is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *milvuspb.TransferNodeRequest
|
|
func (_e *MockQueryCoord_Expecter) TransferNode(_a0 interface{}, _a1 interface{}) *MockQueryCoord_TransferNode_Call {
|
|
return &MockQueryCoord_TransferNode_Call{Call: _e.mock.On("TransferNode", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferNode_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.TransferNodeRequest)) *MockQueryCoord_TransferNode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.TransferNodeRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferNode_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_TransferNode_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferNode_Call) RunAndReturn(run func(context.Context, *milvuspb.TransferNodeRequest) (*commonpb.Status, error)) *MockQueryCoord_TransferNode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TransferReplica provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) TransferReplica(_a0 context.Context, _a1 *querypb.TransferReplicaRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TransferReplica")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferReplicaRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferReplicaRequest) *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, *querypb.TransferReplicaRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_TransferReplica_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransferReplica'
|
|
type MockQueryCoord_TransferReplica_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TransferReplica is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.TransferReplicaRequest
|
|
func (_e *MockQueryCoord_Expecter) TransferReplica(_a0 interface{}, _a1 interface{}) *MockQueryCoord_TransferReplica_Call {
|
|
return &MockQueryCoord_TransferReplica_Call{Call: _e.mock.On("TransferReplica", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferReplica_Call) Run(run func(_a0 context.Context, _a1 *querypb.TransferReplicaRequest)) *MockQueryCoord_TransferReplica_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.TransferReplicaRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferReplica_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_TransferReplica_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferReplica_Call) RunAndReturn(run func(context.Context, *querypb.TransferReplicaRequest) (*commonpb.Status, error)) *MockQueryCoord_TransferReplica_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TransferSegment provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) TransferSegment(_a0 context.Context, _a1 *querypb.TransferSegmentRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TransferSegment")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferSegmentRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.TransferSegmentRequest) *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, *querypb.TransferSegmentRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_TransferSegment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransferSegment'
|
|
type MockQueryCoord_TransferSegment_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TransferSegment is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.TransferSegmentRequest
|
|
func (_e *MockQueryCoord_Expecter) TransferSegment(_a0 interface{}, _a1 interface{}) *MockQueryCoord_TransferSegment_Call {
|
|
return &MockQueryCoord_TransferSegment_Call{Call: _e.mock.On("TransferSegment", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferSegment_Call) Run(run func(_a0 context.Context, _a1 *querypb.TransferSegmentRequest)) *MockQueryCoord_TransferSegment_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.TransferSegmentRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferSegment_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_TransferSegment_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_TransferSegment_Call) RunAndReturn(run func(context.Context, *querypb.TransferSegmentRequest) (*commonpb.Status, error)) *MockQueryCoord_TransferSegment_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateLoadConfig provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) UpdateLoadConfig(_a0 context.Context, _a1 *querypb.UpdateLoadConfigRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateLoadConfig")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateLoadConfigRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateLoadConfigRequest) *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, *querypb.UpdateLoadConfigRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_UpdateLoadConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLoadConfig'
|
|
type MockQueryCoord_UpdateLoadConfig_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateLoadConfig is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.UpdateLoadConfigRequest
|
|
func (_e *MockQueryCoord_Expecter) UpdateLoadConfig(_a0 interface{}, _a1 interface{}) *MockQueryCoord_UpdateLoadConfig_Call {
|
|
return &MockQueryCoord_UpdateLoadConfig_Call{Call: _e.mock.On("UpdateLoadConfig", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateLoadConfig_Call) Run(run func(_a0 context.Context, _a1 *querypb.UpdateLoadConfigRequest)) *MockQueryCoord_UpdateLoadConfig_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.UpdateLoadConfigRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateLoadConfig_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_UpdateLoadConfig_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateLoadConfig_Call) RunAndReturn(run func(context.Context, *querypb.UpdateLoadConfigRequest) (*commonpb.Status, error)) *MockQueryCoord_UpdateLoadConfig_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateResourceGroups provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) UpdateResourceGroups(_a0 context.Context, _a1 *querypb.UpdateResourceGroupsRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateResourceGroups")
|
|
}
|
|
|
|
var r0 *commonpb.Status
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateResourceGroupsRequest) (*commonpb.Status, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.UpdateResourceGroupsRequest) *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, *querypb.UpdateResourceGroupsRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_UpdateResourceGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateResourceGroups'
|
|
type MockQueryCoord_UpdateResourceGroups_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateResourceGroups is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.UpdateResourceGroupsRequest
|
|
func (_e *MockQueryCoord_Expecter) UpdateResourceGroups(_a0 interface{}, _a1 interface{}) *MockQueryCoord_UpdateResourceGroups_Call {
|
|
return &MockQueryCoord_UpdateResourceGroups_Call{Call: _e.mock.On("UpdateResourceGroups", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateResourceGroups_Call) Run(run func(_a0 context.Context, _a1 *querypb.UpdateResourceGroupsRequest)) *MockQueryCoord_UpdateResourceGroups_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.UpdateResourceGroupsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateResourceGroups_Call) Return(_a0 *commonpb.Status, _a1 error) *MockQueryCoord_UpdateResourceGroups_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateResourceGroups_Call) RunAndReturn(run func(context.Context, *querypb.UpdateResourceGroupsRequest) (*commonpb.Status, error)) *MockQueryCoord_UpdateResourceGroups_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateStateCode provides a mock function with given fields: stateCode
|
|
func (_m *MockQueryCoord) UpdateStateCode(stateCode commonpb.StateCode) {
|
|
_m.Called(stateCode)
|
|
}
|
|
|
|
// MockQueryCoord_UpdateStateCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStateCode'
|
|
type MockQueryCoord_UpdateStateCode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateStateCode is a helper method to define mock.On call
|
|
// - stateCode commonpb.StateCode
|
|
func (_e *MockQueryCoord_Expecter) UpdateStateCode(stateCode interface{}) *MockQueryCoord_UpdateStateCode_Call {
|
|
return &MockQueryCoord_UpdateStateCode_Call{Call: _e.mock.On("UpdateStateCode", stateCode)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateStateCode_Call) Run(run func(stateCode commonpb.StateCode)) *MockQueryCoord_UpdateStateCode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(commonpb.StateCode))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateStateCode_Call) Return() *MockQueryCoord_UpdateStateCode_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_UpdateStateCode_Call) RunAndReturn(run func(commonpb.StateCode)) *MockQueryCoord_UpdateStateCode_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// ValidateAnalyzer provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockQueryCoord) ValidateAnalyzer(_a0 context.Context, _a1 *querypb.ValidateAnalyzerRequest) (*querypb.ValidateAnalyzerResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ValidateAnalyzer")
|
|
}
|
|
|
|
var r0 *querypb.ValidateAnalyzerResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ValidateAnalyzerRequest) (*querypb.ValidateAnalyzerResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *querypb.ValidateAnalyzerRequest) *querypb.ValidateAnalyzerResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.ValidateAnalyzerResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *querypb.ValidateAnalyzerRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockQueryCoord_ValidateAnalyzer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateAnalyzer'
|
|
type MockQueryCoord_ValidateAnalyzer_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ValidateAnalyzer is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *querypb.ValidateAnalyzerRequest
|
|
func (_e *MockQueryCoord_Expecter) ValidateAnalyzer(_a0 interface{}, _a1 interface{}) *MockQueryCoord_ValidateAnalyzer_Call {
|
|
return &MockQueryCoord_ValidateAnalyzer_Call{Call: _e.mock.On("ValidateAnalyzer", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ValidateAnalyzer_Call) Run(run func(_a0 context.Context, _a1 *querypb.ValidateAnalyzerRequest)) *MockQueryCoord_ValidateAnalyzer_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*querypb.ValidateAnalyzerRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ValidateAnalyzer_Call) Return(_a0 *querypb.ValidateAnalyzerResponse, _a1 error) *MockQueryCoord_ValidateAnalyzer_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockQueryCoord_ValidateAnalyzer_Call) RunAndReturn(run func(context.Context, *querypb.ValidateAnalyzerRequest) (*querypb.ValidateAnalyzerResponse, error)) *MockQueryCoord_ValidateAnalyzer_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockQueryCoord creates a new instance of MockQueryCoord. 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 NewMockQueryCoord(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockQueryCoord {
|
|
mock := &MockQueryCoord{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|