spec.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: spec.go

// Package glcm is a generated GoMock package.
package glcm

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockHook is a mock of Hook interface.
type MockHook struct {
	ctrl     *gomock.Controller
	recorder *MockHookMockRecorder
}

// MockHookMockRecorder is the mock recorder for MockHook.
type MockHookMockRecorder struct {
	mock *MockHook
}

// NewMockHook creates a new mock instance.
func NewMockHook(ctrl *gomock.Controller) *MockHook {
	mock := &MockHook{ctrl: ctrl}
	mock.recorder = &MockHookMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockHook) EXPECT() *MockHookMockRecorder {
	return m.recorder
}

// Execute mocks base method.
func (m *MockHook) Execute() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Execute")
	ret0, _ := ret[0].(error)
	return ret0
}

// Execute indicates an expected call of Execute.
func (mr *MockHookMockRecorder) Execute() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockHook)(nil).Execute))
}

// Name mocks base method.
func (m *MockHook) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockHookMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockHook)(nil).Name))
}

// MockService is a mock of Service interface.
type MockService struct {
	ctrl     *gomock.Controller
	recorder *MockServiceMockRecorder
}

// MockServiceMockRecorder is the mock recorder for MockService.
type MockServiceMockRecorder struct {
	mock *MockService
}

// NewMockService creates a new mock instance.
func NewMockService(ctrl *gomock.Controller) *MockService {
	mock := &MockService{ctrl: ctrl}
	mock.recorder = &MockServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockService) EXPECT() *MockServiceMockRecorder {
	return m.recorder
}

// Name mocks base method.
func (m *MockService) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockServiceMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockService)(nil).Name))
}

// Start mocks base method.
func (m *MockService) Start(arg0 Terminator) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start", arg0)
}

// Start indicates an expected call of Start.
func (mr *MockServiceMockRecorder) Start(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockService)(nil).Start), arg0)
}

// Status mocks base method.
func (m *MockService) Status() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status")
	ret0, _ := ret[0].(string)
	return ret0
}

// Status indicates an expected call of Status.
func (mr *MockServiceMockRecorder) Status() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockService)(nil).Status))
}

// MockTerminator is a mock of Terminator interface.
type MockTerminator struct {
	ctrl     *gomock.Controller
	recorder *MockTerminatorMockRecorder
}

// MockTerminatorMockRecorder is the mock recorder for MockTerminator.
type MockTerminatorMockRecorder struct {
	mock *MockTerminator
}

// NewMockTerminator creates a new mock instance.
func NewMockTerminator(ctrl *gomock.Controller) *MockTerminator {
	mock := &MockTerminator{ctrl: ctrl}
	mock.recorder = &MockTerminatorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTerminator) EXPECT() *MockTerminatorMockRecorder {
	return m.recorder
}

// TermCh mocks base method.
func (m *MockTerminator) TermCh() chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TermCh")
	ret0, _ := ret[0].(chan struct{})
	return ret0
}

// TermCh indicates an expected call of TermCh.
func (mr *MockTerminatorMockRecorder) TermCh() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TermCh", reflect.TypeOf((*MockTerminator)(nil).TermCh))
}

// MockRunner is a mock of Runner interface.
type MockRunner struct {
	ctrl     *gomock.Controller
	recorder *MockRunnerMockRecorder
}

// MockRunnerMockRecorder is the mock recorder for MockRunner.
type MockRunnerMockRecorder struct {
	mock *MockRunner
}

// NewMockRunner creates a new mock instance.
func NewMockRunner(ctrl *gomock.Controller) *MockRunner {
	mock := &MockRunner{ctrl: ctrl}
	mock.recorder = &MockRunnerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRunner) EXPECT() *MockRunnerMockRecorder {
	return m.recorder
}

// BootUp mocks base method.
func (m *MockRunner) BootUp() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BootUp")
	ret0, _ := ret[0].(error)
	return ret0
}

// BootUp indicates an expected call of BootUp.
func (mr *MockRunnerMockRecorder) BootUp() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BootUp", reflect.TypeOf((*MockRunner)(nil).BootUp))
}

// IsRunning mocks base method.
func (m *MockRunner) IsRunning() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsRunning")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsRunning indicates an expected call of IsRunning.
func (mr *MockRunnerMockRecorder) IsRunning() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsRunning", reflect.TypeOf((*MockRunner)(nil).IsRunning))
}

// RegisterService mocks base method.
func (m *MockRunner) RegisterService(arg0 Service, arg1 ServiceOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterService", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterService indicates an expected call of RegisterService.
func (mr *MockRunnerMockRecorder) RegisterService(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterService", reflect.TypeOf((*MockRunner)(nil).RegisterService), arg0, arg1)
}

// RestartAllServices mocks base method.
func (m *MockRunner) RestartAllServices() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RestartAllServices")
}

// RestartAllServices indicates an expected call of RestartAllServices.
func (mr *MockRunnerMockRecorder) RestartAllServices() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestartAllServices", reflect.TypeOf((*MockRunner)(nil).RestartAllServices))
}

// RestartService mocks base method.
func (m *MockRunner) RestartService(arg0 ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestartService", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RestartService indicates an expected call of RestartService.
func (mr *MockRunnerMockRecorder) RestartService(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestartService", reflect.TypeOf((*MockRunner)(nil).RestartService), arg0...)
}

// Shutdown mocks base method.
func (m *MockRunner) Shutdown() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Shutdown")
}

// Shutdown indicates an expected call of Shutdown.
func (mr *MockRunnerMockRecorder) Shutdown() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockRunner)(nil).Shutdown))
}

// StopAllServices mocks base method.
func (m *MockRunner) StopAllServices() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StopAllServices")
}

// StopAllServices indicates an expected call of StopAllServices.
func (mr *MockRunnerMockRecorder) StopAllServices() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAllServices", reflect.TypeOf((*MockRunner)(nil).StopAllServices))
}

// StopService mocks base method.
func (m *MockRunner) StopService(arg0 ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopService", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// StopService indicates an expected call of StopService.
func (mr *MockRunnerMockRecorder) StopService(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopService", reflect.TypeOf((*MockRunner)(nil).StopService), arg0...)
}