mocks

package

Go to main page

Versions in this module

v0

v0.1.5

Sep 16, 2026

Changes in this version

type MockBackend

+ func (_mock *MockBackend) PinSandbox(context1 context.Context, s string, b bool, s1 string, time1 time.Time) (compute.Sandbox, error)

type MockBackend_Expecter

+ func (_e *MockBackend_Expecter) PinSandbox(context1 interface{}, s interface{}, b interface{}, s1 interface{}, ...) *MockBackend_PinSandbox_Call

+ type MockBackend_PinSandbox_Call struct

+ func (_c *MockBackend_PinSandbox_Call) Return(sandbox compute.Sandbox, err error) *MockBackend_PinSandbox_Call

+ func (_c *MockBackend_PinSandbox_Call) Run(...) *MockBackend_PinSandbox_Call

+ func (_c *MockBackend_PinSandbox_Call) RunAndReturn(...) *MockBackend_PinSandbox_Call

v0.1.4

Sep 16, 2026

v0.1.3

Sep 16, 2026

v0.1.2

Sep 16, 2026

v0.1.1

Sep 15, 2026

v0.1.0

Sep 15, 2026

Changes in this version

+ type MockBackend struct

+ func NewMockBackend(t interface{ ... }) *MockBackend

+ func (_m *MockBackend) EXPECT() *MockBackend_Expecter

+ func (_mock *MockBackend) AddACLRule(context1 context.Context, s string, s1 string, aCLRule compute.ACLRule) (compute.ACLRule, error)

+ func (_mock *MockBackend) AttachNIC(context1 context.Context, ref compute.Ref, s string, s1 string, s2 string, ...) (compute.NIC, error)

+ func (_mock *MockBackend) BeginCreateInstance(context1 context.Context, createInstance compute.CreateInstance) (compute.PendingInstance, error)

+ func (_mock *MockBackend) CreateForward(context1 context.Context, s string, s1 string, ref compute.Ref, n int64, ...) (compute.Forward, error)

+ func (_mock *MockBackend) CreateNetwork(context1 context.Context, s string, network compute.Network) (compute.Network, error)

+ func (_mock *MockBackend) CreateSandbox(context1 context.Context, sandbox compute.Sandbox) error

+ func (_mock *MockBackend) CreateSnapshot(context1 context.Context, ref compute.Ref, s string) error

+ func (_mock *MockBackend) DeleteFile(context1 context.Context, ref compute.Ref, s string) error

+ func (_mock *MockBackend) DeleteInstance(context1 context.Context, ref compute.Ref) error

+ func (_mock *MockBackend) DeleteNetwork(context1 context.Context, s string, s1 string) error

+ func (_mock *MockBackend) DeleteSandbox(context1 context.Context, s string) error

+ func (_mock *MockBackend) DeleteSnapshot(context1 context.Context, ref compute.Ref, s string) error

+ func (_mock *MockBackend) DetachNIC(context1 context.Context, ref compute.Ref, s string) error

+ func (_mock *MockBackend) Exec(context1 context.Context, execRequest compute.ExecRequest, writer io.Writer, ...) (int64, error)

+ func (_mock *MockBackend) ExtendSandbox(context1 context.Context, s string, time1 time.Time) (compute.Sandbox, error)

+ func (_mock *MockBackend) GetInstance(context1 context.Context, ref compute.Ref) (compute.Instance, error)

+ func (_mock *MockBackend) GetNetwork(context1 context.Context, s string, s1 string) (compute.Network, error)

+ func (_mock *MockBackend) GetSandbox(context1 context.Context, s string) (compute.Sandbox, error)

+ func (_mock *MockBackend) GetSandboxImage(context1 context.Context, s string, s1 string) (compute.CatalogImage, error)

+ func (_mock *MockBackend) InstanceForward(context1 context.Context, ref compute.Ref, n int64, s string) (compute.Forward, error)

