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>
656 lines
18 KiB
Go
656 lines
18 KiB
Go
// Code generated by mockery. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
params "github.com/cloudbase/garm/params"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// PoolManager is an autogenerated mock type for the PoolManager type
|
|
type PoolManager struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type PoolManager_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *PoolManager) EXPECT() *PoolManager_Expecter {
|
|
return &PoolManager_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// GetWebhookInfo provides a mock function with given fields: ctx
|
|
func (_m *PoolManager) GetWebhookInfo(ctx context.Context) (params.HookInfo, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetWebhookInfo")
|
|
}
|
|
|
|
var r0 params.HookInfo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) (params.HookInfo, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) params.HookInfo); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Get(0).(params.HookInfo)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PoolManager_GetWebhookInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWebhookInfo'
|
|
type PoolManager_GetWebhookInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetWebhookInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *PoolManager_Expecter) GetWebhookInfo(ctx interface{}) *PoolManager_GetWebhookInfo_Call {
|
|
return &PoolManager_GetWebhookInfo_Call{Call: _e.mock.On("GetWebhookInfo", ctx)}
|
|
}
|
|
|
|
func (_c *PoolManager_GetWebhookInfo_Call) Run(run func(ctx context.Context)) *PoolManager_GetWebhookInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_GetWebhookInfo_Call) Return(_a0 params.HookInfo, _a1 error) *PoolManager_GetWebhookInfo_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_GetWebhookInfo_Call) RunAndReturn(run func(context.Context) (params.HookInfo, error)) *PoolManager_GetWebhookInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GithubRunnerRegistrationToken provides a mock function with no fields
|
|
func (_m *PoolManager) GithubRunnerRegistrationToken() (string, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GithubRunnerRegistrationToken")
|
|
}
|
|
|
|
var r0 string
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (string, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PoolManager_GithubRunnerRegistrationToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GithubRunnerRegistrationToken'
|
|
type PoolManager_GithubRunnerRegistrationToken_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GithubRunnerRegistrationToken is a helper method to define mock.On call
|
|
func (_e *PoolManager_Expecter) GithubRunnerRegistrationToken() *PoolManager_GithubRunnerRegistrationToken_Call {
|
|
return &PoolManager_GithubRunnerRegistrationToken_Call{Call: _e.mock.On("GithubRunnerRegistrationToken")}
|
|
}
|
|
|
|
func (_c *PoolManager_GithubRunnerRegistrationToken_Call) Run(run func()) *PoolManager_GithubRunnerRegistrationToken_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_GithubRunnerRegistrationToken_Call) Return(_a0 string, _a1 error) *PoolManager_GithubRunnerRegistrationToken_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_GithubRunnerRegistrationToken_Call) RunAndReturn(run func() (string, error)) *PoolManager_GithubRunnerRegistrationToken_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// HandleWorkflowJob provides a mock function with given fields: job
|
|
func (_m *PoolManager) HandleWorkflowJob(job params.WorkflowJob) error {
|
|
ret := _m.Called(job)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for HandleWorkflowJob")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(params.WorkflowJob) error); ok {
|
|
r0 = rf(job)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolManager_HandleWorkflowJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleWorkflowJob'
|
|
type PoolManager_HandleWorkflowJob_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// HandleWorkflowJob is a helper method to define mock.On call
|
|
// - job params.WorkflowJob
|
|
func (_e *PoolManager_Expecter) HandleWorkflowJob(job interface{}) *PoolManager_HandleWorkflowJob_Call {
|
|
return &PoolManager_HandleWorkflowJob_Call{Call: _e.mock.On("HandleWorkflowJob", job)}
|
|
}
|
|
|
|
func (_c *PoolManager_HandleWorkflowJob_Call) Run(run func(job params.WorkflowJob)) *PoolManager_HandleWorkflowJob_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(params.WorkflowJob))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_HandleWorkflowJob_Call) Return(_a0 error) *PoolManager_HandleWorkflowJob_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_HandleWorkflowJob_Call) RunAndReturn(run func(params.WorkflowJob) error) *PoolManager_HandleWorkflowJob_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ID provides a mock function with no fields
|
|
func (_m *PoolManager) ID() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ID")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolManager_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
|
|
type PoolManager_ID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ID is a helper method to define mock.On call
|
|
func (_e *PoolManager_Expecter) ID() *PoolManager_ID_Call {
|
|
return &PoolManager_ID_Call{Call: _e.mock.On("ID")}
|
|
}
|
|
|
|
func (_c *PoolManager_ID_Call) Run(run func()) *PoolManager_ID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_ID_Call) Return(_a0 string) *PoolManager_ID_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_ID_Call) RunAndReturn(run func() string) *PoolManager_ID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// InstallWebhook provides a mock function with given fields: ctx, param
|
|
func (_m *PoolManager) InstallWebhook(ctx context.Context, param params.InstallWebhookParams) (params.HookInfo, error) {
|
|
ret := _m.Called(ctx, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for InstallWebhook")
|
|
}
|
|
|
|
var r0 params.HookInfo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.InstallWebhookParams) (params.HookInfo, error)); ok {
|
|
return rf(ctx, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.InstallWebhookParams) params.HookInfo); ok {
|
|
r0 = rf(ctx, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.HookInfo)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.InstallWebhookParams) error); ok {
|
|
r1 = rf(ctx, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PoolManager_InstallWebhook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InstallWebhook'
|
|
type PoolManager_InstallWebhook_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// InstallWebhook is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - param params.InstallWebhookParams
|
|
func (_e *PoolManager_Expecter) InstallWebhook(ctx interface{}, param interface{}) *PoolManager_InstallWebhook_Call {
|
|
return &PoolManager_InstallWebhook_Call{Call: _e.mock.On("InstallWebhook", ctx, param)}
|
|
}
|
|
|
|
func (_c *PoolManager_InstallWebhook_Call) Run(run func(ctx context.Context, param params.InstallWebhookParams)) *PoolManager_InstallWebhook_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(params.InstallWebhookParams))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_InstallWebhook_Call) Return(_a0 params.HookInfo, _a1 error) *PoolManager_InstallWebhook_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_InstallWebhook_Call) RunAndReturn(run func(context.Context, params.InstallWebhookParams) (params.HookInfo, error)) *PoolManager_InstallWebhook_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RootCABundle provides a mock function with no fields
|
|
func (_m *PoolManager) RootCABundle() (params.CertificateBundle, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RootCABundle")
|
|
}
|
|
|
|
var r0 params.CertificateBundle
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (params.CertificateBundle, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() params.CertificateBundle); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(params.CertificateBundle)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PoolManager_RootCABundle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RootCABundle'
|
|
type PoolManager_RootCABundle_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RootCABundle is a helper method to define mock.On call
|
|
func (_e *PoolManager_Expecter) RootCABundle() *PoolManager_RootCABundle_Call {
|
|
return &PoolManager_RootCABundle_Call{Call: _e.mock.On("RootCABundle")}
|
|
}
|
|
|
|
func (_c *PoolManager_RootCABundle_Call) Run(run func()) *PoolManager_RootCABundle_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_RootCABundle_Call) Return(_a0 params.CertificateBundle, _a1 error) *PoolManager_RootCABundle_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_RootCABundle_Call) RunAndReturn(run func() (params.CertificateBundle, error)) *PoolManager_RootCABundle_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetPoolRunningState provides a mock function with given fields: isRunning, failureReason
|
|
func (_m *PoolManager) SetPoolRunningState(isRunning bool, failureReason string) {
|
|
_m.Called(isRunning, failureReason)
|
|
}
|
|
|
|
// PoolManager_SetPoolRunningState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPoolRunningState'
|
|
type PoolManager_SetPoolRunningState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetPoolRunningState is a helper method to define mock.On call
|
|
// - isRunning bool
|
|
// - failureReason string
|
|
func (_e *PoolManager_Expecter) SetPoolRunningState(isRunning interface{}, failureReason interface{}) *PoolManager_SetPoolRunningState_Call {
|
|
return &PoolManager_SetPoolRunningState_Call{Call: _e.mock.On("SetPoolRunningState", isRunning, failureReason)}
|
|
}
|
|
|
|
func (_c *PoolManager_SetPoolRunningState_Call) Run(run func(isRunning bool, failureReason string)) *PoolManager_SetPoolRunningState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(bool), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_SetPoolRunningState_Call) Return() *PoolManager_SetPoolRunningState_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_SetPoolRunningState_Call) RunAndReturn(run func(bool, string)) *PoolManager_SetPoolRunningState_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// Start provides a mock function with no fields
|
|
func (_m *PoolManager) Start() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Start")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolManager_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
|
type PoolManager_Start_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Start is a helper method to define mock.On call
|
|
func (_e *PoolManager_Expecter) Start() *PoolManager_Start_Call {
|
|
return &PoolManager_Start_Call{Call: _e.mock.On("Start")}
|
|
}
|
|
|
|
func (_c *PoolManager_Start_Call) Run(run func()) *PoolManager_Start_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_Start_Call) Return(_a0 error) *PoolManager_Start_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_Start_Call) RunAndReturn(run func() error) *PoolManager_Start_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Status provides a mock function with no fields
|
|
func (_m *PoolManager) Status() params.PoolManagerStatus {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Status")
|
|
}
|
|
|
|
var r0 params.PoolManagerStatus
|
|
if rf, ok := ret.Get(0).(func() params.PoolManagerStatus); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(params.PoolManagerStatus)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolManager_Status_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Status'
|
|
type PoolManager_Status_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Status is a helper method to define mock.On call
|
|
func (_e *PoolManager_Expecter) Status() *PoolManager_Status_Call {
|
|
return &PoolManager_Status_Call{Call: _e.mock.On("Status")}
|
|
}
|
|
|
|
func (_c *PoolManager_Status_Call) Run(run func()) *PoolManager_Status_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_Status_Call) Return(_a0 params.PoolManagerStatus) *PoolManager_Status_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_Status_Call) RunAndReturn(run func() params.PoolManagerStatus) *PoolManager_Status_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Stop provides a mock function with no fields
|
|
func (_m *PoolManager) Stop() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Stop")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolManager_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
|
|
type PoolManager_Stop_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Stop is a helper method to define mock.On call
|
|
func (_e *PoolManager_Expecter) Stop() *PoolManager_Stop_Call {
|
|
return &PoolManager_Stop_Call{Call: _e.mock.On("Stop")}
|
|
}
|
|
|
|
func (_c *PoolManager_Stop_Call) Run(run func()) *PoolManager_Stop_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_Stop_Call) Return(_a0 error) *PoolManager_Stop_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_Stop_Call) RunAndReturn(run func() error) *PoolManager_Stop_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UninstallWebhook provides a mock function with given fields: ctx
|
|
func (_m *PoolManager) UninstallWebhook(ctx context.Context) error {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UninstallWebhook")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) error); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolManager_UninstallWebhook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UninstallWebhook'
|
|
type PoolManager_UninstallWebhook_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UninstallWebhook is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *PoolManager_Expecter) UninstallWebhook(ctx interface{}) *PoolManager_UninstallWebhook_Call {
|
|
return &PoolManager_UninstallWebhook_Call{Call: _e.mock.On("UninstallWebhook", ctx)}
|
|
}
|
|
|
|
func (_c *PoolManager_UninstallWebhook_Call) Run(run func(ctx context.Context)) *PoolManager_UninstallWebhook_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_UninstallWebhook_Call) Return(_a0 error) *PoolManager_UninstallWebhook_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_UninstallWebhook_Call) RunAndReturn(run func(context.Context) error) *PoolManager_UninstallWebhook_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Wait provides a mock function with no fields
|
|
func (_m *PoolManager) Wait() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Wait")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolManager_Wait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wait'
|
|
type PoolManager_Wait_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Wait is a helper method to define mock.On call
|
|
func (_e *PoolManager_Expecter) Wait() *PoolManager_Wait_Call {
|
|
return &PoolManager_Wait_Call{Call: _e.mock.On("Wait")}
|
|
}
|
|
|
|
func (_c *PoolManager_Wait_Call) Run(run func()) *PoolManager_Wait_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_Wait_Call) Return(_a0 error) *PoolManager_Wait_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_Wait_Call) RunAndReturn(run func() error) *PoolManager_Wait_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// WebhookSecret provides a mock function with no fields
|
|
func (_m *PoolManager) WebhookSecret() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WebhookSecret")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolManager_WebhookSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WebhookSecret'
|
|
type PoolManager_WebhookSecret_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// WebhookSecret is a helper method to define mock.On call
|
|
func (_e *PoolManager_Expecter) WebhookSecret() *PoolManager_WebhookSecret_Call {
|
|
return &PoolManager_WebhookSecret_Call{Call: _e.mock.On("WebhookSecret")}
|
|
}
|
|
|
|
func (_c *PoolManager_WebhookSecret_Call) Run(run func()) *PoolManager_WebhookSecret_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_WebhookSecret_Call) Return(_a0 string) *PoolManager_WebhookSecret_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *PoolManager_WebhookSecret_Call) RunAndReturn(run func() string) *PoolManager_WebhookSecret_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewPoolManager creates a new instance of PoolManager. 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 NewPoolManager(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *PoolManager {
|
|
mock := &PoolManager{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|