// Code generated by mockery; DO NOT EDIT.

// github.com/vektra/mockery

// template: testify

package floxy

import (

"context"

"encoding/json"

"time"

"github.com/jackc/pgx/v5"

"github.com/jackc/pgx/v5/pgconn"

mock "github.com/stretchr/testify/mock"

)

// NewMockIEngine creates a new instance of MockIEngine. 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 NewMockIEngine(t interface {

mock.TestingT

Cleanup(func())

}) *MockIEngine {

mock := &MockIEngine{}

mock.Mock.Test(t)

t.Cleanup(func() { mock.AssertExpectations(t) })

return mock

}

// MockIEngine is an autogenerated mock type for the IEngine type

type MockIEngine struct {

mock.Mock

}

type MockIEngine_Expecter struct {

mock *mock.Mock

}

func (_m *MockIEngine) EXPECT() *MockIEngine_Expecter {

return &MockIEngine_Expecter{mock: &_m.Mock}

}

// AbortWorkflow provides a mock function for the type MockIEngine

func (_mock *MockIEngine) AbortWorkflow(ctx context.Context, instanceID int64, requestedBy string, reason string) error {

ret := _mock.Called(ctx, instanceID, requestedBy, reason)

if len(ret) == 0 {

panic("no return value specified for AbortWorkflow")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string) error); ok {

r0 = returnFunc(ctx, instanceID, requestedBy, reason)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockIEngine_AbortWorkflow_Call struct {

*mock.Call

}

// AbortWorkflow is a helper method to define mock.On call

// - ctx context.Context

// - instanceID int64

// - requestedBy string

// - reason string

func (_e *MockIEngine_Expecter) AbortWorkflow(ctx interface{}, instanceID interface{}, requestedBy interface{}, reason interface{}) *MockIEngine_AbortWorkflow_Call {

return &MockIEngine_AbortWorkflow_Call{Call: _e.mock.On("AbortWorkflow", ctx, instanceID, requestedBy, reason)}

}

func (_c *MockIEngine_AbortWorkflow_Call) Run(run func(ctx context.Context, instanceID int64, requestedBy string, reason string)) *MockIEngine_AbortWorkflow_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 int64

if args[1] != nil {

arg1 = args[1].(int64)

}

var arg2 string

if args[2] != nil {

arg2 = args[2].(string)

}

var arg3 string

if args[3] != nil {

arg3 = args[3].(string)

}

run(

arg0,

arg1,

arg2,

arg3,

)

})

return _c

}

func (_c *MockIEngine_AbortWorkflow_Call) Return(err error) *MockIEngine_AbortWorkflow_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockIEngine_AbortWorkflow_Call) RunAndReturn(run func(ctx context.Context, instanceID int64, requestedBy string, reason string) error) *MockIEngine_AbortWorkflow_Call {

_c.Call.Return(run)

return _c

}

// CancelWorkflow provides a mock function for the type MockIEngine

func (_mock *MockIEngine) CancelWorkflow(ctx context.Context, instanceID int64, requestedBy string, reason string) error {

ret := _mock.Called(ctx, instanceID, requestedBy, reason)

if len(ret) == 0 {

panic("no return value specified for CancelWorkflow")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string) error); ok {

r0 = returnFunc(ctx, instanceID, requestedBy, reason)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockIEngine_CancelWorkflow_Call struct {

*mock.Call

}

// CancelWorkflow is a helper method to define mock.On call

// - ctx context.Context

// - instanceID int64

// - requestedBy string

// - reason string

func (_e *MockIEngine_Expecter) CancelWorkflow(ctx interface{}, instanceID interface{}, requestedBy interface{}, reason interface{}) *MockIEngine_CancelWorkflow_Call {

return &MockIEngine_CancelWorkflow_Call{Call: _e.mock.On("CancelWorkflow", ctx, instanceID, requestedBy, reason)}

}

func (_c *MockIEngine_CancelWorkflow_Call) Run(run func(ctx context.Context, instanceID int64, requestedBy string, reason string)) *MockIEngine_CancelWorkflow_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 int64

if args[1] != nil {

arg1 = args[1].(int64)

}

var arg2 string

if args[2] != nil {

arg2 = args[2].(string)

}

var arg3 string

if args[3] != nil {

arg3 = args[3].(string)

}

run(

arg0,

arg1,

arg2,

arg3,

)

})

