providerService.go

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

package mocks

import (
	context "context"

	domain "github.com/goto/guardian/domain"
	mock "github.com/stretchr/testify/mock"
)

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

type ProviderService_Expecter struct {
	mock *mock.Mock
}

func (_m *ProviderService) EXPECT() *ProviderService_Expecter {
	return &ProviderService_Expecter{mock: &_m.Mock}
}

// Create provides a mock function with given fields: _a0, _a1
func (_m *ProviderService) Create(_a0 context.Context, _a1 *domain.Provider) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *domain.Provider) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Create is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *domain.Provider
func (_e *ProviderService_Expecter) Create(_a0 interface{}, _a1 interface{}) *ProviderService_Create_Call {
	return &ProviderService_Create_Call{Call: _e.mock.On("Create", _a0, _a1)}
}

func (_c *ProviderService_Create_Call) Run(run func(_a0 context.Context, _a1 *domain.Provider)) *ProviderService_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*domain.Provider))
	})
	return _c
}

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

func (_c *ProviderService_Create_Call) RunAndReturn(run func(context.Context, *domain.Provider) error) *ProviderService_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: _a0, _a1
func (_m *ProviderService) Delete(_a0 context.Context, _a1 string) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

// Delete is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
func (_e *ProviderService_Expecter) Delete(_a0 interface{}, _a1 interface{}) *ProviderService_Delete_Call {
	return &ProviderService_Delete_Call{Call: _e.mock.On("Delete", _a0, _a1)}
}

func (_c *ProviderService_Delete_Call) Run(run func(_a0 context.Context, _a1 string)) *ProviderService_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

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

func (_c *ProviderService_Delete_Call) RunAndReturn(run func(context.Context, string) error) *ProviderService_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// FetchResources provides a mock function with given fields: _a0
func (_m *ProviderService) FetchResources(_a0 context.Context) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

// FetchResources is a helper method to define mock.On call
//   - _a0 context.Context
func (_e *ProviderService_Expecter) FetchResources(_a0 interface{}) *ProviderService_FetchResources_Call {
	return &ProviderService_FetchResources_Call{Call: _e.mock.On("FetchResources", _a0)}
}

func (_c *ProviderService_FetchResources_Call) Run(run func(_a0 context.Context)) *ProviderService_FetchResources_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

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

func (_c *ProviderService_FetchResources_Call) RunAndReturn(run func(context.Context) error) *ProviderService_FetchResources_Call {
	_c.Call.Return(run)
	return _c
}

// Find provides a mock function with given fields: _a0
func (_m *ProviderService) Find(_a0 context.Context) ([]*domain.Provider, error) {
	ret := _m.Called(_a0)

	var r0 []*domain.Provider
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]*domain.Provider, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []*domain.Provider); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*domain.Provider)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Find is a helper method to define mock.On call
//   - _a0 context.Context
func (_e *ProviderService_Expecter) Find(_a0 interface{}) *ProviderService_Find_Call {
	return &ProviderService_Find_Call{Call: _e.mock.On("Find", _a0)}
}

func (_c *ProviderService_Find_Call) Run(run func(_a0 context.Context)) *ProviderService_Find_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *ProviderService_Find_Call) Return(_a0 []*domain.Provider, _a1 error) *ProviderService_Find_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ProviderService_Find_Call) RunAndReturn(run func(context.Context) ([]*domain.Provider, error)) *ProviderService_Find_Call {
	_c.Call.Return(run)
	return _c
}

// GetByID provides a mock function with given fields: _a0, _a1
func (_m *ProviderService) GetByID(_a0 context.Context, _a1 string) (*domain.Provider, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *domain.Provider
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*domain.Provider, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *domain.Provider); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*domain.Provider)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetByID is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 string
func (_e *ProviderService_Expecter) GetByID(_a0 interface{}, _a1 interface{}) *ProviderService_GetByID_Call {
	return &ProviderService_GetByID_Call{Call: _e.mock.On("GetByID", _a0, _a1)}
}

