factory.go

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

package mocks

import (
	authenticators "github.com/dadrus/heimdall/internal/rules/mechanisms/authenticators"
	authorizers "github.com/dadrus/heimdall/internal/rules/mechanisms/authorizers"

	config "github.com/dadrus/heimdall/internal/config"

	contextualizers "github.com/dadrus/heimdall/internal/rules/mechanisms/contextualizers"

	errorhandlers "github.com/dadrus/heimdall/internal/rules/mechanisms/errorhandlers"

	finalizers "github.com/dadrus/heimdall/internal/rules/mechanisms/finalizers"

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

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

type FactoryMock_Expecter struct {
	mock *mock.Mock
}

func (_m *FactoryMock) EXPECT() *FactoryMock_Expecter {
	return &FactoryMock_Expecter{mock: &_m.Mock}
}

// CreateAuthenticator provides a mock function with given fields: version, id, conf
func (_m *FactoryMock) CreateAuthenticator(version string, id string, conf config.MechanismConfig) (authenticators.Authenticator, error) {
	ret := _m.Called(version, id, conf)

	var r0 authenticators.Authenticator
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) (authenticators.Authenticator, error)); ok {
		return rf(version, id, conf)
	}
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) authenticators.Authenticator); ok {
		r0 = rf(version, id, conf)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(authenticators.Authenticator)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, config.MechanismConfig) error); ok {
		r1 = rf(version, id, conf)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateAuthenticator is a helper method to define mock.On call
//   - version string
//   - id string
//   - conf config.MechanismConfig
func (_e *FactoryMock_Expecter) CreateAuthenticator(version interface{}, id interface{}, conf interface{}) *FactoryMock_CreateAuthenticator_Call {
	return &FactoryMock_CreateAuthenticator_Call{Call: _e.mock.On("CreateAuthenticator", version, id, conf)}
}

func (_c *FactoryMock_CreateAuthenticator_Call) Run(run func(version string, id string, conf config.MechanismConfig)) *FactoryMock_CreateAuthenticator_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(config.MechanismConfig))
	})
	return _c
}

func (_c *FactoryMock_CreateAuthenticator_Call) Return(_a0 authenticators.Authenticator, _a1 error) *FactoryMock_CreateAuthenticator_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FactoryMock_CreateAuthenticator_Call) RunAndReturn(run func(string, string, config.MechanismConfig) (authenticators.Authenticator, error)) *FactoryMock_CreateAuthenticator_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAuthorizer provides a mock function with given fields: version, id, conf
func (_m *FactoryMock) CreateAuthorizer(version string, id string, conf config.MechanismConfig) (authorizers.Authorizer, error) {
	ret := _m.Called(version, id, conf)

	var r0 authorizers.Authorizer
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) (authorizers.Authorizer, error)); ok {
		return rf(version, id, conf)
	}
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) authorizers.Authorizer); ok {
		r0 = rf(version, id, conf)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(authorizers.Authorizer)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, config.MechanismConfig) error); ok {
		r1 = rf(version, id, conf)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateAuthorizer is a helper method to define mock.On call
//   - version string
//   - id string
//   - conf config.MechanismConfig
func (_e *FactoryMock_Expecter) CreateAuthorizer(version interface{}, id interface{}, conf interface{}) *FactoryMock_CreateAuthorizer_Call {
	return &FactoryMock_CreateAuthorizer_Call{Call: _e.mock.On("CreateAuthorizer", version, id, conf)}
}

func (_c *FactoryMock_CreateAuthorizer_Call) Run(run func(version string, id string, conf config.MechanismConfig)) *FactoryMock_CreateAuthorizer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(config.MechanismConfig))
	})
	return _c
}

func (_c *FactoryMock_CreateAuthorizer_Call) Return(_a0 authorizers.Authorizer, _a1 error) *FactoryMock_CreateAuthorizer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FactoryMock_CreateAuthorizer_Call) RunAndReturn(run func(string, string, config.MechanismConfig) (authorizers.Authorizer, error)) *FactoryMock_CreateAuthorizer_Call {
	_c.Call.Return(run)
	return _c
}

// CreateContextualizer provides a mock function with given fields: version, id, conf
func (_m *FactoryMock) CreateContextualizer(version string, id string, conf config.MechanismConfig) (contextualizers.Contextualizer, error) {
	ret := _m.Called(version, id, conf)

	var r0 contextualizers.Contextualizer
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) (contextualizers.Contextualizer, error)); ok {
		return rf(version, id, conf)
	}
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) contextualizers.Contextualizer); ok {
		r0 = rf(version, id, conf)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(contextualizers.Contextualizer)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, config.MechanismConfig) error); ok {
		r1 = rf(version, id, conf)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateContextualizer is a helper method to define mock.On call
//   - version string
//   - id string
//   - conf config.MechanismConfig
func (_e *FactoryMock_Expecter) CreateContextualizer(version interface{}, id interface{}, conf interface{}) *FactoryMock_CreateContextualizer_Call {
	return &FactoryMock_CreateContextualizer_Call{Call: _e.mock.On("CreateContextualizer", version, id, conf)}
}

func (_c *FactoryMock_CreateContextualizer_Call) Run(run func(version string, id string, conf config.MechanismConfig)) *FactoryMock_CreateContextualizer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(config.MechanismConfig))
	})
	return _c
}