return _c

}

func (_c *MockIEngine_CancelWorkflow_Call) Return(err error) *MockIEngine_CancelWorkflow_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockIEngine_CancelWorkflow_Call) RunAndReturn(run func(ctx context.Context, instanceID int64, requestedBy string, reason string) error) *MockIEngine_CancelWorkflow_Call {

_c.Call.Return(run)

return _c

}

// MakeHumanDecision provides a mock function for the type MockIEngine

func (_mock *MockIEngine) MakeHumanDecision(ctx context.Context, stepID int64, decidedBy string, decision HumanDecision, comment *string) error {

ret := _mock.Called(ctx, stepID, decidedBy, decision, comment)

if len(ret) == 0 {

panic("no return value specified for MakeHumanDecision")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, HumanDecision, *string) error); ok {

r0 = returnFunc(ctx, stepID, decidedBy, decision, comment)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockIEngine_MakeHumanDecision_Call struct {

*mock.Call

}

// MakeHumanDecision is a helper method to define mock.On call

// - ctx context.Context

// - stepID int64

// - decidedBy string

// - decision HumanDecision

// - comment *string

func (_e *MockIEngine_Expecter) MakeHumanDecision(ctx interface{}, stepID interface{}, decidedBy interface{}, decision interface{}, comment interface{}) *MockIEngine_MakeHumanDecision_Call {

return &MockIEngine_MakeHumanDecision_Call{Call: _e.mock.On("MakeHumanDecision", ctx, stepID, decidedBy, decision, comment)}

}

func (_c *MockIEngine_MakeHumanDecision_Call) Run(run func(ctx context.Context, stepID int64, decidedBy string, decision HumanDecision, comment *string)) *MockIEngine_MakeHumanDecision_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 int64

if args[1] != nil {

arg1 = args[1].(int64)

}

var arg2 string

if args[2] != nil {

arg2 = args[2].(string)

}

var arg3 HumanDecision

if args[3] != nil {

arg3 = args[3].(HumanDecision)

}

var arg4 *string

if args[4] != nil {

arg4 = args[4].(*string)

}

run(

arg0,

arg1,

arg2,

arg3,

arg4,

)

})

return _c

}

func (_c *MockIEngine_MakeHumanDecision_Call) Return(err error) *MockIEngine_MakeHumanDecision_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockIEngine_MakeHumanDecision_Call) RunAndReturn(run func(ctx context.Context, stepID int64, decidedBy string, decision HumanDecision, comment *string) error) *MockIEngine_MakeHumanDecision_Call {

_c.Call.Return(run)

return _c

}

// RequeueFromDLQ provides a mock function for the type MockIEngine

func (_mock *MockIEngine) RequeueFromDLQ(ctx context.Context, dlqID int64, newInput *json.RawMessage) error {

ret := _mock.Called(ctx, dlqID, newInput)

if len(ret) == 0 {

panic("no return value specified for RequeueFromDLQ")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, int64, *json.RawMessage) error); ok {

r0 = returnFunc(ctx, dlqID, newInput)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockIEngine_RequeueFromDLQ_Call struct {

*mock.Call

}

// RequeueFromDLQ is a helper method to define mock.On call

// - ctx context.Context

// - dlqID int64

// - newInput *json.RawMessage

func (_e *MockIEngine_Expecter) RequeueFromDLQ(ctx interface{}, dlqID interface{}, newInput interface{}) *MockIEngine_RequeueFromDLQ_Call {

return &MockIEngine_RequeueFromDLQ_Call{Call: _e.mock.On("RequeueFromDLQ", ctx, dlqID, newInput)}

}

func (_c *MockIEngine_RequeueFromDLQ_Call) Run(run func(ctx context.Context, dlqID int64, newInput *json.RawMessage)) *MockIEngine_RequeueFromDLQ_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 int64

if args[1] != nil {

arg1 = args[1].(int64)

}

var arg2 *json.RawMessage

if args[2] != nil {

arg2 = args[2].(*json.RawMessage)

}

run(

arg0,

arg1,

arg2,

)

})

