mocks

package
v0.0.0-...-0a82276 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 29, 2024 License: AGPL-3.0 Imports: 11 Imported by: 0

Documentation

Overview

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockAgentConfig 

type MockAgentConfig struct {
	// contains filtered or unexported fields
}

MockAgentConfig is a mock of AgentConfig interface.

func NewMockAgentConfig 

func NewMockAgentConfig(ctrl *gomock.Controller) *MockAgentConfig

NewMockAgentConfig creates a new mock instance.

func (*MockAgentConfig) EXPECT 

func (m *MockAgentConfig) EXPECT() *MockAgentConfigMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockAgentConfig) Model 

func (m *MockAgentConfig) Model() reboot.Model

Model mocks base method.

type MockAgentConfigMockRecorder 

type MockAgentConfigMockRecorder struct {
	// contains filtered or unexported fields
}

MockAgentConfigMockRecorder is the mock recorder for MockAgentConfig.

func (*MockAgentConfigMockRecorder) Model 

func (mr *MockAgentConfigMockRecorder) Model() *MockAgentConfigModelCall

Model indicates an expected call of Model.

type MockAgentConfigModelCall 

type MockAgentConfigModelCall struct {
	*gomock.Call
}

MockAgentConfigModelCall wrap *gomock.Call

func (*MockAgentConfigModelCall) Do 

func (c *MockAgentConfigModelCall) Do(f func() reboot.Model) *MockAgentConfigModelCall

Do rewrite *gomock.Call.Do

func (*MockAgentConfigModelCall) DoAndReturn 

func (c *MockAgentConfigModelCall) DoAndReturn(f func() reboot.Model) *MockAgentConfigModelCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockAgentConfigModelCall) Return 

func (c *MockAgentConfigModelCall) Return(arg0 reboot.Model) *MockAgentConfigModelCall

Return rewrite *gomock.Call.Return

type MockClock 

type MockClock struct {
	// contains filtered or unexported fields
}

MockClock is a mock of Clock interface.

func NewMockClock 

func NewMockClock(ctrl *gomock.Controller) *MockClock

NewMockClock creates a new mock instance.

func (*MockClock) After 

func (m *MockClock) After(arg0 time.Duration) <-chan time.Time

After mocks base method.

func (*MockClock) AfterFunc 

func (m *MockClock) AfterFunc(arg0 time.Duration, arg1 func()) clock.Timer

AfterFunc mocks base method.

func (*MockClock) At 

func (m *MockClock) At(arg0 time.Time) <-chan time.Time

At mocks base method.

func (*MockClock) AtFunc 

func (m *MockClock) AtFunc(arg0 time.Time, arg1 func()) clock.Alarm

AtFunc mocks base method.

func (*MockClock) EXPECT 

func (m *MockClock) EXPECT() *MockClockMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockClock) NewAlarm 

func (m *MockClock) NewAlarm(arg0 time.Time) clock.Alarm

NewAlarm mocks base method.

func (*MockClock) NewTimer 

func (m *MockClock) NewTimer(arg0 time.Duration) clock.Timer

NewTimer mocks base method.

func (*MockClock) Now 

func (m *MockClock) Now() time.Time

Now mocks base method.

type MockClockAfterCall 

type MockClockAfterCall struct {
	*gomock.Call
}

MockClockAfterCall wrap *gomock.Call

func (*MockClockAfterCall) Do 

func (c *MockClockAfterCall) Do(f func(time.Duration) <-chan time.Time) *MockClockAfterCall

Do rewrite *gomock.Call.Do

func (*MockClockAfterCall) DoAndReturn 

func (c *MockClockAfterCall) DoAndReturn(f func(time.Duration) <-chan time.Time) *MockClockAfterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockAfterCall) Return 

func (c *MockClockAfterCall) Return(arg0 <-chan time.Time) *MockClockAfterCall

Return rewrite *gomock.Call.Return

type MockClockAfterFuncCall 

type MockClockAfterFuncCall struct {
	*gomock.Call
}

MockClockAfterFuncCall wrap *gomock.Call

func (*MockClockAfterFuncCall) Do 

func (c *MockClockAfterFuncCall) Do(f func(time.Duration, func()) clock.Timer) *MockClockAfterFuncCall

