diff --git a/Makefile b/Makefile index 9848369e5f049395d79ab203f494b1975a473920..4cda9a40ef9ede5e21e9f77b3453df846ad7a1cc 100644 --- a/Makefile +++ b/Makefile @@ -359,6 +359,7 @@ generate-mockery: getdeps # internal/datacoord $(PWD)/bin/mockery --dir=internal/datacoord --name=compactionPlanContext --filename=mock_compaction_plan_context.go --output=internal/datacoord --structname=MockCompactionPlanContext --with-expecter --inpackage $(PWD)/bin/mockery --dir=internal/datacoord --name=Handler --filename=mock_handler.go --output=internal/datacoord --structname=NMockHandler --with-expecter --inpackage + $(PWD)/bin/mockery --name=DataCoordComponent --dir=$(PWD)/internal/types --output=$(PWD)/internal/types --filename=mock_datacoord.go --with-expecter --structname=MockDataCoord --outpkg=types --inpackage #internal/proxy $(PWD)/bin/mockery --name=LBPolicy --dir=$(PWD)/internal/proxy --output=$(PWD)/internal/proxy --filename=mock_lb_policy.go --structname=MockLBPolicy --with-expecter --outpkg=proxy --inpackage $(PWD)/bin/mockery --name=LBBalancer --dir=$(PWD)/internal/proxy --output=$(PWD)/internal/proxy --filename=mock_lb_balancer.go --structname=MockLBBalancer --with-expecter --outpkg=proxy --inpackage diff --git a/internal/datanode/timetick_sender.go b/internal/datanode/timetick_sender.go index 6dbc268a803c1bbadbda60e91c1d47b1286fb22c..0a42616dfe207ee3df75c1f9d4549e93e46d8c78 100644 --- a/internal/datanode/timetick_sender.go +++ b/internal/datanode/timetick_sender.go @@ -66,7 +66,7 @@ func (m *timeTickSender) start(ctx context.Context) { log.Info("timeTickSender context done") return case t := <-ticker.C: - m.sendReport(ctx, uint64(t.Unix())) + m.sendReport(ctx, uint64(t.UnixMilli())) } } } diff --git a/internal/datanode/timetick_sender_test.go b/internal/datanode/timetick_sender_test.go index 60d06b86ef4d6eb12c8ac3a3ffa82947dbfa815e..5c08a335402f9dcea0c864f581dbc51db8c3a9da 100644 --- a/internal/datanode/timetick_sender_test.go +++ b/internal/datanode/timetick_sender_test.go @@ -22,8 +22,12 @@ import ( "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "go.uber.org/atomic" "github.com/milvus-io/milvus-proto/go-api/v2/commonpb" + "github.com/milvus-io/milvus/internal/proto/datapb" + "github.com/milvus-io/milvus/internal/types" ) func TestTimetickManagerNormal(t *testing.T) { @@ -159,3 +163,25 @@ func TestTimetickManagerSendNotSuccess(t *testing.T) { err := manager.sendReport(ctx, 100) assert.Error(t, err) } + +func TestTimetickManagerSendReport(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + mockDataCoord := types.NewMockDataCoord(t) + tsInMill := time.Now().UnixMilli() + + validTs := atomic.NewBool(false) + mockDataCoord.EXPECT().ReportDataNodeTtMsgs(mock.Anything, mock.Anything).Run(func(ctx context.Context, req *datapb.ReportDataNodeTtMsgsRequest) { + if req.GetBase().Timestamp > uint64(tsInMill) { + validTs.Store(true) + } + }).Return(&commonpb.Status{ + ErrorCode: commonpb.ErrorCode_Success, + }, nil) + manager := newTimeTickManager(mockDataCoord, 0) + go manager.start(ctx) + + assert.Eventually(t, func() bool { + return validTs.Load() + }, 2*time.Second, 500*time.Millisecond) +} diff --git a/internal/types/mock_datacoord.go b/internal/types/mock_datacoord.go new file mode 100644 index 0000000000000000000000000000000000000000..2576e475cd1cae72290011b35070697094f08619 --- /dev/null +++ b/internal/types/mock_datacoord.go @@ -0,0 +1,2793 @@ +// Code generated by mockery v2.21.1. DO NOT EDIT. + +package types + +import ( + context "context" + + commonpb "github.com/milvus-io/milvus-proto/go-api/v2/commonpb" + clientv3 "go.etcd.io/etcd/client/v3" + + datapb "github.com/milvus-io/milvus/internal/proto/datapb" + + indexpb "github.com/milvus-io/milvus/internal/proto/indexpb" + + internalpb "github.com/milvus-io/milvus/internal/proto/internalpb" + + milvuspb "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb" + + mock "github.com/stretchr/testify/mock" +) + +// MockDataCoord is an autogenerated mock type for the DataCoordComponent type +type MockDataCoord struct { + mock.Mock +} + +type MockDataCoord_Expecter struct { + mock *mock.Mock +} + +func (_m *MockDataCoord) EXPECT() *MockDataCoord_Expecter { + return &MockDataCoord_Expecter{mock: &_m.Mock} +} + +// AssignSegmentID provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) AssignSegmentID(ctx context.Context, req *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.AssignSegmentIDResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.AssignSegmentIDRequest) *datapb.AssignSegmentIDResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.AssignSegmentIDResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.AssignSegmentIDRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_AssignSegmentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignSegmentID' +type MockDataCoord_AssignSegmentID_Call struct { + *mock.Call +} + +// AssignSegmentID is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.AssignSegmentIDRequest +func (_e *MockDataCoord_Expecter) AssignSegmentID(ctx interface{}, req interface{}) *MockDataCoord_AssignSegmentID_Call { + return &MockDataCoord_AssignSegmentID_Call{Call: _e.mock.On("AssignSegmentID", ctx, req)} +} + +func (_c *MockDataCoord_AssignSegmentID_Call) Run(run func(ctx context.Context, req *datapb.AssignSegmentIDRequest)) *MockDataCoord_AssignSegmentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.AssignSegmentIDRequest)) + }) + return _c +} + +func (_c *MockDataCoord_AssignSegmentID_Call) Return(_a0 *datapb.AssignSegmentIDResponse, _a1 error) *MockDataCoord_AssignSegmentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_AssignSegmentID_Call) RunAndReturn(run func(context.Context, *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error)) *MockDataCoord_AssignSegmentID_Call { + _c.Call.Return(run) + return _c +} + +// BroadcastAlteredCollection provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) BroadcastAlteredCollection(ctx context.Context, req *datapb.AlterCollectionRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.AlterCollectionRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_BroadcastAlteredCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastAlteredCollection' +type MockDataCoord_BroadcastAlteredCollection_Call struct { + *mock.Call +} + +// BroadcastAlteredCollection is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.AlterCollectionRequest +func (_e *MockDataCoord_Expecter) BroadcastAlteredCollection(ctx interface{}, req interface{}) *MockDataCoord_BroadcastAlteredCollection_Call { + return &MockDataCoord_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection", ctx, req)} +} + +func (_c *MockDataCoord_BroadcastAlteredCollection_Call) Run(run func(ctx context.Context, req *datapb.AlterCollectionRequest)) *MockDataCoord_BroadcastAlteredCollection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.AlterCollectionRequest)) + }) + return _c +} + +func (_c *MockDataCoord_BroadcastAlteredCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_BroadcastAlteredCollection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_BroadcastAlteredCollection_Call) RunAndReturn(run func(context.Context, *datapb.AlterCollectionRequest) (*commonpb.Status, error)) *MockDataCoord_BroadcastAlteredCollection_Call { + _c.Call.Return(run) + return _c +} + +// CheckHealth provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *milvuspb.CheckHealthResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)); ok { + return rf(ctx, req) + } + 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) + } + } + + 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 +} + +// MockDataCoord_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth' +type MockDataCoord_CheckHealth_Call struct { + *mock.Call +} + +// CheckHealth is a helper method to define mock.On call +// - ctx context.Context +// - req *milvuspb.CheckHealthRequest +func (_e *MockDataCoord_Expecter) CheckHealth(ctx interface{}, req interface{}) *MockDataCoord_CheckHealth_Call { + return &MockDataCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, req)} +} + +func (_c *MockDataCoord_CheckHealth_Call) Run(run func(ctx context.Context, req *milvuspb.CheckHealthRequest)) *MockDataCoord_CheckHealth_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest)) + }) + return _c +} + +func (_c *MockDataCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *MockDataCoord_CheckHealth_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_CheckHealth_Call) RunAndReturn(run func(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)) *MockDataCoord_CheckHealth_Call { + _c.Call.Return(run) + return _c +} + +// CreateIndex provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *indexpb.CreateIndexRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex' +type MockDataCoord_CreateIndex_Call struct { + *mock.Call +} + +// CreateIndex is a helper method to define mock.On call +// - ctx context.Context +// - req *indexpb.CreateIndexRequest +func (_e *MockDataCoord_Expecter) CreateIndex(ctx interface{}, req interface{}) *MockDataCoord_CreateIndex_Call { + return &MockDataCoord_CreateIndex_Call{Call: _e.mock.On("CreateIndex", ctx, req)} +} + +func (_c *MockDataCoord_CreateIndex_Call) Run(run func(ctx context.Context, req *indexpb.CreateIndexRequest)) *MockDataCoord_CreateIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*indexpb.CreateIndexRequest)) + }) + return _c +} + +func (_c *MockDataCoord_CreateIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_CreateIndex_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_CreateIndex_Call) RunAndReturn(run func(context.Context, *indexpb.CreateIndexRequest) (*commonpb.Status, error)) *MockDataCoord_CreateIndex_Call { + _c.Call.Return(run) + return _c +} + +// DescribeIndex provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) DescribeIndex(ctx context.Context, req *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *indexpb.DescribeIndexResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DescribeIndexRequest) *indexpb.DescribeIndexResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*indexpb.DescribeIndexResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DescribeIndexRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_DescribeIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIndex' +type MockDataCoord_DescribeIndex_Call struct { + *mock.Call +} + +// DescribeIndex is a helper method to define mock.On call +// - ctx context.Context +// - req *indexpb.DescribeIndexRequest +func (_e *MockDataCoord_Expecter) DescribeIndex(ctx interface{}, req interface{}) *MockDataCoord_DescribeIndex_Call { + return &MockDataCoord_DescribeIndex_Call{Call: _e.mock.On("DescribeIndex", ctx, req)} +} + +func (_c *MockDataCoord_DescribeIndex_Call) Run(run func(ctx context.Context, req *indexpb.DescribeIndexRequest)) *MockDataCoord_DescribeIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*indexpb.DescribeIndexRequest)) + }) + return _c +} + +func (_c *MockDataCoord_DescribeIndex_Call) Return(_a0 *indexpb.DescribeIndexResponse, _a1 error) *MockDataCoord_DescribeIndex_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_DescribeIndex_Call) RunAndReturn(run func(context.Context, *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)) *MockDataCoord_DescribeIndex_Call { + _c.Call.Return(run) + return _c +} + +// DropIndex provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) DropIndex(ctx context.Context, req *indexpb.DropIndexRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DropIndexRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_DropIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropIndex' +type MockDataCoord_DropIndex_Call struct { + *mock.Call +} + +// DropIndex is a helper method to define mock.On call +// - ctx context.Context +// - req *indexpb.DropIndexRequest +func (_e *MockDataCoord_Expecter) DropIndex(ctx interface{}, req interface{}) *MockDataCoord_DropIndex_Call { + return &MockDataCoord_DropIndex_Call{Call: _e.mock.On("DropIndex", ctx, req)} +} + +func (_c *MockDataCoord_DropIndex_Call) Run(run func(ctx context.Context, req *indexpb.DropIndexRequest)) *MockDataCoord_DropIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*indexpb.DropIndexRequest)) + }) + return _c +} + +func (_c *MockDataCoord_DropIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_DropIndex_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_DropIndex_Call) RunAndReturn(run func(context.Context, *indexpb.DropIndexRequest) (*commonpb.Status, error)) *MockDataCoord_DropIndex_Call { + _c.Call.Return(run) + return _c +} + +// DropVirtualChannel provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.DropVirtualChannelResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropVirtualChannelRequest) *datapb.DropVirtualChannelResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.DropVirtualChannelResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.DropVirtualChannelRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_DropVirtualChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropVirtualChannel' +type MockDataCoord_DropVirtualChannel_Call struct { + *mock.Call +} + +// DropVirtualChannel is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.DropVirtualChannelRequest +func (_e *MockDataCoord_Expecter) DropVirtualChannel(ctx interface{}, req interface{}) *MockDataCoord_DropVirtualChannel_Call { + return &MockDataCoord_DropVirtualChannel_Call{Call: _e.mock.On("DropVirtualChannel", ctx, req)} +} + +func (_c *MockDataCoord_DropVirtualChannel_Call) Run(run func(ctx context.Context, req *datapb.DropVirtualChannelRequest)) *MockDataCoord_DropVirtualChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.DropVirtualChannelRequest)) + }) + return _c +} + +func (_c *MockDataCoord_DropVirtualChannel_Call) Return(_a0 *datapb.DropVirtualChannelResponse, _a1 error) *MockDataCoord_DropVirtualChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_DropVirtualChannel_Call) RunAndReturn(run func(context.Context, *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error)) *MockDataCoord_DropVirtualChannel_Call { + _c.Call.Return(run) + return _c +} + +// Flush provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) Flush(ctx context.Context, req *datapb.FlushRequest) (*datapb.FlushResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.FlushResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushRequest) (*datapb.FlushResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.FlushRequest) *datapb.FlushResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.FlushResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.FlushRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush' +type MockDataCoord_Flush_Call struct { + *mock.Call +} + +// Flush is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.FlushRequest +func (_e *MockDataCoord_Expecter) Flush(ctx interface{}, req interface{}) *MockDataCoord_Flush_Call { + return &MockDataCoord_Flush_Call{Call: _e.mock.On("Flush", ctx, req)} +} + +func (_c *MockDataCoord_Flush_Call) Run(run func(ctx context.Context, req *datapb.FlushRequest)) *MockDataCoord_Flush_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.FlushRequest)) + }) + return _c +} + +func (_c *MockDataCoord_Flush_Call) Return(_a0 *datapb.FlushResponse, _a1 error) *MockDataCoord_Flush_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_Flush_Call) RunAndReturn(run func(context.Context, *datapb.FlushRequest) (*datapb.FlushResponse, error)) *MockDataCoord_Flush_Call { + _c.Call.Return(run) + return _c +} + +// GcConfirm provides a mock function with given fields: ctx, request +func (_m *MockDataCoord) GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) { + ret := _m.Called(ctx, request) + + var r0 *datapb.GcConfirmResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcConfirmRequest) *datapb.GcConfirmResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GcConfirmResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GcConfirmRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GcConfirm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GcConfirm' +type MockDataCoord_GcConfirm_Call struct { + *mock.Call +} + +// GcConfirm is a helper method to define mock.On call +// - ctx context.Context +// - request *datapb.GcConfirmRequest +func (_e *MockDataCoord_Expecter) GcConfirm(ctx interface{}, request interface{}) *MockDataCoord_GcConfirm_Call { + return &MockDataCoord_GcConfirm_Call{Call: _e.mock.On("GcConfirm", ctx, request)} +} + +func (_c *MockDataCoord_GcConfirm_Call) Run(run func(ctx context.Context, request *datapb.GcConfirmRequest)) *MockDataCoord_GcConfirm_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GcConfirmRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GcConfirm_Call) Return(_a0 *datapb.GcConfirmResponse, _a1 error) *MockDataCoord_GcConfirm_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GcConfirm_Call) RunAndReturn(run func(context.Context, *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error)) *MockDataCoord_GcConfirm_Call { + _c.Call.Return(run) + return _c +} + +// GetCollectionStatistics provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetCollectionStatistics(ctx context.Context, req *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetCollectionStatisticsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetCollectionStatisticsRequest) *datapb.GetCollectionStatisticsResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetCollectionStatisticsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetCollectionStatisticsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetCollectionStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCollectionStatistics' +type MockDataCoord_GetCollectionStatistics_Call struct { + *mock.Call +} + +// GetCollectionStatistics is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetCollectionStatisticsRequest +func (_e *MockDataCoord_Expecter) GetCollectionStatistics(ctx interface{}, req interface{}) *MockDataCoord_GetCollectionStatistics_Call { + return &MockDataCoord_GetCollectionStatistics_Call{Call: _e.mock.On("GetCollectionStatistics", ctx, req)} +} + +func (_c *MockDataCoord_GetCollectionStatistics_Call) Run(run func(ctx context.Context, req *datapb.GetCollectionStatisticsRequest)) *MockDataCoord_GetCollectionStatistics_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetCollectionStatisticsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetCollectionStatistics_Call) Return(_a0 *datapb.GetCollectionStatisticsResponse, _a1 error) *MockDataCoord_GetCollectionStatistics_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetCollectionStatistics_Call) RunAndReturn(run func(context.Context, *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error)) *MockDataCoord_GetCollectionStatistics_Call { + _c.Call.Return(run) + return _c +} + +// GetCompactionState provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetCompactionState(ctx context.Context, req *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *milvuspb.GetCompactionStateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionStateRequest) *milvuspb.GetCompactionStateResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*milvuspb.GetCompactionStateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetCompactionStateRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetCompactionState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionState' +type MockDataCoord_GetCompactionState_Call struct { + *mock.Call +} + +// GetCompactionState is a helper method to define mock.On call +// - ctx context.Context +// - req *milvuspb.GetCompactionStateRequest +func (_e *MockDataCoord_Expecter) GetCompactionState(ctx interface{}, req interface{}) *MockDataCoord_GetCompactionState_Call { + return &MockDataCoord_GetCompactionState_Call{Call: _e.mock.On("GetCompactionState", ctx, req)} +} + +func (_c *MockDataCoord_GetCompactionState_Call) Run(run func(ctx context.Context, req *milvuspb.GetCompactionStateRequest)) *MockDataCoord_GetCompactionState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.GetCompactionStateRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetCompactionState_Call) Return(_a0 *milvuspb.GetCompactionStateResponse, _a1 error) *MockDataCoord_GetCompactionState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetCompactionState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error)) *MockDataCoord_GetCompactionState_Call { + _c.Call.Return(run) + return _c +} + +// GetCompactionStateWithPlans provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetCompactionStateWithPlans(ctx context.Context, req *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *milvuspb.GetCompactionPlansResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetCompactionPlansRequest) *milvuspb.GetCompactionPlansResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*milvuspb.GetCompactionPlansResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetCompactionPlansRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetCompactionStateWithPlans_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionStateWithPlans' +type MockDataCoord_GetCompactionStateWithPlans_Call struct { + *mock.Call +} + +// GetCompactionStateWithPlans is a helper method to define mock.On call +// - ctx context.Context +// - req *milvuspb.GetCompactionPlansRequest +func (_e *MockDataCoord_Expecter) GetCompactionStateWithPlans(ctx interface{}, req interface{}) *MockDataCoord_GetCompactionStateWithPlans_Call { + return &MockDataCoord_GetCompactionStateWithPlans_Call{Call: _e.mock.On("GetCompactionStateWithPlans", ctx, req)} +} + +func (_c *MockDataCoord_GetCompactionStateWithPlans_Call) Run(run func(ctx context.Context, req *milvuspb.GetCompactionPlansRequest)) *MockDataCoord_GetCompactionStateWithPlans_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.GetCompactionPlansRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetCompactionStateWithPlans_Call) Return(_a0 *milvuspb.GetCompactionPlansResponse, _a1 error) *MockDataCoord_GetCompactionStateWithPlans_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetCompactionStateWithPlans_Call) RunAndReturn(run func(context.Context, *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error)) *MockDataCoord_GetCompactionStateWithPlans_Call { + _c.Call.Return(run) + return _c +} + +// GetComponentStates provides a mock function with given fields: ctx +func (_m *MockDataCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) { + ret := _m.Called(ctx) + + var r0 *milvuspb.ComponentStates + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*milvuspb.ComponentStates, error)); ok { + return rf(ctx) + } + 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) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetComponentStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComponentStates' +type MockDataCoord_GetComponentStates_Call struct { + *mock.Call +} + +// GetComponentStates is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockDataCoord_Expecter) GetComponentStates(ctx interface{}) *MockDataCoord_GetComponentStates_Call { + return &MockDataCoord_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", ctx)} +} + +func (_c *MockDataCoord_GetComponentStates_Call) Run(run func(ctx context.Context)) *MockDataCoord_GetComponentStates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockDataCoord_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *MockDataCoord_GetComponentStates_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetComponentStates_Call) RunAndReturn(run func(context.Context) (*milvuspb.ComponentStates, error)) *MockDataCoord_GetComponentStates_Call { + _c.Call.Return(run) + return _c +} + +// GetFlushAllState provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetFlushAllState(ctx context.Context, req *milvuspb.GetFlushAllStateRequest) (*milvuspb.GetFlushAllStateResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *milvuspb.GetFlushAllStateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetFlushAllStateRequest) (*milvuspb.GetFlushAllStateResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetFlushAllStateRequest) *milvuspb.GetFlushAllStateResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*milvuspb.GetFlushAllStateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetFlushAllStateRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetFlushAllState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushAllState' +type MockDataCoord_GetFlushAllState_Call struct { + *mock.Call +} + +// GetFlushAllState is a helper method to define mock.On call +// - ctx context.Context +// - req *milvuspb.GetFlushAllStateRequest +func (_e *MockDataCoord_Expecter) GetFlushAllState(ctx interface{}, req interface{}) *MockDataCoord_GetFlushAllState_Call { + return &MockDataCoord_GetFlushAllState_Call{Call: _e.mock.On("GetFlushAllState", ctx, req)} +} + +func (_c *MockDataCoord_GetFlushAllState_Call) Run(run func(ctx context.Context, req *milvuspb.GetFlushAllStateRequest)) *MockDataCoord_GetFlushAllState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.GetFlushAllStateRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetFlushAllState_Call) Return(_a0 *milvuspb.GetFlushAllStateResponse, _a1 error) *MockDataCoord_GetFlushAllState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetFlushAllState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetFlushAllStateRequest) (*milvuspb.GetFlushAllStateResponse, error)) *MockDataCoord_GetFlushAllState_Call { + _c.Call.Return(run) + return _c +} + +// GetFlushState provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *milvuspb.GetFlushStateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetFlushStateRequest) *milvuspb.GetFlushStateResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*milvuspb.GetFlushStateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetFlushStateRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetFlushState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushState' +type MockDataCoord_GetFlushState_Call struct { + *mock.Call +} + +// GetFlushState is a helper method to define mock.On call +// - ctx context.Context +// - req *milvuspb.GetFlushStateRequest +func (_e *MockDataCoord_Expecter) GetFlushState(ctx interface{}, req interface{}) *MockDataCoord_GetFlushState_Call { + return &MockDataCoord_GetFlushState_Call{Call: _e.mock.On("GetFlushState", ctx, req)} +} + +func (_c *MockDataCoord_GetFlushState_Call) Run(run func(ctx context.Context, req *milvuspb.GetFlushStateRequest)) *MockDataCoord_GetFlushState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.GetFlushStateRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetFlushState_Call) Return(_a0 *milvuspb.GetFlushStateResponse, _a1 error) *MockDataCoord_GetFlushState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetFlushState_Call) RunAndReturn(run func(context.Context, *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)) *MockDataCoord_GetFlushState_Call { + _c.Call.Return(run) + return _c +} + +// GetFlushedSegments provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetFlushedSegments(ctx context.Context, req *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetFlushedSegmentsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetFlushedSegmentsRequest) *datapb.GetFlushedSegmentsResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetFlushedSegmentsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetFlushedSegmentsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetFlushedSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushedSegments' +type MockDataCoord_GetFlushedSegments_Call struct { + *mock.Call +} + +// GetFlushedSegments is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetFlushedSegmentsRequest +func (_e *MockDataCoord_Expecter) GetFlushedSegments(ctx interface{}, req interface{}) *MockDataCoord_GetFlushedSegments_Call { + return &MockDataCoord_GetFlushedSegments_Call{Call: _e.mock.On("GetFlushedSegments", ctx, req)} +} + +func (_c *MockDataCoord_GetFlushedSegments_Call) Run(run func(ctx context.Context, req *datapb.GetFlushedSegmentsRequest)) *MockDataCoord_GetFlushedSegments_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetFlushedSegmentsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetFlushedSegments_Call) Return(_a0 *datapb.GetFlushedSegmentsResponse, _a1 error) *MockDataCoord_GetFlushedSegments_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetFlushedSegments_Call) RunAndReturn(run func(context.Context, *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error)) *MockDataCoord_GetFlushedSegments_Call { + _c.Call.Return(run) + return _c +} + +// GetIndexBuildProgress provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetIndexBuildProgress(ctx context.Context, req *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *indexpb.GetIndexBuildProgressResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) *indexpb.GetIndexBuildProgressResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*indexpb.GetIndexBuildProgressResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetIndexBuildProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexBuildProgress' +type MockDataCoord_GetIndexBuildProgress_Call struct { + *mock.Call +} + +// GetIndexBuildProgress is a helper method to define mock.On call +// - ctx context.Context +// - req *indexpb.GetIndexBuildProgressRequest +func (_e *MockDataCoord_Expecter) GetIndexBuildProgress(ctx interface{}, req interface{}) *MockDataCoord_GetIndexBuildProgress_Call { + return &MockDataCoord_GetIndexBuildProgress_Call{Call: _e.mock.On("GetIndexBuildProgress", ctx, req)} +} + +func (_c *MockDataCoord_GetIndexBuildProgress_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexBuildProgressRequest)) *MockDataCoord_GetIndexBuildProgress_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*indexpb.GetIndexBuildProgressRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetIndexBuildProgress_Call) Return(_a0 *indexpb.GetIndexBuildProgressResponse, _a1 error) *MockDataCoord_GetIndexBuildProgress_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetIndexBuildProgress_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error)) *MockDataCoord_GetIndexBuildProgress_Call { + _c.Call.Return(run) + return _c +} + +// GetIndexInfos provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetIndexInfos(ctx context.Context, req *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *indexpb.GetIndexInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexInfoRequest) *indexpb.GetIndexInfoResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*indexpb.GetIndexInfoResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexInfoRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetIndexInfos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexInfos' +type MockDataCoord_GetIndexInfos_Call struct { + *mock.Call +} + +// GetIndexInfos is a helper method to define mock.On call +// - ctx context.Context +// - req *indexpb.GetIndexInfoRequest +func (_e *MockDataCoord_Expecter) GetIndexInfos(ctx interface{}, req interface{}) *MockDataCoord_GetIndexInfos_Call { + return &MockDataCoord_GetIndexInfos_Call{Call: _e.mock.On("GetIndexInfos", ctx, req)} +} + +func (_c *MockDataCoord_GetIndexInfos_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexInfoRequest)) *MockDataCoord_GetIndexInfos_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*indexpb.GetIndexInfoRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetIndexInfos_Call) Return(_a0 *indexpb.GetIndexInfoResponse, _a1 error) *MockDataCoord_GetIndexInfos_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetIndexInfos_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error)) *MockDataCoord_GetIndexInfos_Call { + _c.Call.Return(run) + return _c +} + +// GetIndexState provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetIndexState(ctx context.Context, req *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *indexpb.GetIndexStateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStateRequest) *indexpb.GetIndexStateResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*indexpb.GetIndexStateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexStateRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetIndexState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexState' +type MockDataCoord_GetIndexState_Call struct { + *mock.Call +} + +// GetIndexState is a helper method to define mock.On call +// - ctx context.Context +// - req *indexpb.GetIndexStateRequest +func (_e *MockDataCoord_Expecter) GetIndexState(ctx interface{}, req interface{}) *MockDataCoord_GetIndexState_Call { + return &MockDataCoord_GetIndexState_Call{Call: _e.mock.On("GetIndexState", ctx, req)} +} + +func (_c *MockDataCoord_GetIndexState_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexStateRequest)) *MockDataCoord_GetIndexState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*indexpb.GetIndexStateRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetIndexState_Call) Return(_a0 *indexpb.GetIndexStateResponse, _a1 error) *MockDataCoord_GetIndexState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetIndexState_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error)) *MockDataCoord_GetIndexState_Call { + _c.Call.Return(run) + return _c +} + +// GetIndexStatistics provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetIndexStatistics(ctx context.Context, req *indexpb.GetIndexStatisticsRequest) (*indexpb.GetIndexStatisticsResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *indexpb.GetIndexStatisticsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStatisticsRequest) (*indexpb.GetIndexStatisticsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStatisticsRequest) *indexpb.GetIndexStatisticsResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*indexpb.GetIndexStatisticsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexStatisticsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetIndexStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexStatistics' +type MockDataCoord_GetIndexStatistics_Call struct { + *mock.Call +} + +// GetIndexStatistics is a helper method to define mock.On call +// - ctx context.Context +// - req *indexpb.GetIndexStatisticsRequest +func (_e *MockDataCoord_Expecter) GetIndexStatistics(ctx interface{}, req interface{}) *MockDataCoord_GetIndexStatistics_Call { + return &MockDataCoord_GetIndexStatistics_Call{Call: _e.mock.On("GetIndexStatistics", ctx, req)} +} + +func (_c *MockDataCoord_GetIndexStatistics_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexStatisticsRequest)) *MockDataCoord_GetIndexStatistics_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*indexpb.GetIndexStatisticsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetIndexStatistics_Call) Return(_a0 *indexpb.GetIndexStatisticsResponse, _a1 error) *MockDataCoord_GetIndexStatistics_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetIndexStatistics_Call) RunAndReturn(run func(context.Context, *indexpb.GetIndexStatisticsRequest) (*indexpb.GetIndexStatisticsResponse, error)) *MockDataCoord_GetIndexStatistics_Call { + _c.Call.Return(run) + return _c +} + +// GetInsertBinlogPaths provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetInsertBinlogPaths(ctx context.Context, req *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetInsertBinlogPathsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetInsertBinlogPathsRequest) *datapb.GetInsertBinlogPathsResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetInsertBinlogPathsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetInsertBinlogPathsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetInsertBinlogPaths_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInsertBinlogPaths' +type MockDataCoord_GetInsertBinlogPaths_Call struct { + *mock.Call +} + +// GetInsertBinlogPaths is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetInsertBinlogPathsRequest +func (_e *MockDataCoord_Expecter) GetInsertBinlogPaths(ctx interface{}, req interface{}) *MockDataCoord_GetInsertBinlogPaths_Call { + return &MockDataCoord_GetInsertBinlogPaths_Call{Call: _e.mock.On("GetInsertBinlogPaths", ctx, req)} +} + +func (_c *MockDataCoord_GetInsertBinlogPaths_Call) Run(run func(ctx context.Context, req *datapb.GetInsertBinlogPathsRequest)) *MockDataCoord_GetInsertBinlogPaths_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetInsertBinlogPathsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetInsertBinlogPaths_Call) Return(_a0 *datapb.GetInsertBinlogPathsResponse, _a1 error) *MockDataCoord_GetInsertBinlogPaths_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetInsertBinlogPaths_Call) RunAndReturn(run func(context.Context, *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error)) *MockDataCoord_GetInsertBinlogPaths_Call { + _c.Call.Return(run) + return _c +} + +// GetMetrics provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *milvuspb.GetMetricsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)); ok { + return rf(ctx, req) + } + 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) + } + } + + 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 +} + +// MockDataCoord_GetMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetrics' +type MockDataCoord_GetMetrics_Call struct { + *mock.Call +} + +// GetMetrics is a helper method to define mock.On call +// - ctx context.Context +// - req *milvuspb.GetMetricsRequest +func (_e *MockDataCoord_Expecter) GetMetrics(ctx interface{}, req interface{}) *MockDataCoord_GetMetrics_Call { + return &MockDataCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", ctx, req)} +} + +func (_c *MockDataCoord_GetMetrics_Call) Run(run func(ctx context.Context, req *milvuspb.GetMetricsRequest)) *MockDataCoord_GetMetrics_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.GetMetricsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetMetrics_Call) Return(_a0 *milvuspb.GetMetricsResponse, _a1 error) *MockDataCoord_GetMetrics_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetMetrics_Call) RunAndReturn(run func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)) *MockDataCoord_GetMetrics_Call { + _c.Call.Return(run) + return _c +} + +// GetPartitionStatistics provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetPartitionStatistics(ctx context.Context, req *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetPartitionStatisticsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetPartitionStatisticsRequest) *datapb.GetPartitionStatisticsResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetPartitionStatisticsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetPartitionStatisticsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetPartitionStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPartitionStatistics' +type MockDataCoord_GetPartitionStatistics_Call struct { + *mock.Call +} + +// GetPartitionStatistics is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetPartitionStatisticsRequest +func (_e *MockDataCoord_Expecter) GetPartitionStatistics(ctx interface{}, req interface{}) *MockDataCoord_GetPartitionStatistics_Call { + return &MockDataCoord_GetPartitionStatistics_Call{Call: _e.mock.On("GetPartitionStatistics", ctx, req)} +} + +func (_c *MockDataCoord_GetPartitionStatistics_Call) Run(run func(ctx context.Context, req *datapb.GetPartitionStatisticsRequest)) *MockDataCoord_GetPartitionStatistics_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetPartitionStatisticsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetPartitionStatistics_Call) Return(_a0 *datapb.GetPartitionStatisticsResponse, _a1 error) *MockDataCoord_GetPartitionStatistics_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetPartitionStatistics_Call) RunAndReturn(run func(context.Context, *datapb.GetPartitionStatisticsRequest) (*datapb.GetPartitionStatisticsResponse, error)) *MockDataCoord_GetPartitionStatistics_Call { + _c.Call.Return(run) + return _c +} + +// GetRecoveryInfo provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetRecoveryInfo(ctx context.Context, req *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetRecoveryInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequest) *datapb.GetRecoveryInfoResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetRecoveryInfoResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetRecoveryInfoRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetRecoveryInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecoveryInfo' +type MockDataCoord_GetRecoveryInfo_Call struct { + *mock.Call +} + +// GetRecoveryInfo is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetRecoveryInfoRequest +func (_e *MockDataCoord_Expecter) GetRecoveryInfo(ctx interface{}, req interface{}) *MockDataCoord_GetRecoveryInfo_Call { + return &MockDataCoord_GetRecoveryInfo_Call{Call: _e.mock.On("GetRecoveryInfo", ctx, req)} +} + +func (_c *MockDataCoord_GetRecoveryInfo_Call) Run(run func(ctx context.Context, req *datapb.GetRecoveryInfoRequest)) *MockDataCoord_GetRecoveryInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetRecoveryInfoRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetRecoveryInfo_Call) Return(_a0 *datapb.GetRecoveryInfoResponse, _a1 error) *MockDataCoord_GetRecoveryInfo_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetRecoveryInfo_Call) RunAndReturn(run func(context.Context, *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error)) *MockDataCoord_GetRecoveryInfo_Call { + _c.Call.Return(run) + return _c +} + +// GetRecoveryInfoV2 provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetRecoveryInfoV2(ctx context.Context, req *datapb.GetRecoveryInfoRequestV2) (*datapb.GetRecoveryInfoResponseV2, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetRecoveryInfoResponseV2 + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequestV2) (*datapb.GetRecoveryInfoResponseV2, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetRecoveryInfoRequestV2) *datapb.GetRecoveryInfoResponseV2); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetRecoveryInfoResponseV2) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetRecoveryInfoRequestV2) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetRecoveryInfoV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecoveryInfoV2' +type MockDataCoord_GetRecoveryInfoV2_Call struct { + *mock.Call +} + +// GetRecoveryInfoV2 is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetRecoveryInfoRequestV2 +func (_e *MockDataCoord_Expecter) GetRecoveryInfoV2(ctx interface{}, req interface{}) *MockDataCoord_GetRecoveryInfoV2_Call { + return &MockDataCoord_GetRecoveryInfoV2_Call{Call: _e.mock.On("GetRecoveryInfoV2", ctx, req)} +} + +func (_c *MockDataCoord_GetRecoveryInfoV2_Call) Run(run func(ctx context.Context, req *datapb.GetRecoveryInfoRequestV2)) *MockDataCoord_GetRecoveryInfoV2_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetRecoveryInfoRequestV2)) + }) + return _c +} + +func (_c *MockDataCoord_GetRecoveryInfoV2_Call) Return(_a0 *datapb.GetRecoveryInfoResponseV2, _a1 error) *MockDataCoord_GetRecoveryInfoV2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetRecoveryInfoV2_Call) RunAndReturn(run func(context.Context, *datapb.GetRecoveryInfoRequestV2) (*datapb.GetRecoveryInfoResponseV2, error)) *MockDataCoord_GetRecoveryInfoV2_Call { + _c.Call.Return(run) + return _c +} + +// GetSegmentIndexState provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetSegmentIndexState(ctx context.Context, req *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *indexpb.GetSegmentIndexStateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) *indexpb.GetSegmentIndexStateResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*indexpb.GetSegmentIndexStateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetSegmentIndexState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentIndexState' +type MockDataCoord_GetSegmentIndexState_Call struct { + *mock.Call +} + +// GetSegmentIndexState is a helper method to define mock.On call +// - ctx context.Context +// - req *indexpb.GetSegmentIndexStateRequest +func (_e *MockDataCoord_Expecter) GetSegmentIndexState(ctx interface{}, req interface{}) *MockDataCoord_GetSegmentIndexState_Call { + return &MockDataCoord_GetSegmentIndexState_Call{Call: _e.mock.On("GetSegmentIndexState", ctx, req)} +} + +func (_c *MockDataCoord_GetSegmentIndexState_Call) Run(run func(ctx context.Context, req *indexpb.GetSegmentIndexStateRequest)) *MockDataCoord_GetSegmentIndexState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*indexpb.GetSegmentIndexStateRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetSegmentIndexState_Call) Return(_a0 *indexpb.GetSegmentIndexStateResponse, _a1 error) *MockDataCoord_GetSegmentIndexState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetSegmentIndexState_Call) RunAndReturn(run func(context.Context, *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error)) *MockDataCoord_GetSegmentIndexState_Call { + _c.Call.Return(run) + return _c +} + +// GetSegmentInfo provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetSegmentInfo(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetSegmentInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentInfoRequest) *datapb.GetSegmentInfoResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetSegmentInfoResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentInfoRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetSegmentInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentInfo' +type MockDataCoord_GetSegmentInfo_Call struct { + *mock.Call +} + +// GetSegmentInfo is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetSegmentInfoRequest +func (_e *MockDataCoord_Expecter) GetSegmentInfo(ctx interface{}, req interface{}) *MockDataCoord_GetSegmentInfo_Call { + return &MockDataCoord_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo", ctx, req)} +} + +func (_c *MockDataCoord_GetSegmentInfo_Call) Run(run func(ctx context.Context, req *datapb.GetSegmentInfoRequest)) *MockDataCoord_GetSegmentInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetSegmentInfoRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetSegmentInfo_Call) Return(_a0 *datapb.GetSegmentInfoResponse, _a1 error) *MockDataCoord_GetSegmentInfo_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetSegmentInfo_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error)) *MockDataCoord_GetSegmentInfo_Call { + _c.Call.Return(run) + return _c +} + +// GetSegmentInfoChannel provides a mock function with given fields: ctx +func (_m *MockDataCoord) GetSegmentInfoChannel(ctx context.Context) (*milvuspb.StringResponse, error) { + ret := _m.Called(ctx) + + var r0 *milvuspb.StringResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*milvuspb.StringResponse, error)); ok { + return rf(ctx) + } + 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) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetSegmentInfoChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentInfoChannel' +type MockDataCoord_GetSegmentInfoChannel_Call struct { + *mock.Call +} + +// GetSegmentInfoChannel is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockDataCoord_Expecter) GetSegmentInfoChannel(ctx interface{}) *MockDataCoord_GetSegmentInfoChannel_Call { + return &MockDataCoord_GetSegmentInfoChannel_Call{Call: _e.mock.On("GetSegmentInfoChannel", ctx)} +} + +func (_c *MockDataCoord_GetSegmentInfoChannel_Call) Run(run func(ctx context.Context)) *MockDataCoord_GetSegmentInfoChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockDataCoord_GetSegmentInfoChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *MockDataCoord_GetSegmentInfoChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetSegmentInfoChannel_Call) RunAndReturn(run func(context.Context) (*milvuspb.StringResponse, error)) *MockDataCoord_GetSegmentInfoChannel_Call { + _c.Call.Return(run) + return _c +} + +// GetSegmentStates provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetSegmentStates(ctx context.Context, req *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetSegmentStatesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentStatesRequest) *datapb.GetSegmentStatesResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetSegmentStatesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentStatesRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetSegmentStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentStates' +type MockDataCoord_GetSegmentStates_Call struct { + *mock.Call +} + +// GetSegmentStates is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetSegmentStatesRequest +func (_e *MockDataCoord_Expecter) GetSegmentStates(ctx interface{}, req interface{}) *MockDataCoord_GetSegmentStates_Call { + return &MockDataCoord_GetSegmentStates_Call{Call: _e.mock.On("GetSegmentStates", ctx, req)} +} + +func (_c *MockDataCoord_GetSegmentStates_Call) Run(run func(ctx context.Context, req *datapb.GetSegmentStatesRequest)) *MockDataCoord_GetSegmentStates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetSegmentStatesRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetSegmentStates_Call) Return(_a0 *datapb.GetSegmentStatesResponse, _a1 error) *MockDataCoord_GetSegmentStates_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetSegmentStates_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error)) *MockDataCoord_GetSegmentStates_Call { + _c.Call.Return(run) + return _c +} + +// GetSegmentsByStates provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) GetSegmentsByStates(ctx context.Context, req *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.GetSegmentsByStatesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentsByStatesRequest) *datapb.GetSegmentsByStatesResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.GetSegmentsByStatesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentsByStatesRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetSegmentsByStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentsByStates' +type MockDataCoord_GetSegmentsByStates_Call struct { + *mock.Call +} + +// GetSegmentsByStates is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.GetSegmentsByStatesRequest +func (_e *MockDataCoord_Expecter) GetSegmentsByStates(ctx interface{}, req interface{}) *MockDataCoord_GetSegmentsByStates_Call { + return &MockDataCoord_GetSegmentsByStates_Call{Call: _e.mock.On("GetSegmentsByStates", ctx, req)} +} + +func (_c *MockDataCoord_GetSegmentsByStates_Call) Run(run func(ctx context.Context, req *datapb.GetSegmentsByStatesRequest)) *MockDataCoord_GetSegmentsByStates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.GetSegmentsByStatesRequest)) + }) + return _c +} + +func (_c *MockDataCoord_GetSegmentsByStates_Call) Return(_a0 *datapb.GetSegmentsByStatesResponse, _a1 error) *MockDataCoord_GetSegmentsByStates_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetSegmentsByStates_Call) RunAndReturn(run func(context.Context, *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error)) *MockDataCoord_GetSegmentsByStates_Call { + _c.Call.Return(run) + return _c +} + +// GetStatisticsChannel provides a mock function with given fields: ctx +func (_m *MockDataCoord) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) { + ret := _m.Called(ctx) + + var r0 *milvuspb.StringResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*milvuspb.StringResponse, error)); ok { + return rf(ctx) + } + 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) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetStatisticsChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatisticsChannel' +type MockDataCoord_GetStatisticsChannel_Call struct { + *mock.Call +} + +// GetStatisticsChannel is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockDataCoord_Expecter) GetStatisticsChannel(ctx interface{}) *MockDataCoord_GetStatisticsChannel_Call { + return &MockDataCoord_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", ctx)} +} + +func (_c *MockDataCoord_GetStatisticsChannel_Call) Run(run func(ctx context.Context)) *MockDataCoord_GetStatisticsChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockDataCoord_GetStatisticsChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *MockDataCoord_GetStatisticsChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetStatisticsChannel_Call) RunAndReturn(run func(context.Context) (*milvuspb.StringResponse, error)) *MockDataCoord_GetStatisticsChannel_Call { + _c.Call.Return(run) + return _c +} + +// GetTimeTickChannel provides a mock function with given fields: ctx +func (_m *MockDataCoord) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) { + ret := _m.Called(ctx) + + var r0 *milvuspb.StringResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*milvuspb.StringResponse, error)); ok { + return rf(ctx) + } + 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) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_GetTimeTickChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTimeTickChannel' +type MockDataCoord_GetTimeTickChannel_Call struct { + *mock.Call +} + +// GetTimeTickChannel is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockDataCoord_Expecter) GetTimeTickChannel(ctx interface{}) *MockDataCoord_GetTimeTickChannel_Call { + return &MockDataCoord_GetTimeTickChannel_Call{Call: _e.mock.On("GetTimeTickChannel", ctx)} +} + +func (_c *MockDataCoord_GetTimeTickChannel_Call) Run(run func(ctx context.Context)) *MockDataCoord_GetTimeTickChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockDataCoord_GetTimeTickChannel_Call) Return(_a0 *milvuspb.StringResponse, _a1 error) *MockDataCoord_GetTimeTickChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_GetTimeTickChannel_Call) RunAndReturn(run func(context.Context) (*milvuspb.StringResponse, error)) *MockDataCoord_GetTimeTickChannel_Call { + _c.Call.Return(run) + return _c +} + +// Import provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.ImportTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportTaskRequest) *datapb.ImportTaskResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.ImportTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.ImportTaskRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_Import_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Import' +type MockDataCoord_Import_Call struct { + *mock.Call +} + +// Import is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.ImportTaskRequest +func (_e *MockDataCoord_Expecter) Import(ctx interface{}, req interface{}) *MockDataCoord_Import_Call { + return &MockDataCoord_Import_Call{Call: _e.mock.On("Import", ctx, req)} +} + +func (_c *MockDataCoord_Import_Call) Run(run func(ctx context.Context, req *datapb.ImportTaskRequest)) *MockDataCoord_Import_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.ImportTaskRequest)) + }) + return _c +} + +func (_c *MockDataCoord_Import_Call) Return(_a0 *datapb.ImportTaskResponse, _a1 error) *MockDataCoord_Import_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_Import_Call) RunAndReturn(run func(context.Context, *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error)) *MockDataCoord_Import_Call { + _c.Call.Return(run) + return _c +} + +// Init provides a mock function with given fields: +func (_m *MockDataCoord) 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 +} + +// MockDataCoord_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init' +type MockDataCoord_Init_Call struct { + *mock.Call +} + +// Init is a helper method to define mock.On call +func (_e *MockDataCoord_Expecter) Init() *MockDataCoord_Init_Call { + return &MockDataCoord_Init_Call{Call: _e.mock.On("Init")} +} + +func (_c *MockDataCoord_Init_Call) Run(run func()) *MockDataCoord_Init_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDataCoord_Init_Call) Return(_a0 error) *MockDataCoord_Init_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDataCoord_Init_Call) RunAndReturn(run func() error) *MockDataCoord_Init_Call { + _c.Call.Return(run) + return _c +} + +// ManualCompaction provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) ManualCompaction(ctx context.Context, req *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *milvuspb.ManualCompactionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ManualCompactionRequest) *milvuspb.ManualCompactionResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*milvuspb.ManualCompactionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ManualCompactionRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_ManualCompaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManualCompaction' +type MockDataCoord_ManualCompaction_Call struct { + *mock.Call +} + +// ManualCompaction is a helper method to define mock.On call +// - ctx context.Context +// - req *milvuspb.ManualCompactionRequest +func (_e *MockDataCoord_Expecter) ManualCompaction(ctx interface{}, req interface{}) *MockDataCoord_ManualCompaction_Call { + return &MockDataCoord_ManualCompaction_Call{Call: _e.mock.On("ManualCompaction", ctx, req)} +} + +func (_c *MockDataCoord_ManualCompaction_Call) Run(run func(ctx context.Context, req *milvuspb.ManualCompactionRequest)) *MockDataCoord_ManualCompaction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.ManualCompactionRequest)) + }) + return _c +} + +func (_c *MockDataCoord_ManualCompaction_Call) Return(_a0 *milvuspb.ManualCompactionResponse, _a1 error) *MockDataCoord_ManualCompaction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_ManualCompaction_Call) RunAndReturn(run func(context.Context, *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error)) *MockDataCoord_ManualCompaction_Call { + _c.Call.Return(run) + return _c +} + +// MarkSegmentsDropped provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) MarkSegmentsDropped(ctx context.Context, req *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.MarkSegmentsDroppedRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_MarkSegmentsDropped_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkSegmentsDropped' +type MockDataCoord_MarkSegmentsDropped_Call struct { + *mock.Call +} + +// MarkSegmentsDropped is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.MarkSegmentsDroppedRequest +func (_e *MockDataCoord_Expecter) MarkSegmentsDropped(ctx interface{}, req interface{}) *MockDataCoord_MarkSegmentsDropped_Call { + return &MockDataCoord_MarkSegmentsDropped_Call{Call: _e.mock.On("MarkSegmentsDropped", ctx, req)} +} + +func (_c *MockDataCoord_MarkSegmentsDropped_Call) Run(run func(ctx context.Context, req *datapb.MarkSegmentsDroppedRequest)) *MockDataCoord_MarkSegmentsDropped_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.MarkSegmentsDroppedRequest)) + }) + return _c +} + +func (_c *MockDataCoord_MarkSegmentsDropped_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_MarkSegmentsDropped_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_MarkSegmentsDropped_Call) RunAndReturn(run func(context.Context, *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)) *MockDataCoord_MarkSegmentsDropped_Call { + _c.Call.Return(run) + return _c +} + +// Register provides a mock function with given fields: +func (_m *MockDataCoord) 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 +} + +// MockDataCoord_Register_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Register' +type MockDataCoord_Register_Call struct { + *mock.Call +} + +// Register is a helper method to define mock.On call +func (_e *MockDataCoord_Expecter) Register() *MockDataCoord_Register_Call { + return &MockDataCoord_Register_Call{Call: _e.mock.On("Register")} +} + +func (_c *MockDataCoord_Register_Call) Run(run func()) *MockDataCoord_Register_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDataCoord_Register_Call) Return(_a0 error) *MockDataCoord_Register_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDataCoord_Register_Call) RunAndReturn(run func() error) *MockDataCoord_Register_Call { + _c.Call.Return(run) + return _c +} + +// ReportDataNodeTtMsgs provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) ReportDataNodeTtMsgs(ctx context.Context, req *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_ReportDataNodeTtMsgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportDataNodeTtMsgs' +type MockDataCoord_ReportDataNodeTtMsgs_Call struct { + *mock.Call +} + +// ReportDataNodeTtMsgs is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.ReportDataNodeTtMsgsRequest +func (_e *MockDataCoord_Expecter) ReportDataNodeTtMsgs(ctx interface{}, req interface{}) *MockDataCoord_ReportDataNodeTtMsgs_Call { + return &MockDataCoord_ReportDataNodeTtMsgs_Call{Call: _e.mock.On("ReportDataNodeTtMsgs", ctx, req)} +} + +func (_c *MockDataCoord_ReportDataNodeTtMsgs_Call) Run(run func(ctx context.Context, req *datapb.ReportDataNodeTtMsgsRequest)) *MockDataCoord_ReportDataNodeTtMsgs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.ReportDataNodeTtMsgsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_ReportDataNodeTtMsgs_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_ReportDataNodeTtMsgs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_ReportDataNodeTtMsgs_Call) RunAndReturn(run func(context.Context, *datapb.ReportDataNodeTtMsgsRequest) (*commonpb.Status, error)) *MockDataCoord_ReportDataNodeTtMsgs_Call { + _c.Call.Return(run) + return _c +} + +// SaveBinlogPaths provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveBinlogPathsRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.SaveBinlogPathsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_SaveBinlogPaths_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveBinlogPaths' +type MockDataCoord_SaveBinlogPaths_Call struct { + *mock.Call +} + +// SaveBinlogPaths is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.SaveBinlogPathsRequest +func (_e *MockDataCoord_Expecter) SaveBinlogPaths(ctx interface{}, req interface{}) *MockDataCoord_SaveBinlogPaths_Call { + return &MockDataCoord_SaveBinlogPaths_Call{Call: _e.mock.On("SaveBinlogPaths", ctx, req)} +} + +func (_c *MockDataCoord_SaveBinlogPaths_Call) Run(run func(ctx context.Context, req *datapb.SaveBinlogPathsRequest)) *MockDataCoord_SaveBinlogPaths_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.SaveBinlogPathsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_SaveBinlogPaths_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_SaveBinlogPaths_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_SaveBinlogPaths_Call) RunAndReturn(run func(context.Context, *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error)) *MockDataCoord_SaveBinlogPaths_Call { + _c.Call.Return(run) + return _c +} + +// SaveImportSegment provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) SaveImportSegment(ctx context.Context, req *datapb.SaveImportSegmentRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveImportSegmentRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.SaveImportSegmentRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.SaveImportSegmentRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_SaveImportSegment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveImportSegment' +type MockDataCoord_SaveImportSegment_Call struct { + *mock.Call +} + +// SaveImportSegment is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.SaveImportSegmentRequest +func (_e *MockDataCoord_Expecter) SaveImportSegment(ctx interface{}, req interface{}) *MockDataCoord_SaveImportSegment_Call { + return &MockDataCoord_SaveImportSegment_Call{Call: _e.mock.On("SaveImportSegment", ctx, req)} +} + +func (_c *MockDataCoord_SaveImportSegment_Call) Run(run func(ctx context.Context, req *datapb.SaveImportSegmentRequest)) *MockDataCoord_SaveImportSegment_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.SaveImportSegmentRequest)) + }) + return _c +} + +func (_c *MockDataCoord_SaveImportSegment_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_SaveImportSegment_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_SaveImportSegment_Call) RunAndReturn(run func(context.Context, *datapb.SaveImportSegmentRequest) (*commonpb.Status, error)) *MockDataCoord_SaveImportSegment_Call { + _c.Call.Return(run) + return _c +} + +// SetAddress provides a mock function with given fields: address +func (_m *MockDataCoord) SetAddress(address string) { + _m.Called(address) +} + +// MockDataCoord_SetAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAddress' +type MockDataCoord_SetAddress_Call struct { + *mock.Call +} + +// SetAddress is a helper method to define mock.On call +// - address string +func (_e *MockDataCoord_Expecter) SetAddress(address interface{}) *MockDataCoord_SetAddress_Call { + return &MockDataCoord_SetAddress_Call{Call: _e.mock.On("SetAddress", address)} +} + +func (_c *MockDataCoord_SetAddress_Call) Run(run func(address string)) *MockDataCoord_SetAddress_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockDataCoord_SetAddress_Call) Return() *MockDataCoord_SetAddress_Call { + _c.Call.Return() + return _c +} + +func (_c *MockDataCoord_SetAddress_Call) RunAndReturn(run func(string)) *MockDataCoord_SetAddress_Call { + _c.Call.Return(run) + return _c +} + +// SetDataNodeCreator provides a mock function with given fields: _a0 +func (_m *MockDataCoord) SetDataNodeCreator(_a0 func(context.Context, string) (DataNode, error)) { + _m.Called(_a0) +} + +// MockDataCoord_SetDataNodeCreator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDataNodeCreator' +type MockDataCoord_SetDataNodeCreator_Call struct { + *mock.Call +} + +// SetDataNodeCreator is a helper method to define mock.On call +// - _a0 func(context.Context , string)(DataNode , error) +func (_e *MockDataCoord_Expecter) SetDataNodeCreator(_a0 interface{}) *MockDataCoord_SetDataNodeCreator_Call { + return &MockDataCoord_SetDataNodeCreator_Call{Call: _e.mock.On("SetDataNodeCreator", _a0)} +} + +func (_c *MockDataCoord_SetDataNodeCreator_Call) Run(run func(_a0 func(context.Context, string) (DataNode, error))) *MockDataCoord_SetDataNodeCreator_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, string) (DataNode, error))) + }) + return _c +} + +func (_c *MockDataCoord_SetDataNodeCreator_Call) Return() *MockDataCoord_SetDataNodeCreator_Call { + _c.Call.Return() + return _c +} + +func (_c *MockDataCoord_SetDataNodeCreator_Call) RunAndReturn(run func(func(context.Context, string) (DataNode, error))) *MockDataCoord_SetDataNodeCreator_Call { + _c.Call.Return(run) + return _c +} + +// SetEtcdClient provides a mock function with given fields: etcdClient +func (_m *MockDataCoord) SetEtcdClient(etcdClient *clientv3.Client) { + _m.Called(etcdClient) +} + +// MockDataCoord_SetEtcdClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEtcdClient' +type MockDataCoord_SetEtcdClient_Call struct { + *mock.Call +} + +// SetEtcdClient is a helper method to define mock.On call +// - etcdClient *clientv3.Client +func (_e *MockDataCoord_Expecter) SetEtcdClient(etcdClient interface{}) *MockDataCoord_SetEtcdClient_Call { + return &MockDataCoord_SetEtcdClient_Call{Call: _e.mock.On("SetEtcdClient", etcdClient)} +} + +func (_c *MockDataCoord_SetEtcdClient_Call) Run(run func(etcdClient *clientv3.Client)) *MockDataCoord_SetEtcdClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*clientv3.Client)) + }) + return _c +} + +func (_c *MockDataCoord_SetEtcdClient_Call) Return() *MockDataCoord_SetEtcdClient_Call { + _c.Call.Return() + return _c +} + +func (_c *MockDataCoord_SetEtcdClient_Call) RunAndReturn(run func(*clientv3.Client)) *MockDataCoord_SetEtcdClient_Call { + _c.Call.Return(run) + return _c +} + +// SetIndexNodeCreator provides a mock function with given fields: _a0 +func (_m *MockDataCoord) SetIndexNodeCreator(_a0 func(context.Context, string) (IndexNode, error)) { + _m.Called(_a0) +} + +// MockDataCoord_SetIndexNodeCreator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetIndexNodeCreator' +type MockDataCoord_SetIndexNodeCreator_Call struct { + *mock.Call +} + +// SetIndexNodeCreator is a helper method to define mock.On call +// - _a0 func(context.Context , string)(IndexNode , error) +func (_e *MockDataCoord_Expecter) SetIndexNodeCreator(_a0 interface{}) *MockDataCoord_SetIndexNodeCreator_Call { + return &MockDataCoord_SetIndexNodeCreator_Call{Call: _e.mock.On("SetIndexNodeCreator", _a0)} +} + +func (_c *MockDataCoord_SetIndexNodeCreator_Call) Run(run func(_a0 func(context.Context, string) (IndexNode, error))) *MockDataCoord_SetIndexNodeCreator_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, string) (IndexNode, error))) + }) + return _c +} + +func (_c *MockDataCoord_SetIndexNodeCreator_Call) Return() *MockDataCoord_SetIndexNodeCreator_Call { + _c.Call.Return() + return _c +} + +func (_c *MockDataCoord_SetIndexNodeCreator_Call) RunAndReturn(run func(func(context.Context, string) (IndexNode, error))) *MockDataCoord_SetIndexNodeCreator_Call { + _c.Call.Return(run) + return _c +} + +// SetRootCoord provides a mock function with given fields: rootCoord +func (_m *MockDataCoord) SetRootCoord(rootCoord RootCoord) { + _m.Called(rootCoord) +} + +// MockDataCoord_SetRootCoord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetRootCoord' +type MockDataCoord_SetRootCoord_Call struct { + *mock.Call +} + +// SetRootCoord is a helper method to define mock.On call +// - rootCoord RootCoord +func (_e *MockDataCoord_Expecter) SetRootCoord(rootCoord interface{}) *MockDataCoord_SetRootCoord_Call { + return &MockDataCoord_SetRootCoord_Call{Call: _e.mock.On("SetRootCoord", rootCoord)} +} + +func (_c *MockDataCoord_SetRootCoord_Call) Run(run func(rootCoord RootCoord)) *MockDataCoord_SetRootCoord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(RootCoord)) + }) + return _c +} + +func (_c *MockDataCoord_SetRootCoord_Call) Return() *MockDataCoord_SetRootCoord_Call { + _c.Call.Return() + return _c +} + +func (_c *MockDataCoord_SetRootCoord_Call) RunAndReturn(run func(RootCoord)) *MockDataCoord_SetRootCoord_Call { + _c.Call.Return(run) + return _c +} + +// SetSegmentState provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.SetSegmentStateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.SetSegmentStateRequest) *datapb.SetSegmentStateResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.SetSegmentStateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.SetSegmentStateRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_SetSegmentState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSegmentState' +type MockDataCoord_SetSegmentState_Call struct { + *mock.Call +} + +// SetSegmentState is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.SetSegmentStateRequest +func (_e *MockDataCoord_Expecter) SetSegmentState(ctx interface{}, req interface{}) *MockDataCoord_SetSegmentState_Call { + return &MockDataCoord_SetSegmentState_Call{Call: _e.mock.On("SetSegmentState", ctx, req)} +} + +func (_c *MockDataCoord_SetSegmentState_Call) Run(run func(ctx context.Context, req *datapb.SetSegmentStateRequest)) *MockDataCoord_SetSegmentState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.SetSegmentStateRequest)) + }) + return _c +} + +func (_c *MockDataCoord_SetSegmentState_Call) Return(_a0 *datapb.SetSegmentStateResponse, _a1 error) *MockDataCoord_SetSegmentState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_SetSegmentState_Call) RunAndReturn(run func(context.Context, *datapb.SetSegmentStateRequest) (*datapb.SetSegmentStateResponse, error)) *MockDataCoord_SetSegmentState_Call { + _c.Call.Return(run) + return _c +} + +// ShowConfigurations provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *internalpb.ShowConfigurationsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)); ok { + return rf(ctx, req) + } + 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) + } + } + + 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 +} + +// MockDataCoord_ShowConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowConfigurations' +type MockDataCoord_ShowConfigurations_Call struct { + *mock.Call +} + +// ShowConfigurations is a helper method to define mock.On call +// - ctx context.Context +// - req *internalpb.ShowConfigurationsRequest +func (_e *MockDataCoord_Expecter) ShowConfigurations(ctx interface{}, req interface{}) *MockDataCoord_ShowConfigurations_Call { + return &MockDataCoord_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", ctx, req)} +} + +func (_c *MockDataCoord_ShowConfigurations_Call) Run(run func(ctx context.Context, req *internalpb.ShowConfigurationsRequest)) *MockDataCoord_ShowConfigurations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*internalpb.ShowConfigurationsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_ShowConfigurations_Call) Return(_a0 *internalpb.ShowConfigurationsResponse, _a1 error) *MockDataCoord_ShowConfigurations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_ShowConfigurations_Call) RunAndReturn(run func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)) *MockDataCoord_ShowConfigurations_Call { + _c.Call.Return(run) + return _c +} + +// Start provides a mock function with given fields: +func (_m *MockDataCoord) 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 +} + +// MockDataCoord_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type MockDataCoord_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +func (_e *MockDataCoord_Expecter) Start() *MockDataCoord_Start_Call { + return &MockDataCoord_Start_Call{Call: _e.mock.On("Start")} +} + +func (_c *MockDataCoord_Start_Call) Run(run func()) *MockDataCoord_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDataCoord_Start_Call) Return(_a0 error) *MockDataCoord_Start_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDataCoord_Start_Call) RunAndReturn(run func() error) *MockDataCoord_Start_Call { + _c.Call.Return(run) + return _c +} + +// Stop provides a mock function with given fields: +func (_m *MockDataCoord) 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 +} + +// MockDataCoord_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type MockDataCoord_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *MockDataCoord_Expecter) Stop() *MockDataCoord_Stop_Call { + return &MockDataCoord_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *MockDataCoord_Stop_Call) Run(run func()) *MockDataCoord_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDataCoord_Stop_Call) Return(_a0 error) *MockDataCoord_Stop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDataCoord_Stop_Call) RunAndReturn(run func() error) *MockDataCoord_Stop_Call { + _c.Call.Return(run) + return _c +} + +// UnsetIsImportingState provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) UnsetIsImportingState(ctx context.Context, req *datapb.UnsetIsImportingStateRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.UnsetIsImportingStateRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.UnsetIsImportingStateRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.UnsetIsImportingStateRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_UnsetIsImportingState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnsetIsImportingState' +type MockDataCoord_UnsetIsImportingState_Call struct { + *mock.Call +} + +// UnsetIsImportingState is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.UnsetIsImportingStateRequest +func (_e *MockDataCoord_Expecter) UnsetIsImportingState(ctx interface{}, req interface{}) *MockDataCoord_UnsetIsImportingState_Call { + return &MockDataCoord_UnsetIsImportingState_Call{Call: _e.mock.On("UnsetIsImportingState", ctx, req)} +} + +func (_c *MockDataCoord_UnsetIsImportingState_Call) Run(run func(ctx context.Context, req *datapb.UnsetIsImportingStateRequest)) *MockDataCoord_UnsetIsImportingState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.UnsetIsImportingStateRequest)) + }) + return _c +} + +func (_c *MockDataCoord_UnsetIsImportingState_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_UnsetIsImportingState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_UnsetIsImportingState_Call) RunAndReturn(run func(context.Context, *datapb.UnsetIsImportingStateRequest) (*commonpb.Status, error)) *MockDataCoord_UnsetIsImportingState_Call { + _c.Call.Return(run) + return _c +} + +// UpdateChannelCheckpoint provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) UpdateChannelCheckpoint(ctx context.Context, req *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_UpdateChannelCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelCheckpoint' +type MockDataCoord_UpdateChannelCheckpoint_Call struct { + *mock.Call +} + +// UpdateChannelCheckpoint is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.UpdateChannelCheckpointRequest +func (_e *MockDataCoord_Expecter) UpdateChannelCheckpoint(ctx interface{}, req interface{}) *MockDataCoord_UpdateChannelCheckpoint_Call { + return &MockDataCoord_UpdateChannelCheckpoint_Call{Call: _e.mock.On("UpdateChannelCheckpoint", ctx, req)} +} + +func (_c *MockDataCoord_UpdateChannelCheckpoint_Call) Run(run func(ctx context.Context, req *datapb.UpdateChannelCheckpointRequest)) *MockDataCoord_UpdateChannelCheckpoint_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.UpdateChannelCheckpointRequest)) + }) + return _c +} + +func (_c *MockDataCoord_UpdateChannelCheckpoint_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_UpdateChannelCheckpoint_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_UpdateChannelCheckpoint_Call) RunAndReturn(run func(context.Context, *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error)) *MockDataCoord_UpdateChannelCheckpoint_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSegmentStatistics provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) UpdateSegmentStatistics(ctx context.Context, req *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error) { + ret := _m.Called(ctx, req) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) *commonpb.Status); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateSegmentStatisticsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_UpdateSegmentStatistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSegmentStatistics' +type MockDataCoord_UpdateSegmentStatistics_Call struct { + *mock.Call +} + +// UpdateSegmentStatistics is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.UpdateSegmentStatisticsRequest +func (_e *MockDataCoord_Expecter) UpdateSegmentStatistics(ctx interface{}, req interface{}) *MockDataCoord_UpdateSegmentStatistics_Call { + return &MockDataCoord_UpdateSegmentStatistics_Call{Call: _e.mock.On("UpdateSegmentStatistics", ctx, req)} +} + +func (_c *MockDataCoord_UpdateSegmentStatistics_Call) Run(run func(ctx context.Context, req *datapb.UpdateSegmentStatisticsRequest)) *MockDataCoord_UpdateSegmentStatistics_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.UpdateSegmentStatisticsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_UpdateSegmentStatistics_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataCoord_UpdateSegmentStatistics_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_UpdateSegmentStatistics_Call) RunAndReturn(run func(context.Context, *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error)) *MockDataCoord_UpdateSegmentStatistics_Call { + _c.Call.Return(run) + return _c +} + +// WatchChannels provides a mock function with given fields: ctx, req +func (_m *MockDataCoord) WatchChannels(ctx context.Context, req *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.WatchChannelsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.WatchChannelsRequest) *datapb.WatchChannelsResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.WatchChannelsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.WatchChannelsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataCoord_WatchChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchChannels' +type MockDataCoord_WatchChannels_Call struct { + *mock.Call +} + +// WatchChannels is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.WatchChannelsRequest +func (_e *MockDataCoord_Expecter) WatchChannels(ctx interface{}, req interface{}) *MockDataCoord_WatchChannels_Call { + return &MockDataCoord_WatchChannels_Call{Call: _e.mock.On("WatchChannels", ctx, req)} +} + +func (_c *MockDataCoord_WatchChannels_Call) Run(run func(ctx context.Context, req *datapb.WatchChannelsRequest)) *MockDataCoord_WatchChannels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.WatchChannelsRequest)) + }) + return _c +} + +func (_c *MockDataCoord_WatchChannels_Call) Return(_a0 *datapb.WatchChannelsResponse, _a1 error) *MockDataCoord_WatchChannels_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataCoord_WatchChannels_Call) RunAndReturn(run func(context.Context, *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error)) *MockDataCoord_WatchChannels_Call { + _c.Call.Return(run) + return _c +} + +type mockConstructorTestingTNewMockDataCoord interface { + mock.TestingT + Cleanup(func()) +} + +// NewMockDataCoord creates a new instance of MockDataCoord. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +func NewMockDataCoord(t mockConstructorTestingTNewMockDataCoord) *MockDataCoord { + mock := &MockDataCoord{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}