+ func (_mock *MockBackend) ListInstances(context1 context.Context, s string) ([]compute.Instance, error)

+ func (_mock *MockBackend) ListNetworks(context1 context.Context, s string) ([]compute.Network, error)

+ func (_mock *MockBackend) ListSandboxes(context1 context.Context) ([]compute.Sandbox, error)

+ func (_mock *MockBackend) ListSnapshots(context1 context.Context, ref compute.Ref) ([]compute.Snapshot, error)

+ func (_mock *MockBackend) OpenExec(context1 context.Context, execRequest compute.ExecRequest) (io.ReadWriteCloser, error)

+ func (_mock *MockBackend) PeerNetworks(context1 context.Context, s string, s1 string, s2 string) error

+ func (_mock *MockBackend) PublishInstance(context1 context.Context, ref compute.Ref, s string) (string, error)

+ func (_mock *MockBackend) ReadBinaryFile(context1 context.Context, ref compute.Ref, s string) (io.ReadCloser, error)

+ func (_mock *MockBackend) ReadFile(context1 context.Context, fileReadRequest compute.FileReadRequest) (compute.FileReadResult, error)

+ func (_mock *MockBackend) RemoveACLRule(context1 context.Context, s string, s1 string, s2 string) error

+ func (_mock *MockBackend) RestartInstance(context1 context.Context, ref compute.Ref, b bool) (compute.Instance, error)

+ func (_mock *MockBackend) RestoreSnapshot(context1 context.Context, ref compute.Ref, s string) error

+ func (_mock *MockBackend) StartInstance(context1 context.Context, ref compute.Ref, b bool) (compute.Instance, error)

+ func (_mock *MockBackend) StopInstance(context1 context.Context, ref compute.Ref, b bool) (compute.Instance, error)

+ func (_mock *MockBackend) WaitInstance(context1 context.Context, waitRequest compute.WaitRequest) (compute.WaitResult, error)

+ func (_mock *MockBackend) WriteFile(context1 context.Context, fileWriteRequest compute.FileWriteRequest) (compute.FileWriteResult, error)

+ type MockBackend_AddACLRule_Call struct

+ func (_c *MockBackend_AddACLRule_Call) Return(aCLRule1 compute.ACLRule, err error) *MockBackend_AddACLRule_Call

+ func (_c *MockBackend_AddACLRule_Call) Run(...) *MockBackend_AddACLRule_Call

+ func (_c *MockBackend_AddACLRule_Call) RunAndReturn(...) *MockBackend_AddACLRule_Call

+ type MockBackend_AttachNIC_Call struct

+ func (_c *MockBackend_AttachNIC_Call) Return(nIC compute.NIC, err error) *MockBackend_AttachNIC_Call

+ func (_c *MockBackend_AttachNIC_Call) Run(...) *MockBackend_AttachNIC_Call

+ func (_c *MockBackend_AttachNIC_Call) RunAndReturn(...) *MockBackend_AttachNIC_Call

+ type MockBackend_BeginCreateInstance_Call struct

+ func (_c *MockBackend_BeginCreateInstance_Call) Return(pendingInstance compute.PendingInstance, err error) *MockBackend_BeginCreateInstance_Call

+ func (_c *MockBackend_BeginCreateInstance_Call) Run(run func(context1 context.Context, createInstance compute.CreateInstance)) *MockBackend_BeginCreateInstance_Call

+ func (_c *MockBackend_BeginCreateInstance_Call) RunAndReturn(...) *MockBackend_BeginCreateInstance_Call

+ type MockBackend_CreateForward_Call struct

+ func (_c *MockBackend_CreateForward_Call) Return(forward compute.Forward, err error) *MockBackend_CreateForward_Call

+ func (_c *MockBackend_CreateForward_Call) Run(...) *MockBackend_CreateForward_Call

+ func (_c *MockBackend_CreateForward_Call) RunAndReturn(...) *MockBackend_CreateForward_Call

