cacheable_node_handler.go

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

package mocks

import (
	context "context"

	catalog "github.com/flyteorg/flyteplugins/go/tasks/pluginmachinery/catalog"

	handler "github.com/flyteorg/flytepropeller/pkg/controller/nodes/handler"

	interfaces "github.com/flyteorg/flytepropeller/pkg/controller/nodes/interfaces"

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

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

type CacheableNodeHandler_Abort struct {
	*mock.Call
}

func (_m CacheableNodeHandler_Abort) Return(_a0 error) *CacheableNodeHandler_Abort {
	return &CacheableNodeHandler_Abort{Call: _m.Call.Return(_a0)}
}

func (_m *CacheableNodeHandler) OnAbort(ctx context.Context, executionContext interfaces.NodeExecutionContext, reason string) *CacheableNodeHandler_Abort {
	c_call := _m.On("Abort", ctx, executionContext, reason)
	return &CacheableNodeHandler_Abort{Call: c_call}
}

func (_m *CacheableNodeHandler) OnAbortMatch(matchers ...interface{}) *CacheableNodeHandler_Abort {
	c_call := _m.On("Abort", matchers...)
	return &CacheableNodeHandler_Abort{Call: c_call}
}

// Abort provides a mock function with given fields: ctx, executionContext, reason
func (_m *CacheableNodeHandler) Abort(ctx context.Context, executionContext interfaces.NodeExecutionContext, reason string) error {
	ret := _m.Called(ctx, executionContext, reason)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, interfaces.NodeExecutionContext, string) error); ok {
		r0 = rf(ctx, executionContext, reason)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

type CacheableNodeHandler_Finalize struct {
	*mock.Call
}

func (_m CacheableNodeHandler_Finalize) Return(_a0 error) *CacheableNodeHandler_Finalize {
	return &CacheableNodeHandler_Finalize{Call: _m.Call.Return(_a0)}
}

func (_m *CacheableNodeHandler) OnFinalize(ctx context.Context, executionContext interfaces.NodeExecutionContext) *CacheableNodeHandler_Finalize {
	c_call := _m.On("Finalize", ctx, executionContext)
	return &CacheableNodeHandler_Finalize{Call: c_call}
}

func (_m *CacheableNodeHandler) OnFinalizeMatch(matchers ...interface{}) *CacheableNodeHandler_Finalize {
	c_call := _m.On("Finalize", matchers...)
	return &CacheableNodeHandler_Finalize{Call: c_call}
}

// Finalize provides a mock function with given fields: ctx, executionContext
func (_m *CacheableNodeHandler) Finalize(ctx context.Context, executionContext interfaces.NodeExecutionContext) error {
	ret := _m.Called(ctx, executionContext)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, interfaces.NodeExecutionContext) error); ok {
		r0 = rf(ctx, executionContext)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

type CacheableNodeHandler_FinalizeRequired struct {
	*mock.Call
}

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

func (_m *CacheableNodeHandler) OnFinalizeRequired() *CacheableNodeHandler_FinalizeRequired {
	c_call := _m.On("FinalizeRequired")
	return &CacheableNodeHandler_FinalizeRequired{Call: c_call}
}

func (_m *CacheableNodeHandler) OnFinalizeRequiredMatch(matchers ...interface{}) *CacheableNodeHandler_FinalizeRequired {
	c_call := _m.On("FinalizeRequired", matchers...)
	return &CacheableNodeHandler_FinalizeRequired{Call: c_call}
}

// FinalizeRequired provides a mock function with given fields:
func (_m *CacheableNodeHandler) FinalizeRequired() 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
}

type CacheableNodeHandler_GetCatalogKey struct {
	*mock.Call
}

