MutableArrayNodeStatus.go

// Code generated by mockery v1.0.1. DO NOT EDIT.

package mocks

import (
	core "github.com/flyteorg/flyte/flyteidl/gen/pb-go/flyteidl/core"
	bitarray "github.com/flyteorg/flyte/flytestdlib/bitarray"

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

	v1alpha1 "github.com/flyteorg/flyte/flytepropeller/pkg/apis/flyteworkflow/v1alpha1"
)

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

type MutableArrayNodeStatus_GetArrayNodePhase struct {
	*mock.Call
}

func (_m MutableArrayNodeStatus_GetArrayNodePhase) Return(_a0 v1alpha1.ArrayNodePhase) *MutableArrayNodeStatus_GetArrayNodePhase {
	return &MutableArrayNodeStatus_GetArrayNodePhase{Call: _m.Call.Return(_a0)}
}

func (_m *MutableArrayNodeStatus) OnGetArrayNodePhase() *MutableArrayNodeStatus_GetArrayNodePhase {
	c_call := _m.On("GetArrayNodePhase")
	return &MutableArrayNodeStatus_GetArrayNodePhase{Call: c_call}
}

func (_m *MutableArrayNodeStatus) OnGetArrayNodePhaseMatch(matchers ...interface{}) *MutableArrayNodeStatus_GetArrayNodePhase {
	c_call := _m.On("GetArrayNodePhase", matchers...)
	return &MutableArrayNodeStatus_GetArrayNodePhase{Call: c_call}
}

// GetArrayNodePhase provides a mock function with given fields:
func (_m *MutableArrayNodeStatus) GetArrayNodePhase() v1alpha1.ArrayNodePhase {
	ret := _m.Called()

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

	return r0
}

type MutableArrayNodeStatus_GetExecutionError struct {
	*mock.Call
}

func (_m MutableArrayNodeStatus_GetExecutionError) Return(_a0 *core.ExecutionError) *MutableArrayNodeStatus_GetExecutionError {
	return &MutableArrayNodeStatus_GetExecutionError{Call: _m.Call.Return(_a0)}
}

func (_m *MutableArrayNodeStatus) OnGetExecutionError() *MutableArrayNodeStatus_GetExecutionError {
	c_call := _m.On("GetExecutionError")
	return &MutableArrayNodeStatus_GetExecutionError{Call: c_call}
}

func (_m *MutableArrayNodeStatus) OnGetExecutionErrorMatch(matchers ...interface{}) *MutableArrayNodeStatus_GetExecutionError {
	c_call := _m.On("GetExecutionError", matchers...)
	return &MutableArrayNodeStatus_GetExecutionError{Call: c_call}
}

// GetExecutionError provides a mock function with given fields:
func (_m *MutableArrayNodeStatus) GetExecutionError() *core.ExecutionError {
	ret := _m.Called()

	var r0 *core.ExecutionError
	if rf, ok := ret.Get(0).(func() *core.ExecutionError); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*core.ExecutionError)
		}
	}

	return r0
}

type MutableArrayNodeStatus_GetSubNodePhases struct {
	*mock.Call
}

func (_m MutableArrayNodeStatus_GetSubNodePhases) Return(_a0 bitarray.CompactArray) *MutableArrayNodeStatus_GetSubNodePhases {
	return &MutableArrayNodeStatus_GetSubNodePhases{Call: _m.Call.Return(_a0)}
}

func (_m *MutableArrayNodeStatus) OnGetSubNodePhases() *MutableArrayNodeStatus_GetSubNodePhases {
	c_call := _m.On("GetSubNodePhases")
	return &MutableArrayNodeStatus_GetSubNodePhases{Call: c_call}
}

func (_m *MutableArrayNodeStatus) OnGetSubNodePhasesMatch(matchers ...interface{}) *MutableArrayNodeStatus_GetSubNodePhases {
	c_call := _m.On("GetSubNodePhases", matchers...)
	return &MutableArrayNodeStatus_GetSubNodePhases{Call: c_call}
}

// GetSubNodePhases provides a mock function with given fields:
func (_m *MutableArrayNodeStatus) GetSubNodePhases() bitarray.CompactArray {
	ret := _m.Called()

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

	return r0
}

