// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"github.com/aerospike/backup-go/pkg/asinfo"
	mock "github.com/stretchr/testify/mock"
)

// NewMockinfoCommander creates a new instance of MockinfoCommander. 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 NewMockinfoCommander(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockinfoCommander {
	mock := &MockinfoCommander{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockinfoCommander is an autogenerated mock type for the infoCommander type
type MockinfoCommander struct {
	mock.Mock
}

type MockinfoCommander_Expecter struct {
	mock *mock.Mock
}

func (_m *MockinfoCommander) EXPECT() *MockinfoCommander_Expecter {
	return &MockinfoCommander_Expecter{mock: &_m.Mock}
}

// BlockMRTWrites provides a mock function for the type MockinfoCommander
func (_mock *MockinfoCommander) BlockMRTWrites(nodeName string, namespace string) error {
	ret := _mock.Called(nodeName, namespace)

	if len(ret) == 0 {
		panic("no return value specified for BlockMRTWrites")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = returnFunc(nodeName, namespace)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockinfoCommander_BlockMRTWrites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockMRTWrites'
type MockinfoCommander_BlockMRTWrites_Call struct {
	*mock.Call
}

// BlockMRTWrites is a helper method to define mock.On call
//   - nodeName
//   - namespace
func (_e *MockinfoCommander_Expecter) BlockMRTWrites(nodeName interface{}, namespace interface{}) *MockinfoCommander_BlockMRTWrites_Call {
	return &MockinfoCommander_BlockMRTWrites_Call{Call: _e.mock.On("BlockMRTWrites", nodeName, namespace)}
}

func (_c *MockinfoCommander_BlockMRTWrites_Call) Run(run func(nodeName string, namespace string)) *MockinfoCommander_BlockMRTWrites_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockinfoCommander_BlockMRTWrites_Call) Return(err error) *MockinfoCommander_BlockMRTWrites_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockinfoCommander_BlockMRTWrites_Call) RunAndReturn(run func(nodeName string, namespace string) error) *MockinfoCommander_BlockMRTWrites_Call {
	_c.Call.Return(run)
	return _c
}

// GetNodesNames provides a mock function for the type MockinfoCommander
func (_mock *MockinfoCommander) GetNodesNames() []string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetNodesNames")
	}

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

// MockinfoCommander_GetNodesNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodesNames'
type MockinfoCommander_GetNodesNames_Call struct {
	*mock.Call
}

// GetNodesNames is a helper method to define mock.On call
func (_e *MockinfoCommander_Expecter) GetNodesNames() *MockinfoCommander_GetNodesNames_Call {
	return &MockinfoCommander_GetNodesNames_Call{Call: _e.mock.On("GetNodesNames")}
}

func (_c *MockinfoCommander_GetNodesNames_Call) Run(run func()) *MockinfoCommander_GetNodesNames_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockinfoCommander_GetNodesNames_Call) Return(strings []string) *MockinfoCommander_GetNodesNames_Call {
	_c.Call.Return(strings)
	return _c
}

func (_c *MockinfoCommander_GetNodesNames_Call) RunAndReturn(run func() []string) *MockinfoCommander_GetNodesNames_Call {
	_c.Call.Return(run)
	return _c
}

// GetStats provides a mock function for the type MockinfoCommander
func (_mock *MockinfoCommander) GetStats(nodeName string, dc string, namespace string) (asinfo.Stats, error) {
	ret := _mock.Called(nodeName, dc, namespace)

	if len(ret) == 0 {
		panic("no return value specified for GetStats")
	}

	var r0 asinfo.Stats
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, string, string) (asinfo.Stats, error)); ok {
		return returnFunc(nodeName, dc, namespace)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, string) asinfo.Stats); ok {
		r0 = returnFunc(nodeName, dc, namespace)
	} else {
		r0 = ret.Get(0).(asinfo.Stats)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, string) error); ok {
		r1 = returnFunc(nodeName, dc, namespace)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockinfoCommander_GetStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStats'
type MockinfoCommander_GetStats_Call struct {
	*mock.Call
}

// GetStats is a helper method to define mock.On call
//   - nodeName
//   - dc
//   - namespace
func (_e *MockinfoCommander_Expecter) GetStats(nodeName interface{}, dc interface{}, namespace interface{}) *MockinfoCommander_GetStats_Call {
	return &MockinfoCommander_GetStats_Call{Call: _e.mock.On("GetStats", nodeName, dc, namespace)}
}

func (_c *MockinfoCommander_GetStats_Call) Run(run func(nodeName string, dc string, namespace string)) *MockinfoCommander_GetStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockinfoCommander_GetStats_Call) Return(stats asinfo.Stats, err error) *MockinfoCommander_GetStats_Call {
	_c.Call.Return(stats, err)
	return _c
}

