eec158b32c
This change adds a single page application front-end to GARM. It uses a generated REST client, built from the swagger definitions, the websocket interface for live updates of entities and eager loading of everything except runners, as users may have many runners and we don't want to load hundreds of runners in memory. Proper pagination should be implemented in the API, in future commits, to avoid loading lots of elements for no reason. Signed-off-by: Gabriel Adrian Samfira <gsamfira@cloudbasesolutions.com>
708 lines
26 KiB
Go
708 lines
26 KiB
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
|
|
}
|