+ type MockBackend_CreateNetwork_Call struct

+ func (_c *MockBackend_CreateNetwork_Call) Return(network1 compute.Network, err error) *MockBackend_CreateNetwork_Call

+ func (_c *MockBackend_CreateNetwork_Call) Run(run func(context1 context.Context, s string, network compute.Network)) *MockBackend_CreateNetwork_Call

+ func (_c *MockBackend_CreateNetwork_Call) RunAndReturn(...) *MockBackend_CreateNetwork_Call

+ type MockBackend_CreateSandbox_Call struct

+ func (_c *MockBackend_CreateSandbox_Call) Return(err error) *MockBackend_CreateSandbox_Call

+ func (_c *MockBackend_CreateSandbox_Call) Run(run func(context1 context.Context, sandbox compute.Sandbox)) *MockBackend_CreateSandbox_Call

+ func (_c *MockBackend_CreateSandbox_Call) RunAndReturn(run func(context1 context.Context, sandbox compute.Sandbox) error) *MockBackend_CreateSandbox_Call

+ type MockBackend_CreateSnapshot_Call struct

+ func (_c *MockBackend_CreateSnapshot_Call) Return(err error) *MockBackend_CreateSnapshot_Call

+ func (_c *MockBackend_CreateSnapshot_Call) Run(run func(context1 context.Context, ref compute.Ref, s string)) *MockBackend_CreateSnapshot_Call

+ func (_c *MockBackend_CreateSnapshot_Call) RunAndReturn(run func(context1 context.Context, ref compute.Ref, s string) error) *MockBackend_CreateSnapshot_Call

+ type MockBackend_DeleteFile_Call struct

+ func (_c *MockBackend_DeleteFile_Call) Return(err error) *MockBackend_DeleteFile_Call

+ func (_c *MockBackend_DeleteFile_Call) Run(run func(context1 context.Context, ref compute.Ref, s string)) *MockBackend_DeleteFile_Call

+ func (_c *MockBackend_DeleteFile_Call) RunAndReturn(run func(context1 context.Context, ref compute.Ref, s string) error) *MockBackend_DeleteFile_Call

+ type MockBackend_DeleteInstance_Call struct

+ func (_c *MockBackend_DeleteInstance_Call) Return(err error) *MockBackend_DeleteInstance_Call

+ func (_c *MockBackend_DeleteInstance_Call) Run(run func(context1 context.Context, ref compute.Ref)) *MockBackend_DeleteInstance_Call

+ func (_c *MockBackend_DeleteInstance_Call) RunAndReturn(run func(context1 context.Context, ref compute.Ref) error) *MockBackend_DeleteInstance_Call

+ type MockBackend_DeleteNetwork_Call struct

+ func (_c *MockBackend_DeleteNetwork_Call) Return(err error) *MockBackend_DeleteNetwork_Call

+ func (_c *MockBackend_DeleteNetwork_Call) Run(run func(context1 context.Context, s string, s1 string)) *MockBackend_DeleteNetwork_Call

+ func (_c *MockBackend_DeleteNetwork_Call) RunAndReturn(run func(context1 context.Context, s string, s1 string) error) *MockBackend_DeleteNetwork_Call

+ type MockBackend_DeleteSandbox_Call struct

+ func (_c *MockBackend_DeleteSandbox_Call) Return(err error) *MockBackend_DeleteSandbox_Call

+ func (_c *MockBackend_DeleteSandbox_Call) Run(run func(context1 context.Context, s string)) *MockBackend_DeleteSandbox_Call

+ func (_c *MockBackend_DeleteSandbox_Call) RunAndReturn(run func(context1 context.Context, s string) error) *MockBackend_DeleteSandbox_Call

+ type MockBackend_DeleteSnapshot_Call struct

+ func (_c *MockBackend_DeleteSnapshot_Call) Return(err error) *MockBackend_DeleteSnapshot_Call