Do rewrite *gomock.Call.Do

func (*MockClockAfterFuncCall) DoAndReturn 

func (c *MockClockAfterFuncCall) DoAndReturn(f func(time.Duration, func()) clock.Timer) *MockClockAfterFuncCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockAfterFuncCall) Return 

func (c *MockClockAfterFuncCall) Return(arg0 clock.Timer) *MockClockAfterFuncCall

Return rewrite *gomock.Call.Return

type MockClockAtCall 

type MockClockAtCall struct {
	*gomock.Call
}

MockClockAtCall wrap *gomock.Call

func (*MockClockAtCall) Do 

func (c *MockClockAtCall) Do(f func(time.Time) <-chan time.Time) *MockClockAtCall

Do rewrite *gomock.Call.Do

func (*MockClockAtCall) DoAndReturn 

func (c *MockClockAtCall) DoAndReturn(f func(time.Time) <-chan time.Time) *MockClockAtCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockAtCall) Return 

func (c *MockClockAtCall) Return(arg0 <-chan time.Time) *MockClockAtCall

Return rewrite *gomock.Call.Return

type MockClockAtFuncCall 

type MockClockAtFuncCall struct {
	*gomock.Call
}

MockClockAtFuncCall wrap *gomock.Call

func (*MockClockAtFuncCall) Do 

func (c *MockClockAtFuncCall) Do(f func(time.Time, func()) clock.Alarm) *MockClockAtFuncCall

Do rewrite *gomock.Call.Do

func (*MockClockAtFuncCall) DoAndReturn 

func (c *MockClockAtFuncCall) DoAndReturn(f func(time.Time, func()) clock.Alarm) *MockClockAtFuncCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockAtFuncCall) Return 

func (c *MockClockAtFuncCall) Return(arg0 clock.Alarm) *MockClockAtFuncCall

Return rewrite *gomock.Call.Return

type MockClockMockRecorder 

type MockClockMockRecorder struct {
	// contains filtered or unexported fields
}

MockClockMockRecorder is the mock recorder for MockClock.

func (*MockClockMockRecorder) After 

func (mr *MockClockMockRecorder) After(arg0 any) *MockClockAfterCall

After indicates an expected call of After.

func (*MockClockMockRecorder) AfterFunc 

func (mr *MockClockMockRecorder) AfterFunc(arg0, arg1 any) *MockClockAfterFuncCall

AfterFunc indicates an expected call of AfterFunc.

func (*MockClockMockRecorder) At 

func (mr *MockClockMockRecorder) At(arg0 any) *MockClockAtCall

At indicates an expected call of At.

func (*MockClockMockRecorder) AtFunc 

func (mr *MockClockMockRecorder) AtFunc(arg0, arg1 any) *MockClockAtFuncCall

AtFunc indicates an expected call of AtFunc.

func (*MockClockMockRecorder) NewAlarm 

func (mr *MockClockMockRecorder) NewAlarm(arg0 any) *MockClockNewAlarmCall

NewAlarm indicates an expected call of NewAlarm.

func (*MockClockMockRecorder) NewTimer 

func (mr *MockClockMockRecorder) NewTimer(arg0 any) *MockClockNewTimerCall

NewTimer indicates an expected call of NewTimer.

func (*MockClockMockRecorder) Now 

func (mr *MockClockMockRecorder) Now() *MockClockNowCall

Now indicates an expected call of Now.

type MockClockNewAlarmCall 

type MockClockNewAlarmCall struct {
	*gomock.Call
}

MockClockNewAlarmCall wrap *gomock.Call

func (*MockClockNewAlarmCall) Do 

func (c *MockClockNewAlarmCall) Do(f func(time.Time) clock.Alarm) *MockClockNewAlarmCall

Do rewrite *gomock.Call.Do

func (*MockClockNewAlarmCall) DoAndReturn 

func (c *MockClockNewAlarmCall) DoAndReturn(f func(time.Time) clock.Alarm) *MockClockNewAlarmCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockNewAlarmCall) Return 

func (c *MockClockNewAlarmCall) Return(arg0 clock.Alarm) *MockClockNewAlarmCall

Return rewrite *gomock.Call.Return

type MockClockNewTimerCall 

type MockClockNewTimerCall struct {
	*gomock.Call
}

