mirror of
https://gitee.com/milvus-io/milvus.git
synced 2025-12-06 17:18:35 +08:00
78010262f0
issue: https://github.com/milvus-io/milvus/issues/41690 - Merge leader view and channel management into ChannelDistManager, allowing a channel to have multiple delegators. - Improve shard leader switching to ensure a single replica only has one shard leader per channel. The shard leader handles all resource loading and query requests. - Refine the serviceable mechanism: after QC completes loading, sync the query view to the delegator. The delegator then determines its serviceable status based on the query view. - When a delegator encounters forwarding query or deletion failures, mark the corresponding segment as offline and transition it to an unserviceable state. Signed-off-by: Wei Liu <wei.liu@zilliz.com>
1036 lines
27 KiB
Go
1036 lines
27 KiB
Go
// Code generated by mockery v2.46.0. DO NOT EDIT.
|
|
|
|
package meta
|
|
|
|
import mock "github.com/stretchr/testify/mock"
|
|
|
|
// MockReplica is an autogenerated mock type for the ReplicaInterface type
|
|
type MockReplica struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockReplica_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockReplica) EXPECT() *MockReplica_Expecter {
|
|
return &MockReplica_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// ContainRONode provides a mock function with given fields: node
|
|
func (_m *MockReplica) ContainRONode(node int64) bool {
|
|
ret := _m.Called(node)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ContainRONode")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64) bool); ok {
|
|
r0 = rf(node)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_ContainRONode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainRONode'
|
|
type MockReplica_ContainRONode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ContainRONode is a helper method to define mock.On call
|
|
// - node int64
|
|
func (_e *MockReplica_Expecter) ContainRONode(node interface{}) *MockReplica_ContainRONode_Call {
|
|
return &MockReplica_ContainRONode_Call{Call: _e.mock.On("ContainRONode", node)}
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRONode_Call) Run(run func(node int64)) *MockReplica_ContainRONode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRONode_Call) Return(_a0 bool) *MockReplica_ContainRONode_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRONode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainRONode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ContainROSQNode provides a mock function with given fields: node
|
|
func (_m *MockReplica) ContainROSQNode(node int64) bool {
|
|
ret := _m.Called(node)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ContainROSQNode")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64) bool); ok {
|
|
r0 = rf(node)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_ContainROSQNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainROSQNode'
|
|
type MockReplica_ContainROSQNode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ContainROSQNode is a helper method to define mock.On call
|
|
// - node int64
|
|
func (_e *MockReplica_Expecter) ContainROSQNode(node interface{}) *MockReplica_ContainROSQNode_Call {
|
|
return &MockReplica_ContainROSQNode_Call{Call: _e.mock.On("ContainROSQNode", node)}
|
|
}
|
|
|
|
func (_c *MockReplica_ContainROSQNode_Call) Run(run func(node int64)) *MockReplica_ContainROSQNode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainROSQNode_Call) Return(_a0 bool) *MockReplica_ContainROSQNode_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainROSQNode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainROSQNode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ContainRWNode provides a mock function with given fields: node
|
|
func (_m *MockReplica) ContainRWNode(node int64) bool {
|
|
ret := _m.Called(node)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ContainRWNode")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64) bool); ok {
|
|
r0 = rf(node)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_ContainRWNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainRWNode'
|
|
type MockReplica_ContainRWNode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ContainRWNode is a helper method to define mock.On call
|
|
// - node int64
|
|
func (_e *MockReplica_Expecter) ContainRWNode(node interface{}) *MockReplica_ContainRWNode_Call {
|
|
return &MockReplica_ContainRWNode_Call{Call: _e.mock.On("ContainRWNode", node)}
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRWNode_Call) Run(run func(node int64)) *MockReplica_ContainRWNode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRWNode_Call) Return(_a0 bool) *MockReplica_ContainRWNode_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRWNode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainRWNode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ContainRWSQNode provides a mock function with given fields: node
|
|
func (_m *MockReplica) ContainRWSQNode(node int64) bool {
|
|
ret := _m.Called(node)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ContainRWSQNode")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64) bool); ok {
|
|
r0 = rf(node)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_ContainRWSQNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainRWSQNode'
|
|
type MockReplica_ContainRWSQNode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ContainRWSQNode is a helper method to define mock.On call
|
|
// - node int64
|
|
func (_e *MockReplica_Expecter) ContainRWSQNode(node interface{}) *MockReplica_ContainRWSQNode_Call {
|
|
return &MockReplica_ContainRWSQNode_Call{Call: _e.mock.On("ContainRWSQNode", node)}
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRWSQNode_Call) Run(run func(node int64)) *MockReplica_ContainRWSQNode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRWSQNode_Call) Return(_a0 bool) *MockReplica_ContainRWSQNode_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainRWSQNode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainRWSQNode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ContainSQNode provides a mock function with given fields: node
|
|
func (_m *MockReplica) ContainSQNode(node int64) bool {
|
|
ret := _m.Called(node)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ContainSQNode")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64) bool); ok {
|
|
r0 = rf(node)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_ContainSQNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainSQNode'
|
|
type MockReplica_ContainSQNode_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ContainSQNode is a helper method to define mock.On call
|
|
// - node int64
|
|
func (_e *MockReplica_Expecter) ContainSQNode(node interface{}) *MockReplica_ContainSQNode_Call {
|
|
return &MockReplica_ContainSQNode_Call{Call: _e.mock.On("ContainSQNode", node)}
|
|
}
|
|
|
|
func (_c *MockReplica_ContainSQNode_Call) Run(run func(node int64)) *MockReplica_ContainSQNode_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainSQNode_Call) Return(_a0 bool) *MockReplica_ContainSQNode_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ContainSQNode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainSQNode_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Contains provides a mock function with given fields: node
|
|
func (_m *MockReplica) Contains(node int64) bool {
|
|
ret := _m.Called(node)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Contains")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64) bool); ok {
|
|
r0 = rf(node)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_Contains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Contains'
|
|
type MockReplica_Contains_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Contains is a helper method to define mock.On call
|
|
// - node int64
|
|
func (_e *MockReplica_Expecter) Contains(node interface{}) *MockReplica_Contains_Call {
|
|
return &MockReplica_Contains_Call{Call: _e.mock.On("Contains", node)}
|
|
}
|
|
|
|
func (_c *MockReplica_Contains_Call) Run(run func(node int64)) *MockReplica_Contains_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_Contains_Call) Return(_a0 bool) *MockReplica_Contains_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_Contains_Call) RunAndReturn(run func(int64) bool) *MockReplica_Contains_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCollectionID provides a mock function with given fields:
|
|
func (_m *MockReplica) GetCollectionID() int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCollectionID")
|
|
}
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_GetCollectionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCollectionID'
|
|
type MockReplica_GetCollectionID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCollectionID is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) GetCollectionID() *MockReplica_GetCollectionID_Call {
|
|
return &MockReplica_GetCollectionID_Call{Call: _e.mock.On("GetCollectionID")}
|
|
}
|
|
|
|
func (_c *MockReplica_GetCollectionID_Call) Run(run func()) *MockReplica_GetCollectionID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetCollectionID_Call) Return(_a0 int64) *MockReplica_GetCollectionID_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetCollectionID_Call) RunAndReturn(run func() int64) *MockReplica_GetCollectionID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetID provides a mock function with given fields:
|
|
func (_m *MockReplica) GetID() int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetID")
|
|
}
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_GetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetID'
|
|
type MockReplica_GetID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetID is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) GetID() *MockReplica_GetID_Call {
|
|
return &MockReplica_GetID_Call{Call: _e.mock.On("GetID")}
|
|
}
|
|
|
|
func (_c *MockReplica_GetID_Call) Run(run func()) *MockReplica_GetID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetID_Call) Return(_a0 int64) *MockReplica_GetID_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetID_Call) RunAndReturn(run func() int64) *MockReplica_GetID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetNodes provides a mock function with given fields:
|
|
func (_m *MockReplica) GetNodes() []int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetNodes")
|
|
}
|
|
|
|
var r0 []int64
|
|
if rf, ok := ret.Get(0).(func() []int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]int64)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_GetNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodes'
|
|
type MockReplica_GetNodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetNodes is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) GetNodes() *MockReplica_GetNodes_Call {
|
|
return &MockReplica_GetNodes_Call{Call: _e.mock.On("GetNodes")}
|
|
}
|
|
|
|
func (_c *MockReplica_GetNodes_Call) Run(run func()) *MockReplica_GetNodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetNodes_Call) Return(_a0 []int64) *MockReplica_GetNodes_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetNodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetNodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRONodes provides a mock function with given fields:
|
|
func (_m *MockReplica) GetRONodes() []int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRONodes")
|
|
}
|
|
|
|
var r0 []int64
|
|
if rf, ok := ret.Get(0).(func() []int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]int64)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_GetRONodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRONodes'
|
|
type MockReplica_GetRONodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRONodes is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) GetRONodes() *MockReplica_GetRONodes_Call {
|
|
return &MockReplica_GetRONodes_Call{Call: _e.mock.On("GetRONodes")}
|
|
}
|
|
|
|
func (_c *MockReplica_GetRONodes_Call) Run(run func()) *MockReplica_GetRONodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetRONodes_Call) Return(_a0 []int64) *MockReplica_GetRONodes_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetRONodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetRONodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetROSQNodes provides a mock function with given fields:
|
|
func (_m *MockReplica) GetROSQNodes() []int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetROSQNodes")
|
|
}
|
|
|
|
var r0 []int64
|
|
if rf, ok := ret.Get(0).(func() []int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]int64)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_GetROSQNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetROSQNodes'
|
|
type MockReplica_GetROSQNodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetROSQNodes is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) GetROSQNodes() *MockReplica_GetROSQNodes_Call {
|
|
return &MockReplica_GetROSQNodes_Call{Call: _e.mock.On("GetROSQNodes")}
|
|
}
|
|
|
|
func (_c *MockReplica_GetROSQNodes_Call) Run(run func()) *MockReplica_GetROSQNodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetROSQNodes_Call) Return(_a0 []int64) *MockReplica_GetROSQNodes_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetROSQNodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetROSQNodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRWNodes provides a mock function with given fields:
|
|
func (_m *MockReplica) GetRWNodes() []int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRWNodes")
|
|
}
|
|
|
|
var r0 []int64
|
|
if rf, ok := ret.Get(0).(func() []int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]int64)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_GetRWNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRWNodes'
|
|
type MockReplica_GetRWNodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRWNodes is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) GetRWNodes() *MockReplica_GetRWNodes_Call {
|
|
return &MockReplica_GetRWNodes_Call{Call: _e.mock.On("GetRWNodes")}
|
|
}
|
|
|
|
func (_c *MockReplica_GetRWNodes_Call) Run(run func()) *MockReplica_GetRWNodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetRWNodes_Call) Return(_a0 []int64) *MockReplica_GetRWNodes_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetRWNodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetRWNodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRWSQNodes provides a mock function with given fields:
|
|
func (_m *MockReplica) GetRWSQNodes() []int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRWSQNodes")
|
|
}
|
|
|
|
var r0 []int64
|
|
if rf, ok := ret.Get(0).(func() []int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]int64)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_GetRWSQNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRWSQNodes'
|
|
type MockReplica_GetRWSQNodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRWSQNodes is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) GetRWSQNodes() *MockReplica_GetRWSQNodes_Call {
|
|
return &MockReplica_GetRWSQNodes_Call{Call: _e.mock.On("GetRWSQNodes")}
|
|
}
|
|
|
|
func (_c *MockReplica_GetRWSQNodes_Call) Run(run func()) *MockReplica_GetRWSQNodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetRWSQNodes_Call) Return(_a0 []int64) *MockReplica_GetRWSQNodes_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetRWSQNodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetRWSQNodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetResourceGroup provides a mock function with given fields:
|
|
func (_m *MockReplica) GetResourceGroup() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetResourceGroup")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_GetResourceGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResourceGroup'
|
|
type MockReplica_GetResourceGroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetResourceGroup is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) GetResourceGroup() *MockReplica_GetResourceGroup_Call {
|
|
return &MockReplica_GetResourceGroup_Call{Call: _e.mock.On("GetResourceGroup")}
|
|
}
|
|
|
|
func (_c *MockReplica_GetResourceGroup_Call) Run(run func()) *MockReplica_GetResourceGroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetResourceGroup_Call) Return(_a0 string) *MockReplica_GetResourceGroup_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_GetResourceGroup_Call) RunAndReturn(run func() string) *MockReplica_GetResourceGroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NodesCount provides a mock function with given fields:
|
|
func (_m *MockReplica) NodesCount() int {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for NodesCount")
|
|
}
|
|
|
|
var r0 int
|
|
if rf, ok := ret.Get(0).(func() int); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_NodesCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodesCount'
|
|
type MockReplica_NodesCount_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// NodesCount is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) NodesCount() *MockReplica_NodesCount_Call {
|
|
return &MockReplica_NodesCount_Call{Call: _e.mock.On("NodesCount")}
|
|
}
|
|
|
|
func (_c *MockReplica_NodesCount_Call) Run(run func()) *MockReplica_NodesCount_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_NodesCount_Call) Return(_a0 int) *MockReplica_NodesCount_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_NodesCount_Call) RunAndReturn(run func() int) *MockReplica_NodesCount_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RONodesCount provides a mock function with given fields:
|
|
func (_m *MockReplica) RONodesCount() int {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RONodesCount")
|
|
}
|
|
|
|
var r0 int
|
|
if rf, ok := ret.Get(0).(func() int); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_RONodesCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RONodesCount'
|
|
type MockReplica_RONodesCount_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RONodesCount is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) RONodesCount() *MockReplica_RONodesCount_Call {
|
|
return &MockReplica_RONodesCount_Call{Call: _e.mock.On("RONodesCount")}
|
|
}
|
|
|
|
func (_c *MockReplica_RONodesCount_Call) Run(run func()) *MockReplica_RONodesCount_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RONodesCount_Call) Return(_a0 int) *MockReplica_RONodesCount_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RONodesCount_Call) RunAndReturn(run func() int) *MockReplica_RONodesCount_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ROSQNodesCount provides a mock function with given fields:
|
|
func (_m *MockReplica) ROSQNodesCount() int {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ROSQNodesCount")
|
|
}
|
|
|
|
var r0 int
|
|
if rf, ok := ret.Get(0).(func() int); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_ROSQNodesCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ROSQNodesCount'
|
|
type MockReplica_ROSQNodesCount_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ROSQNodesCount is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) ROSQNodesCount() *MockReplica_ROSQNodesCount_Call {
|
|
return &MockReplica_ROSQNodesCount_Call{Call: _e.mock.On("ROSQNodesCount")}
|
|
}
|
|
|
|
func (_c *MockReplica_ROSQNodesCount_Call) Run(run func()) *MockReplica_ROSQNodesCount_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ROSQNodesCount_Call) Return(_a0 int) *MockReplica_ROSQNodesCount_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_ROSQNodesCount_Call) RunAndReturn(run func() int) *MockReplica_ROSQNodesCount_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RWNodesCount provides a mock function with given fields:
|
|
func (_m *MockReplica) RWNodesCount() int {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RWNodesCount")
|
|
}
|
|
|
|
var r0 int
|
|
if rf, ok := ret.Get(0).(func() int); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_RWNodesCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RWNodesCount'
|
|
type MockReplica_RWNodesCount_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RWNodesCount is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) RWNodesCount() *MockReplica_RWNodesCount_Call {
|
|
return &MockReplica_RWNodesCount_Call{Call: _e.mock.On("RWNodesCount")}
|
|
}
|
|
|
|
func (_c *MockReplica_RWNodesCount_Call) Run(run func()) *MockReplica_RWNodesCount_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RWNodesCount_Call) Return(_a0 int) *MockReplica_RWNodesCount_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RWNodesCount_Call) RunAndReturn(run func() int) *MockReplica_RWNodesCount_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RWSQNodesCount provides a mock function with given fields:
|
|
func (_m *MockReplica) RWSQNodesCount() int {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RWSQNodesCount")
|
|
}
|
|
|
|
var r0 int
|
|
if rf, ok := ret.Get(0).(func() int); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockReplica_RWSQNodesCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RWSQNodesCount'
|
|
type MockReplica_RWSQNodesCount_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RWSQNodesCount is a helper method to define mock.On call
|
|
func (_e *MockReplica_Expecter) RWSQNodesCount() *MockReplica_RWSQNodesCount_Call {
|
|
return &MockReplica_RWSQNodesCount_Call{Call: _e.mock.On("RWSQNodesCount")}
|
|
}
|
|
|
|
func (_c *MockReplica_RWSQNodesCount_Call) Run(run func()) *MockReplica_RWSQNodesCount_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RWSQNodesCount_Call) Return(_a0 int) *MockReplica_RWSQNodesCount_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RWSQNodesCount_Call) RunAndReturn(run func() int) *MockReplica_RWSQNodesCount_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RangeOverRONodes provides a mock function with given fields: f
|
|
func (_m *MockReplica) RangeOverRONodes(f func(int64) bool) {
|
|
_m.Called(f)
|
|
}
|
|
|
|
// MockReplica_RangeOverRONodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RangeOverRONodes'
|
|
type MockReplica_RangeOverRONodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RangeOverRONodes is a helper method to define mock.On call
|
|
// - f func(int64) bool
|
|
func (_e *MockReplica_Expecter) RangeOverRONodes(f interface{}) *MockReplica_RangeOverRONodes_Call {
|
|
return &MockReplica_RangeOverRONodes_Call{Call: _e.mock.On("RangeOverRONodes", f)}
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRONodes_Call) Run(run func(f func(int64) bool)) *MockReplica_RangeOverRONodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(func(int64) bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRONodes_Call) Return() *MockReplica_RangeOverRONodes_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRONodes_Call) RunAndReturn(run func(func(int64) bool)) *MockReplica_RangeOverRONodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RangeOverROSQNodes provides a mock function with given fields: f
|
|
func (_m *MockReplica) RangeOverROSQNodes(f func(int64) bool) {
|
|
_m.Called(f)
|
|
}
|
|
|
|
// MockReplica_RangeOverROSQNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RangeOverROSQNodes'
|
|
type MockReplica_RangeOverROSQNodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RangeOverROSQNodes is a helper method to define mock.On call
|
|
// - f func(int64) bool
|
|
func (_e *MockReplica_Expecter) RangeOverROSQNodes(f interface{}) *MockReplica_RangeOverROSQNodes_Call {
|
|
return &MockReplica_RangeOverROSQNodes_Call{Call: _e.mock.On("RangeOverROSQNodes", f)}
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverROSQNodes_Call) Run(run func(f func(int64) bool)) *MockReplica_RangeOverROSQNodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(func(int64) bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverROSQNodes_Call) Return() *MockReplica_RangeOverROSQNodes_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverROSQNodes_Call) RunAndReturn(run func(func(int64) bool)) *MockReplica_RangeOverROSQNodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RangeOverRWNodes provides a mock function with given fields: f
|
|
func (_m *MockReplica) RangeOverRWNodes(f func(int64) bool) {
|
|
_m.Called(f)
|
|
}
|
|
|
|
// MockReplica_RangeOverRWNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RangeOverRWNodes'
|
|
type MockReplica_RangeOverRWNodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RangeOverRWNodes is a helper method to define mock.On call
|
|
// - f func(int64) bool
|
|
func (_e *MockReplica_Expecter) RangeOverRWNodes(f interface{}) *MockReplica_RangeOverRWNodes_Call {
|
|
return &MockReplica_RangeOverRWNodes_Call{Call: _e.mock.On("RangeOverRWNodes", f)}
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRWNodes_Call) Run(run func(f func(int64) bool)) *MockReplica_RangeOverRWNodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(func(int64) bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRWNodes_Call) Return() *MockReplica_RangeOverRWNodes_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRWNodes_Call) RunAndReturn(run func(func(int64) bool)) *MockReplica_RangeOverRWNodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RangeOverRWSQNodes provides a mock function with given fields: f
|
|
func (_m *MockReplica) RangeOverRWSQNodes(f func(int64) bool) {
|
|
_m.Called(f)
|
|
}
|
|
|
|
// MockReplica_RangeOverRWSQNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RangeOverRWSQNodes'
|
|
type MockReplica_RangeOverRWSQNodes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RangeOverRWSQNodes is a helper method to define mock.On call
|
|
// - f func(int64) bool
|
|
func (_e *MockReplica_Expecter) RangeOverRWSQNodes(f interface{}) *MockReplica_RangeOverRWSQNodes_Call {
|
|
return &MockReplica_RangeOverRWSQNodes_Call{Call: _e.mock.On("RangeOverRWSQNodes", f)}
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRWSQNodes_Call) Run(run func(f func(int64) bool)) *MockReplica_RangeOverRWSQNodes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(func(int64) bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRWSQNodes_Call) Return() *MockReplica_RangeOverRWSQNodes_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockReplica_RangeOverRWSQNodes_Call) RunAndReturn(run func(func(int64) bool)) *MockReplica_RangeOverRWSQNodes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockReplica creates a new instance of MockReplica. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockReplica(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockReplica {
|
|
mock := &MockReplica{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|