+ func (_c *MockBackend_DeleteSnapshot_Call) Run(run func(context1 context.Context, ref compute.Ref, s string)) *MockBackend_DeleteSnapshot_Call

+ func (_c *MockBackend_DeleteSnapshot_Call) RunAndReturn(run func(context1 context.Context, ref compute.Ref, s string) error) *MockBackend_DeleteSnapshot_Call

+ type MockBackend_DetachNIC_Call struct

+ func (_c *MockBackend_DetachNIC_Call) Return(err error) *MockBackend_DetachNIC_Call

+ func (_c *MockBackend_DetachNIC_Call) Run(run func(context1 context.Context, ref compute.Ref, s string)) *MockBackend_DetachNIC_Call

+ func (_c *MockBackend_DetachNIC_Call) RunAndReturn(run func(context1 context.Context, ref compute.Ref, s string) error) *MockBackend_DetachNIC_Call

+ type MockBackend_Exec_Call struct

+ func (_c *MockBackend_Exec_Call) Return(n int64, err error) *MockBackend_Exec_Call

+ func (_c *MockBackend_Exec_Call) Run(...) *MockBackend_Exec_Call

+ func (_c *MockBackend_Exec_Call) RunAndReturn(...) *MockBackend_Exec_Call

+ type MockBackend_Expecter struct

+ func (_e *MockBackend_Expecter) AddACLRule(context1 interface{}, s interface{}, s1 interface{}, aCLRule interface{}) *MockBackend_AddACLRule_Call

+ func (_e *MockBackend_Expecter) AttachNIC(context1 interface{}, ref interface{}, s interface{}, s1 interface{}, ...) *MockBackend_AttachNIC_Call

+ func (_e *MockBackend_Expecter) BeginCreateInstance(context1 interface{}, createInstance interface{}) *MockBackend_BeginCreateInstance_Call

+ func (_e *MockBackend_Expecter) CreateForward(context1 interface{}, s interface{}, s1 interface{}, ref interface{}, ...) *MockBackend_CreateForward_Call

+ func (_e *MockBackend_Expecter) CreateNetwork(context1 interface{}, s interface{}, network interface{}) *MockBackend_CreateNetwork_Call

+ func (_e *MockBackend_Expecter) CreateSandbox(context1 interface{}, sandbox interface{}) *MockBackend_CreateSandbox_Call

+ func (_e *MockBackend_Expecter) CreateSnapshot(context1 interface{}, ref interface{}, s interface{}) *MockBackend_CreateSnapshot_Call

+ func (_e *MockBackend_Expecter) DeleteFile(context1 interface{}, ref interface{}, s interface{}) *MockBackend_DeleteFile_Call

+ func (_e *MockBackend_Expecter) DeleteInstance(context1 interface{}, ref interface{}) *MockBackend_DeleteInstance_Call

+ func (_e *MockBackend_Expecter) DeleteNetwork(context1 interface{}, s interface{}, s1 interface{}) *MockBackend_DeleteNetwork_Call

+ func (_e *MockBackend_Expecter) DeleteSandbox(context1 interface{}, s interface{}) *MockBackend_DeleteSandbox_Call

+ func (_e *MockBackend_Expecter) DeleteSnapshot(context1 interface{}, ref interface{}, s interface{}) *MockBackend_DeleteSnapshot_Call

+ func (_e *MockBackend_Expecter) DetachNIC(context1 interface{}, ref interface{}, s interface{}) *MockBackend_DetachNIC_Call

+ func (_e *MockBackend_Expecter) Exec(context1 interface{}, execRequest interface{}, writer interface{}, ...) *MockBackend_Exec_Call

+ func (_e *MockBackend_Expecter) ExtendSandbox(context1 interface{}, s interface{}, time1 interface{}) *MockBackend_ExtendSandbox_Call

+ func (_e *MockBackend_Expecter) GetInstance(context1 interface{}, ref interface{}) *MockBackend_GetInstance_Call

