mocks

package
v0.23.0 Latest Latest
Warning

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

 Go to latest Published: Jan 5, 2026 License: MIT Imports: 13 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockAfterFuture 

type MockAfterFuture struct {
	restatecontext.Selectable
	mock.Mock
}

MockAfterFuture is a mock type for the AfterFuture type

func NewMockAfterFuture 

func NewMockAfterFuture(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAfterFuture

NewMockAfterFuture creates a new instance of MockAfterFuture. 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 (*MockAfterFuture) Done 

func (_m *MockAfterFuture) Done() error

Done provides a mock function with no fields

func (*MockAfterFuture) EXPECT 

func (_m *MockAfterFuture) EXPECT() *MockAfterFuture_Expecter

type MockAfterFuture_Done_Call 

type MockAfterFuture_Done_Call struct {
	*mock.Call
}

MockAfterFuture_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'

func (*MockAfterFuture_Done_Call) Return 

func (_c *MockAfterFuture_Done_Call) Return(_a0 error) *MockAfterFuture_Done_Call

func (*MockAfterFuture_Done_Call) Run 

func (_c *MockAfterFuture_Done_Call) Run(run func()) *MockAfterFuture_Done_Call

func (*MockAfterFuture_Done_Call) RunAndReturn 

func (_c *MockAfterFuture_Done_Call) RunAndReturn(run func() error) *MockAfterFuture_Done_Call

type MockAfterFuture_Expecter 

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

func (*MockAfterFuture_Expecter) Done 

func (_e *MockAfterFuture_Expecter) Done() *MockAfterFuture_Done_Call

Done is a helper method to define mock.On call

type MockAfterFuture_handle_Call added in v0.16.0 

type MockAfterFuture_handle_Call struct {
	*mock.Call
}

MockAfterFuture_handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'handle'

func (*MockAfterFuture_handle_Call) Return added in v0.16.0 

func (_c *MockAfterFuture_handle_Call) Return(_a0 uint32) *MockAfterFuture_handle_Call

func (*MockAfterFuture_handle_Call) Run added in v0.16.0 

func (_c *MockAfterFuture_handle_Call) Run(run func()) *MockAfterFuture_handle_Call

func (*MockAfterFuture_handle_Call) RunAndReturn added in v0.16.0 

func (_c *MockAfterFuture_handle_Call) RunAndReturn(run func() uint32) *MockAfterFuture_handle_Call

type MockAttachFuture added in v0.16.0 

type MockAttachFuture struct {
	restatecontext.Selectable
	mock.Mock
}

MockAttachFuture is a mock type for the AttachFuture type

func NewMockAttachFuture added in v0.16.0 

func NewMockAttachFuture(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAttachFuture

NewMockAttachFuture creates a new instance of MockAttachFuture. 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 (*MockAttachFuture) EXPECT added in v0.16.0 

func (_m *MockAttachFuture) EXPECT() *MockAttachFuture_Expecter

func (*MockAttachFuture) Response added in v0.16.0 

func (_m *MockAttachFuture) Response(output any) error

Response provides a mock function with given fields: output

type MockAttachFuture_Expecter added in v0.16.0 

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

func (*MockAttachFuture_Expecter) Response added in v0.16.0 

func (_e *MockAttachFuture_Expecter) Response(output interface{}) *MockAttachFuture_Response_Call

Response is a helper method to define mock.On call

  • output any

func (*MockAttachFuture_Expecter) ResponseAndReturn added in v0.16.0 

func (_e *MockAttachFuture_Expecter) ResponseAndReturn(value any, err error) *MockAttachFuture_Response_Call

ResponseAndReturn is a helper method to mock a typical 'Response' call on a AttachFuture; return a concrete value or an error

type MockAttachFuture_Response_Call added in v0.16.0 

type MockAttachFuture_Response_Call struct {
	*mock.Call
}

MockAttachFuture_Response_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Response'

func (*MockAttachFuture_Response_Call) Return added in v0.16.0 

func (_c *MockAttachFuture_Response_Call) Return(_a0 error) *MockAttachFuture_Response_Call

func (*MockAttachFuture_Response_Call) Run added in v0.16.0 

func (_c *MockAttachFuture_Response_Call) Run(run func(output any)) *MockAttachFuture_Response_Call

func (*MockAttachFuture_Response_Call) RunAndReturn added in v0.16.0 

func (_c *MockAttachFuture_Response_Call) RunAndReturn(run func(any) error) *MockAttachFuture_Response_Call

type MockAttachFuture_handle_Call added in v0.16.0 

type MockAttachFuture_handle_Call struct {
	*mock.Call
}

MockAttachFuture_handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'handle'

func (*MockAttachFuture_handle_Call) Return added in v0.16.0 

func (_c *MockAttachFuture_handle_Call) Return(_a0 uint32) *MockAttachFuture_handle_Call

func (*MockAttachFuture_handle_Call) Run added in v0.16.0 

func (_c *MockAttachFuture_handle_Call) Run(run func()) *MockAttachFuture_handle_Call

func (*MockAttachFuture_handle_Call) RunAndReturn added in v0.16.0 

func (_c *MockAttachFuture_handle_Call) RunAndReturn(run func() uint32) *MockAttachFuture_handle_Call

type MockAwakeableFuture 

type MockAwakeableFuture struct {
	restatecontext.Selectable
	mock.Mock
}

MockAwakeableFuture is a mock type for the AwakeableFuture type

func NewMockAwakeableFuture 

func NewMockAwakeableFuture(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAwakeableFuture

NewMockAwakeableFuture creates a new instance of MockAwakeableFuture. 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 (*MockAwakeableFuture) EXPECT 

func (_m *MockAwakeableFuture) EXPECT() *MockAwakeableFuture_Expecter

func (*MockAwakeableFuture) Id 

func (_m *MockAwakeableFuture) Id() string

Id provides a mock function with no fields

func (*MockAwakeableFuture) Result 

func (_m *MockAwakeableFuture) Result(output any) error

Result provides a mock function with given fields: output

type MockAwakeableFuture_Expecter 

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

func (*MockAwakeableFuture_Expecter) Id 

func (_e *MockAwakeableFuture_Expecter) Id() *MockAwakeableFuture_Id_Call

Id is a helper method to define mock.On call

func (*MockAwakeableFuture_Expecter) Result 

func (_e *MockAwakeableFuture_Expecter) Result(output interface{}) *MockAwakeableFuture_Result_Call

Result is a helper method to define mock.On call

  • output any

func (*MockAwakeableFuture_Expecter) ResultAndReturn 

func (_e *MockAwakeableFuture_Expecter) ResultAndReturn(value any, err error) *MockAwakeableFuture_Result_Call

ResultAndReturn is a helper method to mock a typical 'Result' call on a AwakeableFuture; return a concrete value or an error

type MockAwakeableFuture_Id_Call 

type MockAwakeableFuture_Id_Call struct {
	*mock.Call
}

MockAwakeableFuture_Id_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Id'

func (*MockAwakeableFuture_Id_Call) Return 

func (_c *MockAwakeableFuture_Id_Call) Return(_a0 string) *MockAwakeableFuture_Id_Call

func (*MockAwakeableFuture_Id_Call) Run 

func (_c *MockAwakeableFuture_Id_Call) Run(run func()) *MockAwakeableFuture_Id_Call

func (*MockAwakeableFuture_Id_Call) RunAndReturn 

func (_c *MockAwakeableFuture_Id_Call) RunAndReturn(run func() string) *MockAwakeableFuture_Id_Call

type MockAwakeableFuture_Result_Call 

type MockAwakeableFuture_Result_Call struct {
	*mock.Call
}

MockAwakeableFuture_Result_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Result'

func (*MockAwakeableFuture_Result_Call) Return 

func (_c *MockAwakeableFuture_Result_Call) Return(_a0 error) *MockAwakeableFuture_Result_Call

func (*MockAwakeableFuture_Result_Call) Run 

func (_c *MockAwakeableFuture_Result_Call) Run(run func(output any)) *MockAwakeableFuture_Result_Call

func (*MockAwakeableFuture_Result_Call) RunAndReturn 

func (_c *MockAwakeableFuture_Result_Call) RunAndReturn(run func(any) error) *MockAwakeableFuture_Result_Call

type MockAwakeableFuture_handle_Call added in v0.16.0 

type MockAwakeableFuture_handle_Call struct {
	*mock.Call
}

MockAwakeableFuture_handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'handle'

func (*MockAwakeableFuture_handle_Call) Return added in v0.16.0 

func (_c *MockAwakeableFuture_handle_Call) Return(_a0 uint32) *MockAwakeableFuture_handle_Call

func (*MockAwakeableFuture_handle_Call) Run added in v0.16.0 

func (_c *MockAwakeableFuture_handle_Call) Run(run func()) *MockAwakeableFuture_handle_Call

func (*MockAwakeableFuture_handle_Call) RunAndReturn added in v0.16.0 

func (_c *MockAwakeableFuture_handle_Call) RunAndReturn(run func() uint32) *MockAwakeableFuture_handle_Call

type MockClient 

type MockClient struct {
	mock.Mock
}

MockClient is an autogenerated mock type for the Client type

func NewMockClient 

func NewMockClient(t *testing.T) *MockClient

NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*MockClient) EXPECT 

func (_m *MockClient) EXPECT() *MockClient_Expecter

func (*MockClient) Request 

func (_m *MockClient) Request(input any, output any, opts ...options.RequestOption) error

Request provides a mock function with given fields: input, output, opts

func (*MockClient) RequestFuture 

func (_m *MockClient) RequestFuture(input any, opts ...options.RequestOption) restatecontext.ResponseFuture

RequestFuture provides a mock function with given fields: input, opts

func (*MockClient) Send 

func (_m *MockClient) Send(input any, opts ...options.SendOption) restatecontext.Invocation

Send provides a mock function with given fields: input, opts

type MockClient_Expecter 

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

func (*MockClient_Expecter) MockResponseFuture 

func (_e *MockClient_Expecter) MockResponseFuture(input interface{}, opts ...interface{}) *MockResponseFuture

MockResponseFuture is a helper method to mock a typical 'RequestFuture' call on a client; return a mocked ResponseFuture object

func (*MockClient_Expecter) MockSend added in v0.16.0 

func (_e *MockClient_Expecter) MockSend(input interface{}, opts ...interface{}) *MockInvocation

MockResponseFuture is a helper method to mock a typical 'Send' call on a client; return a mocked Invocation object

func (*MockClient_Expecter) Request 

func (_e *MockClient_Expecter) Request(input interface{}, output interface{}, opts ...interface{}) *MockClient_Request_Call

Request is a helper method to define mock.On call

  • input any
  • output any
  • opts ...options.RequestOption

func (*MockClient_Expecter) RequestAndReturn 

func (_e *MockClient_Expecter) RequestAndReturn(input interface{}, value any, err error) *MockClient_Request_Call

GetAndReturn is a helper method to mock a typical 'Request' call; return a concrete value or an error

func (*MockClient_Expecter) RequestFuture 

func (_e *MockClient_Expecter) RequestFuture(input interface{}, opts ...interface{}) *MockClient_RequestFuture_Call

RequestFuture is a helper method to define mock.On call

  • input any
  • opts ...options.RequestOption

func (*MockClient_Expecter) Send 

func (_e *MockClient_Expecter) Send(input interface{}, opts ...interface{}) *MockClient_Send_Call

Send is a helper method to define mock.On call

  • input any
  • opts ...options.SendOption

type MockClient_RequestFuture_Call 

type MockClient_RequestFuture_Call struct {
	*mock.Call
}

MockClient_RequestFuture_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestFuture'

func (*MockClient_RequestFuture_Call) Return 

func (_c *MockClient_RequestFuture_Call) Return(_a0 restatecontext.ResponseFuture) *MockClient_RequestFuture_Call

func (*MockClient_RequestFuture_Call) Run 

func (_c *MockClient_RequestFuture_Call) Run(run func(input any, opts ...options.RequestOption)) *MockClient_RequestFuture_Call

func (*MockClient_RequestFuture_Call) RunAndReturn 

func (_c *MockClient_RequestFuture_Call) RunAndReturn(run func(any, ...options.RequestOption) restatecontext.ResponseFuture) *MockClient_RequestFuture_Call

type MockClient_Request_Call 

type MockClient_Request_Call struct {
	*mock.Call
}

MockClient_Request_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Request'

func (*MockClient_Request_Call) Return 

func (_c *MockClient_Request_Call) Return(_a0 error) *MockClient_Request_Call

func (*MockClient_Request_Call) Run 

func (_c *MockClient_Request_Call) Run(run func(input any, output any, opts ...options.RequestOption)) *MockClient_Request_Call

func (*MockClient_Request_Call) RunAndReturn 

func (_c *MockClient_Request_Call) RunAndReturn(run func(any, any, ...options.RequestOption) error) *MockClient_Request_Call

type MockClient_Send_Call 

type MockClient_Send_Call struct {
	*mock.Call
}

MockClient_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'

func (*MockClient_Send_Call) Return 

func (_c *MockClient_Send_Call) Return(_a0 restatecontext.Invocation) *MockClient_Send_Call

func (*MockClient_Send_Call) Run 

func (_c *MockClient_Send_Call) Run(run func(input any, opts ...options.SendOption)) *MockClient_Send_Call

func (*MockClient_Send_Call) RunAndReturn 

func (_c *MockClient_Send_Call) RunAndReturn(run func(any, ...options.SendOption) restatecontext.Invocation) *MockClient_Send_Call

type MockContext 

type MockContext struct {
	mock.Mock
}

MockContext is an autogenerated mock type for the Context type

func NewMockContext 

func NewMockContext(t *testing.T) *MockContext

NewMockContext creates a new instance of MockContext. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*MockContext) After 

func (_m *MockContext) After(d time.Duration, opts ...options.SleepOption) restatecontext.AfterFuture

After provides a mock function with given fields: d, opts

func (*MockContext) AttachInvocation added in v0.16.0 

func (_m *MockContext) AttachInvocation(invocationId string, opts ...options.AttachOption) restatecontext.AttachFuture

AttachInvocation provides a mock function with given fields: invocationId, opts

func (*MockContext) Awakeable 

func (_m *MockContext) Awakeable(_a0 ...options.AwakeableOption) restatecontext.AwakeableFuture

Awakeable provides a mock function with given fields: _a0

func (*MockContext) CancelInvocation added in v0.16.0 

func (_m *MockContext) CancelInvocation(invocationId string)

CancelInvocation provides a mock function with given fields: invocationId

func (*MockContext) Clear 

func (_m *MockContext) Clear(key string)

Clear provides a mock function with given fields: key

func (*MockContext) ClearAll 

func (_m *MockContext) ClearAll()

ClearAll provides a mock function with no fields

func (*MockContext) Deadline 

func (_m *MockContext) Deadline() (time.Time, bool)

Deadline provides a mock function with no fields

func (*MockContext) Done 

func (_m *MockContext) Done() <-chan struct{}

Done provides a mock function with no fields

func (*MockContext) EXPECT 

func (_m *MockContext) EXPECT() *MockContext_Expecter

func (*MockContext) Err 

func (_m *MockContext) Err() error

Err provides a mock function with no fields

func (*MockContext) Get 

func (_m *MockContext) Get(key string, output any, _a2 ...options.GetOption) (bool, error)

Get provides a mock function with given fields: key, output, _a2

func (*MockContext) Key 

func (_m *MockContext) Key() string

Key provides a mock function with no fields

func (*MockContext) Keys 

func (_m *MockContext) Keys() ([]string, error)

Keys provides a mock function with no fields

func (*MockContext) Log 

func (_m *MockContext) Log() *slog.Logger

Log provides a mock function with no fields

func (*MockContext) Object 

func (_m *MockContext) Object(service string, key string, method string, _a3 ...options.ClientOption) restatecontext.Client

Object provides a mock function with given fields: service, key, method, _a3

func (*MockContext) Promise 

func (_m *MockContext) Promise(name string, _a1 ...options.PromiseOption) restatecontext.DurablePromise

Promise provides a mock function with given fields: name, _a1

func (*MockContext) Rand 

func (_m *MockContext) Rand() rand.Rand

Rand provides a mock function with no fields

func (*MockContext) RejectAwakeable 

func (_m *MockContext) RejectAwakeable(id string, reason error)

RejectAwakeable provides a mock function with given fields: id, reason

func (*MockContext) Request 

func (_m *MockContext) Request() *restatecontext.Request

Request provides a mock function with no fields

func (*MockContext) ResolveAwakeable 

func (_m *MockContext) ResolveAwakeable(id string, value any, _a2 ...options.ResolveAwakeableOption)

ResolveAwakeable provides a mock function with given fields: id, value, _a2

func (*MockContext) Run 

func (_m *MockContext) Run(fn func(restatecontext.RunContext) (any, error), output any, _a2 ...options.RunOption) error

Run provides a mock function with given fields: fn, output, _a2

func (*MockContext) RunAsync added in v0.17.0 

func (_m *MockContext) RunAsync(fn func(restatecontext.RunContext) (any, error), _a1 ...options.RunOption) restatecontext.RunAsyncFuture

RunAsync provides a mock function with given fields: fn, _a1

func (*MockContext) Select 

func (_m *MockContext) Select(futs ...restatecontext.Selectable) restatecontext.Selector

Select provides a mock function with given fields: futs

func (*MockContext) Service 

func (_m *MockContext) Service(service string, method string, _a2 ...options.ClientOption) restatecontext.Client

Service provides a mock function with given fields: service, method, _a2

func (*MockContext) Set 

func (_m *MockContext) Set(key string, value any, _a2 ...options.SetOption)

Set provides a mock function with given fields: key, value, _a2

func (*MockContext) Sleep 

func (_m *MockContext) Sleep(d time.Duration, opts ...options.SleepOption) error

Sleep provides a mock function with given fields: d, opts

func (*MockContext) Value 

func (_m *MockContext) Value(key any) any

Value provides a mock function with given fields: key

func (*MockContext) WaitIter added in v0.21.0 

func (_m *MockContext) WaitIter(futs ...restatecontext.Selectable) restatecontext.WaitIterator

WaitIter provides a mock function with given fields: futs

func (*MockContext) Workflow 

func (_m *MockContext) Workflow(seservice string, workflowID string, method string, _a3 ...options.ClientOption) restatecontext.Client

Workflow provides a mock function with given fields: seservice, workflowID, method, _a3

func (*MockContext) Wrap added in v0.23.0 

func (_m *MockContext) Wrap(wrappedCtx context.Context) restatecontext.Context

Wrap provides a mock function with given fields: wrappedCtx

type MockContext_After_Call 

type MockContext_After_Call struct {
	*mock.Call
}

MockContext_After_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'After'

func (*MockContext_After_Call) Return 

func (_c *MockContext_After_Call) Return(_a0 restatecontext.AfterFuture) *MockContext_After_Call

func (*MockContext_After_Call) Run 

func (_c *MockContext_After_Call) Run(run func(d time.Duration, opts ...options.SleepOption)) *MockContext_After_Call

func (*MockContext_After_Call) RunAndReturn 

func (_c *MockContext_After_Call) RunAndReturn(run func(time.Duration, ...options.SleepOption) restatecontext.AfterFuture) *MockContext_After_Call

type MockContext_AttachInvocation_Call added in v0.16.0 

type MockContext_AttachInvocation_Call struct {
	*mock.Call
}

MockContext_AttachInvocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachInvocation'

func (*MockContext_AttachInvocation_Call) Return added in v0.16.0 

func (_c *MockContext_AttachInvocation_Call) Return(_a0 restatecontext.AttachFuture) *MockContext_AttachInvocation_Call

func (*MockContext_AttachInvocation_Call) Run added in v0.16.0 

func (_c *MockContext_AttachInvocation_Call) Run(run func(invocationId string, opts ...options.AttachOption)) *MockContext_AttachInvocation_Call

func (*MockContext_AttachInvocation_Call) RunAndReturn added in v0.16.0 

func (_c *MockContext_AttachInvocation_Call) RunAndReturn(run func(string, ...options.AttachOption) restatecontext.AttachFuture) *MockContext_AttachInvocation_Call

type MockContext_Awakeable_Call 

type MockContext_Awakeable_Call struct {
	*mock.Call
}

MockContext_Awakeable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Awakeable'

func (*MockContext_Awakeable_Call) Return 

func (_c *MockContext_Awakeable_Call) Return(_a0 restatecontext.AwakeableFuture) *MockContext_Awakeable_Call

func (*MockContext_Awakeable_Call) Run 

func (_c *MockContext_Awakeable_Call) Run(run func(_a0 ...options.AwakeableOption)) *MockContext_Awakeable_Call

func (*MockContext_Awakeable_Call) RunAndReturn 

func (_c *MockContext_Awakeable_Call) RunAndReturn(run func(...options.AwakeableOption) restatecontext.AwakeableFuture) *MockContext_Awakeable_Call

type MockContext_CancelInvocation_Call added in v0.16.0 

type MockContext_CancelInvocation_Call struct {
	*mock.Call
}

MockContext_CancelInvocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelInvocation'

func (*MockContext_CancelInvocation_Call) Return added in v0.16.0 

func (_c *MockContext_CancelInvocation_Call) Return() *MockContext_CancelInvocation_Call

func (*MockContext_CancelInvocation_Call) Run added in v0.16.0 

func (_c *MockContext_CancelInvocation_Call) Run(run func(invocationId string)) *MockContext_CancelInvocation_Call

func (*MockContext_CancelInvocation_Call) RunAndReturn added in v0.16.0 

func (_c *MockContext_CancelInvocation_Call) RunAndReturn(run func(string)) *MockContext_CancelInvocation_Call

type MockContext_ClearAll_Call 

type MockContext_ClearAll_Call struct {
	*mock.Call
}

MockContext_ClearAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearAll'

func (*MockContext_ClearAll_Call) Return 

func (_c *MockContext_ClearAll_Call) Return() *MockContext_ClearAll_Call

func (*MockContext_ClearAll_Call) Run 

func (_c *MockContext_ClearAll_Call) Run(run func()) *MockContext_ClearAll_Call

func (*MockContext_ClearAll_Call) RunAndReturn 

func (_c *MockContext_ClearAll_Call) RunAndReturn(run func()) *MockContext_ClearAll_Call

type MockContext_Clear_Call 

type MockContext_Clear_Call struct {
	*mock.Call
}

MockContext_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'

func (*MockContext_Clear_Call) Return 

func (_c *MockContext_Clear_Call) Return() *MockContext_Clear_Call

func (*MockContext_Clear_Call) Run 

func (_c *MockContext_Clear_Call) Run(run func(key string)) *MockContext_Clear_Call

func (*MockContext_Clear_Call) RunAndReturn 

func (_c *MockContext_Clear_Call) RunAndReturn(run func(string)) *MockContext_Clear_Call

type MockContext_Deadline_Call 

type MockContext_Deadline_Call struct {
	*mock.Call
}

MockContext_Deadline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Deadline'

func (*MockContext_Deadline_Call) Return 

func (_c *MockContext_Deadline_Call) Return(deadline time.Time, ok bool) *MockContext_Deadline_Call

func (*MockContext_Deadline_Call) Run 

func (_c *MockContext_Deadline_Call) Run(run func()) *MockContext_Deadline_Call

func (*MockContext_Deadline_Call) RunAndReturn 

func (_c *MockContext_Deadline_Call) RunAndReturn(run func() (time.Time, bool)) *MockContext_Deadline_Call

type MockContext_Done_Call 

type MockContext_Done_Call struct {
	*mock.Call
}

MockContext_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'

func (*MockContext_Done_Call) Return 

func (_c *MockContext_Done_Call) Return(_a0 <-chan struct{}) *MockContext_Done_Call

func (*MockContext_Done_Call) Run 

func (_c *MockContext_Done_Call) Run(run func()) *MockContext_Done_Call

func (*MockContext_Done_Call) RunAndReturn 

func (_c *MockContext_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockContext_Done_Call

type MockContext_Err_Call 

type MockContext_Err_Call struct {
	*mock.Call
}

MockContext_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'

func (*MockContext_Err_Call) Return 

func (_c *MockContext_Err_Call) Return(_a0 error) *MockContext_Err_Call

func (*MockContext_Err_Call) Run 

func (_c *MockContext_Err_Call) Run(run func()) *MockContext_Err_Call

func (*MockContext_Err_Call) RunAndReturn 

func (_c *MockContext_Err_Call) RunAndReturn(run func() error) *MockContext_Err_Call

type MockContext_Expecter 

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

func (*MockContext_Expecter) After 

func (_e *MockContext_Expecter) After(d interface{}, opts ...interface{}) *MockContext_After_Call

After is a helper method to define mock.On call

  • d time.Duration
  • opts ...options.SleepOption

func (*MockContext_Expecter) AttachInvocation added in v0.16.0 

func (_e *MockContext_Expecter) AttachInvocation(invocationId interface{}, opts ...interface{}) *MockContext_AttachInvocation_Call

AttachInvocation is a helper method to define mock.On call

  • invocationId string
  • opts ...options.AttachOption

func (*MockContext_Expecter) Awakeable 

func (_e *MockContext_Expecter) Awakeable(_a0 ...interface{}) *MockContext_Awakeable_Call

Awakeable is a helper method to define mock.On call

  • _a0 ...options.AwakeableOption

func (*MockContext_Expecter) CancelInvocation added in v0.16.0 

func (_e *MockContext_Expecter) CancelInvocation(invocationId interface{}) *MockContext_CancelInvocation_Call

CancelInvocation is a helper method to define mock.On call

  • invocationId string

func (*MockContext_Expecter) Clear 

func (_e *MockContext_Expecter) Clear(key interface{}) *MockContext_Clear_Call

Clear is a helper method to define mock.On call

  • key string

func (*MockContext_Expecter) ClearAll 

func (_e *MockContext_Expecter) ClearAll() *MockContext_ClearAll_Call

ClearAll is a helper method to define mock.On call

func (*MockContext_Expecter) Deadline 

func (_e *MockContext_Expecter) Deadline() *MockContext_Deadline_Call

Deadline is a helper method to define mock.On call

func (*MockContext_Expecter) Done 

func (_e *MockContext_Expecter) Done() *MockContext_Done_Call

Done is a helper method to define mock.On call

func (*MockContext_Expecter) Err 

func (_e *MockContext_Expecter) Err() *MockContext_Err_Call

Err is a helper method to define mock.On call

func (*MockContext_Expecter) Get 

func (_e *MockContext_Expecter) Get(key interface{}, output interface{}, _a2 ...interface{}) *MockContext_Get_Call

Get is a helper method to define mock.On call

  • key string
  • output any
  • _a2 ...options.GetOption

func (*MockContext_Expecter) GetAndReturn 

func (_e *MockContext_Expecter) GetAndReturn(key interface{}, value any) *MockContext_Get_Call

GetAndReturn is a helper method to mock a typical 'Get' call; return a concrete value, or no value if nil interface is provided

func (*MockContext_Expecter) Key 

func (_e *MockContext_Expecter) Key() *MockContext_Key_Call

Key is a helper method to define mock.On call

func (*MockContext_Expecter) Keys 

func (_e *MockContext_Expecter) Keys() *MockContext_Keys_Call

Keys is a helper method to define mock.On call

func (*MockContext_Expecter) Log 

func (_e *MockContext_Expecter) Log() *MockContext_Log_Call

Log is a helper method to define mock.On call

func (*MockContext_Expecter) MockAfter 

func (_e *MockContext_Expecter) MockAfter(duration interface{}) *MockAfterFuture

MockAfter is a helper method to mock a typical 'After' call on a ctx; return a mocked AfterFuture object

func (*MockContext_Expecter) MockObjectClient 

func (_e *MockContext_Expecter) MockObjectClient(service, key, method interface{}) *MockClient_Expecter

MockObjectClient is a helper method to mock a typical 'Object' call on a ctx; return a mocked Client object

func (*MockContext_Expecter) MockRand 

func (_e *MockContext_Expecter) MockRand() *MockRand_Expecter

MockRand is a helper method to mock a typical 'Rand' call on a ctx; return a mocked Rand object

func (*MockContext_Expecter) MockSelector 

func (_e *MockContext_Expecter) MockSelector(futs ...interface{}) *MockSelector_Expecter

MockSelector is a helper method to mock a typical 'Select' call on a ctx; return a mocked Selector object

func (*MockContext_Expecter) MockServiceClient 

func (_e *MockContext_Expecter) MockServiceClient(service, method interface{}) *MockClient_Expecter

MockServiceClient is a helper method to mock a typical 'Service' call on a ctx; return a mocked Client object

func (*MockContext_Expecter) MockWaitIter added in v0.21.0 

func (_e *MockContext_Expecter) MockWaitIter(futs ...interface{}) *MockWaitIterator_Expecter

MockWaitIter is a helper method to mock a typical WaitIter call on a ctx; return a mocked WaitIterator object

func (*MockContext_Expecter) MockWorkflowClient 

func (_e *MockContext_Expecter) MockWorkflowClient(service, workflowID, method interface{}) *MockClient_Expecter

MockWorkflowClient is a helper method to mock a typical 'Workflow' call on a ctx; return a mocked Client object

func (*MockContext_Expecter) Object 

func (_e *MockContext_Expecter) Object(service interface{}, key interface{}, method interface{}, _a3 ...interface{}) *MockContext_Object_Call

Object is a helper method to define mock.On call

  • service string
  • key string
  • method string
  • _a3 ...options.ClientOption

func (*MockContext_Expecter) Promise 

func (_e *MockContext_Expecter) Promise(name interface{}, _a1 ...interface{}) *MockContext_Promise_Call

Promise is a helper method to define mock.On call

  • name string
  • _a1 ...options.PromiseOption

func (*MockContext_Expecter) PromiseByName 

func (_e *MockContext_Expecter) PromiseByName(promiseName string) *MockDurablePromise_Expecter

func (*MockContext_Expecter) Rand 

func (_e *MockContext_Expecter) Rand() *MockContext_Rand_Call

Rand is a helper method to define mock.On call

func (*MockContext_Expecter) RejectAwakeable 

func (_e *MockContext_Expecter) RejectAwakeable(id interface{}, reason interface{}) *MockContext_RejectAwakeable_Call

RejectAwakeable is a helper method to define mock.On call

  • id string
  • reason error

func (*MockContext_Expecter) Request 

func (_e *MockContext_Expecter) Request() *MockContext_Request_Call

Request is a helper method to define mock.On call

func (*MockContext_Expecter) ResolveAwakeable 

func (_e *MockContext_Expecter) ResolveAwakeable(id interface{}, value interface{}, _a2 ...interface{}) *MockContext_ResolveAwakeable_Call

ResolveAwakeable is a helper method to define mock.On call

  • id string
  • value any
  • _a2 ...options.ResolveAwakeableOption

func (*MockContext_Expecter) Run 

func (_e *MockContext_Expecter) Run(fn interface{}, output interface{}, _a2 ...interface{}) *MockContext_Run_Call

Run is a helper method to define mock.On call

  • fn func(restatecontext.RunContext)(any , error)
  • output any
  • _a2 ...options.RunOption

func (*MockContext_Expecter) RunAndExpect 

func (_e *MockContext_Expecter) RunAndExpect(ctx restatecontext.RunContext, expectedValue any, expectedErr error) *MockContext_Run_Call

RunAndExpect is a helper method to mock a 'Run' call where you want to execute the function provided to Run. Non terminal errors will be retried indefinitely, subject to a 1 second delay between retries. The final result or terminal error will be compared to the provided values.

func (*MockContext_Expecter) RunAndReturn 

func (_e *MockContext_Expecter) RunAndReturn(value any, err error) *MockContext_Run_Call

RunAndReturn is a helper method to mock a typical 'Run' call; return a concrete value or an error

func (*MockContext_Expecter) RunAsync added in v0.17.0 

func (_e *MockContext_Expecter) RunAsync(fn interface{}, _a1 ...interface{}) *MockContext_RunAsync_Call

RunAsync is a helper method to define mock.On call

  • fn func(restatecontext.RunContext)(any , error)
  • _a1 ...options.RunOption

func (*MockContext_Expecter) Select 

func (_e *MockContext_Expecter) Select(futs ...interface{}) *MockContext_Select_Call

Select is a helper method to define mock.On call

  • futs ...restatecontext.Selectable

func (*MockContext_Expecter) Service 

func (_e *MockContext_Expecter) Service(service interface{}, method interface{}, _a2 ...interface{}) *MockContext_Service_Call

Service is a helper method to define mock.On call

  • service string
  • method string
  • _a2 ...options.ClientOption

func (*MockContext_Expecter) Set 

func (_e *MockContext_Expecter) Set(key interface{}, value interface{}, _a2 ...interface{}) *MockContext_Set_Call

Set is a helper method to define mock.On call

  • key string
  • value any
  • _a2 ...options.SetOption

func (*MockContext_Expecter) Sleep 

func (_e *MockContext_Expecter) Sleep(d interface{}, opts ...interface{}) *MockContext_Sleep_Call

Sleep is a helper method to define mock.On call

  • d time.Duration
  • opts ...options.SleepOption

func (*MockContext_Expecter) Value 

func (_e *MockContext_Expecter) Value(key interface{}) *MockContext_Value_Call

Value is a helper method to define mock.On call

  • key any

func (*MockContext_Expecter) WaitIter added in v0.21.0 

func (_e *MockContext_Expecter) WaitIter(futs ...interface{}) *MockContext_WaitIter_Call

WaitIter is a helper method to define mock.On call

  • futs ...restatecontext.Selectable

func (*MockContext_Expecter) Workflow 

func (_e *MockContext_Expecter) Workflow(seservice interface{}, workflowID interface{}, method interface{}, _a3 ...interface{}) *MockContext_Workflow_Call

Workflow is a helper method to define mock.On call

  • seservice string
  • workflowID string
  • method string
  • _a3 ...options.ClientOption

func (*MockContext_Expecter) Wrap added in v0.23.0 

func (_e *MockContext_Expecter) Wrap(wrappedCtx interface{}) *MockContext_Wrap_Call

Wrap is a helper method to define mock.On call

  • wrappedCtx context.Context

type MockContext_Get_Call 

type MockContext_Get_Call struct {
	*mock.Call
}

MockContext_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockContext_Get_Call) Return 

func (_c *MockContext_Get_Call) Return(_a0 bool, _a1 error) *MockContext_Get_Call

func (*MockContext_Get_Call) Run 

func (_c *MockContext_Get_Call) Run(run func(key string, output any, _a2 ...options.GetOption)) *MockContext_Get_Call

func (*MockContext_Get_Call) RunAndReturn 

func (_c *MockContext_Get_Call) RunAndReturn(run func(string, any, ...options.GetOption) (bool, error)) *MockContext_Get_Call

type MockContext_Key_Call 

type MockContext_Key_Call struct {
	*mock.Call
}

MockContext_Key_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Key'

func (*MockContext_Key_Call) Return 

func (_c *MockContext_Key_Call) Return(_a0 string) *MockContext_Key_Call

func (*MockContext_Key_Call) Run 

func (_c *MockContext_Key_Call) Run(run func()) *MockContext_Key_Call

func (*MockContext_Key_Call) RunAndReturn 

func (_c *MockContext_Key_Call) RunAndReturn(run func() string) *MockContext_Key_Call

type MockContext_Keys_Call 

type MockContext_Keys_Call struct {
	*mock.Call
}

MockContext_Keys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Keys'

func (*MockContext_Keys_Call) Return 

func (_c *MockContext_Keys_Call) Return(_a0 []string, _a1 error) *MockContext_Keys_Call

func (*MockContext_Keys_Call) Run 

func (_c *MockContext_Keys_Call) Run(run func()) *MockContext_Keys_Call

func (*MockContext_Keys_Call) RunAndReturn 

func (_c *MockContext_Keys_Call) RunAndReturn(run func() ([]string, error)) *MockContext_Keys_Call

type MockContext_Log_Call 

type MockContext_Log_Call struct {
	*mock.Call
}

MockContext_Log_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Log'

func (*MockContext_Log_Call) Return 

func (_c *MockContext_Log_Call) Return(_a0 *slog.Logger) *MockContext_Log_Call

func (*MockContext_Log_Call) Run 

func (_c *MockContext_Log_Call) Run(run func()) *MockContext_Log_Call

func (*MockContext_Log_Call) RunAndReturn 

func (_c *MockContext_Log_Call) RunAndReturn(run func() *slog.Logger) *MockContext_Log_Call

type MockContext_Object_Call 

type MockContext_Object_Call struct {
	*mock.Call
}

MockContext_Object_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Object'

func (*MockContext_Object_Call) Return 

func (_c *MockContext_Object_Call) Return(_a0 restatecontext.Client) *MockContext_Object_Call

func (*MockContext_Object_Call) Run 

func (_c *MockContext_Object_Call) Run(run func(service string, key string, method string, _a3 ...options.ClientOption)) *MockContext_Object_Call

func (*MockContext_Object_Call) RunAndReturn 

func (_c *MockContext_Object_Call) RunAndReturn(run func(string, string, string, ...options.ClientOption) restatecontext.Client) *MockContext_Object_Call

type MockContext_Promise_Call 

type MockContext_Promise_Call struct {
	*mock.Call
}

MockContext_Promise_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Promise'

func (*MockContext_Promise_Call) Return 

func (_c *MockContext_Promise_Call) Return(_a0 restatecontext.DurablePromise) *MockContext_Promise_Call

func (*MockContext_Promise_Call) Run 

func (_c *MockContext_Promise_Call) Run(run func(name string, _a1 ...options.PromiseOption)) *MockContext_Promise_Call

func (*MockContext_Promise_Call) RunAndReturn 

func (_c *MockContext_Promise_Call) RunAndReturn(run func(string, ...options.PromiseOption) restatecontext.DurablePromise) *MockContext_Promise_Call

type MockContext_Rand_Call 

type MockContext_Rand_Call struct {
	*mock.Call
}

MockContext_Rand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Rand'

func (*MockContext_Rand_Call) Return 

func (_c *MockContext_Rand_Call) Return(_a0 rand.Rand) *MockContext_Rand_Call

func (*MockContext_Rand_Call) Run 

func (_c *MockContext_Rand_Call) Run(run func()) *MockContext_Rand_Call

func (*MockContext_Rand_Call) RunAndReturn 

func (_c *MockContext_Rand_Call) RunAndReturn(run func() rand.Rand) *MockContext_Rand_Call

type MockContext_RejectAwakeable_Call 

type MockContext_RejectAwakeable_Call struct {
	*mock.Call
}

MockContext_RejectAwakeable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectAwakeable'

func (*MockContext_RejectAwakeable_Call) Return 

func (_c *MockContext_RejectAwakeable_Call) Return() *MockContext_RejectAwakeable_Call

func (*MockContext_RejectAwakeable_Call) Run 

func (_c *MockContext_RejectAwakeable_Call) Run(run func(id string, reason error)) *MockContext_RejectAwakeable_Call

func (*MockContext_RejectAwakeable_Call) RunAndReturn 

func (_c *MockContext_RejectAwakeable_Call) RunAndReturn(run func(string, error)) *MockContext_RejectAwakeable_Call

type MockContext_Request_Call 

type MockContext_Request_Call struct {
	*mock.Call
}

MockContext_Request_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Request'

func (*MockContext_Request_Call) Return 

func (_c *MockContext_Request_Call) Return(_a0 *restatecontext.Request) *MockContext_Request_Call

func (*MockContext_Request_Call) Run 

func (_c *MockContext_Request_Call) Run(run func()) *MockContext_Request_Call

func (*MockContext_Request_Call) RunAndReturn 

func (_c *MockContext_Request_Call) RunAndReturn(run func() *restatecontext.Request) *MockContext_Request_Call

type MockContext_ResolveAwakeable_Call 

type MockContext_ResolveAwakeable_Call struct {
	*mock.Call
}

MockContext_ResolveAwakeable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveAwakeable'

func (*MockContext_ResolveAwakeable_Call) Return 

func (_c *MockContext_ResolveAwakeable_Call) Return() *MockContext_ResolveAwakeable_Call

func (*MockContext_ResolveAwakeable_Call) Run 

func (_c *MockContext_ResolveAwakeable_Call) Run(run func(id string, value any, _a2 ...options.ResolveAwakeableOption)) *MockContext_ResolveAwakeable_Call

func (*MockContext_ResolveAwakeable_Call) RunAndReturn 

func (_c *MockContext_ResolveAwakeable_Call) RunAndReturn(run func(string, any, ...options.ResolveAwakeableOption)) *MockContext_ResolveAwakeable_Call

type MockContext_RunAsync_Call added in v0.17.0 

type MockContext_RunAsync_Call struct {
	*mock.Call
}

MockContext_RunAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunAsync'

func (*MockContext_RunAsync_Call) Return added in v0.17.0 

func (_c *MockContext_RunAsync_Call) Return(_a0 restatecontext.RunAsyncFuture) *MockContext_RunAsync_Call

func (*MockContext_RunAsync_Call) Run added in v0.17.0 

func (_c *MockContext_RunAsync_Call) Run(run func(fn func(restatecontext.RunContext) (any, error), _a1 ...options.RunOption)) *MockContext_RunAsync_Call

func (*MockContext_RunAsync_Call) RunAndReturn added in v0.17.0 

func (_c *MockContext_RunAsync_Call) RunAndReturn(run func(func(restatecontext.RunContext) (any, error), ...options.RunOption) restatecontext.RunAsyncFuture) *MockContext_RunAsync_Call

type MockContext_Run_Call 

type MockContext_Run_Call struct {
	*mock.Call
}

MockContext_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run'

func (*MockContext_Run_Call) Return 

func (_c *MockContext_Run_Call) Return(_a0 error) *MockContext_Run_Call

func (*MockContext_Run_Call) Run 

func (_c *MockContext_Run_Call) Run(run func(fn func(restatecontext.RunContext) (any, error), output any, _a2 ...options.RunOption)) *MockContext_Run_Call

func (*MockContext_Run_Call) RunAndReturn 

func (_c *MockContext_Run_Call) RunAndReturn(run func(func(restatecontext.RunContext) (any, error), any, ...options.RunOption) error) *MockContext_Run_Call

type MockContext_Select_Call 

type MockContext_Select_Call struct {
	*mock.Call
}

MockContext_Select_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Select'

func (*MockContext_Select_Call) Return 

func (_c *MockContext_Select_Call) Return(_a0 restatecontext.Selector) *MockContext_Select_Call

func (*MockContext_Select_Call) Run 

func (_c *MockContext_Select_Call) Run(run func(futs ...restatecontext.Selectable)) *MockContext_Select_Call

func (*MockContext_Select_Call) RunAndReturn 

func (_c *MockContext_Select_Call) RunAndReturn(run func(...restatecontext.Selectable) restatecontext.Selector) *MockContext_Select_Call

type MockContext_Service_Call 

type MockContext_Service_Call struct {
	*mock.Call
}

MockContext_Service_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Service'

func (*MockContext_Service_Call) Return 

func (_c *MockContext_Service_Call) Return(_a0 restatecontext.Client) *MockContext_Service_Call

func (*MockContext_Service_Call) Run 

func (_c *MockContext_Service_Call) Run(run func(service string, method string, _a2 ...options.ClientOption)) *MockContext_Service_Call

func (*MockContext_Service_Call) RunAndReturn 

func (_c *MockContext_Service_Call) RunAndReturn(run func(string, string, ...options.ClientOption) restatecontext.Client) *MockContext_Service_Call

type MockContext_Set_Call 

type MockContext_Set_Call struct {
	*mock.Call
}

MockContext_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'

func (*MockContext_Set_Call) Return 

func (_c *MockContext_Set_Call) Return() *MockContext_Set_Call

func (*MockContext_Set_Call) Run 

func (_c *MockContext_Set_Call) Run(run func(key string, value any, _a2 ...options.SetOption)) *MockContext_Set_Call

func (*MockContext_Set_Call) RunAndReturn 

func (_c *MockContext_Set_Call) RunAndReturn(run func(string, any, ...options.SetOption)) *MockContext_Set_Call

type MockContext_Sleep_Call 

type MockContext_Sleep_Call struct {
	*mock.Call
}

MockContext_Sleep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sleep'

func (*MockContext_Sleep_Call) Return 

func (_c *MockContext_Sleep_Call) Return(_a0 error) *MockContext_Sleep_Call

func (*MockContext_Sleep_Call) Run 

func (_c *MockContext_Sleep_Call) Run(run func(d time.Duration, opts ...options.SleepOption)) *MockContext_Sleep_Call

func (*MockContext_Sleep_Call) RunAndReturn 

func (_c *MockContext_Sleep_Call) RunAndReturn(run func(time.Duration, ...options.SleepOption) error) *MockContext_Sleep_Call

type MockContext_Value_Call 

type MockContext_Value_Call struct {
	*mock.Call
}

MockContext_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value'

func (*MockContext_Value_Call) Return 

func (_c *MockContext_Value_Call) Return(_a0 any) *MockContext_Value_Call

func (*MockContext_Value_Call) Run 

func (_c *MockContext_Value_Call) Run(run func(key any)) *MockContext_Value_Call

func (*MockContext_Value_Call) RunAndReturn 

func (_c *MockContext_Value_Call) RunAndReturn(run func(any) any) *MockContext_Value_Call

type MockContext_WaitIter_Call added in v0.21.0 

type MockContext_WaitIter_Call struct {
	*mock.Call
}

MockContext_WaitIter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitIter'

func (*MockContext_WaitIter_Call) Return added in v0.21.0 

func (_c *MockContext_WaitIter_Call) Return(_a0 restatecontext.WaitIterator) *MockContext_WaitIter_Call

func (*MockContext_WaitIter_Call) Run added in v0.21.0 

func (_c *MockContext_WaitIter_Call) Run(run func(futs ...restatecontext.Selectable)) *MockContext_WaitIter_Call

func (*MockContext_WaitIter_Call) RunAndReturn added in v0.21.0 

func (_c *MockContext_WaitIter_Call) RunAndReturn(run func(...restatecontext.Selectable) restatecontext.WaitIterator) *MockContext_WaitIter_Call

type MockContext_Workflow_Call 

type MockContext_Workflow_Call struct {
	*mock.Call
}

MockContext_Workflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Workflow'

func (*MockContext_Workflow_Call) Return 

func (_c *MockContext_Workflow_Call) Return(_a0 restatecontext.Client) *MockContext_Workflow_Call

func (*MockContext_Workflow_Call) Run 

func (_c *MockContext_Workflow_Call) Run(run func(seservice string, workflowID string, method string, _a3 ...options.ClientOption)) *MockContext_Workflow_Call

func (*MockContext_Workflow_Call) RunAndReturn 

func (_c *MockContext_Workflow_Call) RunAndReturn(run func(string, string, string, ...options.ClientOption) restatecontext.Client) *MockContext_Workflow_Call

type MockContext_Wrap_Call added in v0.23.0 

type MockContext_Wrap_Call struct {
	*mock.Call
}

MockContext_Wrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wrap'

func (*MockContext_Wrap_Call) Return added in v0.23.0 

func (_c *MockContext_Wrap_Call) Return(_a0 restatecontext.Context) *MockContext_Wrap_Call

func (*MockContext_Wrap_Call) Run added in v0.23.0 

func (_c *MockContext_Wrap_Call) Run(run func(wrappedCtx context.Context)) *MockContext_Wrap_Call

func (*MockContext_Wrap_Call) RunAndReturn added in v0.23.0 

func (_c *MockContext_Wrap_Call) RunAndReturn(run func(context.Context) restatecontext.Context) *MockContext_Wrap_Call

type MockDurablePromise 

type MockDurablePromise struct {
	restatecontext.Selectable
	mock.Mock
}

MockDurablePromise is a mock type for the DurablePromise type

func NewMockDurablePromise 

func NewMockDurablePromise(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockDurablePromise

NewMockDurablePromise creates a new instance of MockDurablePromise. 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 (*MockDurablePromise) EXPECT 

func (_m *MockDurablePromise) EXPECT() *MockDurablePromise_Expecter

func (*MockDurablePromise) Peek 

func (_m *MockDurablePromise) Peek(output any) (bool, error)

Peek provides a mock function with given fields: output

func (*MockDurablePromise) Reject 

func (_m *MockDurablePromise) Reject(reason error) error

Reject provides a mock function with given fields: reason

func (*MockDurablePromise) Resolve 

func (_m *MockDurablePromise) Resolve(value any) error

Resolve provides a mock function with given fields: value

func (*MockDurablePromise) Result 

func (_m *MockDurablePromise) Result(output any) error

Result provides a mock function with given fields: output

type MockDurablePromise_Expecter 

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

func (*MockDurablePromise_Expecter) Peek 

func (_e *MockDurablePromise_Expecter) Peek(output interface{}) *MockDurablePromise_Peek_Call

Peek is a helper method to define mock.On call

  • output any

func (*MockDurablePromise_Expecter) PeekAndReturn 

func (_e *MockDurablePromise_Expecter) PeekAndReturn(value any, ok bool, err error) *MockDurablePromise_Peek_Call

PeekAndReturn is a helper method to mock a typical 'Peek' call on a DurablePromise; return a concrete value, no value, or an error

func (*MockDurablePromise_Expecter) Reject 

func (_e *MockDurablePromise_Expecter) Reject(reason interface{}) *MockDurablePromise_Reject_Call

Reject is a helper method to define mock.On call

  • reason error

func (*MockDurablePromise_Expecter) Resolve 

func (_e *MockDurablePromise_Expecter) Resolve(value interface{}) *MockDurablePromise_Resolve_Call

Resolve is a helper method to define mock.On call

  • value any

func (*MockDurablePromise_Expecter) Result 

func (_e *MockDurablePromise_Expecter) Result(output interface{}) *MockDurablePromise_Result_Call

Result is a helper method to define mock.On call

  • output any

func (*MockDurablePromise_Expecter) ResultAndReturn 

func (_e *MockDurablePromise_Expecter) ResultAndReturn(value any, err error) *MockDurablePromise_Result_Call

ResultAndReturn is a helper method to mock a typical 'Result' call on a DurablePromise; return a concrete value or an error

type MockDurablePromise_Peek_Call 

type MockDurablePromise_Peek_Call struct {
	*mock.Call
}

MockDurablePromise_Peek_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Peek'

func (*MockDurablePromise_Peek_Call) Return 

func (_c *MockDurablePromise_Peek_Call) Return(ok bool, err error) *MockDurablePromise_Peek_Call

func (*MockDurablePromise_Peek_Call) Run 

func (_c *MockDurablePromise_Peek_Call) Run(run func(output any)) *MockDurablePromise_Peek_Call

func (*MockDurablePromise_Peek_Call) RunAndReturn 

func (_c *MockDurablePromise_Peek_Call) RunAndReturn(run func(any) (bool, error)) *MockDurablePromise_Peek_Call

type MockDurablePromise_Reject_Call 

type MockDurablePromise_Reject_Call struct {
	*mock.Call
}

MockDurablePromise_Reject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reject'

func (*MockDurablePromise_Reject_Call) Return 

func (_c *MockDurablePromise_Reject_Call) Return(_a0 error) *MockDurablePromise_Reject_Call

func (*MockDurablePromise_Reject_Call) Run 

func (_c *MockDurablePromise_Reject_Call) Run(run func(reason error)) *MockDurablePromise_Reject_Call

func (*MockDurablePromise_Reject_Call) RunAndReturn 

func (_c *MockDurablePromise_Reject_Call) RunAndReturn(run func(error) error) *MockDurablePromise_Reject_Call

type MockDurablePromise_Resolve_Call 

type MockDurablePromise_Resolve_Call struct {
	*mock.Call
}

MockDurablePromise_Resolve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resolve'

func (*MockDurablePromise_Resolve_Call) Return 

func (_c *MockDurablePromise_Resolve_Call) Return(_a0 error) *MockDurablePromise_Resolve_Call

func (*MockDurablePromise_Resolve_Call) Run 

func (_c *MockDurablePromise_Resolve_Call) Run(run func(value any)) *MockDurablePromise_Resolve_Call

func (*MockDurablePromise_Resolve_Call) RunAndReturn 

func (_c *MockDurablePromise_Resolve_Call) RunAndReturn(run func(any) error) *MockDurablePromise_Resolve_Call

type MockDurablePromise_Result_Call 

type MockDurablePromise_Result_Call struct {
	*mock.Call
}

MockDurablePromise_Result_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Result'

func (*MockDurablePromise_Result_Call) Return 

func (_c *MockDurablePromise_Result_Call) Return(err error) *MockDurablePromise_Result_Call

func (*MockDurablePromise_Result_Call) Run 

func (_c *MockDurablePromise_Result_Call) Run(run func(output any)) *MockDurablePromise_Result_Call

func (*MockDurablePromise_Result_Call) RunAndReturn 

func (_c *MockDurablePromise_Result_Call) RunAndReturn(run func(any) error) *MockDurablePromise_Result_Call

type MockDurablePromise_handle_Call added in v0.16.0 

type MockDurablePromise_handle_Call struct {
	*mock.Call
}

MockDurablePromise_handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'handle'

func (*MockDurablePromise_handle_Call) Return added in v0.16.0 

func (_c *MockDurablePromise_handle_Call) Return(_a0 uint32) *MockDurablePromise_handle_Call

func (*MockDurablePromise_handle_Call) Run added in v0.16.0 

func (_c *MockDurablePromise_handle_Call) Run(run func()) *MockDurablePromise_handle_Call

func (*MockDurablePromise_handle_Call) RunAndReturn added in v0.16.0 

func (_c *MockDurablePromise_handle_Call) RunAndReturn(run func() uint32) *MockDurablePromise_handle_Call

type MockInvocation added in v0.16.0 

type MockInvocation struct {
	mock.Mock
}

MockInvocation is an autogenerated mock type for the Invocation type

func NewMockInvocation added in v0.16.0 

func NewMockInvocation(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInvocation

NewMockInvocation creates a new instance of MockInvocation. 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 (*MockInvocation) EXPECT added in v0.16.0 

func (_m *MockInvocation) EXPECT() *MockInvocation_Expecter

func (*MockInvocation) GetInvocationId added in v0.16.0 

func (_m *MockInvocation) GetInvocationId() string

GetInvocationId provides a mock function with no fields

type MockInvocation_Expecter added in v0.16.0 

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

func (*MockInvocation_Expecter) GetInvocationId added in v0.16.0 

func (_e *MockInvocation_Expecter) GetInvocationId() *MockInvocation_GetInvocationId_Call

GetInvocationId is a helper method to define mock.On call

type MockInvocation_GetInvocationId_Call added in v0.16.0 

type MockInvocation_GetInvocationId_Call struct {
	*mock.Call
}

MockInvocation_GetInvocationId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInvocationId'

func (*MockInvocation_GetInvocationId_Call) Return added in v0.16.0 

func (_c *MockInvocation_GetInvocationId_Call) Return(_a0 string) *MockInvocation_GetInvocationId_Call

func (*MockInvocation_GetInvocationId_Call) Run added in v0.16.0 

func (_c *MockInvocation_GetInvocationId_Call) Run(run func()) *MockInvocation_GetInvocationId_Call

func (*MockInvocation_GetInvocationId_Call) RunAndReturn added in v0.16.0 

func (_c *MockInvocation_GetInvocationId_Call) RunAndReturn(run func() string) *MockInvocation_GetInvocationId_Call

type MockRand 

type MockRand struct {
	mock.Mock
}

MockRand is an autogenerated mock type for the Rand type

func NewMockRand 

func NewMockRand(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRand

NewMockRand creates a new instance of MockRand. 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 (*MockRand) EXPECT 

func (_m *MockRand) EXPECT() *MockRand_Expecter

func (*MockRand) Float64 

func (_m *MockRand) Float64() float64

Float64 provides a mock function with no fields

func (*MockRand) Source 

func (_m *MockRand) Source() rand.Source

Source provides a mock function with no fields

func (*MockRand) UUID 

func (_m *MockRand) UUID() uuid.UUID

UUID provides a mock function with no fields

func (*MockRand) Uint64 

func (_m *MockRand) Uint64() uint64

Uint64 provides a mock function with no fields

type MockRand_Expecter 

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

func (*MockRand_Expecter) Float64 

func (_e *MockRand_Expecter) Float64() *MockRand_Float64_Call

Float64 is a helper method to define mock.On call

func (*MockRand_Expecter) Source 

func (_e *MockRand_Expecter) Source() *MockRand_Source_Call

Source is a helper method to define mock.On call

func (*MockRand_Expecter) UUID 

func (_e *MockRand_Expecter) UUID() *MockRand_UUID_Call

UUID is a helper method to define mock.On call

func (*MockRand_Expecter) Uint64 

func (_e *MockRand_Expecter) Uint64() *MockRand_Uint64_Call

Uint64 is a helper method to define mock.On call

type MockRand_Float64_Call 

type MockRand_Float64_Call struct {
	*mock.Call
}

MockRand_Float64_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Float64'

func (*MockRand_Float64_Call) Return 

func (_c *MockRand_Float64_Call) Return(_a0 float64) *MockRand_Float64_Call

func (*MockRand_Float64_Call) Run 

func (_c *MockRand_Float64_Call) Run(run func()) *MockRand_Float64_Call

func (*MockRand_Float64_Call) RunAndReturn 

func (_c *MockRand_Float64_Call) RunAndReturn(run func() float64) *MockRand_Float64_Call

type MockRand_Source_Call 

type MockRand_Source_Call struct {
	*mock.Call
}

MockRand_Source_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Source'

func (*MockRand_Source_Call) Return 

func (_c *MockRand_Source_Call) Return(_a0 rand.Source) *MockRand_Source_Call

func (*MockRand_Source_Call) Run 

func (_c *MockRand_Source_Call) Run(run func()) *MockRand_Source_Call

func (*MockRand_Source_Call) RunAndReturn 

func (_c *MockRand_Source_Call) RunAndReturn(run func() rand.Source) *MockRand_Source_Call

type MockRand_UUID_Call 

type MockRand_UUID_Call struct {
	*mock.Call
}

MockRand_UUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UUID'

func (*MockRand_UUID_Call) Return 

func (_c *MockRand_UUID_Call) Return(_a0 uuid.UUID) *MockRand_UUID_Call

func (*MockRand_UUID_Call) Run 

func (_c *MockRand_UUID_Call) Run(run func()) *MockRand_UUID_Call

func (*MockRand_UUID_Call) RunAndReturn 

func (_c *MockRand_UUID_Call) RunAndReturn(run func() uuid.UUID) *MockRand_UUID_Call

type MockRand_Uint64_Call 

type MockRand_Uint64_Call struct {
	*mock.Call
}

MockRand_Uint64_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Uint64'

func (*MockRand_Uint64_Call) Return 

func (_c *MockRand_Uint64_Call) Return(_a0 uint64) *MockRand_Uint64_Call

func (*MockRand_Uint64_Call) Run 

func (_c *MockRand_Uint64_Call) Run(run func()) *MockRand_Uint64_Call

func (*MockRand_Uint64_Call) RunAndReturn 

func (_c *MockRand_Uint64_Call) RunAndReturn(run func() uint64) *MockRand_Uint64_Call

type MockResponseFuture 

type MockResponseFuture struct {
	restatecontext.Selectable
	mock.Mock
}

MockResponseFuture is a mock type for the ResponseFuture type

func NewMockResponseFuture 

func NewMockResponseFuture(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockResponseFuture

NewMockResponseFuture creates a new instance of MockResponseFuture. 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 (*MockResponseFuture) EXPECT 

func (_m *MockResponseFuture) EXPECT() *MockResponseFuture_Expecter

func (*MockResponseFuture) GetInvocationId added in v0.16.0 

func (_m *MockResponseFuture) GetInvocationId() string

GetInvocationId provides a mock function with no fields

func (*MockResponseFuture) Response 

func (_m *MockResponseFuture) Response(output any) error

Response provides a mock function with given fields: output

type MockResponseFuture_Expecter 

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

func (*MockResponseFuture_Expecter) GetInvocationId added in v0.16.0 

func (_e *MockResponseFuture_Expecter) GetInvocationId() *MockResponseFuture_GetInvocationId_Call

GetInvocationId is a helper method to define mock.On call

func (*MockResponseFuture_Expecter) Response 

func (_e *MockResponseFuture_Expecter) Response(output interface{}) *MockResponseFuture_Response_Call

Response is a helper method to define mock.On call

  • output any

func (*MockResponseFuture_Expecter) ResponseAndReturn 

func (_e *MockResponseFuture_Expecter) ResponseAndReturn(value any, err error) *MockResponseFuture_Response_Call

ResponseAndReturn is a helper method to mock a typical 'Response' call on a ResponseFuture; return a concrete value or an error

type MockResponseFuture_GetInvocationId_Call added in v0.16.0 

type MockResponseFuture_GetInvocationId_Call struct {
	*mock.Call
}

MockResponseFuture_GetInvocationId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInvocationId'

func (*MockResponseFuture_GetInvocationId_Call) Return added in v0.16.0 

func (_c *MockResponseFuture_GetInvocationId_Call) Return(_a0 string) *MockResponseFuture_GetInvocationId_Call

func (*MockResponseFuture_GetInvocationId_Call) Run added in v0.16.0 

func (_c *MockResponseFuture_GetInvocationId_Call) Run(run func()) *MockResponseFuture_GetInvocationId_Call

func (*MockResponseFuture_GetInvocationId_Call) RunAndReturn added in v0.16.0 

func (_c *MockResponseFuture_GetInvocationId_Call) RunAndReturn(run func() string) *MockResponseFuture_GetInvocationId_Call

type MockResponseFuture_Response_Call 

type MockResponseFuture_Response_Call struct {
	*mock.Call
}

MockResponseFuture_Response_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Response'

func (*MockResponseFuture_Response_Call) Return 

func (_c *MockResponseFuture_Response_Call) Return(_a0 error) *MockResponseFuture_Response_Call

func (*MockResponseFuture_Response_Call) Run 

func (_c *MockResponseFuture_Response_Call) Run(run func(output any)) *MockResponseFuture_Response_Call

func (*MockResponseFuture_Response_Call) RunAndReturn 

func (_c *MockResponseFuture_Response_Call) RunAndReturn(run func(any) error) *MockResponseFuture_Response_Call

type MockResponseFuture_handle_Call added in v0.16.0 

type MockResponseFuture_handle_Call struct {
	*mock.Call
}

MockResponseFuture_handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'handle'

func (*MockResponseFuture_handle_Call) Return added in v0.16.0 

func (_c *MockResponseFuture_handle_Call) Return(_a0 uint32) *MockResponseFuture_handle_Call

func (*MockResponseFuture_handle_Call) Run added in v0.16.0 

func (_c *MockResponseFuture_handle_Call) Run(run func()) *MockResponseFuture_handle_Call

func (*MockResponseFuture_handle_Call) RunAndReturn added in v0.16.0 

func (_c *MockResponseFuture_handle_Call) RunAndReturn(run func() uint32) *MockResponseFuture_handle_Call

type MockRunAsyncFuture added in v0.17.0 

type MockRunAsyncFuture struct {
	restatecontext.Selectable
	mock.Mock
}

MockRunAsyncFuture is a mock type for the RunAsyncFuture type

func NewMockRunAsyncFuture added in v0.17.0 

func NewMockRunAsyncFuture(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRunAsyncFuture

NewMockRunAsyncFuture creates a new instance of MockRunAsyncFuture. 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 (*MockRunAsyncFuture) EXPECT added in v0.17.0 

func (_m *MockRunAsyncFuture) EXPECT() *MockRunAsyncFuture_Expecter

func (*MockRunAsyncFuture) Result added in v0.17.0 

func (_m *MockRunAsyncFuture) Result(output any) error

Result provides a mock function with given fields: output

type MockRunAsyncFuture_Expecter added in v0.17.0 

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

func (*MockRunAsyncFuture_Expecter) Result added in v0.17.0 

func (_e *MockRunAsyncFuture_Expecter) Result(output interface{}) *MockRunAsyncFuture_Result_Call

Result is a helper method to define mock.On call

  • output any

func (*MockRunAsyncFuture_Expecter) ResultAndReturn added in v0.17.0 

func (_e *MockRunAsyncFuture_Expecter) ResultAndReturn(value any, err error) *MockRunAsyncFuture_Result_Call

ResponseAndReturn is a helper method to mock a typical 'Result' call on a RunAsyncFuture; return a concrete value or an error

type MockRunAsyncFuture_Result_Call added in v0.17.0 

type MockRunAsyncFuture_Result_Call struct {
	*mock.Call
}

MockRunAsyncFuture_Result_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Result'

func (*MockRunAsyncFuture_Result_Call) Return added in v0.17.0 

func (_c *MockRunAsyncFuture_Result_Call) Return(_a0 error) *MockRunAsyncFuture_Result_Call

func (*MockRunAsyncFuture_Result_Call) Run added in v0.17.0 

func (_c *MockRunAsyncFuture_Result_Call) Run(run func(output any)) *MockRunAsyncFuture_Result_Call

func (*MockRunAsyncFuture_Result_Call) RunAndReturn added in v0.17.0 

func (_c *MockRunAsyncFuture_Result_Call) RunAndReturn(run func(any) error) *MockRunAsyncFuture_Result_Call

type MockRunAsyncFuture_handle_Call added in v0.17.0 

type MockRunAsyncFuture_handle_Call struct {
	*mock.Call
}

MockRunAsyncFuture_handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'handle'

func (*MockRunAsyncFuture_handle_Call) Return added in v0.17.0 

func (_c *MockRunAsyncFuture_handle_Call) Return(_a0 uint32) *MockRunAsyncFuture_handle_Call

func (*MockRunAsyncFuture_handle_Call) Run added in v0.17.0 

func (_c *MockRunAsyncFuture_handle_Call) Run(run func()) *MockRunAsyncFuture_handle_Call

func (*MockRunAsyncFuture_handle_Call) RunAndReturn added in v0.17.0 

func (_c *MockRunAsyncFuture_handle_Call) RunAndReturn(run func() uint32) *MockRunAsyncFuture_handle_Call

type MockSelector 

type MockSelector struct {
	mock.Mock
}

MockSelector is an autogenerated mock type for the Selector type

func NewMockSelector 

func NewMockSelector(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSelector

NewMockSelector creates a new instance of MockSelector. 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 (*MockSelector) EXPECT 

func (_m *MockSelector) EXPECT() *MockSelector_Expecter

func (*MockSelector) Remaining 

func (_m *MockSelector) Remaining() bool

Remaining provides a mock function with no fields

func (*MockSelector) Select 

func (_m *MockSelector) Select() restatecontext.Selectable

Select provides a mock function with no fields

type MockSelector_Expecter 

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

func (*MockSelector_Expecter) Remaining 

func (_e *MockSelector_Expecter) Remaining() *MockSelector_Remaining_Call

Remaining is a helper method to define mock.On call

func (*MockSelector_Expecter) Select 

func (_e *MockSelector_Expecter) Select() *MockSelector_Select_Call

Select is a helper method to define mock.On call

type MockSelector_Remaining_Call 

type MockSelector_Remaining_Call struct {
	*mock.Call
}

MockSelector_Remaining_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remaining'

func (*MockSelector_Remaining_Call) Return 

func (_c *MockSelector_Remaining_Call) Return(_a0 bool) *MockSelector_Remaining_Call

func (*MockSelector_Remaining_Call) Run 

func (_c *MockSelector_Remaining_Call) Run(run func()) *MockSelector_Remaining_Call

func (*MockSelector_Remaining_Call) RunAndReturn 

func (_c *MockSelector_Remaining_Call) RunAndReturn(run func() bool) *MockSelector_Remaining_Call

type MockSelector_Select_Call 

type MockSelector_Select_Call struct {
	*mock.Call
}

MockSelector_Select_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Select'

func (*MockSelector_Select_Call) Return 

func (_c *MockSelector_Select_Call) Return(_a0 restatecontext.Selectable) *MockSelector_Select_Call

func (*MockSelector_Select_Call) Run 

func (_c *MockSelector_Select_Call) Run(run func()) *MockSelector_Select_Call

func (*MockSelector_Select_Call) RunAndReturn 

func (_c *MockSelector_Select_Call) RunAndReturn(run func() restatecontext.Selectable) *MockSelector_Select_Call

type MockWaitIterator added in v0.21.0 

type MockWaitIterator struct {
	mock.Mock
}

MockWaitIterator is an autogenerated mock type for the WaitIterator type

func NewMockWaitIterator added in v0.21.0 

func NewMockWaitIterator(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWaitIterator

NewMockWaitIterator creates a new instance of MockWaitIterator. 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 (*MockWaitIterator) EXPECT added in v0.21.0 

func (_m *MockWaitIterator) EXPECT() *MockWaitIterator_Expecter

func (*MockWaitIterator) Err added in v0.21.0 

func (_m *MockWaitIterator) Err() error

Err provides a mock function with no fields

func (*MockWaitIterator) Next added in v0.21.0 

func (_m *MockWaitIterator) Next() bool

Next provides a mock function with no fields

func (*MockWaitIterator) Value added in v0.21.0 

func (_m *MockWaitIterator) Value() restatecontext.Selectable

Value provides a mock function with no fields

type MockWaitIterator_Err_Call added in v0.21.0 

type MockWaitIterator_Err_Call struct {
	*mock.Call
}

MockWaitIterator_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'

func (*MockWaitIterator_Err_Call) Return added in v0.21.0 

func (_c *MockWaitIterator_Err_Call) Return(_a0 error) *MockWaitIterator_Err_Call

func (*MockWaitIterator_Err_Call) Run added in v0.21.0 

func (_c *MockWaitIterator_Err_Call) Run(run func()) *MockWaitIterator_Err_Call

func (*MockWaitIterator_Err_Call) RunAndReturn added in v0.21.0 

func (_c *MockWaitIterator_Err_Call) RunAndReturn(run func() error) *MockWaitIterator_Err_Call

type MockWaitIterator_Expecter added in v0.21.0 

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

func (*MockWaitIterator_Expecter) Err added in v0.21.0 

func (_e *MockWaitIterator_Expecter) Err() *MockWaitIterator_Err_Call

Err is a helper method to define mock.On call

func (*MockWaitIterator_Expecter) Next added in v0.21.0 

func (_e *MockWaitIterator_Expecter) Next() *MockWaitIterator_Next_Call

Next is a helper method to define mock.On call

func (*MockWaitIterator_Expecter) Value added in v0.21.0 

func (_e *MockWaitIterator_Expecter) Value() *MockWaitIterator_Value_Call

Value is a helper method to define mock.On call

type MockWaitIterator_Next_Call added in v0.21.0 

type MockWaitIterator_Next_Call struct {
	*mock.Call
}

MockWaitIterator_Next_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Next'

func (*MockWaitIterator_Next_Call) Return added in v0.21.0 

func (_c *MockWaitIterator_Next_Call) Return(_a0 bool) *MockWaitIterator_Next_Call

func (*MockWaitIterator_Next_Call) Run added in v0.21.0 

func (_c *MockWaitIterator_Next_Call) Run(run func()) *MockWaitIterator_Next_Call

func (*MockWaitIterator_Next_Call) RunAndReturn added in v0.21.0 

func (_c *MockWaitIterator_Next_Call) RunAndReturn(run func() bool) *MockWaitIterator_Next_Call

type MockWaitIterator_Value_Call added in v0.21.0 

type MockWaitIterator_Value_Call struct {
	*mock.Call
}

MockWaitIterator_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value'

func (*MockWaitIterator_Value_Call) Return added in v0.21.0 

func (_c *MockWaitIterator_Value_Call) Return(_a0 restatecontext.Selectable) *MockWaitIterator_Value_Call

func (*MockWaitIterator_Value_Call) Run added in v0.21.0 

func (_c *MockWaitIterator_Value_Call) Run(run func()) *MockWaitIterator_Value_Call

func (*MockWaitIterator_Value_Call) RunAndReturn added in v0.21.0 

func (_c *MockWaitIterator_Value_Call) RunAndReturn(run func() restatecontext.Selectable) *MockWaitIterator_Value_Call

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.