type MutableArrayNodeStatus_GetSubNodeRetryAttempts struct {
	*mock.Call
}

func (_m MutableArrayNodeStatus_GetSubNodeRetryAttempts) Return(_a0 bitarray.CompactArray) *MutableArrayNodeStatus_GetSubNodeRetryAttempts {
	return &MutableArrayNodeStatus_GetSubNodeRetryAttempts{Call: _m.Call.Return(_a0)}
}

func (_m *MutableArrayNodeStatus) OnGetSubNodeRetryAttempts() *MutableArrayNodeStatus_GetSubNodeRetryAttempts {
	c_call := _m.On("GetSubNodeRetryAttempts")
	return &MutableArrayNodeStatus_GetSubNodeRetryAttempts{Call: c_call}
}

func (_m *MutableArrayNodeStatus) OnGetSubNodeRetryAttemptsMatch(matchers ...interface{}) *MutableArrayNodeStatus_GetSubNodeRetryAttempts {
	c_call := _m.On("GetSubNodeRetryAttempts", matchers...)
	return &MutableArrayNodeStatus_GetSubNodeRetryAttempts{Call: c_call}
}

// GetSubNodeRetryAttempts provides a mock function with given fields:
func (_m *MutableArrayNodeStatus) GetSubNodeRetryAttempts() bitarray.CompactArray {
	ret := _m.Called()

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

	return r0
}

type MutableArrayNodeStatus_GetSubNodeSystemFailures struct {
	*mock.Call
}

func (_m MutableArrayNodeStatus_GetSubNodeSystemFailures) Return(_a0 bitarray.CompactArray) *MutableArrayNodeStatus_GetSubNodeSystemFailures {
	return &MutableArrayNodeStatus_GetSubNodeSystemFailures{Call: _m.Call.Return(_a0)}
}

func (_m *MutableArrayNodeStatus) OnGetSubNodeSystemFailures() *MutableArrayNodeStatus_GetSubNodeSystemFailures {
	c_call := _m.On("GetSubNodeSystemFailures")
	return &MutableArrayNodeStatus_GetSubNodeSystemFailures{Call: c_call}
}

func (_m *MutableArrayNodeStatus) OnGetSubNodeSystemFailuresMatch(matchers ...interface{}) *MutableArrayNodeStatus_GetSubNodeSystemFailures {
	c_call := _m.On("GetSubNodeSystemFailures", matchers...)
	return &MutableArrayNodeStatus_GetSubNodeSystemFailures{Call: c_call}
}

// GetSubNodeSystemFailures provides a mock function with given fields:
func (_m *MutableArrayNodeStatus) GetSubNodeSystemFailures() bitarray.CompactArray {
	ret := _m.Called()

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

	return r0
}

type MutableArrayNodeStatus_GetSubNodeTaskPhases struct {
	*mock.Call
}

func (_m MutableArrayNodeStatus_GetSubNodeTaskPhases) Return(_a0 bitarray.CompactArray) *MutableArrayNodeStatus_GetSubNodeTaskPhases {
	return &MutableArrayNodeStatus_GetSubNodeTaskPhases{Call: _m.Call.Return(_a0)}
}

func (_m *MutableArrayNodeStatus) OnGetSubNodeTaskPhases() *MutableArrayNodeStatus_GetSubNodeTaskPhases {
	c_call := _m.On("GetSubNodeTaskPhases")
	return &MutableArrayNodeStatus_GetSubNodeTaskPhases{Call: c_call}
}

func (_m *MutableArrayNodeStatus) OnGetSubNodeTaskPhasesMatch(matchers ...interface{}) *MutableArrayNodeStatus_GetSubNodeTaskPhases {
	c_call := _m.On("GetSubNodeTaskPhases", matchers...)
	return &MutableArrayNodeStatus_GetSubNodeTaskPhases{Call: c_call}
}

// GetSubNodeTaskPhases provides a mock function with given fields:
func (_m *MutableArrayNodeStatus) GetSubNodeTaskPhases() bitarray.CompactArray {
	ret := _m.Called()

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

	return r0
}