+ func (_e *MockBackend_Expecter) GetNetwork(context1 interface{}, s interface{}, s1 interface{}) *MockBackend_GetNetwork_Call

+ func (_e *MockBackend_Expecter) GetSandbox(context1 interface{}, s interface{}) *MockBackend_GetSandbox_Call

+ func (_e *MockBackend_Expecter) GetSandboxImage(context1 interface{}, s interface{}, s1 interface{}) *MockBackend_GetSandboxImage_Call

+ func (_e *MockBackend_Expecter) InstanceForward(context1 interface{}, ref interface{}, n interface{}, s interface{}) *MockBackend_InstanceForward_Call

+ func (_e *MockBackend_Expecter) ListInstances(context1 interface{}, s interface{}) *MockBackend_ListInstances_Call

+ func (_e *MockBackend_Expecter) ListNetworks(context1 interface{}, s interface{}) *MockBackend_ListNetworks_Call

+ func (_e *MockBackend_Expecter) ListSandboxes(context1 interface{}) *MockBackend_ListSandboxes_Call

+ func (_e *MockBackend_Expecter) ListSnapshots(context1 interface{}, ref interface{}) *MockBackend_ListSnapshots_Call

+ func (_e *MockBackend_Expecter) OpenExec(context1 interface{}, execRequest interface{}) *MockBackend_OpenExec_Call

+ func (_e *MockBackend_Expecter) PeerNetworks(context1 interface{}, s interface{}, s1 interface{}, s2 interface{}) *MockBackend_PeerNetworks_Call

+ func (_e *MockBackend_Expecter) PublishInstance(context1 interface{}, ref interface{}, s interface{}) *MockBackend_PublishInstance_Call

+ func (_e *MockBackend_Expecter) ReadBinaryFile(context1 interface{}, ref interface{}, s interface{}) *MockBackend_ReadBinaryFile_Call

+ func (_e *MockBackend_Expecter) ReadFile(context1 interface{}, fileReadRequest interface{}) *MockBackend_ReadFile_Call

+ func (_e *MockBackend_Expecter) RemoveACLRule(context1 interface{}, s interface{}, s1 interface{}, s2 interface{}) *MockBackend_RemoveACLRule_Call

+ func (_e *MockBackend_Expecter) RestartInstance(context1 interface{}, ref interface{}, b interface{}) *MockBackend_RestartInstance_Call

+ func (_e *MockBackend_Expecter) RestoreSnapshot(context1 interface{}, ref interface{}, s interface{}) *MockBackend_RestoreSnapshot_Call

+ func (_e *MockBackend_Expecter) StartInstance(context1 interface{}, ref interface{}, b interface{}) *MockBackend_StartInstance_Call

+ func (_e *MockBackend_Expecter) StopInstance(context1 interface{}, ref interface{}, b interface{}) *MockBackend_StopInstance_Call

+ func (_e *MockBackend_Expecter) WaitInstance(context1 interface{}, waitRequest interface{}) *MockBackend_WaitInstance_Call

+ func (_e *MockBackend_Expecter) WriteFile(context1 interface{}, fileWriteRequest interface{}) *MockBackend_WriteFile_Call

+ type MockBackend_ExtendSandbox_Call struct

+ func (_c *MockBackend_ExtendSandbox_Call) Return(sandbox compute.Sandbox, err error) *MockBackend_ExtendSandbox_Call

+ func (_c *MockBackend_ExtendSandbox_Call) Run(run func(context1 context.Context, s string, time1 time.Time)) *MockBackend_ExtendSandbox_Call

+ func (_c *MockBackend_ExtendSandbox_Call) RunAndReturn(...) *MockBackend_ExtendSandbox_Call

+ type MockBackend_GetInstance_Call struct

+ func (_c *MockBackend_GetInstance_Call) Return(instance compute.Instance, err error) *MockBackend_GetInstance_Call