MockClockNewTimerCall wrap *gomock.Call

func (*MockClockNewTimerCall) Do 

func (c *MockClockNewTimerCall) Do(f func(time.Duration) clock.Timer) *MockClockNewTimerCall

Do rewrite *gomock.Call.Do

func (*MockClockNewTimerCall) DoAndReturn 

func (c *MockClockNewTimerCall) DoAndReturn(f func(time.Duration) clock.Timer) *MockClockNewTimerCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockNewTimerCall) Return 

func (c *MockClockNewTimerCall) Return(arg0 clock.Timer) *MockClockNewTimerCall

Return rewrite *gomock.Call.Return

type MockClockNowCall 

type MockClockNowCall struct {
	*gomock.Call
}

MockClockNowCall wrap *gomock.Call

func (*MockClockNowCall) Do 

func (c *MockClockNowCall) Do(f func() time.Time) *MockClockNowCall

Do rewrite *gomock.Call.Do

func (*MockClockNowCall) DoAndReturn 

func (c *MockClockNowCall) DoAndReturn(f func() time.Time) *MockClockNowCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockNowCall) Return 

func (c *MockClockNowCall) Return(arg0 time.Time) *MockClockNowCall

Return rewrite *gomock.Call.Return

type MockInstance 

type MockInstance struct {
	// contains filtered or unexported fields
}

MockInstance is a mock of Instance interface.

func NewMockInstance 

func NewMockInstance(ctrl *gomock.Controller) *MockInstance

NewMockInstance creates a new mock instance.

func (*MockInstance) Addresses 

func (m *MockInstance) Addresses(arg0 envcontext.ProviderCallContext) (network.ProviderAddresses, error)

Addresses mocks base method.

func (*MockInstance) EXPECT 

func (m *MockInstance) EXPECT() *MockInstanceMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockInstance) Id 

func (m *MockInstance) Id() instance.Id

Id mocks base method.

func (*MockInstance) Status 

func (m *MockInstance) Status(arg0 envcontext.ProviderCallContext) instance.Status

Status mocks base method.

type MockInstanceAddressesCall 

type MockInstanceAddressesCall struct {
	*gomock.Call
}

MockInstanceAddressesCall wrap *gomock.Call

func (*MockInstanceAddressesCall) Do 

func (c *MockInstanceAddressesCall) Do(f func(envcontext.ProviderCallContext) (network.ProviderAddresses, error)) *MockInstanceAddressesCall

Do rewrite *gomock.Call.Do

func (*MockInstanceAddressesCall) DoAndReturn 

func (c *MockInstanceAddressesCall) DoAndReturn(f func(envcontext.ProviderCallContext) (network.ProviderAddresses, error)) *MockInstanceAddressesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockInstanceAddressesCall) Return 

func (c *MockInstanceAddressesCall) Return(arg0 network.ProviderAddresses, arg1 error) *MockInstanceAddressesCall

Return rewrite *gomock.Call.Return

type MockInstanceIdCall 

type MockInstanceIdCall struct {
	*gomock.Call
}

MockInstanceIdCall wrap *gomock.Call

func (*MockInstanceIdCall) Do 

func (c *MockInstanceIdCall) Do(f func() instance.Id) *MockInstanceIdCall

Do rewrite *gomock.Call.Do

func (*MockInstanceIdCall) DoAndReturn 

func (c *MockInstanceIdCall) DoAndReturn(f func() instance.Id) *MockInstanceIdCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockInstanceIdCall) Return 

func (c *MockInstanceIdCall) Return(arg0 instance.Id) *MockInstanceIdCall

Return rewrite *gomock.Call.Return

type MockInstanceMockRecorder 

type MockInstanceMockRecorder struct {
	// contains filtered or unexported fields
}

MockInstanceMockRecorder is the mock recorder for MockInstance.

func (*MockInstanceMockRecorder) Addresses 

func (mr *MockInstanceMockRecorder) Addresses(arg0 any) *MockInstanceAddressesCall

Addresses indicates an expected call of Addresses.

func (*MockInstanceMockRecorder) Id 

func (mr *MockInstanceMockRecorder) Id() *MockInstanceIdCall

Id indicates an expected call of Id.

func (*MockInstanceMockRecorder) Status 