func (_c *MockinfoCommander_GetStats_Call) RunAndReturn(run func(nodeName string, dc string, namespace string) (asinfo.Stats, error)) *MockinfoCommander_GetStats_Call {
	_c.Call.Return(run)
	return _c
}

// StartXDR provides a mock function for the type MockinfoCommander
func (_mock *MockinfoCommander) StartXDR(nodeName string, dc string, hostPort string, namespace string, rewind string, throughput int, forward bool) error {
	ret := _mock.Called(nodeName, dc, hostPort, namespace, rewind, throughput, forward)

	if len(ret) == 0 {
		panic("no return value specified for StartXDR")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string, string, string, string, int, bool) error); ok {
		r0 = returnFunc(nodeName, dc, hostPort, namespace, rewind, throughput, forward)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockinfoCommander_StartXDR_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartXDR'
type MockinfoCommander_StartXDR_Call struct {
	*mock.Call
}

// StartXDR is a helper method to define mock.On call
//   - nodeName
//   - dc
//   - hostPort
//   - namespace
//   - rewind
//   - throughput
//   - forward
func (_e *MockinfoCommander_Expecter) StartXDR(nodeName interface{}, dc interface{}, hostPort interface{}, namespace interface{}, rewind interface{}, throughput interface{}, forward interface{}) *MockinfoCommander_StartXDR_Call {
	return &MockinfoCommander_StartXDR_Call{Call: _e.mock.On("StartXDR", nodeName, dc, hostPort, namespace, rewind, throughput, forward)}
}

func (_c *MockinfoCommander_StartXDR_Call) Run(run func(nodeName string, dc string, hostPort string, namespace string, rewind string, throughput int, forward bool)) *MockinfoCommander_StartXDR_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(int), args[6].(bool))
	})
	return _c
}

func (_c *MockinfoCommander_StartXDR_Call) Return(err error) *MockinfoCommander_StartXDR_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockinfoCommander_StartXDR_Call) RunAndReturn(run func(nodeName string, dc string, hostPort string, namespace string, rewind string, throughput int, forward bool) error) *MockinfoCommander_StartXDR_Call {
	_c.Call.Return(run)
	return _c
}

// StopXDR provides a mock function for the type MockinfoCommander
func (_mock *MockinfoCommander) StopXDR(nodeName string, dc string) error {
	ret := _mock.Called(nodeName, dc)

	if len(ret) == 0 {
		panic("no return value specified for StopXDR")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = returnFunc(nodeName, dc)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockinfoCommander_StopXDR_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopXDR'
type MockinfoCommander_StopXDR_Call struct {
	*mock.Call
}

// StopXDR is a helper method to define mock.On call
//   - nodeName
//   - dc
func (_e *MockinfoCommander_Expecter) StopXDR(nodeName interface{}, dc interface{}) *MockinfoCommander_StopXDR_Call {
	return &MockinfoCommander_StopXDR_Call{Call: _e.mock.On("StopXDR", nodeName, dc)}
}

func (_c *MockinfoCommander_StopXDR_Call) Run(run func(nodeName string, dc string)) *MockinfoCommander_StopXDR_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockinfoCommander_StopXDR_Call) Return(err error) *MockinfoCommander_StopXDR_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockinfoCommander_StopXDR_Call) RunAndReturn(run func(nodeName string, dc string) error) *MockinfoCommander_StopXDR_Call {
	_c.Call.Return(run)
	return _c
}

// UnBlockMRTWrites provides a mock function for the type MockinfoCommander
func (_mock *MockinfoCommander) UnBlockMRTWrites(nodeName string, namespace string) error {
	ret := _mock.Called(nodeName, namespace)

	if len(ret) == 0 {
		panic("no return value specified for UnBlockMRTWrites")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = returnFunc(nodeName, namespace)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockinfoCommander_UnBlockMRTWrites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnBlockMRTWrites'
type MockinfoCommander_UnBlockMRTWrites_Call struct {
	*mock.Call
}

// UnBlockMRTWrites is a helper method to define mock.On call
//   - nodeName
//   - namespace
func (_e *MockinfoCommander_Expecter) UnBlockMRTWrites(nodeName interface{}, namespace interface{}) *MockinfoCommander_UnBlockMRTWrites_Call {
	return &MockinfoCommander_UnBlockMRTWrites_Call{Call: _e.mock.On("UnBlockMRTWrites", nodeName, namespace)}
}

func (_c *MockinfoCommander_UnBlockMRTWrites_Call) Run(run func(nodeName string, namespace string)) *MockinfoCommander_UnBlockMRTWrites_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockinfoCommander_UnBlockMRTWrites_Call) Return(err error) *MockinfoCommander_UnBlockMRTWrites_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockinfoCommander_UnBlockMRTWrites_Call) RunAndReturn(run func(nodeName string, namespace string) error) *MockinfoCommander_UnBlockMRTWrites_Call {
	_c.Call.Return(run)
	return _c
}