+ func (_c *MockBackend_GetInstance_Call) Run(run func(context1 context.Context, ref compute.Ref)) *MockBackend_GetInstance_Call

+ func (_c *MockBackend_GetInstance_Call) RunAndReturn(run func(context1 context.Context, ref compute.Ref) (compute.Instance, error)) *MockBackend_GetInstance_Call

+ type MockBackend_GetNetwork_Call struct

+ func (_c *MockBackend_GetNetwork_Call) Return(network compute.Network, err error) *MockBackend_GetNetwork_Call

+ func (_c *MockBackend_GetNetwork_Call) Run(run func(context1 context.Context, s string, s1 string)) *MockBackend_GetNetwork_Call

+ func (_c *MockBackend_GetNetwork_Call) RunAndReturn(...) *MockBackend_GetNetwork_Call

+ type MockBackend_GetSandboxImage_Call struct

+ func (_c *MockBackend_GetSandboxImage_Call) Return(catalogImage compute.CatalogImage, err error) *MockBackend_GetSandboxImage_Call

+ func (_c *MockBackend_GetSandboxImage_Call) Run(run func(context1 context.Context, s string, s1 string)) *MockBackend_GetSandboxImage_Call

+ func (_c *MockBackend_GetSandboxImage_Call) RunAndReturn(...) *MockBackend_GetSandboxImage_Call

+ type MockBackend_GetSandbox_Call struct

+ func (_c *MockBackend_GetSandbox_Call) Return(sandbox compute.Sandbox, err error) *MockBackend_GetSandbox_Call

+ func (_c *MockBackend_GetSandbox_Call) Run(run func(context1 context.Context, s string)) *MockBackend_GetSandbox_Call

+ func (_c *MockBackend_GetSandbox_Call) RunAndReturn(run func(context1 context.Context, s string) (compute.Sandbox, error)) *MockBackend_GetSandbox_Call

+ type MockBackend_InstanceForward_Call struct

+ func (_c *MockBackend_InstanceForward_Call) Return(forward compute.Forward, err error) *MockBackend_InstanceForward_Call

+ func (_c *MockBackend_InstanceForward_Call) Run(run func(context1 context.Context, ref compute.Ref, n int64, s string)) *MockBackend_InstanceForward_Call

+ func (_c *MockBackend_InstanceForward_Call) RunAndReturn(...) *MockBackend_InstanceForward_Call

+ type MockBackend_ListInstances_Call struct

+ func (_c *MockBackend_ListInstances_Call) Return(instances []compute.Instance, err error) *MockBackend_ListInstances_Call

+ func (_c *MockBackend_ListInstances_Call) Run(run func(context1 context.Context, s string)) *MockBackend_ListInstances_Call

+ func (_c *MockBackend_ListInstances_Call) RunAndReturn(run func(context1 context.Context, s string) ([]compute.Instance, error)) *MockBackend_ListInstances_Call

+ type MockBackend_ListNetworks_Call struct

+ func (_c *MockBackend_ListNetworks_Call) Return(networks []compute.Network, err error) *MockBackend_ListNetworks_Call

+ func (_c *MockBackend_ListNetworks_Call) Run(run func(context1 context.Context, s string)) *MockBackend_ListNetworks_Call

+ func (_c *MockBackend_ListNetworks_Call) RunAndReturn(run func(context1 context.Context, s string) ([]compute.Network, error)) *MockBackend_ListNetworks_Call

+ type MockBackend_ListSandboxes_Call struct

+ func (_c *MockBackend_ListSandboxes_Call) Return(sandboxs []compute.Sandbox, err error) *MockBackend_ListSandboxes_Call

+ func (_c *MockBackend_ListSandboxes_Call) Run(run func(context1 context.Context)) *MockBackend_ListSandboxes_Call

+ func (_c *MockBackend_ListSandboxes_Call) RunAndReturn(run func(context1 context.Context) ([]compute.Sandbox, error)) *MockBackend_ListSandboxes_Call

