499fbde60c
This change adds the ability to filter the list of entities returned by the API by entity owner, name or endpoint, depending on the entity type. Signed-off-by: Gabriel Adrian Samfira <gsamfira@cloudbasesolutions.com>
2395 lines
68 KiB
Go
2395 lines
68 KiB
Go
// Code generated by mockery v2.53.3. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
params "github.com/cloudbase/garm/params"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// Store is an autogenerated mock type for the Store type
|
|
type Store struct {
|
|
mock.Mock
|
|
}
|
|
|
|
// AddEntityEvent provides a mock function with given fields: ctx, entity, event, eventLevel, statusMessage, maxEvents
|
|
func (_m *Store) AddEntityEvent(ctx context.Context, entity params.ForgeEntity, event params.EventType, eventLevel params.EventLevel, statusMessage string, maxEvents int) error {
|
|
ret := _m.Called(ctx, entity, event, eventLevel, statusMessage, maxEvents)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddEntityEvent")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, params.EventType, params.EventLevel, string, int) error); ok {
|
|
r0 = rf(ctx, entity, event, eventLevel, statusMessage, maxEvents)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// AddInstanceEvent provides a mock function with given fields: ctx, instanceName, event, eventLevel, eventMessage
|
|
func (_m *Store) AddInstanceEvent(ctx context.Context, instanceName string, event params.EventType, eventLevel params.EventLevel, eventMessage string) error {
|
|
ret := _m.Called(ctx, instanceName, event, eventLevel, eventMessage)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddInstanceEvent")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.EventType, params.EventLevel, string) error); ok {
|
|
r0 = rf(ctx, instanceName, event, eventLevel, eventMessage)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// BreakLockJobIsQueued provides a mock function with given fields: ctx, jobID
|
|
func (_m *Store) BreakLockJobIsQueued(ctx context.Context, jobID int64) error {
|
|
ret := _m.Called(ctx, jobID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for BreakLockJobIsQueued")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok {
|
|
r0 = rf(ctx, jobID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ControllerInfo provides a mock function with no fields
|
|
func (_m *Store) ControllerInfo() (params.ControllerInfo, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ControllerInfo")
|
|
}
|
|
|
|
var r0 params.ControllerInfo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (params.ControllerInfo, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() params.ControllerInfo); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(params.ControllerInfo)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateEnterprise provides a mock function with given fields: ctx, name, credentialsName, webhookSecret, poolBalancerType
|
|
func (_m *Store) CreateEnterprise(ctx context.Context, name string, credentialsName params.ForgeCredentials, webhookSecret string, poolBalancerType params.PoolBalancerType) (params.Enterprise, error) {
|
|
ret := _m.Called(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateEnterprise")
|
|
}
|
|
|
|
var r0 params.Enterprise
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.ForgeCredentials, string, params.PoolBalancerType) (params.Enterprise, error)); ok {
|
|
return rf(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.ForgeCredentials, string, params.PoolBalancerType) params.Enterprise); ok {
|
|
r0 = rf(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Enterprise)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.ForgeCredentials, string, params.PoolBalancerType) error); ok {
|
|
r1 = rf(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateEntityPool provides a mock function with given fields: ctx, entity, param
|
|
func (_m *Store) CreateEntityPool(ctx context.Context, entity params.ForgeEntity, param params.CreatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, entity, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateEntityPool")
|
|
}
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, params.CreatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, entity, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, params.CreatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, entity, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntity, params.CreatePoolParams) error); ok {
|
|
r1 = rf(ctx, entity, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateEntityScaleSet provides a mock function with given fields: _a0, entity, param
|
|
func (_m *Store) CreateEntityScaleSet(_a0 context.Context, entity params.ForgeEntity, param params.CreateScaleSetParams) (params.ScaleSet, error) {
|
|
ret := _m.Called(_a0, entity, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateEntityScaleSet")
|
|
}
|
|
|
|
var r0 params.ScaleSet
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, params.CreateScaleSetParams) (params.ScaleSet, error)); ok {
|
|
return rf(_a0, entity, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, params.CreateScaleSetParams) params.ScaleSet); ok {
|
|
r0 = rf(_a0, entity, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ScaleSet)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntity, params.CreateScaleSetParams) error); ok {
|
|
r1 = rf(_a0, entity, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateGiteaCredentials provides a mock function with given fields: ctx, param
|
|
func (_m *Store) CreateGiteaCredentials(ctx context.Context, param params.CreateGiteaCredentialsParams) (params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateGiteaCredentials")
|
|
}
|
|
|
|
var r0 params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGiteaCredentialsParams) (params.ForgeCredentials, error)); ok {
|
|
return rf(ctx, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGiteaCredentialsParams) params.ForgeCredentials); ok {
|
|
r0 = rf(ctx, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.CreateGiteaCredentialsParams) error); ok {
|
|
r1 = rf(ctx, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateGiteaEndpoint provides a mock function with given fields: _a0, param
|
|
func (_m *Store) CreateGiteaEndpoint(_a0 context.Context, param params.CreateGiteaEndpointParams) (params.ForgeEndpoint, error) {
|
|
ret := _m.Called(_a0, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateGiteaEndpoint")
|
|
}
|
|
|
|
var r0 params.ForgeEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGiteaEndpointParams) (params.ForgeEndpoint, error)); ok {
|
|
return rf(_a0, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGiteaEndpointParams) params.ForgeEndpoint); ok {
|
|
r0 = rf(_a0, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.CreateGiteaEndpointParams) error); ok {
|
|
r1 = rf(_a0, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateGithubCredentials provides a mock function with given fields: ctx, param
|
|
func (_m *Store) CreateGithubCredentials(ctx context.Context, param params.CreateGithubCredentialsParams) (params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateGithubCredentials")
|
|
}
|
|
|
|
var r0 params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGithubCredentialsParams) (params.ForgeCredentials, error)); ok {
|
|
return rf(ctx, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGithubCredentialsParams) params.ForgeCredentials); ok {
|
|
r0 = rf(ctx, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.CreateGithubCredentialsParams) error); ok {
|
|
r1 = rf(ctx, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateGithubEndpoint provides a mock function with given fields: ctx, param
|
|
func (_m *Store) CreateGithubEndpoint(ctx context.Context, param params.CreateGithubEndpointParams) (params.ForgeEndpoint, error) {
|
|
ret := _m.Called(ctx, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateGithubEndpoint")
|
|
}
|
|
|
|
var r0 params.ForgeEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGithubEndpointParams) (params.ForgeEndpoint, error)); ok {
|
|
return rf(ctx, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGithubEndpointParams) params.ForgeEndpoint); ok {
|
|
r0 = rf(ctx, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.CreateGithubEndpointParams) error); ok {
|
|
r1 = rf(ctx, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateInstance provides a mock function with given fields: ctx, poolID, param
|
|
func (_m *Store) CreateInstance(ctx context.Context, poolID string, param params.CreateInstanceParams) (params.Instance, error) {
|
|
ret := _m.Called(ctx, poolID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateInstance")
|
|
}
|
|
|
|
var r0 params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreateInstanceParams) (params.Instance, error)); ok {
|
|
return rf(ctx, poolID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreateInstanceParams) params.Instance); ok {
|
|
r0 = rf(ctx, poolID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Instance)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.CreateInstanceParams) error); ok {
|
|
r1 = rf(ctx, poolID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateOrUpdateJob provides a mock function with given fields: ctx, job
|
|
func (_m *Store) CreateOrUpdateJob(ctx context.Context, job params.Job) (params.Job, error) {
|
|
ret := _m.Called(ctx, job)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateOrUpdateJob")
|
|
}
|
|
|
|
var r0 params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.Job) (params.Job, error)); ok {
|
|
return rf(ctx, job)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.Job) params.Job); ok {
|
|
r0 = rf(ctx, job)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Job)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.Job) error); ok {
|
|
r1 = rf(ctx, job)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateOrganization provides a mock function with given fields: ctx, name, credentials, webhookSecret, poolBalancerType
|
|
func (_m *Store) CreateOrganization(ctx context.Context, name string, credentials params.ForgeCredentials, webhookSecret string, poolBalancerType params.PoolBalancerType) (params.Organization, error) {
|
|
ret := _m.Called(ctx, name, credentials, webhookSecret, poolBalancerType)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateOrganization")
|
|
}
|
|
|
|
var r0 params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.ForgeCredentials, string, params.PoolBalancerType) (params.Organization, error)); ok {
|
|
return rf(ctx, name, credentials, webhookSecret, poolBalancerType)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.ForgeCredentials, string, params.PoolBalancerType) params.Organization); ok {
|
|
r0 = rf(ctx, name, credentials, webhookSecret, poolBalancerType)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Organization)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.ForgeCredentials, string, params.PoolBalancerType) error); ok {
|
|
r1 = rf(ctx, name, credentials, webhookSecret, poolBalancerType)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateRepository provides a mock function with given fields: ctx, owner, name, credentials, webhookSecret, poolBalancerType
|
|
func (_m *Store) CreateRepository(ctx context.Context, owner string, name string, credentials params.ForgeCredentials, webhookSecret string, poolBalancerType params.PoolBalancerType) (params.Repository, error) {
|
|
ret := _m.Called(ctx, owner, name, credentials, webhookSecret, poolBalancerType)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRepository")
|
|
}
|
|
|
|
var r0 params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, params.ForgeCredentials, string, params.PoolBalancerType) (params.Repository, error)); ok {
|
|
return rf(ctx, owner, name, credentials, webhookSecret, poolBalancerType)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, params.ForgeCredentials, string, params.PoolBalancerType) params.Repository); ok {
|
|
r0 = rf(ctx, owner, name, credentials, webhookSecret, poolBalancerType)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Repository)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, params.ForgeCredentials, string, params.PoolBalancerType) error); ok {
|
|
r1 = rf(ctx, owner, name, credentials, webhookSecret, poolBalancerType)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateScaleSetInstance provides a mock function with given fields: _a0, scaleSetID, param
|
|
func (_m *Store) CreateScaleSetInstance(_a0 context.Context, scaleSetID uint, param params.CreateInstanceParams) (params.Instance, error) {
|
|
ret := _m.Called(_a0, scaleSetID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateScaleSetInstance")
|
|
}
|
|
|
|
var r0 params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, params.CreateInstanceParams) (params.Instance, error)); ok {
|
|
return rf(_a0, scaleSetID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, params.CreateInstanceParams) params.Instance); ok {
|
|
r0 = rf(_a0, scaleSetID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Instance)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint, params.CreateInstanceParams) error); ok {
|
|
r1 = rf(_a0, scaleSetID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateUser provides a mock function with given fields: ctx, user
|
|
func (_m *Store) CreateUser(ctx context.Context, user params.NewUserParams) (params.User, error) {
|
|
ret := _m.Called(ctx, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateUser")
|
|
}
|
|
|
|
var r0 params.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.NewUserParams) (params.User, error)); ok {
|
|
return rf(ctx, user)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.NewUserParams) params.User); ok {
|
|
r0 = rf(ctx, user)
|
|
} else {
|
|
r0 = ret.Get(0).(params.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.NewUserParams) error); ok {
|
|
r1 = rf(ctx, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteCompletedJobs provides a mock function with given fields: ctx
|
|
func (_m *Store) DeleteCompletedJobs(ctx context.Context) error {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteCompletedJobs")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) error); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteEnterprise provides a mock function with given fields: ctx, enterpriseID
|
|
func (_m *Store) DeleteEnterprise(ctx context.Context, enterpriseID string) error {
|
|
ret := _m.Called(ctx, enterpriseID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteEnterprise")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, enterpriseID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteEntityPool provides a mock function with given fields: ctx, entity, poolID
|
|
func (_m *Store) DeleteEntityPool(ctx context.Context, entity params.ForgeEntity, poolID string) error {
|
|
ret := _m.Called(ctx, entity, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteEntityPool")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, string) error); ok {
|
|
r0 = rf(ctx, entity, poolID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteGiteaCredentials provides a mock function with given fields: ctx, id
|
|
func (_m *Store) DeleteGiteaCredentials(ctx context.Context, id uint) error {
|
|
ret := _m.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteGiteaCredentials")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint) error); ok {
|
|
r0 = rf(ctx, id)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteGiteaEndpoint provides a mock function with given fields: _a0, name
|
|
func (_m *Store) DeleteGiteaEndpoint(_a0 context.Context, name string) error {
|
|
ret := _m.Called(_a0, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteGiteaEndpoint")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(_a0, name)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteGithubCredentials provides a mock function with given fields: ctx, id
|
|
func (_m *Store) DeleteGithubCredentials(ctx context.Context, id uint) error {
|
|
ret := _m.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteGithubCredentials")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint) error); ok {
|
|
r0 = rf(ctx, id)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteGithubEndpoint provides a mock function with given fields: ctx, name
|
|
func (_m *Store) DeleteGithubEndpoint(ctx context.Context, name string) error {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteGithubEndpoint")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, name)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteInstance provides a mock function with given fields: ctx, poolID, instanceName
|
|
func (_m *Store) DeleteInstance(ctx context.Context, poolID string, instanceName string) error {
|
|
ret := _m.Called(ctx, poolID, instanceName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteInstance")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, poolID, instanceName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteInstanceByName provides a mock function with given fields: ctx, instanceName
|
|
func (_m *Store) DeleteInstanceByName(ctx context.Context, instanceName string) error {
|
|
ret := _m.Called(ctx, instanceName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteInstanceByName")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, instanceName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteJob provides a mock function with given fields: ctx, jobID
|
|
func (_m *Store) DeleteJob(ctx context.Context, jobID int64) error {
|
|
ret := _m.Called(ctx, jobID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteJob")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok {
|
|
r0 = rf(ctx, jobID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteOrganization provides a mock function with given fields: ctx, orgID
|
|
func (_m *Store) DeleteOrganization(ctx context.Context, orgID string) error {
|
|
ret := _m.Called(ctx, orgID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteOrganization")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, orgID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeletePoolByID provides a mock function with given fields: ctx, poolID
|
|
func (_m *Store) DeletePoolByID(ctx context.Context, poolID string) error {
|
|
ret := _m.Called(ctx, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeletePoolByID")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, poolID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteRepository provides a mock function with given fields: ctx, repoID
|
|
func (_m *Store) DeleteRepository(ctx context.Context, repoID string) error {
|
|
ret := _m.Called(ctx, repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteRepository")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, repoID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteScaleSetByID provides a mock function with given fields: ctx, scaleSetID
|
|
func (_m *Store) DeleteScaleSetByID(ctx context.Context, scaleSetID uint) error {
|
|
ret := _m.Called(ctx, scaleSetID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteScaleSetByID")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint) error); ok {
|
|
r0 = rf(ctx, scaleSetID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// FindPoolsMatchingAllTags provides a mock function with given fields: ctx, entityType, entityID, tags
|
|
func (_m *Store) FindPoolsMatchingAllTags(ctx context.Context, entityType params.ForgeEntityType, entityID string, tags []string) ([]params.Pool, error) {
|
|
ret := _m.Called(ctx, entityType, entityID, tags)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for FindPoolsMatchingAllTags")
|
|
}
|
|
|
|
var r0 []params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntityType, string, []string) ([]params.Pool, error)); ok {
|
|
return rf(ctx, entityType, entityID, tags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntityType, string, []string) []params.Pool); ok {
|
|
r0 = rf(ctx, entityType, entityID, tags)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Pool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntityType, string, []string) error); ok {
|
|
r1 = rf(ctx, entityType, entityID, tags)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetAdminUser provides a mock function with given fields: ctx
|
|
func (_m *Store) GetAdminUser(ctx context.Context) (params.User, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAdminUser")
|
|
}
|
|
|
|
var r0 params.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) (params.User, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) params.User); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Get(0).(params.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetEnterprise provides a mock function with given fields: ctx, name, endpointName
|
|
func (_m *Store) GetEnterprise(ctx context.Context, name string, endpointName string) (params.Enterprise, error) {
|
|
ret := _m.Called(ctx, name, endpointName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEnterprise")
|
|
}
|
|
|
|
var r0 params.Enterprise
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Enterprise, error)); ok {
|
|
return rf(ctx, name, endpointName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Enterprise); ok {
|
|
r0 = rf(ctx, name, endpointName)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Enterprise)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, name, endpointName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetEnterpriseByID provides a mock function with given fields: ctx, enterpriseID
|
|
func (_m *Store) GetEnterpriseByID(ctx context.Context, enterpriseID string) (params.Enterprise, error) {
|
|
ret := _m.Called(ctx, enterpriseID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEnterpriseByID")
|
|
}
|
|
|
|
var r0 params.Enterprise
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.Enterprise, error)); ok {
|
|
return rf(ctx, enterpriseID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.Enterprise); ok {
|
|
r0 = rf(ctx, enterpriseID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Enterprise)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, enterpriseID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetEntityPool provides a mock function with given fields: ctx, entity, poolID
|
|
func (_m *Store) GetEntityPool(ctx context.Context, entity params.ForgeEntity, poolID string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, entity, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEntityPool")
|
|
}
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, string) (params.Pool, error)); ok {
|
|
return rf(ctx, entity, poolID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, string) params.Pool); ok {
|
|
r0 = rf(ctx, entity, poolID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntity, string) error); ok {
|
|
r1 = rf(ctx, entity, poolID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetForgeEntity provides a mock function with given fields: _a0, entityType, entityID
|
|
func (_m *Store) GetForgeEntity(_a0 context.Context, entityType params.ForgeEntityType, entityID string) (params.ForgeEntity, error) {
|
|
ret := _m.Called(_a0, entityType, entityID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetForgeEntity")
|
|
}
|
|
|
|
var r0 params.ForgeEntity
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntityType, string) (params.ForgeEntity, error)); ok {
|
|
return rf(_a0, entityType, entityID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntityType, string) params.ForgeEntity); ok {
|
|
r0 = rf(_a0, entityType, entityID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeEntity)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntityType, string) error); ok {
|
|
r1 = rf(_a0, entityType, entityID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGiteaCredentials provides a mock function with given fields: ctx, id, detailed
|
|
func (_m *Store) GetGiteaCredentials(ctx context.Context, id uint, detailed bool) (params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx, id, detailed)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGiteaCredentials")
|
|
}
|
|
|
|
var r0 params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, bool) (params.ForgeCredentials, error)); ok {
|
|
return rf(ctx, id, detailed)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, bool) params.ForgeCredentials); ok {
|
|
r0 = rf(ctx, id, detailed)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint, bool) error); ok {
|
|
r1 = rf(ctx, id, detailed)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGiteaCredentialsByName provides a mock function with given fields: ctx, name, detailed
|
|
func (_m *Store) GetGiteaCredentialsByName(ctx context.Context, name string, detailed bool) (params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx, name, detailed)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGiteaCredentialsByName")
|
|
}
|
|
|
|
var r0 params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, bool) (params.ForgeCredentials, error)); ok {
|
|
return rf(ctx, name, detailed)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, bool) params.ForgeCredentials); ok {
|
|
r0 = rf(ctx, name, detailed)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
|
|
r1 = rf(ctx, name, detailed)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGiteaEndpoint provides a mock function with given fields: _a0, name
|
|
func (_m *Store) GetGiteaEndpoint(_a0 context.Context, name string) (params.ForgeEndpoint, error) {
|
|
ret := _m.Called(_a0, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGiteaEndpoint")
|
|
}
|
|
|
|
var r0 params.ForgeEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.ForgeEndpoint, error)); ok {
|
|
return rf(_a0, name)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.ForgeEndpoint); ok {
|
|
r0 = rf(_a0, name)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(_a0, name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGithubCredentials provides a mock function with given fields: ctx, id, detailed
|
|
func (_m *Store) GetGithubCredentials(ctx context.Context, id uint, detailed bool) (params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx, id, detailed)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGithubCredentials")
|
|
}
|
|
|
|
var r0 params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, bool) (params.ForgeCredentials, error)); ok {
|
|
return rf(ctx, id, detailed)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, bool) params.ForgeCredentials); ok {
|
|
r0 = rf(ctx, id, detailed)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint, bool) error); ok {
|
|
r1 = rf(ctx, id, detailed)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGithubCredentialsByName provides a mock function with given fields: ctx, name, detailed
|
|
func (_m *Store) GetGithubCredentialsByName(ctx context.Context, name string, detailed bool) (params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx, name, detailed)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGithubCredentialsByName")
|
|
}
|
|
|
|
var r0 params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, bool) (params.ForgeCredentials, error)); ok {
|
|
return rf(ctx, name, detailed)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, bool) params.ForgeCredentials); ok {
|
|
r0 = rf(ctx, name, detailed)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
|
|
r1 = rf(ctx, name, detailed)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGithubEndpoint provides a mock function with given fields: ctx, name
|
|
func (_m *Store) GetGithubEndpoint(ctx context.Context, name string) (params.ForgeEndpoint, error) {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGithubEndpoint")
|
|
}
|
|
|
|
var r0 params.ForgeEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.ForgeEndpoint, error)); ok {
|
|
return rf(ctx, name)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.ForgeEndpoint); ok {
|
|
r0 = rf(ctx, name)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetInstanceByName provides a mock function with given fields: ctx, instanceName
|
|
func (_m *Store) GetInstanceByName(ctx context.Context, instanceName string) (params.Instance, error) {
|
|
ret := _m.Called(ctx, instanceName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetInstanceByName")
|
|
}
|
|
|
|
var r0 params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.Instance, error)); ok {
|
|
return rf(ctx, instanceName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.Instance); ok {
|
|
r0 = rf(ctx, instanceName)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Instance)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, instanceName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetJobByID provides a mock function with given fields: ctx, jobID
|
|
func (_m *Store) GetJobByID(ctx context.Context, jobID int64) (params.Job, error) {
|
|
ret := _m.Called(ctx, jobID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetJobByID")
|
|
}
|
|
|
|
var r0 params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) (params.Job, error)); ok {
|
|
return rf(ctx, jobID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) params.Job); ok {
|
|
r0 = rf(ctx, jobID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Job)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
|
|
r1 = rf(ctx, jobID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetOrganization provides a mock function with given fields: ctx, name, endpointName
|
|
func (_m *Store) GetOrganization(ctx context.Context, name string, endpointName string) (params.Organization, error) {
|
|
ret := _m.Called(ctx, name, endpointName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetOrganization")
|
|
}
|
|
|
|
var r0 params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Organization, error)); ok {
|
|
return rf(ctx, name, endpointName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Organization); ok {
|
|
r0 = rf(ctx, name, endpointName)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Organization)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, name, endpointName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetOrganizationByID provides a mock function with given fields: ctx, orgID
|
|
func (_m *Store) GetOrganizationByID(ctx context.Context, orgID string) (params.Organization, error) {
|
|
ret := _m.Called(ctx, orgID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetOrganizationByID")
|
|
}
|
|
|
|
var r0 params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.Organization, error)); ok {
|
|
return rf(ctx, orgID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.Organization); ok {
|
|
r0 = rf(ctx, orgID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Organization)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, orgID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPoolByID provides a mock function with given fields: ctx, poolID
|
|
func (_m *Store) GetPoolByID(ctx context.Context, poolID string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPoolByID")
|
|
}
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.Pool, error)); ok {
|
|
return rf(ctx, poolID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.Pool); ok {
|
|
r0 = rf(ctx, poolID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, poolID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPoolInstanceByName provides a mock function with given fields: ctx, poolID, instanceName
|
|
func (_m *Store) GetPoolInstanceByName(ctx context.Context, poolID string, instanceName string) (params.Instance, error) {
|
|
ret := _m.Called(ctx, poolID, instanceName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPoolInstanceByName")
|
|
}
|
|
|
|
var r0 params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Instance, error)); ok {
|
|
return rf(ctx, poolID, instanceName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Instance); ok {
|
|
r0 = rf(ctx, poolID, instanceName)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Instance)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, poolID, instanceName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetRepository provides a mock function with given fields: ctx, owner, name, endpointName
|
|
func (_m *Store) GetRepository(ctx context.Context, owner string, name string, endpointName string) (params.Repository, error) {
|
|
ret := _m.Called(ctx, owner, name, endpointName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepository")
|
|
}
|
|
|
|
var r0 params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) (params.Repository, error)); ok {
|
|
return rf(ctx, owner, name, endpointName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) params.Repository); ok {
|
|
r0 = rf(ctx, owner, name, endpointName)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Repository)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
|
|
r1 = rf(ctx, owner, name, endpointName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetRepositoryByID provides a mock function with given fields: ctx, repoID
|
|
func (_m *Store) GetRepositoryByID(ctx context.Context, repoID string) (params.Repository, error) {
|
|
ret := _m.Called(ctx, repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepositoryByID")
|
|
}
|
|
|
|
var r0 params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.Repository, error)); ok {
|
|
return rf(ctx, repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.Repository); ok {
|
|
r0 = rf(ctx, repoID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Repository)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetScaleSetByID provides a mock function with given fields: ctx, scaleSet
|
|
func (_m *Store) GetScaleSetByID(ctx context.Context, scaleSet uint) (params.ScaleSet, error) {
|
|
ret := _m.Called(ctx, scaleSet)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetScaleSetByID")
|
|
}
|
|
|
|
var r0 params.ScaleSet
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint) (params.ScaleSet, error)); ok {
|
|
return rf(ctx, scaleSet)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint) params.ScaleSet); ok {
|
|
r0 = rf(ctx, scaleSet)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ScaleSet)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint) error); ok {
|
|
r1 = rf(ctx, scaleSet)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetUser provides a mock function with given fields: ctx, user
|
|
func (_m *Store) GetUser(ctx context.Context, user string) (params.User, error) {
|
|
ret := _m.Called(ctx, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUser")
|
|
}
|
|
|
|
var r0 params.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.User, error)); ok {
|
|
return rf(ctx, user)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.User); ok {
|
|
r0 = rf(ctx, user)
|
|
} else {
|
|
r0 = ret.Get(0).(params.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetUserByID provides a mock function with given fields: ctx, userID
|
|
func (_m *Store) GetUserByID(ctx context.Context, userID string) (params.User, error) {
|
|
ret := _m.Called(ctx, userID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserByID")
|
|
}
|
|
|
|
var r0 params.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.User, error)); ok {
|
|
return rf(ctx, userID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.User); ok {
|
|
r0 = rf(ctx, userID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, userID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// HasAdminUser provides a mock function with given fields: ctx
|
|
func (_m *Store) HasAdminUser(ctx context.Context) bool {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for HasAdminUser")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(context.Context) bool); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// InitController provides a mock function with no fields
|
|
func (_m *Store) InitController() (params.ControllerInfo, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for InitController")
|
|
}
|
|
|
|
var r0 params.ControllerInfo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (params.ControllerInfo, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() params.ControllerInfo); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(params.ControllerInfo)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListAllInstances provides a mock function with given fields: ctx
|
|
func (_m *Store) ListAllInstances(ctx context.Context) ([]params.Instance, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListAllInstances")
|
|
}
|
|
|
|
var r0 []params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.Instance, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.Instance); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Instance)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListAllJobs provides a mock function with given fields: ctx
|
|
func (_m *Store) ListAllJobs(ctx context.Context) ([]params.Job, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListAllJobs")
|
|
}
|
|
|
|
var r0 []params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.Job, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.Job); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Job)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListAllPools provides a mock function with given fields: ctx
|
|
func (_m *Store) ListAllPools(ctx context.Context) ([]params.Pool, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListAllPools")
|
|
}
|
|
|
|
var r0 []params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.Pool, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.Pool); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Pool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListAllScaleSets provides a mock function with given fields: ctx
|
|
func (_m *Store) ListAllScaleSets(ctx context.Context) ([]params.ScaleSet, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListAllScaleSets")
|
|
}
|
|
|
|
var r0 []params.ScaleSet
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.ScaleSet, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.ScaleSet); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.ScaleSet)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEnterprises provides a mock function with given fields: ctx, filter
|
|
func (_m *Store) ListEnterprises(ctx context.Context, filter params.EnterpriseFilter) ([]params.Enterprise, error) {
|
|
ret := _m.Called(ctx, filter)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEnterprises")
|
|
}
|
|
|
|
var r0 []params.Enterprise
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.EnterpriseFilter) ([]params.Enterprise, error)); ok {
|
|
return rf(ctx, filter)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.EnterpriseFilter) []params.Enterprise); ok {
|
|
r0 = rf(ctx, filter)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Enterprise)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.EnterpriseFilter) error); ok {
|
|
r1 = rf(ctx, filter)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEntityInstances provides a mock function with given fields: ctx, entity
|
|
func (_m *Store) ListEntityInstances(ctx context.Context, entity params.ForgeEntity) ([]params.Instance, error) {
|
|
ret := _m.Called(ctx, entity)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEntityInstances")
|
|
}
|
|
|
|
var r0 []params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity) ([]params.Instance, error)); ok {
|
|
return rf(ctx, entity)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity) []params.Instance); ok {
|
|
r0 = rf(ctx, entity)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Instance)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntity) error); ok {
|
|
r1 = rf(ctx, entity)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEntityJobsByStatus provides a mock function with given fields: ctx, entityType, entityID, status
|
|
func (_m *Store) ListEntityJobsByStatus(ctx context.Context, entityType params.ForgeEntityType, entityID string, status params.JobStatus) ([]params.Job, error) {
|
|
ret := _m.Called(ctx, entityType, entityID, status)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEntityJobsByStatus")
|
|
}
|
|
|
|
var r0 []params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntityType, string, params.JobStatus) ([]params.Job, error)); ok {
|
|
return rf(ctx, entityType, entityID, status)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntityType, string, params.JobStatus) []params.Job); ok {
|
|
r0 = rf(ctx, entityType, entityID, status)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Job)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntityType, string, params.JobStatus) error); ok {
|
|
r1 = rf(ctx, entityType, entityID, status)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEntityPools provides a mock function with given fields: ctx, entity
|
|
func (_m *Store) ListEntityPools(ctx context.Context, entity params.ForgeEntity) ([]params.Pool, error) {
|
|
ret := _m.Called(ctx, entity)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEntityPools")
|
|
}
|
|
|
|
var r0 []params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity) ([]params.Pool, error)); ok {
|
|
return rf(ctx, entity)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity) []params.Pool); ok {
|
|
r0 = rf(ctx, entity)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Pool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntity) error); ok {
|
|
r1 = rf(ctx, entity)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEntityScaleSets provides a mock function with given fields: _a0, entity
|
|
func (_m *Store) ListEntityScaleSets(_a0 context.Context, entity params.ForgeEntity) ([]params.ScaleSet, error) {
|
|
ret := _m.Called(_a0, entity)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEntityScaleSets")
|
|
}
|
|
|
|
var r0 []params.ScaleSet
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity) ([]params.ScaleSet, error)); ok {
|
|
return rf(_a0, entity)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity) []params.ScaleSet); ok {
|
|
r0 = rf(_a0, entity)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.ScaleSet)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntity) error); ok {
|
|
r1 = rf(_a0, entity)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListGiteaCredentials provides a mock function with given fields: ctx
|
|
func (_m *Store) ListGiteaCredentials(ctx context.Context) ([]params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListGiteaCredentials")
|
|
}
|
|
|
|
var r0 []params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.ForgeCredentials, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.ForgeCredentials); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.ForgeCredentials)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListGiteaEndpoints provides a mock function with given fields: _a0
|
|
func (_m *Store) ListGiteaEndpoints(_a0 context.Context) ([]params.ForgeEndpoint, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListGiteaEndpoints")
|
|
}
|
|
|
|
var r0 []params.ForgeEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.ForgeEndpoint, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.ForgeEndpoint); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.ForgeEndpoint)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListGithubCredentials provides a mock function with given fields: ctx
|
|
func (_m *Store) ListGithubCredentials(ctx context.Context) ([]params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListGithubCredentials")
|
|
}
|
|
|
|
var r0 []params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.ForgeCredentials, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.ForgeCredentials); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.ForgeCredentials)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListGithubEndpoints provides a mock function with given fields: ctx
|
|
func (_m *Store) ListGithubEndpoints(ctx context.Context) ([]params.ForgeEndpoint, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListGithubEndpoints")
|
|
}
|
|
|
|
var r0 []params.ForgeEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.ForgeEndpoint, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.ForgeEndpoint); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.ForgeEndpoint)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListJobsByStatus provides a mock function with given fields: ctx, status
|
|
func (_m *Store) ListJobsByStatus(ctx context.Context, status params.JobStatus) ([]params.Job, error) {
|
|
ret := _m.Called(ctx, status)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListJobsByStatus")
|
|
}
|
|
|
|
var r0 []params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.JobStatus) ([]params.Job, error)); ok {
|
|
return rf(ctx, status)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.JobStatus) []params.Job); ok {
|
|
r0 = rf(ctx, status)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Job)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.JobStatus) error); ok {
|
|
r1 = rf(ctx, status)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListOrganizations provides a mock function with given fields: ctx, filter
|
|
func (_m *Store) ListOrganizations(ctx context.Context, filter params.OrganizationFilter) ([]params.Organization, error) {
|
|
ret := _m.Called(ctx, filter)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListOrganizations")
|
|
}
|
|
|
|
var r0 []params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.OrganizationFilter) ([]params.Organization, error)); ok {
|
|
return rf(ctx, filter)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.OrganizationFilter) []params.Organization); ok {
|
|
r0 = rf(ctx, filter)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Organization)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.OrganizationFilter) error); ok {
|
|
r1 = rf(ctx, filter)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListPoolInstances provides a mock function with given fields: ctx, poolID
|
|
func (_m *Store) ListPoolInstances(ctx context.Context, poolID string) ([]params.Instance, error) {
|
|
ret := _m.Called(ctx, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListPoolInstances")
|
|
}
|
|
|
|
var r0 []params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Instance, error)); ok {
|
|
return rf(ctx, poolID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []params.Instance); ok {
|
|
r0 = rf(ctx, poolID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Instance)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, poolID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListRepositories provides a mock function with given fields: ctx, filter
|
|
func (_m *Store) ListRepositories(ctx context.Context, filter params.RepositoryFilter) ([]params.Repository, error) {
|
|
ret := _m.Called(ctx, filter)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListRepositories")
|
|
}
|
|
|
|
var r0 []params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.RepositoryFilter) ([]params.Repository, error)); ok {
|
|
return rf(ctx, filter)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.RepositoryFilter) []params.Repository); ok {
|
|
r0 = rf(ctx, filter)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Repository)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.RepositoryFilter) error); ok {
|
|
r1 = rf(ctx, filter)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListScaleSetInstances provides a mock function with given fields: _a0, scalesetID
|
|
func (_m *Store) ListScaleSetInstances(_a0 context.Context, scalesetID uint) ([]params.Instance, error) {
|
|
ret := _m.Called(_a0, scalesetID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListScaleSetInstances")
|
|
}
|
|
|
|
var r0 []params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint) ([]params.Instance, error)); ok {
|
|
return rf(_a0, scalesetID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint) []params.Instance); ok {
|
|
r0 = rf(_a0, scalesetID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Instance)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint) error); ok {
|
|
r1 = rf(_a0, scalesetID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// LockJob provides a mock function with given fields: ctx, jobID, entityID
|
|
func (_m *Store) LockJob(ctx context.Context, jobID int64, entityID string) error {
|
|
ret := _m.Called(ctx, jobID, entityID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LockJob")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, string) error); ok {
|
|
r0 = rf(ctx, jobID, entityID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PoolInstanceCount provides a mock function with given fields: ctx, poolID
|
|
func (_m *Store) PoolInstanceCount(ctx context.Context, poolID string) (int64, error) {
|
|
ret := _m.Called(ctx, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PoolInstanceCount")
|
|
}
|
|
|
|
var r0 int64
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (int64, error)); ok {
|
|
return rf(ctx, poolID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) int64); ok {
|
|
r0 = rf(ctx, poolID)
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, poolID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SetScaleSetDesiredRunnerCount provides a mock function with given fields: ctx, scaleSetID, desiredRunnerCount
|
|
func (_m *Store) SetScaleSetDesiredRunnerCount(ctx context.Context, scaleSetID uint, desiredRunnerCount int) error {
|
|
ret := _m.Called(ctx, scaleSetID, desiredRunnerCount)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetScaleSetDesiredRunnerCount")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, int) error); ok {
|
|
r0 = rf(ctx, scaleSetID, desiredRunnerCount)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// SetScaleSetLastMessageID provides a mock function with given fields: ctx, scaleSetID, lastMessageID
|
|
func (_m *Store) SetScaleSetLastMessageID(ctx context.Context, scaleSetID uint, lastMessageID int64) error {
|
|
ret := _m.Called(ctx, scaleSetID, lastMessageID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetScaleSetLastMessageID")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, int64) error); ok {
|
|
r0 = rf(ctx, scaleSetID, lastMessageID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// UnlockJob provides a mock function with given fields: ctx, jobID, entityID
|
|
func (_m *Store) UnlockJob(ctx context.Context, jobID int64, entityID string) error {
|
|
ret := _m.Called(ctx, jobID, entityID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UnlockJob")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64, string) error); ok {
|
|
r0 = rf(ctx, jobID, entityID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// UpdateController provides a mock function with given fields: info
|
|
func (_m *Store) UpdateController(info params.UpdateControllerParams) (params.ControllerInfo, error) {
|
|
ret := _m.Called(info)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateController")
|
|
}
|
|
|
|
var r0 params.ControllerInfo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(params.UpdateControllerParams) (params.ControllerInfo, error)); ok {
|
|
return rf(info)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(params.UpdateControllerParams) params.ControllerInfo); ok {
|
|
r0 = rf(info)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ControllerInfo)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(params.UpdateControllerParams) error); ok {
|
|
r1 = rf(info)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateEnterprise provides a mock function with given fields: ctx, enterpriseID, param
|
|
func (_m *Store) UpdateEnterprise(ctx context.Context, enterpriseID string, param params.UpdateEntityParams) (params.Enterprise, error) {
|
|
ret := _m.Called(ctx, enterpriseID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEnterprise")
|
|
}
|
|
|
|
var r0 params.Enterprise
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) (params.Enterprise, error)); ok {
|
|
return rf(ctx, enterpriseID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) params.Enterprise); ok {
|
|
r0 = rf(ctx, enterpriseID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Enterprise)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateEntityParams) error); ok {
|
|
r1 = rf(ctx, enterpriseID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateEntityPool provides a mock function with given fields: ctx, entity, poolID, param
|
|
func (_m *Store) UpdateEntityPool(ctx context.Context, entity params.ForgeEntity, poolID string, param params.UpdatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, entity, poolID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEntityPool")
|
|
}
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, string, params.UpdatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, entity, poolID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, string, params.UpdatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, entity, poolID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntity, string, params.UpdatePoolParams) error); ok {
|
|
r1 = rf(ctx, entity, poolID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateEntityScaleSet provides a mock function with given fields: _a0, entity, scaleSetID, param, callback
|
|
func (_m *Store) UpdateEntityScaleSet(_a0 context.Context, entity params.ForgeEntity, scaleSetID uint, param params.UpdateScaleSetParams, callback func(params.ScaleSet, params.ScaleSet) error) (params.ScaleSet, error) {
|
|
ret := _m.Called(_a0, entity, scaleSetID, param, callback)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEntityScaleSet")
|
|
}
|
|
|
|
var r0 params.ScaleSet
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, uint, params.UpdateScaleSetParams, func(params.ScaleSet, params.ScaleSet) error) (params.ScaleSet, error)); ok {
|
|
return rf(_a0, entity, scaleSetID, param, callback)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.ForgeEntity, uint, params.UpdateScaleSetParams, func(params.ScaleSet, params.ScaleSet) error) params.ScaleSet); ok {
|
|
r0 = rf(_a0, entity, scaleSetID, param, callback)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ScaleSet)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.ForgeEntity, uint, params.UpdateScaleSetParams, func(params.ScaleSet, params.ScaleSet) error) error); ok {
|
|
r1 = rf(_a0, entity, scaleSetID, param, callback)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateGiteaCredentials provides a mock function with given fields: ctx, id, param
|
|
func (_m *Store) UpdateGiteaCredentials(ctx context.Context, id uint, param params.UpdateGiteaCredentialsParams) (params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx, id, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateGiteaCredentials")
|
|
}
|
|
|
|
var r0 params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, params.UpdateGiteaCredentialsParams) (params.ForgeCredentials, error)); ok {
|
|
return rf(ctx, id, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, params.UpdateGiteaCredentialsParams) params.ForgeCredentials); ok {
|
|
r0 = rf(ctx, id, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint, params.UpdateGiteaCredentialsParams) error); ok {
|
|
r1 = rf(ctx, id, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateGiteaEndpoint provides a mock function with given fields: _a0, name, param
|
|
func (_m *Store) UpdateGiteaEndpoint(_a0 context.Context, name string, param params.UpdateGiteaEndpointParams) (params.ForgeEndpoint, error) {
|
|
ret := _m.Called(_a0, name, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateGiteaEndpoint")
|
|
}
|
|
|
|
var r0 params.ForgeEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateGiteaEndpointParams) (params.ForgeEndpoint, error)); ok {
|
|
return rf(_a0, name, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateGiteaEndpointParams) params.ForgeEndpoint); ok {
|
|
r0 = rf(_a0, name, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateGiteaEndpointParams) error); ok {
|
|
r1 = rf(_a0, name, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateGithubCredentials provides a mock function with given fields: ctx, id, param
|
|
func (_m *Store) UpdateGithubCredentials(ctx context.Context, id uint, param params.UpdateGithubCredentialsParams) (params.ForgeCredentials, error) {
|
|
ret := _m.Called(ctx, id, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateGithubCredentials")
|
|
}
|
|
|
|
var r0 params.ForgeCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, params.UpdateGithubCredentialsParams) (params.ForgeCredentials, error)); ok {
|
|
return rf(ctx, id, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, params.UpdateGithubCredentialsParams) params.ForgeCredentials); ok {
|
|
r0 = rf(ctx, id, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint, params.UpdateGithubCredentialsParams) error); ok {
|
|
r1 = rf(ctx, id, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateGithubEndpoint provides a mock function with given fields: ctx, name, param
|
|
func (_m *Store) UpdateGithubEndpoint(ctx context.Context, name string, param params.UpdateGithubEndpointParams) (params.ForgeEndpoint, error) {
|
|
ret := _m.Called(ctx, name, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateGithubEndpoint")
|
|
}
|
|
|
|
var r0 params.ForgeEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateGithubEndpointParams) (params.ForgeEndpoint, error)); ok {
|
|
return rf(ctx, name, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateGithubEndpointParams) params.ForgeEndpoint); ok {
|
|
r0 = rf(ctx, name, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.ForgeEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateGithubEndpointParams) error); ok {
|
|
r1 = rf(ctx, name, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateInstance provides a mock function with given fields: ctx, instanceName, param
|
|
func (_m *Store) UpdateInstance(ctx context.Context, instanceName string, param params.UpdateInstanceParams) (params.Instance, error) {
|
|
ret := _m.Called(ctx, instanceName, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateInstance")
|
|
}
|
|
|
|
var r0 params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateInstanceParams) (params.Instance, error)); ok {
|
|
return rf(ctx, instanceName, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateInstanceParams) params.Instance); ok {
|
|
r0 = rf(ctx, instanceName, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Instance)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateInstanceParams) error); ok {
|
|
r1 = rf(ctx, instanceName, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateOrganization provides a mock function with given fields: ctx, orgID, param
|
|
func (_m *Store) UpdateOrganization(ctx context.Context, orgID string, param params.UpdateEntityParams) (params.Organization, error) {
|
|
ret := _m.Called(ctx, orgID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateOrganization")
|
|
}
|
|
|
|
var r0 params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) (params.Organization, error)); ok {
|
|
return rf(ctx, orgID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) params.Organization); ok {
|
|
r0 = rf(ctx, orgID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Organization)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateEntityParams) error); ok {
|
|
r1 = rf(ctx, orgID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateRepository provides a mock function with given fields: ctx, repoID, param
|
|
func (_m *Store) UpdateRepository(ctx context.Context, repoID string, param params.UpdateEntityParams) (params.Repository, error) {
|
|
ret := _m.Called(ctx, repoID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateRepository")
|
|
}
|
|
|
|
var r0 params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) (params.Repository, error)); ok {
|
|
return rf(ctx, repoID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) params.Repository); ok {
|
|
r0 = rf(ctx, repoID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Repository)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateEntityParams) error); ok {
|
|
r1 = rf(ctx, repoID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateUser provides a mock function with given fields: ctx, user, param
|
|
func (_m *Store) UpdateUser(ctx context.Context, user string, param params.UpdateUserParams) (params.User, error) {
|
|
ret := _m.Called(ctx, user, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateUser")
|
|
}
|
|
|
|
var r0 params.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateUserParams) (params.User, error)); ok {
|
|
return rf(ctx, user, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateUserParams) params.User); ok {
|
|
r0 = rf(ctx, user, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateUserParams) error); ok {
|
|
r1 = rf(ctx, user, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// NewStore creates a new instance of Store. 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 NewStore(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *Store {
|
|
mock := &Store{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|