mocks

package

Go to main page

Versions in this module

v0

v0.6.0

Feb 5, 2025

Changes in this version

+ type TestTaskProcessor struct

+ func NewTestTaskPocessor(name string) *TestTaskProcessor

+ func (t *TestTaskProcessor) AbandonWorkItem(ctx context.Context, wi backend.WorkItem) error

+ func (t *TestTaskProcessor) AbandonedWorkItems() []backend.WorkItem

+ func (t *TestTaskProcessor) AddWorkItems(wis ...backend.WorkItem)

+ func (t *TestTaskProcessor) BlockProcessing()

+ func (t *TestTaskProcessor) CompleteWorkItem(ctx context.Context, wi backend.WorkItem) error

+ func (t *TestTaskProcessor) CompletedWorkItems() []backend.WorkItem

+ func (t *TestTaskProcessor) FetchWorkItem(context.Context) (backend.WorkItem, error)

+ func (t *TestTaskProcessor) Name() string

+ func (t *TestTaskProcessor) PendingWorkItems() []backend.WorkItem

+ func (t *TestTaskProcessor) ProcessWorkItem(ctx context.Context, wi backend.WorkItem) error

+ func (t *TestTaskProcessor) UnblockProcessing()

v0.5.0

Jun 28, 2024

v0.4.0

Dec 18, 2023

v0.3.2

Dec 18, 2023

Changes in this version

type Backend_AbandonActivityWorkItem_Call

+ func (_c *Backend_AbandonActivityWorkItem_Call) RunAndReturn(run func(context.Context, *backend.ActivityWorkItem) error) *Backend_AbandonActivityWorkItem_Call

type Backend_AbandonOrchestrationWorkItem_Call

+ func (_c *Backend_AbandonOrchestrationWorkItem_Call) RunAndReturn(run func(context.Context, *backend.OrchestrationWorkItem) error) *Backend_AbandonOrchestrationWorkItem_Call

type Backend_AddNewOrchestrationEvent_Call

+ func (_c *Backend_AddNewOrchestrationEvent_Call) RunAndReturn(run func(context.Context, api.InstanceID, *protos.HistoryEvent) error) *Backend_AddNewOrchestrationEvent_Call

type Backend_CompleteActivityWorkItem_Call

+ func (_c *Backend_CompleteActivityWorkItem_Call) RunAndReturn(run func(context.Context, *backend.ActivityWorkItem) error) *Backend_CompleteActivityWorkItem_Call

type Backend_CompleteOrchestrationWorkItem_Call

+ func (_c *Backend_CompleteOrchestrationWorkItem_Call) RunAndReturn(run func(context.Context, *backend.OrchestrationWorkItem) error) *Backend_CompleteOrchestrationWorkItem_Call

type Backend_CreateOrchestrationInstance_Call

+ func (_c *Backend_CreateOrchestrationInstance_Call) RunAndReturn(run func(context.Context, *protos.HistoryEvent, ...) error) *Backend_CreateOrchestrationInstance_Call

type Backend_CreateTaskHub_Call

+ func (_c *Backend_CreateTaskHub_Call) RunAndReturn(run func(context.Context) error) *Backend_CreateTaskHub_Call

type Backend_DeleteTaskHub_Call

+ func (_c *Backend_DeleteTaskHub_Call) RunAndReturn(run func(context.Context) error) *Backend_DeleteTaskHub_Call

type Backend_GetActivityWorkItem_Call

+ func (_c *Backend_GetActivityWorkItem_Call) RunAndReturn(run func(context.Context) (*backend.ActivityWorkItem, error)) *Backend_GetActivityWorkItem_Call

type Backend_GetOrchestrationMetadata_Call

+ func (_c *Backend_GetOrchestrationMetadata_Call) RunAndReturn(run func(context.Context, api.InstanceID) (*api.OrchestrationMetadata, error)) *Backend_GetOrchestrationMetadata_Call

type Backend_GetOrchestrationRuntimeState_Call

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