return _c

}

func (_c *MockIEngine_RequeueFromDLQ_Call) Return(err error) *MockIEngine_RequeueFromDLQ_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockIEngine_RequeueFromDLQ_Call) RunAndReturn(run func(ctx context.Context, dlqID int64, newInput *json.RawMessage) error) *MockIEngine_RequeueFromDLQ_Call {

_c.Call.Return(run)

return _c

}

// NewMockMonitor creates a new instance of MockMonitor. 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 NewMockMonitor(t interface {

mock.TestingT

Cleanup(func())

}) *MockMonitor {

mock := &MockMonitor{}

mock.Mock.Test(t)

t.Cleanup(func() { mock.AssertExpectations(t) })

return mock

}

// MockMonitor is an autogenerated mock type for the Monitor type

type MockMonitor struct {

mock.Mock

}

type MockMonitor_Expecter struct {

mock *mock.Mock

}

func (_m *MockMonitor) EXPECT() *MockMonitor_Expecter {

return &MockMonitor_Expecter{mock: &_m.Mock}

}

// GetWorkflowStats provides a mock function for the type MockMonitor

func (_mock *MockMonitor) GetWorkflowStats(ctx context.Context) ([]WorkflowStats, error) {

ret := _mock.Called(ctx)

if len(ret) == 0 {

panic("no return value specified for GetWorkflowStats")

}

var r0 []WorkflowStats

var r1 error

if returnFunc, ok := ret.Get(0).(func(context.Context) ([]WorkflowStats, error)); ok {

return returnFunc(ctx)

}

if returnFunc, ok := ret.Get(0).(func(context.Context) []WorkflowStats); ok {

r0 = returnFunc(ctx)

} else {

if ret.Get(0) != nil {

r0 = ret.Get(0).([]WorkflowStats)

}

}

if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {

r1 = returnFunc(ctx)

} else {

r1 = ret.Error(1)

}

return r0, r1

}

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

type MockMonitor_GetWorkflowStats_Call struct {

*mock.Call

}

// GetWorkflowStats is a helper method to define mock.On call

// - ctx context.Context

func (_e *MockMonitor_Expecter) GetWorkflowStats(ctx interface{}) *MockMonitor_GetWorkflowStats_Call {

return &MockMonitor_GetWorkflowStats_Call{Call: _e.mock.On("GetWorkflowStats", ctx)}

}

func (_c *MockMonitor_GetWorkflowStats_Call) Run(run func(ctx context.Context)) *MockMonitor_GetWorkflowStats_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

run(

arg0,

)

})

return _c

}

func (_c *MockMonitor_GetWorkflowStats_Call) Return(workflowStatss []WorkflowStats, err error) *MockMonitor_GetWorkflowStats_Call {

_c.Call.Return(workflowStatss, err)

return _c

}

func (_c *MockMonitor_GetWorkflowStats_Call) RunAndReturn(run func(ctx context.Context) ([]WorkflowStats, error)) *MockMonitor_GetWorkflowStats_Call {

_c.Call.Return(run)

return _c

}

// NewMockPlugin creates a new instance of MockPlugin. 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 NewMockPlugin(t interface {

mock.TestingT

Cleanup(func())

}) *MockPlugin {

mock := &MockPlugin{}

mock.Mock.Test(t)

t.Cleanup(func() { mock.AssertExpectations(t) })

return mock

}

// MockPlugin is an autogenerated mock type for the Plugin type

type MockPlugin struct {

mock.Mock

}

type MockPlugin_Expecter struct {

mock *mock.Mock

}

func (_m *MockPlugin) EXPECT() *MockPlugin_Expecter {

return &MockPlugin_Expecter{mock: &_m.Mock}

}