func (_c *ProviderService_GetByID_Call) Run(run func(_a0 context.Context, _a1 string)) *ProviderService_GetByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *ProviderService_GetByID_Call) Return(_a0 *domain.Provider, _a1 error) *ProviderService_GetByID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ProviderService_GetByID_Call) RunAndReturn(run func(context.Context, string) (*domain.Provider, error)) *ProviderService_GetByID_Call {
	_c.Call.Return(run)
	return _c
}

// GetOne provides a mock function with given fields: ctx, pType, urn
func (_m *ProviderService) GetOne(ctx context.Context, pType string, urn string) (*domain.Provider, error) {
	ret := _m.Called(ctx, pType, urn)

	var r0 *domain.Provider
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (*domain.Provider, error)); ok {
		return rf(ctx, pType, urn)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) *domain.Provider); ok {
		r0 = rf(ctx, pType, urn)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*domain.Provider)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, pType, urn)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetOne is a helper method to define mock.On call
//   - ctx context.Context
//   - pType string
//   - urn string
func (_e *ProviderService_Expecter) GetOne(ctx interface{}, pType interface{}, urn interface{}) *ProviderService_GetOne_Call {
	return &ProviderService_GetOne_Call{Call: _e.mock.On("GetOne", ctx, pType, urn)}
}

func (_c *ProviderService_GetOne_Call) Run(run func(ctx context.Context, pType string, urn string)) *ProviderService_GetOne_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *ProviderService_GetOne_Call) Return(_a0 *domain.Provider, _a1 error) *ProviderService_GetOne_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ProviderService_GetOne_Call) RunAndReturn(run func(context.Context, string, string) (*domain.Provider, error)) *ProviderService_GetOne_Call {
	_c.Call.Return(run)
	return _c
}

// GetRoles provides a mock function with given fields: ctx, id, resourceType
func (_m *ProviderService) GetRoles(ctx context.Context, id string, resourceType string) ([]*domain.Role, error) {
	ret := _m.Called(ctx, id, resourceType)

	var r0 []*domain.Role
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) ([]*domain.Role, error)); ok {
		return rf(ctx, id, resourceType)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) []*domain.Role); ok {
		r0 = rf(ctx, id, resourceType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*domain.Role)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, id, resourceType)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - resourceType string
func (_e *ProviderService_Expecter) GetRoles(ctx interface{}, id interface{}, resourceType interface{}) *ProviderService_GetRoles_Call {
	return &ProviderService_GetRoles_Call{Call: _e.mock.On("GetRoles", ctx, id, resourceType)}
}

func (_c *ProviderService_GetRoles_Call) Run(run func(ctx context.Context, id string, resourceType string)) *ProviderService_GetRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *ProviderService_GetRoles_Call) Return(_a0 []*domain.Role, _a1 error) *ProviderService_GetRoles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ProviderService_GetRoles_Call) RunAndReturn(run func(context.Context, string, string) ([]*domain.Role, error)) *ProviderService_GetRoles_Call {
	_c.Call.Return(run)
	return _c
}

// GetTypes provides a mock function with given fields: _a0
func (_m *ProviderService) GetTypes(_a0 context.Context) ([]domain.ProviderType, error) {
	ret := _m.Called(_a0)

	var r0 []domain.ProviderType
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]domain.ProviderType, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []domain.ProviderType); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]domain.ProviderType)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetTypes is a helper method to define mock.On call
//   - _a0 context.Context
func (_e *ProviderService_Expecter) GetTypes(_a0 interface{}) *ProviderService_GetTypes_Call {
	return &ProviderService_GetTypes_Call{Call: _e.mock.On("GetTypes", _a0)}
}

func (_c *ProviderService_GetTypes_Call) Run(run func(_a0 context.Context)) *ProviderService_GetTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *ProviderService_GetTypes_Call) Return(_a0 []domain.ProviderType, _a1 error) *ProviderService_GetTypes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ProviderService_GetTypes_Call) RunAndReturn(run func(context.Context) ([]domain.ProviderType, error)) *ProviderService_GetTypes_Call {
	_c.Call.Return(run)
	return _c
}

