2022-09-07 16:14:35 +08:00
// Code generated by mockery v2.14.0. DO NOT EDIT.
package mocks
import (
context "context"
2022-10-16 20:49:27 +08:00
commonpb "github.com/milvus-io/milvus-proto/go-api/commonpb"
2022-09-07 16:14:35 +08:00
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
2022-10-16 20:49:27 +08:00
milvuspb "github.com/milvus-io/milvus-proto/go-api/milvuspb"
2022-09-07 16:14:35 +08:00
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
}
2022-10-18 13:39:26 +08:00
// 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
}
2022-09-07 16:14:35 +08:00
// 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
}
// 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
2022-10-10 15:55:22 +08:00
func ( _m * RootCoord ) GetComponentStates ( ctx context . Context ) ( * milvuspb . ComponentStates , error ) {
2022-09-07 16:14:35 +08:00
ret := _m . Called ( ctx )
2022-10-10 15:55:22 +08:00
var r0 * milvuspb . ComponentStates
if rf , ok := ret . Get ( 0 ) . ( func ( context . Context ) * milvuspb . ComponentStates ) ; ok {
2022-09-07 16:14:35 +08:00
r0 = rf ( ctx )
} else {
if ret . Get ( 0 ) != nil {
2022-10-10 15:55:22 +08:00
r0 = ret . Get ( 0 ) . ( * milvuspb . ComponentStates )
2022-09-07 16:14:35 +08:00
}
}
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
}
2022-10-10 15:55:22 +08:00
func ( _c * RootCoord_GetComponentStates_Call ) Return ( _a0 * milvuspb . ComponentStates , _a1 error ) * RootCoord_GetComponentStates_Call {
2022-09-07 16:14:35 +08:00
_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
}
// 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
}
// 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
}