func (_c *FactoryMock_CreateContextualizer_Call) Return(_a0 contextualizers.Contextualizer, _a1 error) *FactoryMock_CreateContextualizer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FactoryMock_CreateContextualizer_Call) RunAndReturn(run func(string, string, config.MechanismConfig) (contextualizers.Contextualizer, error)) *FactoryMock_CreateContextualizer_Call {
	_c.Call.Return(run)
	return _c
}

// CreateErrorHandler provides a mock function with given fields: version, id, conf
func (_m *FactoryMock) CreateErrorHandler(version string, id string, conf config.MechanismConfig) (errorhandlers.ErrorHandler, error) {
	ret := _m.Called(version, id, conf)

	var r0 errorhandlers.ErrorHandler
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) (errorhandlers.ErrorHandler, error)); ok {
		return rf(version, id, conf)
	}
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) errorhandlers.ErrorHandler); ok {
		r0 = rf(version, id, conf)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errorhandlers.ErrorHandler)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, config.MechanismConfig) error); ok {
		r1 = rf(version, id, conf)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateErrorHandler is a helper method to define mock.On call
//   - version string
//   - id string
//   - conf config.MechanismConfig
func (_e *FactoryMock_Expecter) CreateErrorHandler(version interface{}, id interface{}, conf interface{}) *FactoryMock_CreateErrorHandler_Call {
	return &FactoryMock_CreateErrorHandler_Call{Call: _e.mock.On("CreateErrorHandler", version, id, conf)}
}

func (_c *FactoryMock_CreateErrorHandler_Call) Run(run func(version string, id string, conf config.MechanismConfig)) *FactoryMock_CreateErrorHandler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(config.MechanismConfig))
	})
	return _c
}

func (_c *FactoryMock_CreateErrorHandler_Call) Return(_a0 errorhandlers.ErrorHandler, _a1 error) *FactoryMock_CreateErrorHandler_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FactoryMock_CreateErrorHandler_Call) RunAndReturn(run func(string, string, config.MechanismConfig) (errorhandlers.ErrorHandler, error)) *FactoryMock_CreateErrorHandler_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFinalizer provides a mock function with given fields: version, id, conf
func (_m *FactoryMock) CreateFinalizer(version string, id string, conf config.MechanismConfig) (finalizers.Finalizer, error) {
	ret := _m.Called(version, id, conf)

	var r0 finalizers.Finalizer
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) (finalizers.Finalizer, error)); ok {
		return rf(version, id, conf)
	}
	if rf, ok := ret.Get(0).(func(string, string, config.MechanismConfig) finalizers.Finalizer); ok {
		r0 = rf(version, id, conf)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(finalizers.Finalizer)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, config.MechanismConfig) error); ok {
		r1 = rf(version, id, conf)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateFinalizer is a helper method to define mock.On call
//   - version string
//   - id string
//   - conf config.MechanismConfig
func (_e *FactoryMock_Expecter) CreateFinalizer(version interface{}, id interface{}, conf interface{}) *FactoryMock_CreateFinalizer_Call {
	return &FactoryMock_CreateFinalizer_Call{Call: _e.mock.On("CreateFinalizer", version, id, conf)}
}

func (_c *FactoryMock_CreateFinalizer_Call) Run(run func(version string, id string, conf config.MechanismConfig)) *FactoryMock_CreateFinalizer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(config.MechanismConfig))
	})
	return _c
}

func (_c *FactoryMock_CreateFinalizer_Call) Return(_a0 finalizers.Finalizer, _a1 error) *FactoryMock_CreateFinalizer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FactoryMock_CreateFinalizer_Call) RunAndReturn(run func(string, string, config.MechanismConfig) (finalizers.Finalizer, error)) *FactoryMock_CreateFinalizer_Call {
	_c.Call.Return(run)
	return _c
}

type mockConstructorTestingTNewFactoryMock interface {
	mock.TestingT
	Cleanup(func())
}

// NewFactoryMock creates a new instance of FactoryMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewFactoryMock(t mockConstructorTestingTNewFactoryMock) *FactoryMock {
	mock := &FactoryMock{}
	mock.Mock.Test(t)

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

	return mock
}