type Backend_GetOrchestrationWorkItem_Call

+ func (_c *Backend_GetOrchestrationWorkItem_Call) RunAndReturn(run func(context.Context) (*backend.OrchestrationWorkItem, error)) *Backend_GetOrchestrationWorkItem_Call

type Backend_PurgeOrchestrationState_Call

+ func (_c *Backend_PurgeOrchestrationState_Call) RunAndReturn(run func(context.Context, api.InstanceID) error) *Backend_PurgeOrchestrationState_Call

type Backend_Start_Call

+ func (_c *Backend_Start_Call) RunAndReturn(run func(context.Context) error) *Backend_Start_Call

type Backend_Stop_Call

+ func (_c *Backend_Stop_Call) RunAndReturn(run func(context.Context) error) *Backend_Stop_Call

type Executor_ExecuteActivity_Call

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

type Executor_ExecuteOrchestrator_Call

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

type TaskWorker_ProcessNext_Call

+ func (_c *TaskWorker_ProcessNext_Call) RunAndReturn(run func(context.Context) (bool, error)) *TaskWorker_ProcessNext_Call

type TaskWorker_Start_Call

+ func (_c *TaskWorker_Start_Call) RunAndReturn(run func(context.Context)) *TaskWorker_Start_Call

type TaskWorker_StopAndDrain_Call

+ func (_c *TaskWorker_StopAndDrain_Call) RunAndReturn(run func()) *TaskWorker_StopAndDrain_Call

v0.3.1

Sep 8, 2023

v0.3.0

Jul 13, 2023

v0.2.4

May 26, 2023

v0.2.3

May 23, 2023

v0.2.2

May 19, 2023

v0.2.1

May 1, 2023

v0.2.0

Mar 30, 2023

Changes in this version

type Backend

+ func (_m *Backend) PurgeOrchestrationState(_a0 context.Context, _a1 api.InstanceID) error

type Backend_Expecter

+ func (_e *Backend_Expecter) PurgeOrchestrationState(_a0 interface{}, _a1 interface{}) *Backend_PurgeOrchestrationState_Call

+ type Backend_PurgeOrchestrationState_Call struct

+ func (_c *Backend_PurgeOrchestrationState_Call) Return(_a0 error) *Backend_PurgeOrchestrationState_Call

+ func (_c *Backend_PurgeOrchestrationState_Call) Run(run func(_a0 context.Context, _a1 api.InstanceID)) *Backend_PurgeOrchestrationState_Call

v0.1.4

Feb 23, 2023

v0.1.3

Jan 27, 2023

v0.1.2

Jan 25, 2023

v0.1.1

Jan 20, 2023

v0.1.0

Sep 15, 2022

Changes in this version

+ type Backend struct

+ func NewBackend(t mockConstructorTestingTNewBackend) *Backend

+ func (_m *Backend) AbandonActivityWorkItem(_a0 context.Context, _a1 *backend.ActivityWorkItem) error

+ func (_m *Backend) AbandonOrchestrationWorkItem(_a0 context.Context, _a1 *backend.OrchestrationWorkItem) error

+ func (_m *Backend) AddNewOrchestrationEvent(_a0 context.Context, _a1 api.InstanceID, _a2 *protos.HistoryEvent) error

+ func (_m *Backend) CompleteActivityWorkItem(_a0 context.Context, _a1 *backend.ActivityWorkItem) error

+ func (_m *Backend) CompleteOrchestrationWorkItem(_a0 context.Context, _a1 *backend.OrchestrationWorkItem) error

+ func (_m *Backend) CreateOrchestrationInstance(_a0 context.Context, _a1 *protos.HistoryEvent) error

+ func (_m *Backend) CreateTaskHub(_a0 context.Context) error

+ func (_m *Backend) DeleteTaskHub(_a0 context.Context) error

+ func (_m *Backend) EXPECT() *Backend_Expecter