// Name provides a mock function for the type MockPlugin

func (_mock *MockPlugin) Name() string {

ret := _mock.Called()

if len(ret) == 0 {

panic("no return value specified for Name")

}

var r0 string

if returnFunc, ok := ret.Get(0).(func() string); ok {

r0 = returnFunc()

} else {

r0 = ret.Get(0).(string)

}

return r0

}

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

type MockPlugin_Name_Call struct {

*mock.Call

}

// Name is a helper method to define mock.On call

func (_e *MockPlugin_Expecter) Name() *MockPlugin_Name_Call {

return &MockPlugin_Name_Call{Call: _e.mock.On("Name")}

}

func (_c *MockPlugin_Name_Call) Run(run func()) *MockPlugin_Name_Call {

_c.Call.Run(func(args mock.Arguments) {

run()

})

return _c

}

func (_c *MockPlugin_Name_Call) Return(s string) *MockPlugin_Name_Call {

_c.Call.Return(s)

return _c

}

func (_c *MockPlugin_Name_Call) RunAndReturn(run func() string) *MockPlugin_Name_Call {

_c.Call.Return(run)

return _c

}

// OnRollbackStepChain provides a mock function for the type MockPlugin

func (_mock *MockPlugin) OnRollbackStepChain(ctx context.Context, instanceID int64, stepName string, depth int) error {

ret := _mock.Called(ctx, instanceID, stepName, depth)

if len(ret) == 0 {

panic("no return value specified for OnRollbackStepChain")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, int) error); ok {

r0 = returnFunc(ctx, instanceID, stepName, depth)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockPlugin_OnRollbackStepChain_Call struct {

*mock.Call

}

// OnRollbackStepChain is a helper method to define mock.On call

// - ctx context.Context

// - instanceID int64

// - stepName string

// - depth int

func (_e *MockPlugin_Expecter) OnRollbackStepChain(ctx interface{}, instanceID interface{}, stepName interface{}, depth interface{}) *MockPlugin_OnRollbackStepChain_Call {

return &MockPlugin_OnRollbackStepChain_Call{Call: _e.mock.On("OnRollbackStepChain", ctx, instanceID, stepName, depth)}

}

func (_c *MockPlugin_OnRollbackStepChain_Call) Run(run func(ctx context.Context, instanceID int64, stepName string, depth int)) *MockPlugin_OnRollbackStepChain_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 int64

if args[1] != nil {

arg1 = args[1].(int64)

}

var arg2 string

if args[2] != nil {

arg2 = args[2].(string)

}

var arg3 int

if args[3] != nil {

arg3 = args[3].(int)

}

run(

arg0,

arg1,

arg2,

arg3,

)

})

return _c

}

func (_c *MockPlugin_OnRollbackStepChain_Call) Return(err error) *MockPlugin_OnRollbackStepChain_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockPlugin_OnRollbackStepChain_Call) RunAndReturn(run func(ctx context.Context, instanceID int64, stepName string, depth int) error) *MockPlugin_OnRollbackStepChain_Call {

_c.Call.Return(run)

return _c

}

// OnStepComplete provides a mock function for the type MockPlugin

func (_mock *MockPlugin) OnStepComplete(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep) error {

ret := _mock.Called(ctx, instance, step)

if len(ret) == 0 {

panic("no return value specified for OnStepComplete")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, *WorkflowInstance, *WorkflowStep) error); ok {

r0 = returnFunc(ctx, instance, step)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockPlugin_OnStepComplete_Call struct {

*mock.Call

}

// OnStepComplete is a helper method to define mock.On call

// - ctx context.Context

// - instance *WorkflowInstance

// - step *WorkflowStep

func (_e *MockPlugin_Expecter) OnStepComplete(ctx interface{}, instance interface{}, step interface{}) *MockPlugin_OnStepComplete_Call {

return &MockPlugin_OnStepComplete_Call{Call: _e.mock.On("OnStepComplete", ctx, instance, step)}

}

func (_c *MockPlugin_OnStepComplete_Call) Run(run func(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep)) *MockPlugin_OnStepComplete_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 *WorkflowInstance

if args[1] != nil {

arg1 = args[1].(*WorkflowInstance)

}

var arg2 *WorkflowStep

if args[2] != nil {

arg2 = args[2].(*WorkflowStep)

}

run(

arg0,

arg1,

arg2,

)

})

return _c

}

func (_c *MockPlugin_OnStepComplete_Call) Return(err error) *MockPlugin_OnStepComplete_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockPlugin_OnStepComplete_Call) RunAndReturn(run func(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep) error) *MockPlugin_OnStepComplete_Call {

_c.Call.Return(run)

return _c

}

// OnStepFailed provides a mock function for the type MockPlugin

func (_mock *MockPlugin) OnStepFailed(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep, err error) error {

ret := _mock.Called(ctx, instance, step, err)

if len(ret) == 0 {

panic("no return value specified for OnStepFailed")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, *WorkflowInstance, *WorkflowStep, error) error); ok {

r0 = returnFunc(ctx, instance, step, err)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockPlugin_OnStepFailed_Call struct {

*mock.Call

}

// OnStepFailed is a helper method to define mock.On call

// - ctx context.Context

// - instance *WorkflowInstance

// - step *WorkflowStep

// - err error

func (_e *MockPlugin_Expecter) OnStepFailed(ctx interface{}, instance interface{}, step interface{}, err interface{}) *MockPlugin_OnStepFailed_Call {

return &MockPlugin_OnStepFailed_Call{Call: _e.mock.On("OnStepFailed", ctx, instance, step, err)}

}

func (_c *MockPlugin_OnStepFailed_Call) Run(run func(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep, err error)) *MockPlugin_OnStepFailed_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 *WorkflowInstance

if args[1] != nil {

arg1 = args[1].(*WorkflowInstance)

}

var arg2 *WorkflowStep

if args[2] != nil {

arg2 = args[2].(*WorkflowStep)

}

var arg3 error

if args[3] != nil {

arg3 = args[3].(error)

}

run(

arg0,

arg1,

arg2,

arg3,

)

})

return _c

}

func (_c *MockPlugin_OnStepFailed_Call) Return(err1 error) *MockPlugin_OnStepFailed_Call {

_c.Call.Return(err1)

return _c

}

func (_c *MockPlugin_OnStepFailed_Call) RunAndReturn(run func(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep, err error) error) *MockPlugin_OnStepFailed_Call {

_c.Call.Return(run)

return _c

}

// OnStepStart provides a mock function for the type MockPlugin

func (_mock *MockPlugin) OnStepStart(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep) error {

ret := _mock.Called(ctx, instance, step)

if len(ret) == 0 {

panic("no return value specified for OnStepStart")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, *WorkflowInstance, *WorkflowStep) error); ok {

r0 = returnFunc(ctx, instance, step)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockPlugin_OnStepStart_Call struct {

*mock.Call

}

// OnStepStart is a helper method to define mock.On call

// - ctx context.Context

// - instance *WorkflowInstance

// - step *WorkflowStep

func (_e *MockPlugin_Expecter) OnStepStart(ctx interface{}, instance interface{}, step interface{}) *MockPlugin_OnStepStart_Call {

return &MockPlugin_OnStepStart_Call{Call: _e.mock.On("OnStepStart", ctx, instance, step)}

}

func (_c *MockPlugin_OnStepStart_Call) Run(run func(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep)) *MockPlugin_OnStepStart_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 *WorkflowInstance

if args[1] != nil {

arg1 = args[1].(*WorkflowInstance)

}

var arg2 *WorkflowStep

if args[2] != nil {

arg2 = args[2].(*WorkflowStep)

}

run(

arg0,

arg1,

arg2,

)

})

return _c

}

func (_c *MockPlugin_OnStepStart_Call) Return(err error) *MockPlugin_OnStepStart_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockPlugin_OnStepStart_Call) RunAndReturn(run func(ctx context.Context, instance *WorkflowInstance, step *WorkflowStep) error) *MockPlugin_OnStepStart_Call {

_c.Call.Return(run)

return _c

}

// OnWorkflowComplete provides a mock function for the type MockPlugin

func (_mock *MockPlugin) OnWorkflowComplete(ctx context.Context, instance *WorkflowInstance) error {

ret := _mock.Called(ctx, instance)

if len(ret) == 0 {

panic("no return value specified for OnWorkflowComplete")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, *WorkflowInstance) error); ok {

r0 = returnFunc(ctx, instance)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockPlugin_OnWorkflowComplete_Call struct {

*mock.Call

}

// OnWorkflowComplete is a helper method to define mock.On call

// - ctx context.Context

// - instance *WorkflowInstance

func (_e *MockPlugin_Expecter) OnWorkflowComplete(ctx interface{}, instance interface{}) *MockPlugin_OnWorkflowComplete_Call {

return &MockPlugin_OnWorkflowComplete_Call{Call: _e.mock.On("OnWorkflowComplete", ctx, instance)}

}

func (_c *MockPlugin_OnWorkflowComplete_Call) Run(run func(ctx context.Context, instance *WorkflowInstance)) *MockPlugin_OnWorkflowComplete_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 *WorkflowInstance

if args[1] != nil {

arg1 = args[1].(*WorkflowInstance)

}

run(

arg0,

arg1,

)

})

return _c

}

func (_c *MockPlugin_OnWorkflowComplete_Call) Return(err error) *MockPlugin_OnWorkflowComplete_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockPlugin_OnWorkflowComplete_Call) RunAndReturn(run func(ctx context.Context, instance *WorkflowInstance) error) *MockPlugin_OnWorkflowComplete_Call {

_c.Call.Return(run)

return _c

}

// OnWorkflowFailed provides a mock function for the type MockPlugin

func (_mock *MockPlugin) OnWorkflowFailed(ctx context.Context, instance *WorkflowInstance) error {

ret := _mock.Called(ctx, instance)

if len(ret) == 0 {

panic("no return value specified for OnWorkflowFailed")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, *WorkflowInstance) error); ok {

r0 = returnFunc(ctx, instance)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockPlugin_OnWorkflowFailed_Call struct {

*mock.Call

}

// OnWorkflowFailed is a helper method to define mock.On call

// - ctx context.Context

// - instance *WorkflowInstance

func (_e *MockPlugin_Expecter) OnWorkflowFailed(ctx interface{}, instance interface{}) *MockPlugin_OnWorkflowFailed_Call {

return &MockPlugin_OnWorkflowFailed_Call{Call: _e.mock.On("OnWorkflowFailed", ctx, instance)}

}

func (_c *MockPlugin_OnWorkflowFailed_Call) Run(run func(ctx context.Context, instance *WorkflowInstance)) *MockPlugin_OnWorkflowFailed_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 *WorkflowInstance

if args[1] != nil {

arg1 = args[1].(*WorkflowInstance)

}

run(

arg0,

arg1,

)

})

return _c

}

func (_c *MockPlugin_OnWorkflowFailed_Call) Return(err error) *MockPlugin_OnWorkflowFailed_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockPlugin_OnWorkflowFailed_Call) RunAndReturn(run func(ctx context.Context, instance *WorkflowInstance) error) *MockPlugin_OnWorkflowFailed_Call {

_c.Call.Return(run)

return _c

}

// OnWorkflowStart provides a mock function for the type MockPlugin

func (_mock *MockPlugin) OnWorkflowStart(ctx context.Context, instance *WorkflowInstance) error {

ret := _mock.Called(ctx, instance)

if len(ret) == 0 {

panic("no return value specified for OnWorkflowStart")

}

var r0 error

if returnFunc, ok := ret.Get(0).(func(context.Context, *WorkflowInstance) error); ok {

r0 = returnFunc(ctx, instance)

} else {

r0 = ret.Error(0)

}

return r0

}

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

type MockPlugin_OnWorkflowStart_Call struct {

*mock.Call

}

// OnWorkflowStart is a helper method to define mock.On call

// - ctx context.Context

// - instance *WorkflowInstance

func (_e *MockPlugin_Expecter) OnWorkflowStart(ctx interface{}, instance interface{}) *MockPlugin_OnWorkflowStart_Call {

return &MockPlugin_OnWorkflowStart_Call{Call: _e.mock.On("OnWorkflowStart", ctx, instance)}

}

func (_c *MockPlugin_OnWorkflowStart_Call) Run(run func(ctx context.Context, instance *WorkflowInstance)) *MockPlugin_OnWorkflowStart_Call {

_c.Call.Run(func(args mock.Arguments) {

var arg0 context.Context

if args[0] != nil {

arg0 = args[0].(context.Context)

}

var arg1 *WorkflowInstance

if args[1] != nil {

arg1 = args[1].(*WorkflowInstance)

}

run(

arg0,

arg1,

)

})

return _c

}

func (_c *MockPlugin_OnWorkflowStart_Call) Return(err error) *MockPlugin_OnWorkflowStart_Call {

_c.Call.Return(err)

return _c

}

func (_c *MockPlugin_OnWorkflowStart_Call) RunAndReturn(run func(ctx context.Context, instance *WorkflowInstance) error) *MockPlugin_OnWorkflowStart_Call {

_c.Call.Return(run)

return _c

}

// Priority provides a mock function for the type MockPlugin

func (_mock *MockPlugin) Priority() Priority {

ret := _mock.Called()

if len(ret) == 0 {

panic("no return value specified for Priority")

}

var r0 Priority

if returnFunc, ok := ret.Get(0).(func() Priority); ok {

r0 = returnFunc()

} else {

r0 = ret.Get(0).(Priority)

}

return r0

}

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

type MockPlugin_Priority_Call struct {

*mock.Call

}

// Priority is a helper method to define mock.On call

func (_e *MockPlugin_Expecter) Priority() *MockPlugin_Priority_Call {

return &MockPlugin_Priority_Call{Call: _e.mock.On("Priority")}

}

func (_c *MockPlugin_Priority_Call) Run(run func()) *MockPlugin_Priority_Call {

_c.Call.Run(func(args mock.Arguments) {

run()

})

return _c

}

func (_c *MockPlugin_Priority_Call) Return(priority Priority) *MockPlugin_Priority_Call {

_c.Call.Return(priority)

return _c

}

func (_c *MockPlugin_Priority_Call) RunAndReturn(run func() Priority) *MockPlugin_Priority_Call {

_c.Call.Return(run)

return _c

}

// NewMockStepHandler creates a new instance of MockStepHandler. 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 NewMockStepHandler(t interface {

mock.TestingT

Cleanup(func())

}) *MockStepHandler {

mock := &MockStepHandler{}

mock.Mock.Test(t)

t.Cleanup(func() { mock.AssertExpectations(t) })

return mock

}

// MockStepHandler is an autogenerated mock type for the StepHandler type

type MockStepHandler struct {

mock.Mock

}

type MockStepHandler_Expecter struct {

mock *mock.Mock

}

func (_m *MockStepHandler) EXPECT() *MockStepHandler_Expecter {

return &MockStepHandler_Expecter{mock: &_m.Mock}

}

// Execute provides a mock function for the type MockStepHandler

func (_mock *MockStepHandler) Execute(ctx context.Context, stepCtx StepContext, input json.RawMessage) (json.RawMessage, error) {

ret := _mock.Called(ctx, stepCtx, input)

if len(ret) == 0 {

panic("no return value specified for Execute")

}

var r0 json.RawMessage

var r1 error

if returnFunc, ok := ret.Get(0).(func(context.Context, StepContext, json.RawMessage) (json.RawMessage, error)); ok {

return returnFunc(ctx, stepCtx, input)

}

if returnFunc, ok := ret.Get(0).(func(context.Context, StepContext, json.RawMessage) json.RawMessage); ok {

r0 = returnFunc(ctx, stepCtx, input)