type MutableArrayNodeStatus_GetTaskPhaseVersion struct {
	*mock.Call
}

func (_m MutableArrayNodeStatus_GetTaskPhaseVersion) Return(_a0 uint32) *MutableArrayNodeStatus_GetTaskPhaseVersion {
	return &MutableArrayNodeStatus_GetTaskPhaseVersion{Call: _m.Call.Return(_a0)}
}

func (_m *MutableArrayNodeStatus) OnGetTaskPhaseVersion() *MutableArrayNodeStatus_GetTaskPhaseVersion {
	c_call := _m.On("GetTaskPhaseVersion")
	return &MutableArrayNodeStatus_GetTaskPhaseVersion{Call: c_call}
}

func (_m *MutableArrayNodeStatus) OnGetTaskPhaseVersionMatch(matchers ...interface{}) *MutableArrayNodeStatus_GetTaskPhaseVersion {
	c_call := _m.On("GetTaskPhaseVersion", matchers...)
	return &MutableArrayNodeStatus_GetTaskPhaseVersion{Call: c_call}
}

// GetTaskPhaseVersion provides a mock function with given fields:
func (_m *MutableArrayNodeStatus) GetTaskPhaseVersion() uint32 {
	ret := _m.Called()

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

	return r0
}

type MutableArrayNodeStatus_IsDirty struct {
	*mock.Call
}

func (_m MutableArrayNodeStatus_IsDirty) Return(_a0 bool) *MutableArrayNodeStatus_IsDirty {
	return &MutableArrayNodeStatus_IsDirty{Call: _m.Call.Return(_a0)}
}

func (_m *MutableArrayNodeStatus) OnIsDirty() *MutableArrayNodeStatus_IsDirty {
	c_call := _m.On("IsDirty")
	return &MutableArrayNodeStatus_IsDirty{Call: c_call}
}

func (_m *MutableArrayNodeStatus) OnIsDirtyMatch(matchers ...interface{}) *MutableArrayNodeStatus_IsDirty {
	c_call := _m.On("IsDirty", matchers...)
	return &MutableArrayNodeStatus_IsDirty{Call: c_call}
}

// IsDirty provides a mock function with given fields:
func (_m *MutableArrayNodeStatus) IsDirty() bool {
	ret := _m.Called()

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

	return r0
}

// SetArrayNodePhase provides a mock function with given fields: phase
func (_m *MutableArrayNodeStatus) SetArrayNodePhase(phase v1alpha1.ArrayNodePhase) {
	_m.Called(phase)
}

// SetExecutionError provides a mock function with given fields: executionError
func (_m *MutableArrayNodeStatus) SetExecutionError(executionError *core.ExecutionError) {
	_m.Called(executionError)
}

// SetSubNodePhases provides a mock function with given fields: subNodePhases
func (_m *MutableArrayNodeStatus) SetSubNodePhases(subNodePhases bitarray.CompactArray) {
	_m.Called(subNodePhases)
}

// SetSubNodeRetryAttempts provides a mock function with given fields: subNodeRetryAttempts
func (_m *MutableArrayNodeStatus) SetSubNodeRetryAttempts(subNodeRetryAttempts bitarray.CompactArray) {
	_m.Called(subNodeRetryAttempts)
}

// SetSubNodeSystemFailures provides a mock function with given fields: subNodeSystemFailures
func (_m *MutableArrayNodeStatus) SetSubNodeSystemFailures(subNodeSystemFailures bitarray.CompactArray) {
	_m.Called(subNodeSystemFailures)
}

// SetSubNodeTaskPhases provides a mock function with given fields: subNodeTaskPhases
func (_m *MutableArrayNodeStatus) SetSubNodeTaskPhases(subNodeTaskPhases bitarray.CompactArray) {
	_m.Called(subNodeTaskPhases)
}

// SetTaskPhaseVersion provides a mock function with given fields: taskPhaseVersion
func (_m *MutableArrayNodeStatus) SetTaskPhaseVersion(taskPhaseVersion uint32) {
	_m.Called(taskPhaseVersion)
}