common/mock_JobTrace.go

// Code generated by mockery v2.53.3. DO NOT EDIT.

package common

import (
	context "context"

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

// MockJobTrace is an autogenerated mock type for the JobTrace type
type MockJobTrace struct {
	mock.Mock
}

type MockJobTrace_Expecter struct {
	mock *mock.Mock
}

func (_m *MockJobTrace) EXPECT() *MockJobTrace_Expecter {
	return &MockJobTrace_Expecter{mock: &_m.Mock}
}

// Abort provides a mock function with no fields
func (_m *MockJobTrace) Abort() bool {
	ret := _m.Called()

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

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// Abort is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) Abort() *MockJobTrace_Abort_Call {
	return &MockJobTrace_Abort_Call{Call: _e.mock.On("Abort")}
}

func (_c *MockJobTrace_Abort_Call) Run(run func()) *MockJobTrace_Abort_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockJobTrace_Abort_Call) Return(_a0 bool) *MockJobTrace_Abort_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockJobTrace_Abort_Call) RunAndReturn(run func() bool) *MockJobTrace_Abort_Call {
	_c.Call.Return(run)
	return _c
}

// Cancel provides a mock function with no fields
func (_m *MockJobTrace) Cancel() bool {
	ret := _m.Called()

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

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// Cancel is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) Cancel() *MockJobTrace_Cancel_Call {
	return &MockJobTrace_Cancel_Call{Call: _e.mock.On("Cancel")}
}

func (_c *MockJobTrace_Cancel_Call) Run(run func()) *MockJobTrace_Cancel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockJobTrace_Cancel_Call) Return(_a0 bool) *MockJobTrace_Cancel_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockJobTrace_Cancel_Call) RunAndReturn(run func() bool) *MockJobTrace_Cancel_Call {
	_c.Call.Return(run)
	return _c
}

// Fail provides a mock function with given fields: err, failureData
func (_m *MockJobTrace) Fail(err error, failureData JobFailureData) error {
	ret := _m.Called(err, failureData)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(error, JobFailureData) error); ok {
		r0 = rf(err, failureData)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Fail is a helper method to define mock.On call
//   - err error
//   - failureData JobFailureData
func (_e *MockJobTrace_Expecter) Fail(err interface{}, failureData interface{}) *MockJobTrace_Fail_Call {
	return &MockJobTrace_Fail_Call{Call: _e.mock.On("Fail", err, failureData)}
}

func (_c *MockJobTrace_Fail_Call) Run(run func(err error, failureData JobFailureData)) *MockJobTrace_Fail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(error), args[1].(JobFailureData))
	})
	return _c
}

func (_c *MockJobTrace_Fail_Call) Return(_a0 error) *MockJobTrace_Fail_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockJobTrace_Fail_Call) RunAndReturn(run func(error, JobFailureData) error) *MockJobTrace_Fail_Call {
	_c.Call.Return(run)
	return _c
}

// IsStdout provides a mock function with no fields
func (_m *MockJobTrace) IsStdout() bool {
	ret := _m.Called()

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

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// IsStdout is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) IsStdout() *MockJobTrace_IsStdout_Call {
	return &MockJobTrace_IsStdout_Call{Call: _e.mock.On("IsStdout")}
}

func (_c *MockJobTrace_IsStdout_Call) Run(run func()) *MockJobTrace_IsStdout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockJobTrace_IsStdout_Call) Return(_a0 bool) *MockJobTrace_IsStdout_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockJobTrace_IsStdout_Call) RunAndReturn(run func() bool) *MockJobTrace_IsStdout_Call {
	_c.Call.Return(run)
	return _c
}

// SetAbortFunc provides a mock function with given fields: abortFunc
func (_m *MockJobTrace) SetAbortFunc(abortFunc context.CancelFunc) {
	_m.Called(abortFunc)
}

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

// SetAbortFunc is a helper method to define mock.On call
//   - abortFunc context.CancelFunc
func (_e *MockJobTrace_Expecter) SetAbortFunc(abortFunc interface{}) *MockJobTrace_SetAbortFunc_Call {
	return &MockJobTrace_SetAbortFunc_Call{Call: _e.mock.On("SetAbortFunc", abortFunc)}
}

func (_c *MockJobTrace_SetAbortFunc_Call) Run(run func(abortFunc context.CancelFunc)) *MockJobTrace_SetAbortFunc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.CancelFunc))
	})
	return _c
}

func (_c *MockJobTrace_SetAbortFunc_Call) Return() *MockJobTrace_SetAbortFunc_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockJobTrace_SetAbortFunc_Call) RunAndReturn(run func(context.CancelFunc)) *MockJobTrace_SetAbortFunc_Call {
	_c.Run(run)
	return _c
}

// SetCancelFunc provides a mock function with given fields: cancelFunc
func (_m *MockJobTrace) SetCancelFunc(cancelFunc context.CancelFunc) {
	_m.Called(cancelFunc)
}

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

// SetCancelFunc is a helper method to define mock.On call
//   - cancelFunc context.CancelFunc
func (_e *MockJobTrace_Expecter) SetCancelFunc(cancelFunc interface{}) *MockJobTrace_SetCancelFunc_Call {
	return &MockJobTrace_SetCancelFunc_Call{Call: _e.mock.On("SetCancelFunc", cancelFunc)}
}

func (_c *MockJobTrace_SetCancelFunc_Call) Run(run func(cancelFunc context.CancelFunc)) *MockJobTrace_SetCancelFunc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.CancelFunc))
	})
	return _c
}