+ func (_m *Backend) GetActivityWorkItem(_a0 context.Context) (*backend.ActivityWorkItem, error)

+ func (_m *Backend) GetOrchestrationMetadata(_a0 context.Context, _a1 api.InstanceID) (*api.OrchestrationMetadata, error)

+ func (_m *Backend) GetOrchestrationRuntimeState(_a0 context.Context, _a1 *backend.OrchestrationWorkItem) (*backend.OrchestrationRuntimeState, error)

+ func (_m *Backend) GetOrchestrationWorkItem(_a0 context.Context) (*backend.OrchestrationWorkItem, error)

+ func (_m *Backend) Start(_a0 context.Context) error

+ func (_m *Backend) Stop(_a0 context.Context) error

+ type Backend_AbandonActivityWorkItem_Call struct

+ func (_c *Backend_AbandonActivityWorkItem_Call) Return(_a0 error) *Backend_AbandonActivityWorkItem_Call

+ func (_c *Backend_AbandonActivityWorkItem_Call) Run(run func(_a0 context.Context, _a1 *backend.ActivityWorkItem)) *Backend_AbandonActivityWorkItem_Call

+ type Backend_AbandonOrchestrationWorkItem_Call struct

+ func (_c *Backend_AbandonOrchestrationWorkItem_Call) Return(_a0 error) *Backend_AbandonOrchestrationWorkItem_Call

+ func (_c *Backend_AbandonOrchestrationWorkItem_Call) Run(run func(_a0 context.Context, _a1 *backend.OrchestrationWorkItem)) *Backend_AbandonOrchestrationWorkItem_Call

+ type Backend_AddNewOrchestrationEvent_Call struct

+ func (_c *Backend_AddNewOrchestrationEvent_Call) Return(_a0 error) *Backend_AddNewOrchestrationEvent_Call

+ func (_c *Backend_AddNewOrchestrationEvent_Call) Run(run func(_a0 context.Context, _a1 api.InstanceID, _a2 *protos.HistoryEvent)) *Backend_AddNewOrchestrationEvent_Call

+ type Backend_CompleteActivityWorkItem_Call struct

+ func (_c *Backend_CompleteActivityWorkItem_Call) Return(_a0 error) *Backend_CompleteActivityWorkItem_Call

+ func (_c *Backend_CompleteActivityWorkItem_Call) Run(run func(_a0 context.Context, _a1 *backend.ActivityWorkItem)) *Backend_CompleteActivityWorkItem_Call

+ type Backend_CompleteOrchestrationWorkItem_Call struct

+ func (_c *Backend_CompleteOrchestrationWorkItem_Call) Return(_a0 error) *Backend_CompleteOrchestrationWorkItem_Call

+ func (_c *Backend_CompleteOrchestrationWorkItem_Call) Run(run func(_a0 context.Context, _a1 *backend.OrchestrationWorkItem)) *Backend_CompleteOrchestrationWorkItem_Call

+ type Backend_CreateOrchestrationInstance_Call struct

+ func (_c *Backend_CreateOrchestrationInstance_Call) Return(_a0 error) *Backend_CreateOrchestrationInstance_Call

+ func (_c *Backend_CreateOrchestrationInstance_Call) Run(run func(_a0 context.Context, _a1 *protos.HistoryEvent)) *Backend_CreateOrchestrationInstance_Call

+ type Backend_CreateTaskHub_Call struct

+ func (_c *Backend_CreateTaskHub_Call) Return(_a0 error) *Backend_CreateTaskHub_Call

+ func (_c *Backend_CreateTaskHub_Call) Run(run func(_a0 context.Context)) *Backend_CreateTaskHub_Call

+ type Backend_DeleteTaskHub_Call struct

+ func (_c *Backend_DeleteTaskHub_Call) Return(_a0 error) *Backend_DeleteTaskHub_Call

+ func (_c *Backend_DeleteTaskHub_Call) Run(run func(_a0 context.Context)) *Backend_DeleteTaskHub_Call