func (mr *MockInstanceMockRecorder) Status(arg0 any) *MockInstanceStatusCall

Status indicates an expected call of Status.

type MockInstanceStatusCall 

type MockInstanceStatusCall struct {
	*gomock.Call
}

MockInstanceStatusCall wrap *gomock.Call

func (*MockInstanceStatusCall) Do 

func (c *MockInstanceStatusCall) Do(f func(envcontext.ProviderCallContext) instance.Status) *MockInstanceStatusCall

Do rewrite *gomock.Call.Do

func (*MockInstanceStatusCall) DoAndReturn 

func (c *MockInstanceStatusCall) DoAndReturn(f func(envcontext.ProviderCallContext) instance.Status) *MockInstanceStatusCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockInstanceStatusCall) Return 

func (c *MockInstanceStatusCall) Return(arg0 instance.Status) *MockInstanceStatusCall

Return rewrite *gomock.Call.Return

type MockManager 

type MockManager struct {
	// contains filtered or unexported fields
}

MockManager is a mock of Manager interface.

func NewMockManager 

func NewMockManager(ctrl *gomock.Controller) *MockManager

NewMockManager creates a new mock instance.

func (*MockManager) EXPECT 

func (m *MockManager) EXPECT() *MockManagerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockManager) IsInitialized 

func (m *MockManager) IsInitialized() bool

IsInitialized mocks base method.

func (*MockManager) ListContainers 

func (m *MockManager) ListContainers() ([]instances.Instance, error)

ListContainers mocks base method.

type MockManagerIsInitializedCall 

type MockManagerIsInitializedCall struct {
	*gomock.Call
}

MockManagerIsInitializedCall wrap *gomock.Call

func (*MockManagerIsInitializedCall) Do 

func (c *MockManagerIsInitializedCall) Do(f func() bool) *MockManagerIsInitializedCall

Do rewrite *gomock.Call.Do

func (*MockManagerIsInitializedCall) DoAndReturn 

func (c *MockManagerIsInitializedCall) DoAndReturn(f func() bool) *MockManagerIsInitializedCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockManagerIsInitializedCall) Return 

func (c *MockManagerIsInitializedCall) Return(arg0 bool) *MockManagerIsInitializedCall

Return rewrite *gomock.Call.Return

type MockManagerListContainersCall 

type MockManagerListContainersCall struct {
	*gomock.Call
}

MockManagerListContainersCall wrap *gomock.Call

func (*MockManagerListContainersCall) Do 

func (c *MockManagerListContainersCall) Do(f func() ([]instances.Instance, error)) *MockManagerListContainersCall

Do rewrite *gomock.Call.Do

func (*MockManagerListContainersCall) DoAndReturn 

func (c *MockManagerListContainersCall) DoAndReturn(f func() ([]instances.Instance, error)) *MockManagerListContainersCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockManagerListContainersCall) Return 

func (c *MockManagerListContainersCall) Return(arg0 []instances.Instance, arg1 error) *MockManagerListContainersCall

Return rewrite *gomock.Call.Return

type MockManagerMockRecorder 

type MockManagerMockRecorder struct {
	// contains filtered or unexported fields
}

MockManagerMockRecorder is the mock recorder for MockManager.

func (*MockManagerMockRecorder) IsInitialized 

func (mr *MockManagerMockRecorder) IsInitialized() *MockManagerIsInitializedCall

IsInitialized indicates an expected call of IsInitialized.

func (*MockManagerMockRecorder) ListContainers 

func (mr *MockManagerMockRecorder) ListContainers() *MockManagerListContainersCall

ListContainers indicates an expected call of ListContainers.

type MockModel 

type MockModel struct {
	// contains filtered or unexported fields
}

MockModel is a mock of Model interface.

func NewMockModel 

func NewMockModel(ctrl *gomock.Controller) *MockModel

NewMockModel creates a new mock instance.

func (*MockModel) EXPECT 

func (m *MockModel) EXPECT() *MockModelMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockModel) Id 

func (m *MockModel) Id() string

Id mocks base method.

type MockModelIdCall 

type MockModelIdCall struct {
	*gomock.Call
}

MockModelIdCall wrap *gomock.Call

func (*MockModelIdCall) Do 