+ type MockBackend_ListSnapshots_Call struct

+ func (_c *MockBackend_ListSnapshots_Call) Return(snapshots []compute.Snapshot, err error) *MockBackend_ListSnapshots_Call

+ func (_c *MockBackend_ListSnapshots_Call) Run(run func(context1 context.Context, ref compute.Ref)) *MockBackend_ListSnapshots_Call

+ func (_c *MockBackend_ListSnapshots_Call) RunAndReturn(...) *MockBackend_ListSnapshots_Call

+ type MockBackend_OpenExec_Call struct

+ func (_c *MockBackend_OpenExec_Call) Return(readWriteCloser io.ReadWriteCloser, err error) *MockBackend_OpenExec_Call

+ func (_c *MockBackend_OpenExec_Call) Run(run func(context1 context.Context, execRequest compute.ExecRequest)) *MockBackend_OpenExec_Call

+ func (_c *MockBackend_OpenExec_Call) RunAndReturn(...) *MockBackend_OpenExec_Call

+ type MockBackend_PeerNetworks_Call struct

+ func (_c *MockBackend_PeerNetworks_Call) Return(err error) *MockBackend_PeerNetworks_Call

+ func (_c *MockBackend_PeerNetworks_Call) Run(run func(context1 context.Context, s string, s1 string, s2 string)) *MockBackend_PeerNetworks_Call

+ func (_c *MockBackend_PeerNetworks_Call) RunAndReturn(run func(context1 context.Context, s string, s1 string, s2 string) error) *MockBackend_PeerNetworks_Call

+ type MockBackend_PublishInstance_Call struct

+ func (_c *MockBackend_PublishInstance_Call) Return(s1 string, err error) *MockBackend_PublishInstance_Call

+ func (_c *MockBackend_PublishInstance_Call) Run(run func(context1 context.Context, ref compute.Ref, s string)) *MockBackend_PublishInstance_Call

+ func (_c *MockBackend_PublishInstance_Call) RunAndReturn(run func(context1 context.Context, ref compute.Ref, s string) (string, error)) *MockBackend_PublishInstance_Call

+ type MockBackend_ReadBinaryFile_Call struct

+ func (_c *MockBackend_ReadBinaryFile_Call) Return(readCloser io.ReadCloser, err error) *MockBackend_ReadBinaryFile_Call

+ func (_c *MockBackend_ReadBinaryFile_Call) Run(run func(context1 context.Context, ref compute.Ref, s string)) *MockBackend_ReadBinaryFile_Call

+ func (_c *MockBackend_ReadBinaryFile_Call) RunAndReturn(...) *MockBackend_ReadBinaryFile_Call

+ type MockBackend_ReadFile_Call struct

+ func (_c *MockBackend_ReadFile_Call) Return(fileReadResult compute.FileReadResult, err error) *MockBackend_ReadFile_Call

+ func (_c *MockBackend_ReadFile_Call) Run(run func(context1 context.Context, fileReadRequest compute.FileReadRequest)) *MockBackend_ReadFile_Call

+ func (_c *MockBackend_ReadFile_Call) RunAndReturn(...) *MockBackend_ReadFile_Call

+ type MockBackend_RemoveACLRule_Call struct

+ func (_c *MockBackend_RemoveACLRule_Call) Return(err error) *MockBackend_RemoveACLRule_Call

+ func (_c *MockBackend_RemoveACLRule_Call) Run(run func(context1 context.Context, s string, s1 string, s2 string)) *MockBackend_RemoveACLRule_Call

+ func (_c *MockBackend_RemoveACLRule_Call) RunAndReturn(run func(context1 context.Context, s string, s1 string, s2 string) error) *MockBackend_RemoveACLRule_Call

+ type MockBackend_RestartInstance_Call struct