+ type Backend_Expecter struct

+ func (_e *Backend_Expecter) AbandonActivityWorkItem(_a0 interface{}, _a1 interface{}) *Backend_AbandonActivityWorkItem_Call

+ func (_e *Backend_Expecter) AbandonOrchestrationWorkItem(_a0 interface{}, _a1 interface{}) *Backend_AbandonOrchestrationWorkItem_Call

+ func (_e *Backend_Expecter) AddNewOrchestrationEvent(_a0 interface{}, _a1 interface{}, _a2 interface{}) *Backend_AddNewOrchestrationEvent_Call

+ func (_e *Backend_Expecter) CompleteActivityWorkItem(_a0 interface{}, _a1 interface{}) *Backend_CompleteActivityWorkItem_Call

+ func (_e *Backend_Expecter) CompleteOrchestrationWorkItem(_a0 interface{}, _a1 interface{}) *Backend_CompleteOrchestrationWorkItem_Call

+ func (_e *Backend_Expecter) CreateOrchestrationInstance(_a0 interface{}, _a1 interface{}) *Backend_CreateOrchestrationInstance_Call

+ func (_e *Backend_Expecter) CreateTaskHub(_a0 interface{}) *Backend_CreateTaskHub_Call

+ func (_e *Backend_Expecter) DeleteTaskHub(_a0 interface{}) *Backend_DeleteTaskHub_Call

+ func (_e *Backend_Expecter) GetActivityWorkItem(_a0 interface{}) *Backend_GetActivityWorkItem_Call

+ func (_e *Backend_Expecter) GetOrchestrationMetadata(_a0 interface{}, _a1 interface{}) *Backend_GetOrchestrationMetadata_Call

+ func (_e *Backend_Expecter) GetOrchestrationRuntimeState(_a0 interface{}, _a1 interface{}) *Backend_GetOrchestrationRuntimeState_Call

+ func (_e *Backend_Expecter) GetOrchestrationWorkItem(_a0 interface{}) *Backend_GetOrchestrationWorkItem_Call

+ func (_e *Backend_Expecter) Start(_a0 interface{}) *Backend_Start_Call

+ func (_e *Backend_Expecter) Stop(_a0 interface{}) *Backend_Stop_Call

+ type Backend_GetActivityWorkItem_Call struct

+ func (_c *Backend_GetActivityWorkItem_Call) Return(_a0 *backend.ActivityWorkItem, _a1 error) *Backend_GetActivityWorkItem_Call

+ func (_c *Backend_GetActivityWorkItem_Call) Run(run func(_a0 context.Context)) *Backend_GetActivityWorkItem_Call

+ type Backend_GetOrchestrationMetadata_Call struct

+ func (_c *Backend_GetOrchestrationMetadata_Call) Return(_a0 *api.OrchestrationMetadata, _a1 error) *Backend_GetOrchestrationMetadata_Call

+ func (_c *Backend_GetOrchestrationMetadata_Call) Run(run func(_a0 context.Context, _a1 api.InstanceID)) *Backend_GetOrchestrationMetadata_Call

+ type Backend_GetOrchestrationRuntimeState_Call struct

+ func (_c *Backend_GetOrchestrationRuntimeState_Call) Return(_a0 *backend.OrchestrationRuntimeState, _a1 error) *Backend_GetOrchestrationRuntimeState_Call

+ func (_c *Backend_GetOrchestrationRuntimeState_Call) Run(run func(_a0 context.Context, _a1 *backend.OrchestrationWorkItem)) *Backend_GetOrchestrationRuntimeState_Call

+ type Backend_GetOrchestrationWorkItem_Call struct

+ func (_c *Backend_GetOrchestrationWorkItem_Call) Return(_a0 *backend.OrchestrationWorkItem, _a1 error) *Backend_GetOrchestrationWorkItem_Call

+ func (_c *Backend_GetOrchestrationWorkItem_Call) Run(run func(_a0 context.Context)) *Backend_GetOrchestrationWorkItem_Call