func (c *MockModelIdCall) Do(f func() string) *MockModelIdCall

Do rewrite *gomock.Call.Do

func (*MockModelIdCall) DoAndReturn 

func (c *MockModelIdCall) DoAndReturn(f func() string) *MockModelIdCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockModelIdCall) Return 

func (c *MockModelIdCall) Return(arg0 string) *MockModelIdCall

Return rewrite *gomock.Call.Return

type MockModelMockRecorder 

type MockModelMockRecorder struct {
	// contains filtered or unexported fields
}

MockModelMockRecorder is the mock recorder for MockModel.

func (*MockModelMockRecorder) Id 

func (mr *MockModelMockRecorder) Id() *MockModelIdCall

Id indicates an expected call of Id.

type MockRebootWaiter 

type MockRebootWaiter struct {
	// contains filtered or unexported fields
}

MockRebootWaiter is a mock of RebootWaiter interface.

func NewMockRebootWaiter 

func NewMockRebootWaiter(ctrl *gomock.Controller) *MockRebootWaiter

NewMockRebootWaiter creates a new mock instance.

func (*MockRebootWaiter) EXPECT 

func (m *MockRebootWaiter) EXPECT() *MockRebootWaiterMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockRebootWaiter) ListServices 

func (m *MockRebootWaiter) ListServices() ([]string, error)

ListServices mocks base method.

func (*MockRebootWaiter) NewContainerManager 

func (m *MockRebootWaiter) NewContainerManager(arg0 instance.ContainerType, arg1 container.ManagerConfig) (reboot.Manager, error)

NewContainerManager mocks base method.

func (*MockRebootWaiter) NewServiceReference 

func (m *MockRebootWaiter) NewServiceReference(arg0 string) (reboot.Service, error)

NewServiceReference mocks base method.

func (*MockRebootWaiter) ScheduleAction 

func (m *MockRebootWaiter) ScheduleAction(arg0 params.RebootAction, arg1 int) error

ScheduleAction mocks base method.

type MockRebootWaiterListServicesCall 

type MockRebootWaiterListServicesCall struct {
	*gomock.Call
}

MockRebootWaiterListServicesCall wrap *gomock.Call

func (*MockRebootWaiterListServicesCall) Do 

func (c *MockRebootWaiterListServicesCall) Do(f func() ([]string, error)) *MockRebootWaiterListServicesCall

Do rewrite *gomock.Call.Do

func (*MockRebootWaiterListServicesCall) DoAndReturn 

func (c *MockRebootWaiterListServicesCall) DoAndReturn(f func() ([]string, error)) *MockRebootWaiterListServicesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRebootWaiterListServicesCall) Return 

func (c *MockRebootWaiterListServicesCall) Return(arg0 []string, arg1 error) *MockRebootWaiterListServicesCall

Return rewrite *gomock.Call.Return

type MockRebootWaiterMockRecorder 

type MockRebootWaiterMockRecorder struct {
	// contains filtered or unexported fields
}

MockRebootWaiterMockRecorder is the mock recorder for MockRebootWaiter.

func (*MockRebootWaiterMockRecorder) ListServices 

func (mr *MockRebootWaiterMockRecorder) ListServices() *MockRebootWaiterListServicesCall

ListServices indicates an expected call of ListServices.

func (*MockRebootWaiterMockRecorder) NewContainerManager 

func (mr *MockRebootWaiterMockRecorder) NewContainerManager(arg0, arg1 any) *MockRebootWaiterNewContainerManagerCall

NewContainerManager indicates an expected call of NewContainerManager.

func (*MockRebootWaiterMockRecorder) NewServiceReference 

func (mr *MockRebootWaiterMockRecorder) NewServiceReference(arg0 any) *MockRebootWaiterNewServiceReferenceCall

NewServiceReference indicates an expected call of NewServiceReference.

func (*MockRebootWaiterMockRecorder) ScheduleAction 

func (mr *MockRebootWaiterMockRecorder) ScheduleAction(arg0, arg1 any) *MockRebootWaiterScheduleActionCall

ScheduleAction indicates an expected call of ScheduleAction.

type MockRebootWaiterNewContainerManagerCall 

type MockRebootWaiterNewContainerManagerCall struct {
	*gomock.Call
}

