mirror of
https://gitee.com/milvus-io/milvus.git
synced 2024-12-05 05:18:52 +08:00
2257 lines
74 KiB
Go
2257 lines
74 KiB
Go
// Code generated by mockery v2.14.0. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
commonpb "github.com/milvus-io/milvus-proto/go-api/commonpb"
|
|
|
|
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
|
|
|
|
milvuspb "github.com/milvus-io/milvus-proto/go-api/milvuspb"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
proxypb "github.com/milvus-io/milvus/internal/proto/proxypb"
|
|
|
|
rootcoordpb "github.com/milvus-io/milvus/internal/proto/rootcoordpb"
|
|
)
|
|
|
|
// RootCoord is an autogenerated mock type for the RootCoord type
|
|
type RootCoord struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type RootCoord_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *RootCoord) EXPECT() *RootCoord_Expecter {
|
|
return &RootCoord_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// AllocID provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) AllocID(ctx context.Context, req *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *rootcoordpb.AllocIDResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AllocIDRequest) *rootcoordpb.AllocIDResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*rootcoordpb.AllocIDResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.AllocIDRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_AllocID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllocID'
|
|
type RootCoord_AllocID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AllocID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *rootcoordpb.AllocIDRequest
|
|
func (_e *RootCoord_Expecter) AllocID(ctx interface{}, req interface{}) *RootCoord_AllocID_Call {
|
|
return &RootCoord_AllocID_Call{Call: _e.mock.On("AllocID", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_AllocID_Call) Run(run func(ctx context.Context, req *rootcoordpb.AllocIDRequest)) *RootCoord_AllocID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*rootcoordpb.AllocIDRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_AllocID_Call) Return(_a0 *rootcoordpb.AllocIDResponse, _a1 error) *RootCoord_AllocID_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// AllocTimestamp provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) AllocTimestamp(ctx context.Context, req *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *rootcoordpb.AllocTimestampResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AllocTimestampRequest) *rootcoordpb.AllocTimestampResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*rootcoordpb.AllocTimestampResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.AllocTimestampRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_AllocTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllocTimestamp'
|
|
type RootCoord_AllocTimestamp_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AllocTimestamp is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *rootcoordpb.AllocTimestampRequest
|
|
func (_e *RootCoord_Expecter) AllocTimestamp(ctx interface{}, req interface{}) *RootCoord_AllocTimestamp_Call {
|
|
return &RootCoord_AllocTimestamp_Call{Call: _e.mock.On("AllocTimestamp", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_AllocTimestamp_Call) Run(run func(ctx context.Context, req *rootcoordpb.AllocTimestampRequest)) *RootCoord_AllocTimestamp_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*rootcoordpb.AllocTimestampRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_AllocTimestamp_Call) Return(_a0 *rootcoordpb.AllocTimestampResponse, _a1 error) *RootCoord_AllocTimestamp_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// AlterAlias provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterAliasRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterAliasRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_AlterAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterAlias'
|
|
type RootCoord_AlterAlias_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AlterAlias is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.AlterAliasRequest
|
|
func (_e *RootCoord_Expecter) AlterAlias(ctx interface{}, req interface{}) *RootCoord_AlterAlias_Call {
|
|
return &RootCoord_AlterAlias_Call{Call: _e.mock.On("AlterAlias", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_AlterAlias_Call) Run(run func(ctx context.Context, req *milvuspb.AlterAliasRequest)) *RootCoord_AlterAlias_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.AlterAliasRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_AlterAlias_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_AlterAlias_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// AlterCollection provides a mock function with given fields: ctx, request
|
|
func (_m *RootCoord) AlterCollection(ctx context.Context, request *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, request)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, request)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionRequest) error); ok {
|
|
r1 = rf(ctx, request)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_AlterCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollection'
|
|
type RootCoord_AlterCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AlterCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - request *milvuspb.AlterCollectionRequest
|
|
func (_e *RootCoord_Expecter) AlterCollection(ctx interface{}, request interface{}) *RootCoord_AlterCollection_Call {
|
|
return &RootCoord_AlterCollection_Call{Call: _e.mock.On("AlterCollection", ctx, request)}
|
|
}
|
|
|
|
func (_c *RootCoord_AlterCollection_Call) Run(run func(ctx context.Context, request *milvuspb.AlterCollectionRequest)) *RootCoord_AlterCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_AlterCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_AlterCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// CheckHealth provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.CheckHealthResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) *milvuspb.CheckHealthResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.CheckHealthResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CheckHealthRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'
|
|
type RootCoord_CheckHealth_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CheckHealth is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.CheckHealthRequest
|
|
func (_e *RootCoord_Expecter) CheckHealth(ctx interface{}, req interface{}) *RootCoord_CheckHealth_Call {
|
|
return &RootCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_CheckHealth_Call) Run(run func(ctx context.Context, req *milvuspb.CheckHealthRequest)) *RootCoord_CheckHealth_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *RootCoord_CheckHealth_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// CreateAlias provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateAliasRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateAliasRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_CreateAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAlias'
|
|
type RootCoord_CreateAlias_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateAlias is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.CreateAliasRequest
|
|
func (_e *RootCoord_Expecter) CreateAlias(ctx interface{}, req interface{}) *RootCoord_CreateAlias_Call {
|
|
return &RootCoord_CreateAlias_Call{Call: _e.mock.On("CreateAlias", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_CreateAlias_Call) Run(run func(ctx context.Context, req *milvuspb.CreateAliasRequest)) *RootCoord_CreateAlias_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CreateAliasRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_CreateAlias_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_CreateAlias_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// CreateCollection provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) CreateCollection(ctx context.Context, req *milvuspb.CreateCollectionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateCollectionRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateCollectionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_CreateCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCollection'
|
|
type RootCoord_CreateCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.CreateCollectionRequest
|
|
func (_e *RootCoord_Expecter) CreateCollection(ctx interface{}, req interface{}) *RootCoord_CreateCollection_Call {
|
|
return &RootCoord_CreateCollection_Call{Call: _e.mock.On("CreateCollection", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_CreateCollection_Call) Run(run func(ctx context.Context, req *milvuspb.CreateCollectionRequest)) *RootCoord_CreateCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CreateCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_CreateCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_CreateCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// CreateCredential provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) CreateCredential(ctx context.Context, req *internalpb.CredentialInfo) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.CredentialInfo) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_CreateCredential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCredential'
|
|
type RootCoord_CreateCredential_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateCredential is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *internalpb.CredentialInfo
|
|
func (_e *RootCoord_Expecter) CreateCredential(ctx interface{}, req interface{}) *RootCoord_CreateCredential_Call {
|
|
return &RootCoord_CreateCredential_Call{Call: _e.mock.On("CreateCredential", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_CreateCredential_Call) Run(run func(ctx context.Context, req *internalpb.CredentialInfo)) *RootCoord_CreateCredential_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.CredentialInfo))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_CreateCredential_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_CreateCredential_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// CreatePartition provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) CreatePartition(ctx context.Context, req *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreatePartitionRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreatePartitionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_CreatePartition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePartition'
|
|
type RootCoord_CreatePartition_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreatePartition is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.CreatePartitionRequest
|
|
func (_e *RootCoord_Expecter) CreatePartition(ctx interface{}, req interface{}) *RootCoord_CreatePartition_Call {
|
|
return &RootCoord_CreatePartition_Call{Call: _e.mock.On("CreatePartition", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_CreatePartition_Call) Run(run func(ctx context.Context, req *milvuspb.CreatePartitionRequest)) *RootCoord_CreatePartition_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CreatePartitionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_CreatePartition_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_CreatePartition_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// CreateRole provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) CreateRole(ctx context.Context, req *milvuspb.CreateRoleRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateRoleRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateRoleRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_CreateRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRole'
|
|
type RootCoord_CreateRole_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateRole is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.CreateRoleRequest
|
|
func (_e *RootCoord_Expecter) CreateRole(ctx interface{}, req interface{}) *RootCoord_CreateRole_Call {
|
|
return &RootCoord_CreateRole_Call{Call: _e.mock.On("CreateRole", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_CreateRole_Call) Run(run func(ctx context.Context, req *milvuspb.CreateRoleRequest)) *RootCoord_CreateRole_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.CreateRoleRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_CreateRole_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_CreateRole_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// DeleteCredential provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) DeleteCredential(ctx context.Context, req *milvuspb.DeleteCredentialRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DeleteCredentialRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DeleteCredentialRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_DeleteCredential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCredential'
|
|
type RootCoord_DeleteCredential_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteCredential is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.DeleteCredentialRequest
|
|
func (_e *RootCoord_Expecter) DeleteCredential(ctx interface{}, req interface{}) *RootCoord_DeleteCredential_Call {
|
|
return &RootCoord_DeleteCredential_Call{Call: _e.mock.On("DeleteCredential", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_DeleteCredential_Call) Run(run func(ctx context.Context, req *milvuspb.DeleteCredentialRequest)) *RootCoord_DeleteCredential_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.DeleteCredentialRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_DeleteCredential_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_DeleteCredential_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// DescribeCollection provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) DescribeCollection(ctx context.Context, req *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.DescribeCollectionResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeCollectionRequest) *milvuspb.DescribeCollectionResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.DescribeCollectionResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DescribeCollectionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_DescribeCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCollection'
|
|
type RootCoord_DescribeCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DescribeCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.DescribeCollectionRequest
|
|
func (_e *RootCoord_Expecter) DescribeCollection(ctx interface{}, req interface{}) *RootCoord_DescribeCollection_Call {
|
|
return &RootCoord_DescribeCollection_Call{Call: _e.mock.On("DescribeCollection", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_DescribeCollection_Call) Run(run func(ctx context.Context, req *milvuspb.DescribeCollectionRequest)) *RootCoord_DescribeCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.DescribeCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_DescribeCollection_Call) Return(_a0 *milvuspb.DescribeCollectionResponse, _a1 error) *RootCoord_DescribeCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// DescribeCollectionInternal provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) DescribeCollectionInternal(ctx context.Context, req *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.DescribeCollectionResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeCollectionRequest) *milvuspb.DescribeCollectionResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.DescribeCollectionResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DescribeCollectionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_DescribeCollectionInternal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCollectionInternal'
|
|
type RootCoord_DescribeCollectionInternal_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DescribeCollectionInternal is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.DescribeCollectionRequest
|
|
func (_e *RootCoord_Expecter) DescribeCollectionInternal(ctx interface{}, req interface{}) *RootCoord_DescribeCollectionInternal_Call {
|
|
return &RootCoord_DescribeCollectionInternal_Call{Call: _e.mock.On("DescribeCollectionInternal", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_DescribeCollectionInternal_Call) Run(run func(ctx context.Context, req *milvuspb.DescribeCollectionRequest)) *RootCoord_DescribeCollectionInternal_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.DescribeCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_DescribeCollectionInternal_Call) Return(_a0 *milvuspb.DescribeCollectionResponse, _a1 error) *RootCoord_DescribeCollectionInternal_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// DropAlias provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) DropAlias(ctx context.Context, req *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropAliasRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropAliasRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_DropAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropAlias'
|
|
type RootCoord_DropAlias_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropAlias is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.DropAliasRequest
|
|
func (_e *RootCoord_Expecter) DropAlias(ctx interface{}, req interface{}) *RootCoord_DropAlias_Call {
|
|
return &RootCoord_DropAlias_Call{Call: _e.mock.On("DropAlias", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_DropAlias_Call) Run(run func(ctx context.Context, req *milvuspb.DropAliasRequest)) *RootCoord_DropAlias_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.DropAliasRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_DropAlias_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_DropAlias_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// DropCollection provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) DropCollection(ctx context.Context, req *milvuspb.DropCollectionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_DropCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollection'
|
|
type RootCoord_DropCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.DropCollectionRequest
|
|
func (_e *RootCoord_Expecter) DropCollection(ctx interface{}, req interface{}) *RootCoord_DropCollection_Call {
|
|
return &RootCoord_DropCollection_Call{Call: _e.mock.On("DropCollection", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_DropCollection_Call) Run(run func(ctx context.Context, req *milvuspb.DropCollectionRequest)) *RootCoord_DropCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.DropCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_DropCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_DropCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// DropPartition provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) DropPartition(ctx context.Context, req *milvuspb.DropPartitionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropPartitionRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropPartitionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_DropPartition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropPartition'
|
|
type RootCoord_DropPartition_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropPartition is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.DropPartitionRequest
|
|
func (_e *RootCoord_Expecter) DropPartition(ctx interface{}, req interface{}) *RootCoord_DropPartition_Call {
|
|
return &RootCoord_DropPartition_Call{Call: _e.mock.On("DropPartition", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_DropPartition_Call) Run(run func(ctx context.Context, req *milvuspb.DropPartitionRequest)) *RootCoord_DropPartition_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.DropPartitionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_DropPartition_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_DropPartition_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// DropRole provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) DropRole(ctx context.Context, req *milvuspb.DropRoleRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropRoleRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropRoleRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_DropRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropRole'
|
|
type RootCoord_DropRole_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropRole is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.DropRoleRequest
|
|
func (_e *RootCoord_Expecter) DropRole(ctx interface{}, req interface{}) *RootCoord_DropRole_Call {
|
|
return &RootCoord_DropRole_Call{Call: _e.mock.On("DropRole", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_DropRole_Call) Run(run func(ctx context.Context, req *milvuspb.DropRoleRequest)) *RootCoord_DropRole_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.DropRoleRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_DropRole_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_DropRole_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetComponentStates provides a mock function with given fields: ctx
|
|
func (_m *RootCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 *milvuspb.ComponentStates
|
|
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.ComponentStates); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ComponentStates)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_GetComponentStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComponentStates'
|
|
type RootCoord_GetComponentStates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetComponentStates is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *RootCoord_Expecter) GetComponentStates(ctx interface{}) *RootCoord_GetComponentStates_Call {
|
|
return &RootCoord_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", ctx)}
|
|
}
|
|
|
|
func (_c *RootCoord_GetComponentStates_Call) Run(run func(ctx context.Context)) *RootCoord_GetComponentStates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *RootCoord_GetComponentStates_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetCredential provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) GetCredential(ctx context.Context, req *rootcoordpb.GetCredentialRequest) (*rootcoordpb.GetCredentialResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *rootcoordpb.GetCredentialResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.GetCredentialRequest) *rootcoordpb.GetCredentialResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*rootcoordpb.GetCredentialResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.GetCredentialRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_GetCredential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCredential'
|
|
type RootCoord_GetCredential_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCredential is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *rootcoordpb.GetCredentialRequest
|
|
func (_e *RootCoord_Expecter) GetCredential(ctx interface{}, req interface{}) *RootCoord_GetCredential_Call {
|
|
return &RootCoord_GetCredential_Call{Call: _e.mock.On("GetCredential", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_GetCredential_Call) Run(run func(ctx context.Context, req *rootcoordpb.GetCredentialRequest)) *RootCoord_GetCredential_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*rootcoordpb.GetCredentialRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_GetCredential_Call) Return(_a0 *rootcoordpb.GetCredentialResponse, _a1 error) *RootCoord_GetCredential_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetImportState provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) GetImportState(ctx context.Context, req *milvuspb.GetImportStateRequest) (*milvuspb.GetImportStateResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.GetImportStateResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetImportStateRequest) *milvuspb.GetImportStateResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetImportStateResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetImportStateRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_GetImportState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImportState'
|
|
type RootCoord_GetImportState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetImportState is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.GetImportStateRequest
|
|
func (_e *RootCoord_Expecter) GetImportState(ctx interface{}, req interface{}) *RootCoord_GetImportState_Call {
|
|
return &RootCoord_GetImportState_Call{Call: _e.mock.On("GetImportState", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_GetImportState_Call) Run(run func(ctx context.Context, req *milvuspb.GetImportStateRequest)) *RootCoord_GetImportState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetImportStateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_GetImportState_Call) Return(_a0 *milvuspb.GetImportStateResponse, _a1 error) *RootCoord_GetImportState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetMetrics provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.GetMetricsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.GetMetricsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetMetricsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_GetMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetrics'
|
|
type RootCoord_GetMetrics_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetMetrics is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.GetMetricsRequest
|
|
func (_e *RootCoord_Expecter) GetMetrics(ctx interface{}, req interface{}) *RootCoord_GetMetrics_Call {
|
|
return &RootCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_GetMetrics_Call) Run(run func(ctx context.Context, req *milvuspb.GetMetricsRequest)) *RootCoord_GetMetrics_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.GetMetricsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_GetMetrics_Call) Return(_a0 *milvuspb.GetMetricsResponse, _a1 error) *RootCoord_GetMetrics_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetStatisticsChannel provides a mock function with given fields: ctx
|
|
func (_m *RootCoord) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 *milvuspb.StringResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.StringResponse); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.StringResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_GetStatisticsChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatisticsChannel'
|
|
type RootCoord_GetStatisticsChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetStatisticsChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *RootCoord_Expecter) GetStatisticsChannel(ctx interface{}) *RootCoord_GetStatisticsChannel_Call {
|
|
return &RootCoord_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", ctx)}
|
|
}
|
|
|
|
func (_c *RootCoord_GetStatisticsChannel_Call) Run(run func(ctx context.Context)) *RootCoord_GetStatisticsChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_GetStatisticsChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *RootCoord_GetStatisticsChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// GetTimeTickChannel provides a mock function with given fields: ctx
|
|
func (_m *RootCoord) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 *milvuspb.StringResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.StringResponse); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.StringResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_GetTimeTickChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTimeTickChannel'
|
|
type RootCoord_GetTimeTickChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTimeTickChannel is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *RootCoord_Expecter) GetTimeTickChannel(ctx interface{}) *RootCoord_GetTimeTickChannel_Call {
|
|
return &RootCoord_GetTimeTickChannel_Call{Call: _e.mock.On("GetTimeTickChannel", ctx)}
|
|
}
|
|
|
|
func (_c *RootCoord_GetTimeTickChannel_Call) Run(run func(ctx context.Context)) *RootCoord_GetTimeTickChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_GetTimeTickChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *RootCoord_GetTimeTickChannel_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// HasCollection provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) HasCollection(ctx context.Context, req *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.BoolResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.HasCollectionRequest) *milvuspb.BoolResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.BoolResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.HasCollectionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_HasCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCollection'
|
|
type RootCoord_HasCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// HasCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.HasCollectionRequest
|
|
func (_e *RootCoord_Expecter) HasCollection(ctx interface{}, req interface{}) *RootCoord_HasCollection_Call {
|
|
return &RootCoord_HasCollection_Call{Call: _e.mock.On("HasCollection", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_HasCollection_Call) Run(run func(ctx context.Context, req *milvuspb.HasCollectionRequest)) *RootCoord_HasCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.HasCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_HasCollection_Call) Return(_a0 *milvuspb.BoolResponse, _a1 error) *RootCoord_HasCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// HasPartition provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) HasPartition(ctx context.Context, req *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.BoolResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.HasPartitionRequest) *milvuspb.BoolResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.BoolResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.HasPartitionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_HasPartition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasPartition'
|
|
type RootCoord_HasPartition_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// HasPartition is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.HasPartitionRequest
|
|
func (_e *RootCoord_Expecter) HasPartition(ctx interface{}, req interface{}) *RootCoord_HasPartition_Call {
|
|
return &RootCoord_HasPartition_Call{Call: _e.mock.On("HasPartition", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_HasPartition_Call) Run(run func(ctx context.Context, req *milvuspb.HasPartitionRequest)) *RootCoord_HasPartition_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.HasPartitionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_HasPartition_Call) Return(_a0 *milvuspb.BoolResponse, _a1 error) *RootCoord_HasPartition_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Import provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) Import(ctx context.Context, req *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.ImportResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ImportRequest) *milvuspb.ImportResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ImportResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ImportRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_Import_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Import'
|
|
type RootCoord_Import_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Import is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.ImportRequest
|
|
func (_e *RootCoord_Expecter) Import(ctx interface{}, req interface{}) *RootCoord_Import_Call {
|
|
return &RootCoord_Import_Call{Call: _e.mock.On("Import", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_Import_Call) Run(run func(ctx context.Context, req *milvuspb.ImportRequest)) *RootCoord_Import_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ImportRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_Import_Call) Return(_a0 *milvuspb.ImportResponse, _a1 error) *RootCoord_Import_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Init provides a mock function with given fields:
|
|
func (_m *RootCoord) Init() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RootCoord_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init'
|
|
type RootCoord_Init_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Init is a helper method to define mock.On call
|
|
func (_e *RootCoord_Expecter) Init() *RootCoord_Init_Call {
|
|
return &RootCoord_Init_Call{Call: _e.mock.On("Init")}
|
|
}
|
|
|
|
func (_c *RootCoord_Init_Call) Run(run func()) *RootCoord_Init_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_Init_Call) Return(_a0 error) *RootCoord_Init_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// InvalidateCollectionMetaCache provides a mock function with given fields: ctx, request
|
|
func (_m *RootCoord) InvalidateCollectionMetaCache(ctx context.Context, request *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, request)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proxypb.InvalidateCollMetaCacheRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, request)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proxypb.InvalidateCollMetaCacheRequest) error); ok {
|
|
r1 = rf(ctx, request)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_InvalidateCollectionMetaCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvalidateCollectionMetaCache'
|
|
type RootCoord_InvalidateCollectionMetaCache_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// InvalidateCollectionMetaCache is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - request *proxypb.InvalidateCollMetaCacheRequest
|
|
func (_e *RootCoord_Expecter) InvalidateCollectionMetaCache(ctx interface{}, request interface{}) *RootCoord_InvalidateCollectionMetaCache_Call {
|
|
return &RootCoord_InvalidateCollectionMetaCache_Call{Call: _e.mock.On("InvalidateCollectionMetaCache", ctx, request)}
|
|
}
|
|
|
|
func (_c *RootCoord_InvalidateCollectionMetaCache_Call) Run(run func(ctx context.Context, request *proxypb.InvalidateCollMetaCacheRequest)) *RootCoord_InvalidateCollectionMetaCache_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proxypb.InvalidateCollMetaCacheRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_InvalidateCollectionMetaCache_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_InvalidateCollectionMetaCache_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ListCredUsers provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) ListCredUsers(ctx context.Context, req *milvuspb.ListCredUsersRequest) (*milvuspb.ListCredUsersResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.ListCredUsersResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListCredUsersRequest) *milvuspb.ListCredUsersResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ListCredUsersResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListCredUsersRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ListCredUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCredUsers'
|
|
type RootCoord_ListCredUsers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListCredUsers is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.ListCredUsersRequest
|
|
func (_e *RootCoord_Expecter) ListCredUsers(ctx interface{}, req interface{}) *RootCoord_ListCredUsers_Call {
|
|
return &RootCoord_ListCredUsers_Call{Call: _e.mock.On("ListCredUsers", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_ListCredUsers_Call) Run(run func(ctx context.Context, req *milvuspb.ListCredUsersRequest)) *RootCoord_ListCredUsers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ListCredUsersRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ListCredUsers_Call) Return(_a0 *milvuspb.ListCredUsersResponse, _a1 error) *RootCoord_ListCredUsers_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ListImportTasks provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) ListImportTasks(ctx context.Context, req *milvuspb.ListImportTasksRequest) (*milvuspb.ListImportTasksResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.ListImportTasksResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListImportTasksRequest) *milvuspb.ListImportTasksResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ListImportTasksResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListImportTasksRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ListImportTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListImportTasks'
|
|
type RootCoord_ListImportTasks_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListImportTasks is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.ListImportTasksRequest
|
|
func (_e *RootCoord_Expecter) ListImportTasks(ctx interface{}, req interface{}) *RootCoord_ListImportTasks_Call {
|
|
return &RootCoord_ListImportTasks_Call{Call: _e.mock.On("ListImportTasks", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_ListImportTasks_Call) Run(run func(ctx context.Context, req *milvuspb.ListImportTasksRequest)) *RootCoord_ListImportTasks_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ListImportTasksRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ListImportTasks_Call) Return(_a0 *milvuspb.ListImportTasksResponse, _a1 error) *RootCoord_ListImportTasks_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ListPolicy provides a mock function with given fields: ctx, in
|
|
func (_m *RootCoord) ListPolicy(ctx context.Context, in *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error) {
|
|
ret := _m.Called(ctx, in)
|
|
|
|
var r0 *internalpb.ListPolicyResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ListPolicyRequest) *internalpb.ListPolicyResponse); ok {
|
|
r0 = rf(ctx, in)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*internalpb.ListPolicyResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ListPolicyRequest) error); ok {
|
|
r1 = rf(ctx, in)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ListPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPolicy'
|
|
type RootCoord_ListPolicy_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListPolicy is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *internalpb.ListPolicyRequest
|
|
func (_e *RootCoord_Expecter) ListPolicy(ctx interface{}, in interface{}) *RootCoord_ListPolicy_Call {
|
|
return &RootCoord_ListPolicy_Call{Call: _e.mock.On("ListPolicy", ctx, in)}
|
|
}
|
|
|
|
func (_c *RootCoord_ListPolicy_Call) Run(run func(ctx context.Context, in *internalpb.ListPolicyRequest)) *RootCoord_ListPolicy_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.ListPolicyRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ListPolicy_Call) Return(_a0 *internalpb.ListPolicyResponse, _a1 error) *RootCoord_ListPolicy_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// OperatePrivilege provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) OperatePrivilege(ctx context.Context, req *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperatePrivilegeRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_OperatePrivilege_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperatePrivilege'
|
|
type RootCoord_OperatePrivilege_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// OperatePrivilege is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.OperatePrivilegeRequest
|
|
func (_e *RootCoord_Expecter) OperatePrivilege(ctx interface{}, req interface{}) *RootCoord_OperatePrivilege_Call {
|
|
return &RootCoord_OperatePrivilege_Call{Call: _e.mock.On("OperatePrivilege", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_OperatePrivilege_Call) Run(run func(ctx context.Context, req *milvuspb.OperatePrivilegeRequest)) *RootCoord_OperatePrivilege_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.OperatePrivilegeRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_OperatePrivilege_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_OperatePrivilege_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// OperateUserRole provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) OperateUserRole(ctx context.Context, req *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperateUserRoleRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.OperateUserRoleRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_OperateUserRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperateUserRole'
|
|
type RootCoord_OperateUserRole_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// OperateUserRole is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.OperateUserRoleRequest
|
|
func (_e *RootCoord_Expecter) OperateUserRole(ctx interface{}, req interface{}) *RootCoord_OperateUserRole_Call {
|
|
return &RootCoord_OperateUserRole_Call{Call: _e.mock.On("OperateUserRole", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_OperateUserRole_Call) Run(run func(ctx context.Context, req *milvuspb.OperateUserRoleRequest)) *RootCoord_OperateUserRole_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.OperateUserRoleRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_OperateUserRole_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_OperateUserRole_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Register provides a mock function with given fields:
|
|
func (_m *RootCoord) Register() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RootCoord_Register_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Register'
|
|
type RootCoord_Register_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Register is a helper method to define mock.On call
|
|
func (_e *RootCoord_Expecter) Register() *RootCoord_Register_Call {
|
|
return &RootCoord_Register_Call{Call: _e.mock.On("Register")}
|
|
}
|
|
|
|
func (_c *RootCoord_Register_Call) Run(run func()) *RootCoord_Register_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_Register_Call) Return(_a0 error) *RootCoord_Register_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// RenameCollection provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) RenameCollection(ctx context.Context, req *milvuspb.RenameCollectionRequest) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RenameCollectionRequest) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.RenameCollectionRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_RenameCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameCollection'
|
|
type RootCoord_RenameCollection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RenameCollection is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.RenameCollectionRequest
|
|
func (_e *RootCoord_Expecter) RenameCollection(ctx interface{}, req interface{}) *RootCoord_RenameCollection_Call {
|
|
return &RootCoord_RenameCollection_Call{Call: _e.mock.On("RenameCollection", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_RenameCollection_Call) Run(run func(ctx context.Context, req *milvuspb.RenameCollectionRequest)) *RootCoord_RenameCollection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.RenameCollectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_RenameCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_RenameCollection_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ReportImport provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) ReportImport(ctx context.Context, req *rootcoordpb.ImportResult) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.ImportResult) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.ImportResult) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ReportImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportImport'
|
|
type RootCoord_ReportImport_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ReportImport is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *rootcoordpb.ImportResult
|
|
func (_e *RootCoord_Expecter) ReportImport(ctx interface{}, req interface{}) *RootCoord_ReportImport_Call {
|
|
return &RootCoord_ReportImport_Call{Call: _e.mock.On("ReportImport", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_ReportImport_Call) Run(run func(ctx context.Context, req *rootcoordpb.ImportResult)) *RootCoord_ReportImport_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*rootcoordpb.ImportResult))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ReportImport_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_ReportImport_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// SelectGrant provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) SelectGrant(ctx context.Context, req *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.SelectGrantResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectGrantRequest) *milvuspb.SelectGrantResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.SelectGrantResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectGrantRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_SelectGrant_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectGrant'
|
|
type RootCoord_SelectGrant_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SelectGrant is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.SelectGrantRequest
|
|
func (_e *RootCoord_Expecter) SelectGrant(ctx interface{}, req interface{}) *RootCoord_SelectGrant_Call {
|
|
return &RootCoord_SelectGrant_Call{Call: _e.mock.On("SelectGrant", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_SelectGrant_Call) Run(run func(ctx context.Context, req *milvuspb.SelectGrantRequest)) *RootCoord_SelectGrant_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.SelectGrantRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_SelectGrant_Call) Return(_a0 *milvuspb.SelectGrantResponse, _a1 error) *RootCoord_SelectGrant_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// SelectRole provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) SelectRole(ctx context.Context, req *milvuspb.SelectRoleRequest) (*milvuspb.SelectRoleResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.SelectRoleResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectRoleRequest) *milvuspb.SelectRoleResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.SelectRoleResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectRoleRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_SelectRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectRole'
|
|
type RootCoord_SelectRole_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SelectRole is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.SelectRoleRequest
|
|
func (_e *RootCoord_Expecter) SelectRole(ctx interface{}, req interface{}) *RootCoord_SelectRole_Call {
|
|
return &RootCoord_SelectRole_Call{Call: _e.mock.On("SelectRole", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_SelectRole_Call) Run(run func(ctx context.Context, req *milvuspb.SelectRoleRequest)) *RootCoord_SelectRole_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.SelectRoleRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_SelectRole_Call) Return(_a0 *milvuspb.SelectRoleResponse, _a1 error) *RootCoord_SelectRole_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// SelectUser provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) SelectUser(ctx context.Context, req *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.SelectUserResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectUserRequest) *milvuspb.SelectUserResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.SelectUserResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.SelectUserRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_SelectUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectUser'
|
|
type RootCoord_SelectUser_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SelectUser is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.SelectUserRequest
|
|
func (_e *RootCoord_Expecter) SelectUser(ctx interface{}, req interface{}) *RootCoord_SelectUser_Call {
|
|
return &RootCoord_SelectUser_Call{Call: _e.mock.On("SelectUser", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_SelectUser_Call) Run(run func(ctx context.Context, req *milvuspb.SelectUserRequest)) *RootCoord_SelectUser_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.SelectUserRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_SelectUser_Call) Return(_a0 *milvuspb.SelectUserResponse, _a1 error) *RootCoord_SelectUser_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ShowCollections provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) ShowCollections(ctx context.Context, req *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.ShowCollectionsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowCollectionsRequest) *milvuspb.ShowCollectionsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ShowCollectionsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowCollectionsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ShowCollections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowCollections'
|
|
type RootCoord_ShowCollections_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowCollections is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.ShowCollectionsRequest
|
|
func (_e *RootCoord_Expecter) ShowCollections(ctx interface{}, req interface{}) *RootCoord_ShowCollections_Call {
|
|
return &RootCoord_ShowCollections_Call{Call: _e.mock.On("ShowCollections", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_ShowCollections_Call) Run(run func(ctx context.Context, req *milvuspb.ShowCollectionsRequest)) *RootCoord_ShowCollections_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ShowCollectionsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ShowCollections_Call) Return(_a0 *milvuspb.ShowCollectionsResponse, _a1 error) *RootCoord_ShowCollections_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ShowConfigurations provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *internalpb.ShowConfigurationsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) *internalpb.ShowConfigurationsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*internalpb.ShowConfigurationsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ShowConfigurationsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ShowConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowConfigurations'
|
|
type RootCoord_ShowConfigurations_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowConfigurations is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *internalpb.ShowConfigurationsRequest
|
|
func (_e *RootCoord_Expecter) ShowConfigurations(ctx interface{}, req interface{}) *RootCoord_ShowConfigurations_Call {
|
|
return &RootCoord_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_ShowConfigurations_Call) Run(run func(ctx context.Context, req *internalpb.ShowConfigurationsRequest)) *RootCoord_ShowConfigurations_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.ShowConfigurationsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ShowConfigurations_Call) Return(_a0 *internalpb.ShowConfigurationsResponse, _a1 error) *RootCoord_ShowConfigurations_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ShowPartitions provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) ShowPartitions(ctx context.Context, req *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.ShowPartitionsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowPartitionsRequest) *milvuspb.ShowPartitionsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ShowPartitionsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowPartitionsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ShowPartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowPartitions'
|
|
type RootCoord_ShowPartitions_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowPartitions is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.ShowPartitionsRequest
|
|
func (_e *RootCoord_Expecter) ShowPartitions(ctx interface{}, req interface{}) *RootCoord_ShowPartitions_Call {
|
|
return &RootCoord_ShowPartitions_Call{Call: _e.mock.On("ShowPartitions", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_ShowPartitions_Call) Run(run func(ctx context.Context, req *milvuspb.ShowPartitionsRequest)) *RootCoord_ShowPartitions_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ShowPartitionsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ShowPartitions_Call) Return(_a0 *milvuspb.ShowPartitionsResponse, _a1 error) *RootCoord_ShowPartitions_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ShowPartitionsInternal provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) ShowPartitionsInternal(ctx context.Context, req *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.ShowPartitionsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowPartitionsRequest) *milvuspb.ShowPartitionsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ShowPartitionsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowPartitionsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ShowPartitionsInternal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowPartitionsInternal'
|
|
type RootCoord_ShowPartitionsInternal_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowPartitionsInternal is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.ShowPartitionsRequest
|
|
func (_e *RootCoord_Expecter) ShowPartitionsInternal(ctx interface{}, req interface{}) *RootCoord_ShowPartitionsInternal_Call {
|
|
return &RootCoord_ShowPartitionsInternal_Call{Call: _e.mock.On("ShowPartitionsInternal", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_ShowPartitionsInternal_Call) Run(run func(ctx context.Context, req *milvuspb.ShowPartitionsRequest)) *RootCoord_ShowPartitionsInternal_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ShowPartitionsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ShowPartitionsInternal_Call) Return(_a0 *milvuspb.ShowPartitionsResponse, _a1 error) *RootCoord_ShowPartitionsInternal_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// ShowSegments provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) ShowSegments(ctx context.Context, req *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *milvuspb.ShowSegmentsResponse
|
|
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowSegmentsRequest) *milvuspb.ShowSegmentsResponse); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*milvuspb.ShowSegmentsResponse)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ShowSegmentsRequest) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_ShowSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowSegments'
|
|
type RootCoord_ShowSegments_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ShowSegments is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *milvuspb.ShowSegmentsRequest
|
|
func (_e *RootCoord_Expecter) ShowSegments(ctx interface{}, req interface{}) *RootCoord_ShowSegments_Call {
|
|
return &RootCoord_ShowSegments_Call{Call: _e.mock.On("ShowSegments", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_ShowSegments_Call) Run(run func(ctx context.Context, req *milvuspb.ShowSegmentsRequest)) *RootCoord_ShowSegments_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*milvuspb.ShowSegmentsRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_ShowSegments_Call) Return(_a0 *milvuspb.ShowSegmentsResponse, _a1 error) *RootCoord_ShowSegments_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// Start provides a mock function with given fields:
|
|
func (_m *RootCoord) Start() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RootCoord_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
|
type RootCoord_Start_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Start is a helper method to define mock.On call
|
|
func (_e *RootCoord_Expecter) Start() *RootCoord_Start_Call {
|
|
return &RootCoord_Start_Call{Call: _e.mock.On("Start")}
|
|
}
|
|
|
|
func (_c *RootCoord_Start_Call) Run(run func()) *RootCoord_Start_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_Start_Call) Return(_a0 error) *RootCoord_Start_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// Stop provides a mock function with given fields:
|
|
func (_m *RootCoord) Stop() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RootCoord_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
|
|
type RootCoord_Stop_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Stop is a helper method to define mock.On call
|
|
func (_e *RootCoord_Expecter) Stop() *RootCoord_Stop_Call {
|
|
return &RootCoord_Stop_Call{Call: _e.mock.On("Stop")}
|
|
}
|
|
|
|
func (_c *RootCoord_Stop_Call) Run(run func()) *RootCoord_Stop_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_Stop_Call) Return(_a0 error) *RootCoord_Stop_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
// UpdateChannelTimeTick provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) UpdateChannelTimeTick(ctx context.Context, req *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ChannelTimeTickMsg) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ChannelTimeTickMsg) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_UpdateChannelTimeTick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelTimeTick'
|
|
type RootCoord_UpdateChannelTimeTick_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateChannelTimeTick is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *internalpb.ChannelTimeTickMsg
|
|
func (_e *RootCoord_Expecter) UpdateChannelTimeTick(ctx interface{}, req interface{}) *RootCoord_UpdateChannelTimeTick_Call {
|
|
return &RootCoord_UpdateChannelTimeTick_Call{Call: _e.mock.On("UpdateChannelTimeTick", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_UpdateChannelTimeTick_Call) Run(run func(ctx context.Context, req *internalpb.ChannelTimeTickMsg)) *RootCoord_UpdateChannelTimeTick_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.ChannelTimeTickMsg))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_UpdateChannelTimeTick_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_UpdateChannelTimeTick_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
// UpdateCredential provides a mock function with given fields: ctx, req
|
|
func (_m *RootCoord) UpdateCredential(ctx context.Context, req *internalpb.CredentialInfo) (*commonpb.Status, error) {
|
|
ret := _m.Called(ctx, req)
|
|
|
|
var r0 *commonpb.Status
|
|
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo) *commonpb.Status); ok {
|
|
r0 = rf(ctx, req)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*commonpb.Status)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.CredentialInfo) error); ok {
|
|
r1 = rf(ctx, req)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RootCoord_UpdateCredential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCredential'
|
|
type RootCoord_UpdateCredential_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateCredential is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - req *internalpb.CredentialInfo
|
|
func (_e *RootCoord_Expecter) UpdateCredential(ctx interface{}, req interface{}) *RootCoord_UpdateCredential_Call {
|
|
return &RootCoord_UpdateCredential_Call{Call: _e.mock.On("UpdateCredential", ctx, req)}
|
|
}
|
|
|
|
func (_c *RootCoord_UpdateCredential_Call) Run(run func(ctx context.Context, req *internalpb.CredentialInfo)) *RootCoord_UpdateCredential_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*internalpb.CredentialInfo))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *RootCoord_UpdateCredential_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_UpdateCredential_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
type mockConstructorTestingTNewRootCoord interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}
|
|
|
|
// NewRootCoord creates a new instance of RootCoord. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
func NewRootCoord(t mockConstructorTestingTNewRootCoord) *RootCoord {
|
|
mock := &RootCoord{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|