// GrantAccess provides a mock function with given fields: _a0, _a1
func (_m *ProviderService) GrantAccess(_a0 context.Context, _a1 domain.Grant) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, domain.Grant) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// GrantAccess is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 domain.Grant
func (_e *ProviderService_Expecter) GrantAccess(_a0 interface{}, _a1 interface{}) *ProviderService_GrantAccess_Call {
	return &ProviderService_GrantAccess_Call{Call: _e.mock.On("GrantAccess", _a0, _a1)}
}

func (_c *ProviderService_GrantAccess_Call) Run(run func(_a0 context.Context, _a1 domain.Grant)) *ProviderService_GrantAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.Grant))
	})
	return _c
}

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

func (_c *ProviderService_GrantAccess_Call) RunAndReturn(run func(context.Context, domain.Grant) error) *ProviderService_GrantAccess_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeAccess provides a mock function with given fields: _a0, _a1
func (_m *ProviderService) RevokeAccess(_a0 context.Context, _a1 domain.Grant) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, domain.Grant) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RevokeAccess is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 domain.Grant
func (_e *ProviderService_Expecter) RevokeAccess(_a0 interface{}, _a1 interface{}) *ProviderService_RevokeAccess_Call {
	return &ProviderService_RevokeAccess_Call{Call: _e.mock.On("RevokeAccess", _a0, _a1)}
}

func (_c *ProviderService_RevokeAccess_Call) Run(run func(_a0 context.Context, _a1 domain.Grant)) *ProviderService_RevokeAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.Grant))
	})
	return _c
}

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

func (_c *ProviderService_RevokeAccess_Call) RunAndReturn(run func(context.Context, domain.Grant) error) *ProviderService_RevokeAccess_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function with given fields: _a0, _a1
func (_m *ProviderService) Update(_a0 context.Context, _a1 *domain.Provider) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *domain.Provider) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Update is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *domain.Provider
func (_e *ProviderService_Expecter) Update(_a0 interface{}, _a1 interface{}) *ProviderService_Update_Call {
	return &ProviderService_Update_Call{Call: _e.mock.On("Update", _a0, _a1)}
}

func (_c *ProviderService_Update_Call) Run(run func(_a0 context.Context, _a1 *domain.Provider)) *ProviderService_Update_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*domain.Provider))
	})
	return _c
}

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

func (_c *ProviderService_Update_Call) RunAndReturn(run func(context.Context, *domain.Provider) error) *ProviderService_Update_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateAppeal provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ProviderService) ValidateAppeal(_a0 context.Context, _a1 *domain.Appeal, _a2 *domain.Provider, _a3 *domain.Policy) error {
	ret := _m.Called(_a0, _a1, _a2, _a3)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *domain.Appeal, *domain.Provider, *domain.Policy) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ValidateAppeal is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *domain.Appeal
//   - _a2 *domain.Provider
//   - _a3 *domain.Policy
func (_e *ProviderService_Expecter) ValidateAppeal(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 interface{}) *ProviderService_ValidateAppeal_Call {
	return &ProviderService_ValidateAppeal_Call{Call: _e.mock.On("ValidateAppeal", _a0, _a1, _a2, _a3)}
}

func (_c *ProviderService_ValidateAppeal_Call) Run(run func(_a0 context.Context, _a1 *domain.Appeal, _a2 *domain.Provider, _a3 *domain.Policy)) *ProviderService_ValidateAppeal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*domain.Appeal), args[2].(*domain.Provider), args[3].(*domain.Policy))
	})
	return _c
}

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

func (_c *ProviderService_ValidateAppeal_Call) RunAndReturn(run func(context.Context, *domain.Appeal, *domain.Provider, *domain.Policy) error) *ProviderService_ValidateAppeal_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}