MockRebootWaiterNewContainerManagerCall wrap *gomock.Call

func (*MockRebootWaiterNewContainerManagerCall) Do 

func (c *MockRebootWaiterNewContainerManagerCall) Do(f func(instance.ContainerType, container.ManagerConfig) (reboot.Manager, error)) *MockRebootWaiterNewContainerManagerCall

Do rewrite *gomock.Call.Do

func (*MockRebootWaiterNewContainerManagerCall) DoAndReturn 

func (c *MockRebootWaiterNewContainerManagerCall) DoAndReturn(f func(instance.ContainerType, container.ManagerConfig) (reboot.Manager, error)) *MockRebootWaiterNewContainerManagerCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRebootWaiterNewContainerManagerCall) Return 

func (c *MockRebootWaiterNewContainerManagerCall) Return(arg0 reboot.Manager, arg1 error) *MockRebootWaiterNewContainerManagerCall

Return rewrite *gomock.Call.Return

type MockRebootWaiterNewServiceReferenceCall 

type MockRebootWaiterNewServiceReferenceCall struct {
	*gomock.Call
}

MockRebootWaiterNewServiceReferenceCall wrap *gomock.Call

func (*MockRebootWaiterNewServiceReferenceCall) Do 

func (c *MockRebootWaiterNewServiceReferenceCall) Do(f func(string) (reboot.Service, error)) *MockRebootWaiterNewServiceReferenceCall

Do rewrite *gomock.Call.Do

func (*MockRebootWaiterNewServiceReferenceCall) DoAndReturn 

func (c *MockRebootWaiterNewServiceReferenceCall) DoAndReturn(f func(string) (reboot.Service, error)) *MockRebootWaiterNewServiceReferenceCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRebootWaiterNewServiceReferenceCall) Return 

func (c *MockRebootWaiterNewServiceReferenceCall) Return(arg0 reboot.Service, arg1 error) *MockRebootWaiterNewServiceReferenceCall

Return rewrite *gomock.Call.Return

type MockRebootWaiterScheduleActionCall 

type MockRebootWaiterScheduleActionCall struct {
	*gomock.Call
}

MockRebootWaiterScheduleActionCall wrap *gomock.Call

func (*MockRebootWaiterScheduleActionCall) Do 

func (c *MockRebootWaiterScheduleActionCall) Do(f func(params.RebootAction, int) error) *MockRebootWaiterScheduleActionCall

Do rewrite *gomock.Call.Do

func (*MockRebootWaiterScheduleActionCall) DoAndReturn 

func (c *MockRebootWaiterScheduleActionCall) DoAndReturn(f func(params.RebootAction, int) error) *MockRebootWaiterScheduleActionCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRebootWaiterScheduleActionCall) Return 

func (c *MockRebootWaiterScheduleActionCall) Return(arg0 error) *MockRebootWaiterScheduleActionCall

Return rewrite *gomock.Call.Return

type MockService 

type MockService struct {
	// contains filtered or unexported fields
}

MockService is a mock of Service interface.

func NewMockService 

func NewMockService(ctrl *gomock.Controller) *MockService

NewMockService creates a new mock instance.

func (*MockService) EXPECT 

func (m *MockService) EXPECT() *MockServiceMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockService) Stop 

func (m *MockService) Stop() error

Stop mocks base method.

type MockServiceMockRecorder 

type MockServiceMockRecorder struct {
	// contains filtered or unexported fields
}

MockServiceMockRecorder is the mock recorder for MockService.

func (*MockServiceMockRecorder) Stop 

func (mr *MockServiceMockRecorder) Stop() *MockServiceStopCall

Stop indicates an expected call of Stop.

type MockServiceStopCall 

type MockServiceStopCall struct {
	*gomock.Call
}

MockServiceStopCall wrap *gomock.Call

func (*MockServiceStopCall) Do 

func (c *MockServiceStopCall) Do(f func() error) *MockServiceStopCall

Do rewrite *gomock.Call.Do

func (*MockServiceStopCall) DoAndReturn 

func (c *MockServiceStopCall) DoAndReturn(f func() error) *MockServiceStopCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceStopCall) Return 

func (c *MockServiceStopCall) Return(arg0 error) *MockServiceStopCall

Return rewrite *gomock.Call.Return

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.