func (_m CacheableNodeHandler_GetCatalogKey) Return(_a0 catalog.Key, _a1 error) *CacheableNodeHandler_GetCatalogKey {
	return &CacheableNodeHandler_GetCatalogKey{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *CacheableNodeHandler) OnGetCatalogKey(ctx context.Context, executionContext interfaces.NodeExecutionContext) *CacheableNodeHandler_GetCatalogKey {
	c_call := _m.On("GetCatalogKey", ctx, executionContext)
	return &CacheableNodeHandler_GetCatalogKey{Call: c_call}
}

func (_m *CacheableNodeHandler) OnGetCatalogKeyMatch(matchers ...interface{}) *CacheableNodeHandler_GetCatalogKey {
	c_call := _m.On("GetCatalogKey", matchers...)
	return &CacheableNodeHandler_GetCatalogKey{Call: c_call}
}

// GetCatalogKey provides a mock function with given fields: ctx, executionContext
func (_m *CacheableNodeHandler) GetCatalogKey(ctx context.Context, executionContext interfaces.NodeExecutionContext) (catalog.Key, error) {
	ret := _m.Called(ctx, executionContext)

	var r0 catalog.Key
	if rf, ok := ret.Get(0).(func(context.Context, interfaces.NodeExecutionContext) catalog.Key); ok {
		r0 = rf(ctx, executionContext)
	} else {
		r0 = ret.Get(0).(catalog.Key)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, interfaces.NodeExecutionContext) error); ok {
		r1 = rf(ctx, executionContext)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type CacheableNodeHandler_Handle struct {
	*mock.Call
}

func (_m CacheableNodeHandler_Handle) Return(_a0 handler.Transition, _a1 error) *CacheableNodeHandler_Handle {
	return &CacheableNodeHandler_Handle{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *CacheableNodeHandler) OnHandle(ctx context.Context, executionContext interfaces.NodeExecutionContext) *CacheableNodeHandler_Handle {
	c_call := _m.On("Handle", ctx, executionContext)
	return &CacheableNodeHandler_Handle{Call: c_call}
}

func (_m *CacheableNodeHandler) OnHandleMatch(matchers ...interface{}) *CacheableNodeHandler_Handle {
	c_call := _m.On("Handle", matchers...)
	return &CacheableNodeHandler_Handle{Call: c_call}
}

// Handle provides a mock function with given fields: ctx, executionContext
func (_m *CacheableNodeHandler) Handle(ctx context.Context, executionContext interfaces.NodeExecutionContext) (handler.Transition, error) {
	ret := _m.Called(ctx, executionContext)

	var r0 handler.Transition
	if rf, ok := ret.Get(0).(func(context.Context, interfaces.NodeExecutionContext) handler.Transition); ok {
		r0 = rf(ctx, executionContext)
	} else {
		r0 = ret.Get(0).(handler.Transition)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, interfaces.NodeExecutionContext) error); ok {
		r1 = rf(ctx, executionContext)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type CacheableNodeHandler_IsCacheable struct {
	*mock.Call
}

func (_m CacheableNodeHandler_IsCacheable) Return(_a0 bool, _a1 bool, _a2 error) *CacheableNodeHandler_IsCacheable {
	return &CacheableNodeHandler_IsCacheable{Call: _m.Call.Return(_a0, _a1, _a2)}
}

func (_m *CacheableNodeHandler) OnIsCacheable(ctx context.Context, executionContext interfaces.NodeExecutionContext) *CacheableNodeHandler_IsCacheable {
	c_call := _m.On("IsCacheable", ctx, executionContext)
	return &CacheableNodeHandler_IsCacheable{Call: c_call}
}

func (_m *CacheableNodeHandler) OnIsCacheableMatch(matchers ...interface{}) *CacheableNodeHandler_IsCacheable {
	c_call := _m.On("IsCacheable", matchers...)
	return &CacheableNodeHandler_IsCacheable{Call: c_call}
}

// IsCacheable provides a mock function with given fields: ctx, executionContext
func (_m *CacheableNodeHandler) IsCacheable(ctx context.Context, executionContext interfaces.NodeExecutionContext) (bool, bool, error) {
	ret := _m.Called(ctx, executionContext)

	var r0 bool
	if rf, ok := ret.Get(0).(func(context.Context, interfaces.NodeExecutionContext) bool); ok {
		r0 = rf(ctx, executionContext)
	} else {
		r0 = ret.Get(0).(bool)
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(context.Context, interfaces.NodeExecutionContext) bool); ok {
		r1 = rf(ctx, executionContext)
	} else {
		r1 = ret.Get(1).(bool)
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, interfaces.NodeExecutionContext) error); ok {
		r2 = rf(ctx, executionContext)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

type CacheableNodeHandler_Setup struct {
	*mock.Call
}

func (_m CacheableNodeHandler_Setup) Return(_a0 error) *CacheableNodeHandler_Setup {
	return &CacheableNodeHandler_Setup{Call: _m.Call.Return(_a0)}
}

func (_m *CacheableNodeHandler) OnSetup(ctx context.Context, setupContext interfaces.SetupContext) *CacheableNodeHandler_Setup {
	c_call := _m.On("Setup", ctx, setupContext)
	return &CacheableNodeHandler_Setup{Call: c_call}
}

func (_m *CacheableNodeHandler) OnSetupMatch(matchers ...interface{}) *CacheableNodeHandler_Setup {
	c_call := _m.On("Setup", matchers...)
	return &CacheableNodeHandler_Setup{Call: c_call}
}

// Setup provides a mock function with given fields: ctx, setupContext
func (_m *CacheableNodeHandler) Setup(ctx context.Context, setupContext interfaces.SetupContext) error {
	ret := _m.Called(ctx, setupContext)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, interfaces.SetupContext) error); ok {
		r0 = rf(ctx, setupContext)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}