garm/runner/mocks/PoolManagerController.go

// Code generated by mockery. DO NOT EDIT.

package mocks

import (
	context "context"

	common "github.com/cloudbase/garm/runner/common"

	databasecommon "github.com/cloudbase/garm/database/common"

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

	params "github.com/cloudbase/garm/params"
)

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

type PoolManagerController_Expecter struct {
	mock *mock.Mock
}

func (_m *PoolManagerController) EXPECT() *PoolManagerController_Expecter {
	return &PoolManagerController_Expecter{mock: &_m.Mock}
}

// CreateEnterprisePoolManager provides a mock function with given fields: ctx, enterprise, providers, store
func (_m *PoolManagerController) CreateEnterprisePoolManager(ctx context.Context, enterprise params.Enterprise, providers map[string]common.Provider, store databasecommon.Store) (common.PoolManager, error) {
	ret := _m.Called(ctx, enterprise, providers, store)

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

	var r0 common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.Enterprise, map[string]common.Provider, databasecommon.Store) (common.PoolManager, error)); ok {
		return rf(ctx, enterprise, providers, store)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.Enterprise, map[string]common.Provider, databasecommon.Store) common.PoolManager); ok {
		r0 = rf(ctx, enterprise, providers, store)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.PoolManager)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.Enterprise, map[string]common.Provider, databasecommon.Store) error); ok {
		r1 = rf(ctx, enterprise, providers, store)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateEnterprisePoolManager is a helper method to define mock.On call
//   - ctx context.Context
//   - enterprise params.Enterprise
//   - providers map[string]common.Provider
//   - store databasecommon.Store
func (_e *PoolManagerController_Expecter) CreateEnterprisePoolManager(ctx interface{}, enterprise interface{}, providers interface{}, store interface{}) *PoolManagerController_CreateEnterprisePoolManager_Call {
	return &PoolManagerController_CreateEnterprisePoolManager_Call{Call: _e.mock.On("CreateEnterprisePoolManager", ctx, enterprise, providers, store)}
}

func (_c *PoolManagerController_CreateEnterprisePoolManager_Call) Run(run func(ctx context.Context, enterprise params.Enterprise, providers map[string]common.Provider, store databasecommon.Store)) *PoolManagerController_CreateEnterprisePoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(params.Enterprise), args[2].(map[string]common.Provider), args[3].(databasecommon.Store))
	})
	return _c
}

func (_c *PoolManagerController_CreateEnterprisePoolManager_Call) Return(_a0 common.PoolManager, _a1 error) *PoolManagerController_CreateEnterprisePoolManager_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_CreateEnterprisePoolManager_Call) RunAndReturn(run func(context.Context, params.Enterprise, map[string]common.Provider, databasecommon.Store) (common.PoolManager, error)) *PoolManagerController_CreateEnterprisePoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOrgPoolManager provides a mock function with given fields: ctx, org, providers, store
func (_m *PoolManagerController) CreateOrgPoolManager(ctx context.Context, org params.Organization, providers map[string]common.Provider, store databasecommon.Store) (common.PoolManager, error) {
	ret := _m.Called(ctx, org, providers, store)

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

	var r0 common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.Organization, map[string]common.Provider, databasecommon.Store) (common.PoolManager, error)); ok {
		return rf(ctx, org, providers, store)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.Organization, map[string]common.Provider, databasecommon.Store) common.PoolManager); ok {
		r0 = rf(ctx, org, providers, store)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.PoolManager)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.Organization, map[string]common.Provider, databasecommon.Store) error); ok {
		r1 = rf(ctx, org, providers, store)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateOrgPoolManager is a helper method to define mock.On call
//   - ctx context.Context
//   - org params.Organization
//   - providers map[string]common.Provider
//   - store databasecommon.Store
func (_e *PoolManagerController_Expecter) CreateOrgPoolManager(ctx interface{}, org interface{}, providers interface{}, store interface{}) *PoolManagerController_CreateOrgPoolManager_Call {
	return &PoolManagerController_CreateOrgPoolManager_Call{Call: _e.mock.On("CreateOrgPoolManager", ctx, org, providers, store)}
}

func (_c *PoolManagerController_CreateOrgPoolManager_Call) Run(run func(ctx context.Context, org params.Organization, providers map[string]common.Provider, store databasecommon.Store)) *PoolManagerController_CreateOrgPoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(params.Organization), args[2].(map[string]common.Provider), args[3].(databasecommon.Store))
	})
	return _c
}

func (_c *PoolManagerController_CreateOrgPoolManager_Call) Return(_a0 common.PoolManager, _a1 error) *PoolManagerController_CreateOrgPoolManager_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_CreateOrgPoolManager_Call) RunAndReturn(run func(context.Context, params.Organization, map[string]common.Provider, databasecommon.Store) (common.PoolManager, error)) *PoolManagerController_CreateOrgPoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRepoPoolManager provides a mock function with given fields: ctx, repo, providers, store
func (_m *PoolManagerController) CreateRepoPoolManager(ctx context.Context, repo params.Repository, providers map[string]common.Provider, store databasecommon.Store) (common.PoolManager, error) {
	ret := _m.Called(ctx, repo, providers, store)

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

	var r0 common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.Repository, map[string]common.Provider, databasecommon.Store) (common.PoolManager, error)); ok {
		return rf(ctx, repo, providers, store)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.Repository, map[string]common.Provider, databasecommon.Store) common.PoolManager); ok {
		r0 = rf(ctx, repo, providers, store)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.PoolManager)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.Repository, map[string]common.Provider, databasecommon.Store) error); ok {
		r1 = rf(ctx, repo, providers, store)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateRepoPoolManager is a helper method to define mock.On call
//   - ctx context.Context
//   - repo params.Repository
//   - providers map[string]common.Provider
//   - store databasecommon.Store
func (_e *PoolManagerController_Expecter) CreateRepoPoolManager(ctx interface{}, repo interface{}, providers interface{}, store interface{}) *PoolManagerController_CreateRepoPoolManager_Call {
	return &PoolManagerController_CreateRepoPoolManager_Call{Call: _e.mock.On("CreateRepoPoolManager", ctx, repo, providers, store)}
}

func (_c *PoolManagerController_CreateRepoPoolManager_Call) Run(run func(ctx context.Context, repo params.Repository, providers map[string]common.Provider, store databasecommon.Store)) *PoolManagerController_CreateRepoPoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(params.Repository), args[2].(map[string]common.Provider), args[3].(databasecommon.Store))
	})
	return _c
}

func (_c *PoolManagerController_CreateRepoPoolManager_Call) Return(_a0 common.PoolManager, _a1 error) *PoolManagerController_CreateRepoPoolManager_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_CreateRepoPoolManager_Call) RunAndReturn(run func(context.Context, params.Repository, map[string]common.Provider, databasecommon.Store) (common.PoolManager, error)) *PoolManagerController_CreateRepoPoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteEnterprisePoolManager provides a mock function with given fields: enterprise
func (_m *PoolManagerController) DeleteEnterprisePoolManager(enterprise params.Enterprise) error {
	ret := _m.Called(enterprise)

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

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

	return r0
}

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

// DeleteEnterprisePoolManager is a helper method to define mock.On call
//   - enterprise params.Enterprise
func (_e *PoolManagerController_Expecter) DeleteEnterprisePoolManager(enterprise interface{}) *PoolManagerController_DeleteEnterprisePoolManager_Call {
	return &PoolManagerController_DeleteEnterprisePoolManager_Call{Call: _e.mock.On("DeleteEnterprisePoolManager", enterprise)}
}

func (_c *PoolManagerController_DeleteEnterprisePoolManager_Call) Run(run func(enterprise params.Enterprise)) *PoolManagerController_DeleteEnterprisePoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(params.Enterprise))
	})
	return _c
}

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

func (_c *PoolManagerController_DeleteEnterprisePoolManager_Call) RunAndReturn(run func(params.Enterprise) error) *PoolManagerController_DeleteEnterprisePoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteOrgPoolManager provides a mock function with given fields: org
func (_m *PoolManagerController) DeleteOrgPoolManager(org params.Organization) error {
	ret := _m.Called(org)

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

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

	return r0
}

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

// DeleteOrgPoolManager is a helper method to define mock.On call
//   - org params.Organization
func (_e *PoolManagerController_Expecter) DeleteOrgPoolManager(org interface{}) *PoolManagerController_DeleteOrgPoolManager_Call {
	return &PoolManagerController_DeleteOrgPoolManager_Call{Call: _e.mock.On("DeleteOrgPoolManager", org)}
}

func (_c *PoolManagerController_DeleteOrgPoolManager_Call) Run(run func(org params.Organization)) *PoolManagerController_DeleteOrgPoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(params.Organization))
	})
	return _c
}

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

func (_c *PoolManagerController_DeleteOrgPoolManager_Call) RunAndReturn(run func(params.Organization) error) *PoolManagerController_DeleteOrgPoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRepoPoolManager provides a mock function with given fields: repo
func (_m *PoolManagerController) DeleteRepoPoolManager(repo params.Repository) error {
	ret := _m.Called(repo)

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

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

	return r0
}

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

// DeleteRepoPoolManager is a helper method to define mock.On call
//   - repo params.Repository
func (_e *PoolManagerController_Expecter) DeleteRepoPoolManager(repo interface{}) *PoolManagerController_DeleteRepoPoolManager_Call {
	return &PoolManagerController_DeleteRepoPoolManager_Call{Call: _e.mock.On("DeleteRepoPoolManager", repo)}
}

func (_c *PoolManagerController_DeleteRepoPoolManager_Call) Run(run func(repo params.Repository)) *PoolManagerController_DeleteRepoPoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(params.Repository))
	})
	return _c
}

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

func (_c *PoolManagerController_DeleteRepoPoolManager_Call) RunAndReturn(run func(params.Repository) error) *PoolManagerController_DeleteRepoPoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// GetEnterprisePoolManager provides a mock function with given fields: enterprise
func (_m *PoolManagerController) GetEnterprisePoolManager(enterprise params.Enterprise) (common.PoolManager, error) {
	ret := _m.Called(enterprise)

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

	var r0 common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func(params.Enterprise) (common.PoolManager, error)); ok {
		return rf(enterprise)
	}
	if rf, ok := ret.Get(0).(func(params.Enterprise) common.PoolManager); ok {
		r0 = rf(enterprise)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.PoolManager)
		}
	}

	if rf, ok := ret.Get(1).(func(params.Enterprise) error); ok {
		r1 = rf(enterprise)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetEnterprisePoolManager is a helper method to define mock.On call
//   - enterprise params.Enterprise
func (_e *PoolManagerController_Expecter) GetEnterprisePoolManager(enterprise interface{}) *PoolManagerController_GetEnterprisePoolManager_Call {
	return &PoolManagerController_GetEnterprisePoolManager_Call{Call: _e.mock.On("GetEnterprisePoolManager", enterprise)}
}

func (_c *PoolManagerController_GetEnterprisePoolManager_Call) Run(run func(enterprise params.Enterprise)) *PoolManagerController_GetEnterprisePoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(params.Enterprise))
	})
	return _c
}

func (_c *PoolManagerController_GetEnterprisePoolManager_Call) Return(_a0 common.PoolManager, _a1 error) *PoolManagerController_GetEnterprisePoolManager_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_GetEnterprisePoolManager_Call) RunAndReturn(run func(params.Enterprise) (common.PoolManager, error)) *PoolManagerController_GetEnterprisePoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// GetEnterprisePoolManagers provides a mock function with no fields
func (_m *PoolManagerController) GetEnterprisePoolManagers() (map[string]common.PoolManager, error) {
	ret := _m.Called()

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

	var r0 map[string]common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func() (map[string]common.PoolManager, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() map[string]common.PoolManager); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]common.PoolManager)
		}
	}

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

	return r0, r1
}

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

// GetEnterprisePoolManagers is a helper method to define mock.On call
func (_e *PoolManagerController_Expecter) GetEnterprisePoolManagers() *PoolManagerController_GetEnterprisePoolManagers_Call {
	return &PoolManagerController_GetEnterprisePoolManagers_Call{Call: _e.mock.On("GetEnterprisePoolManagers")}
}

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

func (_c *PoolManagerController_GetEnterprisePoolManagers_Call) Return(_a0 map[string]common.PoolManager, _a1 error) *PoolManagerController_GetEnterprisePoolManagers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_GetEnterprisePoolManagers_Call) RunAndReturn(run func() (map[string]common.PoolManager, error)) *PoolManagerController_GetEnterprisePoolManagers_Call {
	_c.Call.Return(run)
	return _c
}

// GetOrgPoolManager provides a mock function with given fields: org
func (_m *PoolManagerController) GetOrgPoolManager(org params.Organization) (common.PoolManager, error) {
	ret := _m.Called(org)

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

	var r0 common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func(params.Organization) (common.PoolManager, error)); ok {
		return rf(org)
	}
	if rf, ok := ret.Get(0).(func(params.Organization) common.PoolManager); ok {
		r0 = rf(org)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.PoolManager)
		}
	}

	if rf, ok := ret.Get(1).(func(params.Organization) error); ok {
		r1 = rf(org)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetOrgPoolManager is a helper method to define mock.On call
//   - org params.Organization
func (_e *PoolManagerController_Expecter) GetOrgPoolManager(org interface{}) *PoolManagerController_GetOrgPoolManager_Call {
	return &PoolManagerController_GetOrgPoolManager_Call{Call: _e.mock.On("GetOrgPoolManager", org)}
}

func (_c *PoolManagerController_GetOrgPoolManager_Call) Run(run func(org params.Organization)) *PoolManagerController_GetOrgPoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(params.Organization))
	})
	return _c
}

func (_c *PoolManagerController_GetOrgPoolManager_Call) Return(_a0 common.PoolManager, _a1 error) *PoolManagerController_GetOrgPoolManager_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_GetOrgPoolManager_Call) RunAndReturn(run func(params.Organization) (common.PoolManager, error)) *PoolManagerController_GetOrgPoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// GetOrgPoolManagers provides a mock function with no fields
func (_m *PoolManagerController) GetOrgPoolManagers() (map[string]common.PoolManager, error) {
	ret := _m.Called()

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

	var r0 map[string]common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func() (map[string]common.PoolManager, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() map[string]common.PoolManager); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]common.PoolManager)
		}
	}

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

	return r0, r1
}

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

// GetOrgPoolManagers is a helper method to define mock.On call
func (_e *PoolManagerController_Expecter) GetOrgPoolManagers() *PoolManagerController_GetOrgPoolManagers_Call {
	return &PoolManagerController_GetOrgPoolManagers_Call{Call: _e.mock.On("GetOrgPoolManagers")}
}

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

func (_c *PoolManagerController_GetOrgPoolManagers_Call) Return(_a0 map[string]common.PoolManager, _a1 error) *PoolManagerController_GetOrgPoolManagers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_GetOrgPoolManagers_Call) RunAndReturn(run func() (map[string]common.PoolManager, error)) *PoolManagerController_GetOrgPoolManagers_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepoPoolManager provides a mock function with given fields: repo
func (_m *PoolManagerController) GetRepoPoolManager(repo params.Repository) (common.PoolManager, error) {
	ret := _m.Called(repo)

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

	var r0 common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func(params.Repository) (common.PoolManager, error)); ok {
		return rf(repo)
	}
	if rf, ok := ret.Get(0).(func(params.Repository) common.PoolManager); ok {
		r0 = rf(repo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.PoolManager)
		}
	}

	if rf, ok := ret.Get(1).(func(params.Repository) error); ok {
		r1 = rf(repo)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRepoPoolManager is a helper method to define mock.On call
//   - repo params.Repository
func (_e *PoolManagerController_Expecter) GetRepoPoolManager(repo interface{}) *PoolManagerController_GetRepoPoolManager_Call {
	return &PoolManagerController_GetRepoPoolManager_Call{Call: _e.mock.On("GetRepoPoolManager", repo)}
}

func (_c *PoolManagerController_GetRepoPoolManager_Call) Run(run func(repo params.Repository)) *PoolManagerController_GetRepoPoolManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(params.Repository))
	})
	return _c
}

func (_c *PoolManagerController_GetRepoPoolManager_Call) Return(_a0 common.PoolManager, _a1 error) *PoolManagerController_GetRepoPoolManager_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_GetRepoPoolManager_Call) RunAndReturn(run func(params.Repository) (common.PoolManager, error)) *PoolManagerController_GetRepoPoolManager_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepoPoolManagers provides a mock function with no fields
func (_m *PoolManagerController) GetRepoPoolManagers() (map[string]common.PoolManager, error) {
	ret := _m.Called()

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

	var r0 map[string]common.PoolManager
	var r1 error
	if rf, ok := ret.Get(0).(func() (map[string]common.PoolManager, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() map[string]common.PoolManager); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]common.PoolManager)
		}
	}

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

	return r0, r1
}

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

// GetRepoPoolManagers is a helper method to define mock.On call
func (_e *PoolManagerController_Expecter) GetRepoPoolManagers() *PoolManagerController_GetRepoPoolManagers_Call {
	return &PoolManagerController_GetRepoPoolManagers_Call{Call: _e.mock.On("GetRepoPoolManagers")}
}

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

func (_c *PoolManagerController_GetRepoPoolManagers_Call) Return(_a0 map[string]common.PoolManager, _a1 error) *PoolManagerController_GetRepoPoolManagers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManagerController_GetRepoPoolManagers_Call) RunAndReturn(run func() (map[string]common.PoolManager, error)) *PoolManagerController_GetRepoPoolManagers_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}