func (_c *MockJobTrace_SetCancelFunc_Call) Return() *MockJobTrace_SetCancelFunc_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockJobTrace_SetCancelFunc_Call) RunAndReturn(run func(context.CancelFunc)) *MockJobTrace_SetCancelFunc_Call {
	_c.Run(run)
	return _c
}

// SetDebugModeEnabled provides a mock function with given fields: isEnabled
func (_m *MockJobTrace) SetDebugModeEnabled(isEnabled bool) {
	_m.Called(isEnabled)
}

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

// SetDebugModeEnabled is a helper method to define mock.On call
//   - isEnabled bool
func (_e *MockJobTrace_Expecter) SetDebugModeEnabled(isEnabled interface{}) *MockJobTrace_SetDebugModeEnabled_Call {
	return &MockJobTrace_SetDebugModeEnabled_Call{Call: _e.mock.On("SetDebugModeEnabled", isEnabled)}
}

func (_c *MockJobTrace_SetDebugModeEnabled_Call) Run(run func(isEnabled bool)) *MockJobTrace_SetDebugModeEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool))
	})
	return _c
}

func (_c *MockJobTrace_SetDebugModeEnabled_Call) Return() *MockJobTrace_SetDebugModeEnabled_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockJobTrace_SetDebugModeEnabled_Call) RunAndReturn(run func(bool)) *MockJobTrace_SetDebugModeEnabled_Call {
	_c.Run(run)
	return _c
}

// SetFailuresCollector provides a mock function with given fields: fc
func (_m *MockJobTrace) SetFailuresCollector(fc FailuresCollector) {
	_m.Called(fc)
}

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

// SetFailuresCollector is a helper method to define mock.On call
//   - fc FailuresCollector
func (_e *MockJobTrace_Expecter) SetFailuresCollector(fc interface{}) *MockJobTrace_SetFailuresCollector_Call {
	return &MockJobTrace_SetFailuresCollector_Call{Call: _e.mock.On("SetFailuresCollector", fc)}
}

func (_c *MockJobTrace_SetFailuresCollector_Call) Run(run func(fc FailuresCollector)) *MockJobTrace_SetFailuresCollector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(FailuresCollector))
	})
	return _c
}

func (_c *MockJobTrace_SetFailuresCollector_Call) Return() *MockJobTrace_SetFailuresCollector_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockJobTrace_SetFailuresCollector_Call) RunAndReturn(run func(FailuresCollector)) *MockJobTrace_SetFailuresCollector_Call {
	_c.Run(run)
	return _c
}

// SetSupportedFailureReasonMapper provides a mock function with given fields: f
func (_m *MockJobTrace) SetSupportedFailureReasonMapper(f SupportedFailureReasonMapper) {
	_m.Called(f)
}

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

// SetSupportedFailureReasonMapper is a helper method to define mock.On call
//   - f SupportedFailureReasonMapper
func (_e *MockJobTrace_Expecter) SetSupportedFailureReasonMapper(f interface{}) *MockJobTrace_SetSupportedFailureReasonMapper_Call {
	return &MockJobTrace_SetSupportedFailureReasonMapper_Call{Call: _e.mock.On("SetSupportedFailureReasonMapper", f)}
}

func (_c *MockJobTrace_SetSupportedFailureReasonMapper_Call) Run(run func(f SupportedFailureReasonMapper)) *MockJobTrace_SetSupportedFailureReasonMapper_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(SupportedFailureReasonMapper))
	})
	return _c
}

func (_c *MockJobTrace_SetSupportedFailureReasonMapper_Call) Return() *MockJobTrace_SetSupportedFailureReasonMapper_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockJobTrace_SetSupportedFailureReasonMapper_Call) RunAndReturn(run func(SupportedFailureReasonMapper)) *MockJobTrace_SetSupportedFailureReasonMapper_Call {
	_c.Run(run)
	return _c
}

// Success provides a mock function with no fields
func (_m *MockJobTrace) Success() error {
	ret := _m.Called()

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

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Success is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) Success() *MockJobTrace_Success_Call {
	return &MockJobTrace_Success_Call{Call: _e.mock.On("Success")}
}

func (_c *MockJobTrace_Success_Call) Run(run func()) *MockJobTrace_Success_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockJobTrace_Success_Call) Return(_a0 error) *MockJobTrace_Success_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockJobTrace_Success_Call) RunAndReturn(run func() error) *MockJobTrace_Success_Call {
	_c.Call.Return(run)
	return _c
}

// Write provides a mock function with given fields: p
func (_m *MockJobTrace) Write(p []byte) (int, error) {
	ret := _m.Called(p)

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

	var r0 int
	var r1 error
	if rf, ok := ret.Get(0).(func([]byte) (int, error)); ok {
		return rf(p)
	}
	if rf, ok := ret.Get(0).(func([]byte) int); ok {
		r0 = rf(p)
	} else {
		r0 = ret.Get(0).(int)
	}

	if rf, ok := ret.Get(1).(func([]byte) error); ok {
		r1 = rf(p)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Write is a helper method to define mock.On call
//   - p []byte
func (_e *MockJobTrace_Expecter) Write(p interface{}) *MockJobTrace_Write_Call {
	return &MockJobTrace_Write_Call{Call: _e.mock.On("Write", p)}
}

func (_c *MockJobTrace_Write_Call) Run(run func(p []byte)) *MockJobTrace_Write_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]byte))
	})
	return _c
}

func (_c *MockJobTrace_Write_Call) Return(n int, err error) *MockJobTrace_Write_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MockJobTrace_Write_Call) RunAndReturn(run func([]byte) (int, error)) *MockJobTrace_Write_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}