+ func (_c *MockBackend_RestartInstance_Call) Return(instance compute.Instance, err error) *MockBackend_RestartInstance_Call

+ func (_c *MockBackend_RestartInstance_Call) Run(run func(context1 context.Context, ref compute.Ref, b bool)) *MockBackend_RestartInstance_Call

+ func (_c *MockBackend_RestartInstance_Call) RunAndReturn(...) *MockBackend_RestartInstance_Call

+ type MockBackend_RestoreSnapshot_Call struct

+ func (_c *MockBackend_RestoreSnapshot_Call) Return(err error) *MockBackend_RestoreSnapshot_Call

+ func (_c *MockBackend_RestoreSnapshot_Call) Run(run func(context1 context.Context, ref compute.Ref, s string)) *MockBackend_RestoreSnapshot_Call

+ func (_c *MockBackend_RestoreSnapshot_Call) RunAndReturn(run func(context1 context.Context, ref compute.Ref, s string) error) *MockBackend_RestoreSnapshot_Call

+ type MockBackend_StartInstance_Call struct

+ func (_c *MockBackend_StartInstance_Call) Return(instance compute.Instance, err error) *MockBackend_StartInstance_Call

+ func (_c *MockBackend_StartInstance_Call) Run(run func(context1 context.Context, ref compute.Ref, b bool)) *MockBackend_StartInstance_Call

+ func (_c *MockBackend_StartInstance_Call) RunAndReturn(...) *MockBackend_StartInstance_Call

+ type MockBackend_StopInstance_Call struct

+ func (_c *MockBackend_StopInstance_Call) Return(instance compute.Instance, err error) *MockBackend_StopInstance_Call

+ func (_c *MockBackend_StopInstance_Call) Run(run func(context1 context.Context, ref compute.Ref, b bool)) *MockBackend_StopInstance_Call

+ func (_c *MockBackend_StopInstance_Call) RunAndReturn(...) *MockBackend_StopInstance_Call

+ type MockBackend_WaitInstance_Call struct

+ func (_c *MockBackend_WaitInstance_Call) Return(waitResult compute.WaitResult, err error) *MockBackend_WaitInstance_Call

+ func (_c *MockBackend_WaitInstance_Call) Run(run func(context1 context.Context, waitRequest compute.WaitRequest)) *MockBackend_WaitInstance_Call

+ func (_c *MockBackend_WaitInstance_Call) RunAndReturn(...) *MockBackend_WaitInstance_Call

+ type MockBackend_WriteFile_Call struct

+ func (_c *MockBackend_WriteFile_Call) Return(fileWriteResult compute.FileWriteResult, err error) *MockBackend_WriteFile_Call

+ func (_c *MockBackend_WriteFile_Call) Run(run func(context1 context.Context, fileWriteRequest compute.FileWriteRequest)) *MockBackend_WriteFile_Call

+ func (_c *MockBackend_WriteFile_Call) RunAndReturn(...) *MockBackend_WriteFile_Call

+ type MockPendingInstance struct

+ func NewMockPendingInstance(t interface{ ... }) *MockPendingInstance

+ func (_m *MockPendingInstance) EXPECT() *MockPendingInstance_Expecter

+ func (_mock *MockPendingInstance) Wait(context1 context.Context) (compute.Instance, error)

+ type MockPendingInstance_Expecter struct

+ func (_e *MockPendingInstance_Expecter) Wait(context1 interface{}) *MockPendingInstance_Wait_Call

+ type MockPendingInstance_Wait_Call struct

+ func (_c *MockPendingInstance_Wait_Call) Return(instance compute.Instance, err error) *MockPendingInstance_Wait_Call

+ func (_c *MockPendingInstance_Wait_Call) Run(run func(context1 context.Context)) *MockPendingInstance_Wait_Call

+ func (_c *MockPendingInstance_Wait_Call) RunAndReturn(run func(context1 context.Context) (compute.Instance, error)) *MockPendingInstance_Wait_Call

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL