// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package briefkit

import (
	"context"

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

// NewMockExecutionRepository creates a new instance of MockExecutionRepository. 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 NewMockExecutionRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockExecutionRepository {
	mock := &MockExecutionRepository{}
	mock.Mock.Test(t)

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

	return mock
}

// MockExecutionRepository is an autogenerated mock type for the ExecutionRepository type
type MockExecutionRepository struct {
	mock.Mock
}

type MockExecutionRepository_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExecutionRepository) EXPECT() *MockExecutionRepository_Expecter {
	return &MockExecutionRepository_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type MockExecutionRepository
func (_mock *MockExecutionRepository) Create(ctx context.Context, input ExecutionInput, agentConfig Config) (ExecutionID, error) {
	ret := _mock.Called(ctx, input, agentConfig)

	if len(ret) == 0 {
		panic("no return value specified for Create")
	}

	var r0 ExecutionID
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ExecutionInput, Config) (ExecutionID, error)); ok {
		return returnFunc(ctx, input, agentConfig)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ExecutionInput, Config) ExecutionID); ok {
		r0 = returnFunc(ctx, input, agentConfig)
	} else {
		r0 = ret.Get(0).(ExecutionID)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ExecutionInput, Config) error); ok {
		r1 = returnFunc(ctx, input, agentConfig)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockExecutionRepository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
type MockExecutionRepository_Create_Call struct {
	*mock.Call
}

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - input ExecutionInput
//   - agentConfig Config
func (_e *MockExecutionRepository_Expecter) Create(ctx interface{}, input interface{}, agentConfig interface{}) *MockExecutionRepository_Create_Call {
	return &MockExecutionRepository_Create_Call{Call: _e.mock.On("Create", ctx, input, agentConfig)}
}

func (_c *MockExecutionRepository_Create_Call) Run(run func(ctx context.Context, input ExecutionInput, agentConfig Config)) *MockExecutionRepository_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ExecutionInput
		if args[1] != nil {
			arg1 = args[1].(ExecutionInput)
		}
		var arg2 Config
		if args[2] != nil {
			arg2 = args[2].(Config)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockExecutionRepository_Create_Call) Return(executionID ExecutionID, err error) *MockExecutionRepository_Create_Call {
	_c.Call.Return(executionID, err)
	return _c
}

func (_c *MockExecutionRepository_Create_Call) RunAndReturn(run func(ctx context.Context, input ExecutionInput, agentConfig Config) (ExecutionID, error)) *MockExecutionRepository_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Exists provides a mock function for the type MockExecutionRepository
func (_mock *MockExecutionRepository) Exists(ctx context.Context, id ExecutionID) (bool, error) {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for Exists")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ExecutionID) (bool, error)); ok {
		return returnFunc(ctx, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ExecutionID) bool); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ExecutionID) error); ok {
		r1 = returnFunc(ctx, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockExecutionRepository_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists'
type MockExecutionRepository_Exists_Call struct {
	*mock.Call
}

// Exists is a helper method to define mock.On call
//   - ctx context.Context
//   - id ExecutionID
func (_e *MockExecutionRepository_Expecter) Exists(ctx interface{}, id interface{}) *MockExecutionRepository_Exists_Call {
	return &MockExecutionRepository_Exists_Call{Call: _e.mock.On("Exists", ctx, id)}
}

func (_c *MockExecutionRepository_Exists_Call) Run(run func(ctx context.Context, id ExecutionID)) *MockExecutionRepository_Exists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ExecutionID
		if args[1] != nil {
			arg1 = args[1].(ExecutionID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockExecutionRepository_Exists_Call) Return(b bool, err error) *MockExecutionRepository_Exists_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockExecutionRepository_Exists_Call) RunAndReturn(run func(ctx context.Context, id ExecutionID) (bool, error)) *MockExecutionRepository_Exists_Call {
	_c.Call.Return(run)
	return _c
}

// Find provides a mock function for the type MockExecutionRepository
func (_mock *MockExecutionRepository) Find(ctx context.Context, filters ...ExecutionFilter) ([]ExecutionID, error) {
	var tmpRet mock.Arguments
	if len(filters) > 0 {
		tmpRet = _mock.Called(ctx, filters)
	} else {
		tmpRet = _mock.Called(ctx)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for Find")
	}

	var r0 []ExecutionID
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...ExecutionFilter) ([]ExecutionID, error)); ok {
		return returnFunc(ctx, filters...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...ExecutionFilter) []ExecutionID); ok {
		r0 = returnFunc(ctx, filters...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]ExecutionID)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ...ExecutionFilter) error); ok {
		r1 = returnFunc(ctx, filters...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockExecutionRepository_Find_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Find'
type MockExecutionRepository_Find_Call struct {
	*mock.Call
}

// Find is a helper method to define mock.On call
//   - ctx context.Context
//   - filters ...ExecutionFilter
func (_e *MockExecutionRepository_Expecter) Find(ctx interface{}, filters ...interface{}) *MockExecutionRepository_Find_Call {
	return &MockExecutionRepository_Find_Call{Call: _e.mock.On("Find",
		append([]interface{}{ctx}, filters...)...)}
}

func (_c *MockExecutionRepository_Find_Call) Run(run func(ctx context.Context, filters ...ExecutionFilter)) *MockExecutionRepository_Find_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []ExecutionFilter
		var variadicArgs []ExecutionFilter
		if len(args) > 1 {
			variadicArgs = args[1].([]ExecutionFilter)
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockExecutionRepository_Find_Call) Return(executionIDs []ExecutionID, err error) *MockExecutionRepository_Find_Call {
	_c.Call.Return(executionIDs, err)
	return _c
}

func (_c *MockExecutionRepository_Find_Call) RunAndReturn(run func(ctx context.Context, filters ...ExecutionFilter) ([]ExecutionID, error)) *MockExecutionRepository_Find_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function for the type MockExecutionRepository
func (_mock *MockExecutionRepository) Get(ctx context.Context, id ExecutionID) (Execution, error) {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for Get")
	}

	var r0 Execution
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ExecutionID) (Execution, error)); ok {
		return returnFunc(ctx, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ExecutionID) Execution); ok {
		r0 = returnFunc(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(Execution)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ExecutionID) error); ok {
		r1 = returnFunc(ctx, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - id ExecutionID
func (_e *MockExecutionRepository_Expecter) Get(ctx interface{}, id interface{}) *MockExecutionRepository_Get_Call {
	return &MockExecutionRepository_Get_Call{Call: _e.mock.On("Get", ctx, id)}
}

func (_c *MockExecutionRepository_Get_Call) Run(run func(ctx context.Context, id ExecutionID)) *MockExecutionRepository_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ExecutionID
		if args[1] != nil {
			arg1 = args[1].(ExecutionID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockExecutionRepository_Get_Call) Return(execution Execution, err error) *MockExecutionRepository_Get_Call {
	_c.Call.Return(execution, err)
	return _c
}

func (_c *MockExecutionRepository_Get_Call) RunAndReturn(run func(ctx context.Context, id ExecutionID) (Execution, error)) *MockExecutionRepository_Get_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockExecution creates a new instance of MockExecution. 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 NewMockExecution(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockExecution {
	mock := &MockExecution{}
	mock.Mock.Test(t)

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

	return mock
}

// MockExecution is an autogenerated mock type for the Execution type
type MockExecution struct {
	mock.Mock
}

type MockExecution_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExecution) EXPECT() *MockExecution_Expecter {
	return &MockExecution_Expecter{mock: &_m.Mock}
}

// GetAgentConfig provides a mock function for the type MockExecution
func (_mock *MockExecution) GetAgentConfig(ctx context.Context) (Config, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetAgentConfig")
	}

	var r0 Config
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (Config, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) Config); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(Config)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockExecution_GetAgentConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAgentConfig'
type MockExecution_GetAgentConfig_Call struct {
	*mock.Call
}

// GetAgentConfig is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockExecution_Expecter) GetAgentConfig(ctx interface{}) *MockExecution_GetAgentConfig_Call {
	return &MockExecution_GetAgentConfig_Call{Call: _e.mock.On("GetAgentConfig", ctx)}
}

func (_c *MockExecution_GetAgentConfig_Call) Run(run func(ctx context.Context)) *MockExecution_GetAgentConfig_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 *MockExecution_GetAgentConfig_Call) Return(config Config, err error) *MockExecution_GetAgentConfig_Call {
	_c.Call.Return(config, err)
	return _c
}

func (_c *MockExecution_GetAgentConfig_Call) RunAndReturn(run func(ctx context.Context) (Config, error)) *MockExecution_GetAgentConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetInput provides a mock function for the type MockExecution
func (_mock *MockExecution) GetInput(ctx context.Context) (ExecutionInput, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetInput")
	}

	var r0 ExecutionInput
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (ExecutionInput, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) ExecutionInput); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(ExecutionInput)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockExecution_GetInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInput'
type MockExecution_GetInput_Call struct {
	*mock.Call
}

// GetInput is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockExecution_Expecter) GetInput(ctx interface{}) *MockExecution_GetInput_Call {
	return &MockExecution_GetInput_Call{Call: _e.mock.On("GetInput", ctx)}
}

func (_c *MockExecution_GetInput_Call) Run(run func(ctx context.Context)) *MockExecution_GetInput_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 *MockExecution_GetInput_Call) Return(executionInput ExecutionInput, err error) *MockExecution_GetInput_Call {
	_c.Call.Return(executionInput, err)
	return _c
}

func (_c *MockExecution_GetInput_Call) RunAndReturn(run func(ctx context.Context) (ExecutionInput, error)) *MockExecution_GetInput_Call {
	_c.Call.Return(run)
	return _c
}

// GetResult provides a mock function for the type MockExecution
func (_mock *MockExecution) GetResult(ctx context.Context) (ExecutionResult, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetResult")
	}

	var r0 ExecutionResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (ExecutionResult, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) ExecutionResult); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(ExecutionResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockExecution_GetResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResult'
type MockExecution_GetResult_Call struct {
	*mock.Call
}

// GetResult is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockExecution_Expecter) GetResult(ctx interface{}) *MockExecution_GetResult_Call {
	return &MockExecution_GetResult_Call{Call: _e.mock.On("GetResult", ctx)}
}

func (_c *MockExecution_GetResult_Call) Run(run func(ctx context.Context)) *MockExecution_GetResult_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 *MockExecution_GetResult_Call) Return(executionResult ExecutionResult, err error) *MockExecution_GetResult_Call {
	_c.Call.Return(executionResult, err)
	return _c
}

func (_c *MockExecution_GetResult_Call) RunAndReturn(run func(ctx context.Context) (ExecutionResult, error)) *MockExecution_GetResult_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatus provides a mock function for the type MockExecution
func (_mock *MockExecution) GetStatus(ctx context.Context) (ExecutionStatus, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetStatus")
	}

	var r0 ExecutionStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (ExecutionStatus, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) ExecutionStatus); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(ExecutionStatus)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockExecution_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
type MockExecution_GetStatus_Call struct {
	*mock.Call
}

// GetStatus is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockExecution_Expecter) GetStatus(ctx interface{}) *MockExecution_GetStatus_Call {
	return &MockExecution_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx)}
}

func (_c *MockExecution_GetStatus_Call) Run(run func(ctx context.Context)) *MockExecution_GetStatus_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 *MockExecution_GetStatus_Call) Return(executionStatus ExecutionStatus, err error) *MockExecution_GetStatus_Call {
	_c.Call.Return(executionStatus, err)
	return _c
}

func (_c *MockExecution_GetStatus_Call) RunAndReturn(run func(ctx context.Context) (ExecutionStatus, error)) *MockExecution_GetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// HasResult provides a mock function for the type MockExecution
func (_mock *MockExecution) HasResult(ctx context.Context) (bool, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for HasResult")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (bool, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockExecution_HasResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasResult'
type MockExecution_HasResult_Call struct {
	*mock.Call
}

// HasResult is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockExecution_Expecter) HasResult(ctx interface{}) *MockExecution_HasResult_Call {
	return &MockExecution_HasResult_Call{Call: _e.mock.On("HasResult", ctx)}
}

func (_c *MockExecution_HasResult_Call) Run(run func(ctx context.Context)) *MockExecution_HasResult_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 *MockExecution_HasResult_Call) Return(b bool, err error) *MockExecution_HasResult_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockExecution_HasResult_Call) RunAndReturn(run func(ctx context.Context) (bool, error)) *MockExecution_HasResult_Call {
	_c.Call.Return(run)
	return _c
}

// SetResult provides a mock function for the type MockExecution
func (_mock *MockExecution) SetResult(ctx context.Context, result ExecutionResult) error {
	ret := _mock.Called(ctx, result)

	if len(ret) == 0 {
		panic("no return value specified for SetResult")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ExecutionResult) error); ok {
		r0 = returnFunc(ctx, result)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockExecution_SetResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResult'
type MockExecution_SetResult_Call struct {
	*mock.Call
}

// SetResult is a helper method to define mock.On call
//   - ctx context.Context
//   - result ExecutionResult
func (_e *MockExecution_Expecter) SetResult(ctx interface{}, result interface{}) *MockExecution_SetResult_Call {
	return &MockExecution_SetResult_Call{Call: _e.mock.On("SetResult", ctx, result)}
}

func (_c *MockExecution_SetResult_Call) Run(run func(ctx context.Context, result ExecutionResult)) *MockExecution_SetResult_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ExecutionResult
		if args[1] != nil {
			arg1 = args[1].(ExecutionResult)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockExecution_SetResult_Call) Return(err error) *MockExecution_SetResult_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockExecution_SetResult_Call) RunAndReturn(run func(ctx context.Context, result ExecutionResult) error) *MockExecution_SetResult_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStatus provides a mock function for the type MockExecution
func (_mock *MockExecution) UpdateStatus(ctx context.Context, status ExecutionStatus) error {
	ret := _mock.Called(ctx, status)

	if len(ret) == 0 {
		panic("no return value specified for UpdateStatus")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ExecutionStatus) error); ok {
		r0 = returnFunc(ctx, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockExecution_UpdateStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStatus'
type MockExecution_UpdateStatus_Call struct {
	*mock.Call
}

// UpdateStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - status ExecutionStatus
func (_e *MockExecution_Expecter) UpdateStatus(ctx interface{}, status interface{}) *MockExecution_UpdateStatus_Call {
	return &MockExecution_UpdateStatus_Call{Call: _e.mock.On("UpdateStatus", ctx, status)}
}

func (_c *MockExecution_UpdateStatus_Call) Run(run func(ctx context.Context, status ExecutionStatus)) *MockExecution_UpdateStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ExecutionStatus
		if args[1] != nil {
			arg1 = args[1].(ExecutionStatus)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockExecution_UpdateStatus_Call) Return(err error) *MockExecution_UpdateStatus_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockExecution_UpdateStatus_Call) RunAndReturn(run func(ctx context.Context, status ExecutionStatus) error) *MockExecution_UpdateStatus_Call {
	_c.Call.Return(run)
	return _c
}