+ type Backend_Start_Call struct

+ func (_c *Backend_Start_Call) Return(_a0 error) *Backend_Start_Call

+ func (_c *Backend_Start_Call) Run(run func(_a0 context.Context)) *Backend_Start_Call

+ type Backend_Stop_Call struct

+ func (_c *Backend_Stop_Call) Return(_a0 error) *Backend_Stop_Call

+ func (_c *Backend_Stop_Call) Run(run func(_a0 context.Context)) *Backend_Stop_Call

+ type Executor struct

+ func NewExecutor(t mockConstructorTestingTNewExecutor) *Executor

+ func (_m *Executor) EXPECT() *Executor_Expecter

+ func (_m *Executor) ExecuteActivity(_a0 context.Context, _a1 api.InstanceID, _a2 *protos.HistoryEvent) (*protos.HistoryEvent, error)

+ func (_m *Executor) ExecuteOrchestrator(ctx context.Context, iid api.InstanceID, oldEvents []*protos.HistoryEvent, ...) (*backend.ExecutionResults, error)

+ type Executor_ExecuteActivity_Call struct

+ func (_c *Executor_ExecuteActivity_Call) Return(_a0 *protos.HistoryEvent, _a1 error) *Executor_ExecuteActivity_Call

+ func (_c *Executor_ExecuteActivity_Call) Run(run func(_a0 context.Context, _a1 api.InstanceID, _a2 *protos.HistoryEvent)) *Executor_ExecuteActivity_Call

+ type Executor_ExecuteOrchestrator_Call struct

+ func (_c *Executor_ExecuteOrchestrator_Call) Return(_a0 *backend.ExecutionResults, _a1 error) *Executor_ExecuteOrchestrator_Call

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

+ type Executor_Expecter struct

+ func (_e *Executor_Expecter) ExecuteActivity(_a0 interface{}, _a1 interface{}, _a2 interface{}) *Executor_ExecuteActivity_Call

+ func (_e *Executor_Expecter) ExecuteOrchestrator(ctx interface{}, iid interface{}, oldEvents interface{}, newEvents interface{}) *Executor_ExecuteOrchestrator_Call

+ type TaskWorker struct

+ func NewTaskWorker(t mockConstructorTestingTNewTaskWorker) *TaskWorker

+ func (_m *TaskWorker) EXPECT() *TaskWorker_Expecter

+ func (_m *TaskWorker) ProcessNext(_a0 context.Context) (bool, error)

+ func (_m *TaskWorker) Start(_a0 context.Context)

+ func (_m *TaskWorker) StopAndDrain()

+ type TaskWorker_Expecter struct

+ func (_e *TaskWorker_Expecter) ProcessNext(_a0 interface{}) *TaskWorker_ProcessNext_Call

+ func (_e *TaskWorker_Expecter) Start(_a0 interface{}) *TaskWorker_Start_Call

+ func (_e *TaskWorker_Expecter) StopAndDrain() *TaskWorker_StopAndDrain_Call

+ type TaskWorker_ProcessNext_Call struct

+ func (_c *TaskWorker_ProcessNext_Call) Return(_a0 bool, _a1 error) *TaskWorker_ProcessNext_Call

+ func (_c *TaskWorker_ProcessNext_Call) Run(run func(_a0 context.Context)) *TaskWorker_ProcessNext_Call

+ type TaskWorker_Start_Call struct

+ func (_c *TaskWorker_Start_Call) Return() *TaskWorker_Start_Call

+ func (_c *TaskWorker_Start_Call) Run(run func(_a0 context.Context)) *TaskWorker_Start_Call

+ type TaskWorker_StopAndDrain_Call struct

+ func (_c *TaskWorker_StopAndDrain_Call) Return() *TaskWorker_StopAndDrain_Call

+ func (_c *TaskWorker_StopAndDrain_Call) Run(run func()) *TaskWorker_StopAndDrain_Call

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