d09f12dfd8
This branch adds the ability to forcefully remove a runner from GARM. When the operator wishes to manually remove a runner, the workflow is as follows: * Check that the runner exists in GitHub. If it does, attempt to remove it. An error here indicates that the runner may be processing a job. In this case, we don't continue and the operator gets immediate feedback from the API. * Mark the runner in the database as pending_delete * Allow the consolidate loop to reap it from the provider and remove it from the database. Removing the instance from the provider is async. If the provider errs out, GARM will keep trying to remove it in perpetuity until the provider succedes. In situations where the provider is misconfigured, this will never happen, leaving the instance in a permanent state of pending_delete. A provider may fail for various reasons. Either credentials have expired, the API endpoint has changed, the provider is misconfigured or the operator may just have removed it from the config before cleaning up the runners. While some cases are recoverable, some are not. We cannot have a situation in which we cannot clean resources in garm because of a misconfiguration. This change adds the pending_force_delete instance status. Instances marked with this status, will be removed from GARM even if the provider reports an error. The GARM cli has been modified to give new meaning to the --force-remove-runner option. This option in the CLI is no longer mandatory. Instead, setting it will mark the runner with the new pending_force_delete status. Omitting it will mark the runner with the old status of pending_delete. Fixes: #160 Signed-off-by: Gabriel Adrian Samfira <gsamfira@cloudbasesolutions.com>
1594 lines
45 KiB
Go
1594 lines
45 KiB
Go
// Code generated by mockery v2.28.1. 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
|
|
}
|
|
|
|
// AddInstanceEvent provides a mock function with given fields: ctx, instanceID, event, eventLevel, eventMessage
|
|
func (_m *Store) AddInstanceEvent(ctx context.Context, instanceID string, event params.EventType, eventLevel params.EventLevel, eventMessage string) error {
|
|
ret := _m.Called(ctx, instanceID, event, eventLevel, eventMessage)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.EventType, params.EventLevel, string) error); ok {
|
|
r0 = rf(ctx, instanceID, 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)
|
|
|
|
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 given fields:
|
|
func (_m *Store) ControllerInfo() (params.ControllerInfo, error) {
|
|
ret := _m.Called()
|
|
|
|
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
|
|
func (_m *Store) CreateEnterprise(ctx context.Context, name string, credentialsName string, webhookSecret string) (params.Enterprise, error) {
|
|
ret := _m.Called(ctx, name, credentialsName, webhookSecret)
|
|
|
|
var r0 params.Enterprise
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) (params.Enterprise, error)); ok {
|
|
return rf(ctx, name, credentialsName, webhookSecret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) params.Enterprise); ok {
|
|
r0 = rf(ctx, name, credentialsName, webhookSecret)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Enterprise)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
|
|
r1 = rf(ctx, name, credentialsName, webhookSecret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateEnterprisePool provides a mock function with given fields: ctx, enterpriseID, param
|
|
func (_m *Store) CreateEnterprisePool(ctx context.Context, enterpriseID string, param params.CreatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, enterpriseID, param)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, enterpriseID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, enterpriseID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok {
|
|
r1 = rf(ctx, enterpriseID, 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)
|
|
|
|
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)
|
|
|
|
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, credentialsName, webhookSecret
|
|
func (_m *Store) CreateOrganization(ctx context.Context, name string, credentialsName string, webhookSecret string) (params.Organization, error) {
|
|
ret := _m.Called(ctx, name, credentialsName, webhookSecret)
|
|
|
|
var r0 params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) (params.Organization, error)); ok {
|
|
return rf(ctx, name, credentialsName, webhookSecret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) params.Organization); ok {
|
|
r0 = rf(ctx, name, credentialsName, webhookSecret)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Organization)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
|
|
r1 = rf(ctx, name, credentialsName, webhookSecret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateOrganizationPool provides a mock function with given fields: ctx, orgId, param
|
|
func (_m *Store) CreateOrganizationPool(ctx context.Context, orgId string, param params.CreatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, orgId, param)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, orgId, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, orgId, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok {
|
|
r1 = rf(ctx, orgId, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateRepository provides a mock function with given fields: ctx, owner, name, credentialsName, webhookSecret
|
|
func (_m *Store) CreateRepository(ctx context.Context, owner string, name string, credentialsName string, webhookSecret string) (params.Repository, error) {
|
|
ret := _m.Called(ctx, owner, name, credentialsName, webhookSecret)
|
|
|
|
var r0 params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) (params.Repository, error)); ok {
|
|
return rf(ctx, owner, name, credentialsName, webhookSecret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) params.Repository); ok {
|
|
r0 = rf(ctx, owner, name, credentialsName, webhookSecret)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Repository)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
|
|
r1 = rf(ctx, owner, name, credentialsName, webhookSecret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateRepositoryPool provides a mock function with given fields: ctx, repoId, param
|
|
func (_m *Store) CreateRepositoryPool(ctx context.Context, repoId string, param params.CreatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, repoId, param)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, repoId, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, repoId, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok {
|
|
r1 = rf(ctx, repoId, 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)
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// DeleteEnterprisePool provides a mock function with given fields: ctx, enterpriseID, poolID
|
|
func (_m *Store) DeleteEnterprisePool(ctx context.Context, enterpriseID string, poolID string) error {
|
|
ret := _m.Called(ctx, enterpriseID, poolID)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, enterpriseID, poolID)
|
|
} 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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// DeleteOrganizationPool provides a mock function with given fields: ctx, orgID, poolID
|
|
func (_m *Store) DeleteOrganizationPool(ctx context.Context, orgID string, poolID string) error {
|
|
ret := _m.Called(ctx, orgID, poolID)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, orgID, poolID)
|
|
} 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)
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// DeleteRepositoryPool provides a mock function with given fields: ctx, repoID, poolID
|
|
func (_m *Store) DeleteRepositoryPool(ctx context.Context, repoID string, poolID string) error {
|
|
ret := _m.Called(ctx, repoID, poolID)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, repoID, poolID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// FindEnterprisePoolByTags provides a mock function with given fields: ctx, enterpriseID, tags
|
|
func (_m *Store) FindEnterprisePoolByTags(ctx context.Context, enterpriseID string, tags []string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, enterpriseID, tags)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, []string) (params.Pool, error)); ok {
|
|
return rf(ctx, enterpriseID, tags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, []string) params.Pool); ok {
|
|
r0 = rf(ctx, enterpriseID, tags)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
|
|
r1 = rf(ctx, enterpriseID, tags)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// FindOrganizationPoolByTags provides a mock function with given fields: ctx, orgID, tags
|
|
func (_m *Store) FindOrganizationPoolByTags(ctx context.Context, orgID string, tags []string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, orgID, tags)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, []string) (params.Pool, error)); ok {
|
|
return rf(ctx, orgID, tags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, []string) params.Pool); ok {
|
|
r0 = rf(ctx, orgID, tags)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
|
|
r1 = rf(ctx, orgID, tags)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// FindPoolsMatchingAllTags provides a mock function with given fields: ctx, entityType, entityID, tags
|
|
func (_m *Store) FindPoolsMatchingAllTags(ctx context.Context, entityType params.PoolType, entityID string, tags []string) ([]params.Pool, error) {
|
|
ret := _m.Called(ctx, entityType, entityID, tags)
|
|
|
|
var r0 []params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.PoolType, string, []string) ([]params.Pool, error)); ok {
|
|
return rf(ctx, entityType, entityID, tags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.PoolType, 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.PoolType, string, []string) error); ok {
|
|
r1 = rf(ctx, entityType, entityID, tags)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// FindRepositoryPoolByTags provides a mock function with given fields: ctx, repoID, tags
|
|
func (_m *Store) FindRepositoryPoolByTags(ctx context.Context, repoID string, tags []string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, repoID, tags)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, []string) (params.Pool, error)); ok {
|
|
return rf(ctx, repoID, tags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, []string) params.Pool); ok {
|
|
r0 = rf(ctx, repoID, tags)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
|
|
r1 = rf(ctx, repoID, tags)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetEnterprise provides a mock function with given fields: ctx, name
|
|
func (_m *Store) GetEnterprise(ctx context.Context, name string) (params.Enterprise, error) {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
var r0 params.Enterprise
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.Enterprise, error)); ok {
|
|
return rf(ctx, name)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.Enterprise); ok {
|
|
r0 = rf(ctx, name)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Enterprise)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, name)
|
|
} 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)
|
|
|
|
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
|
|
}
|
|
|
|
// GetEnterprisePool provides a mock function with given fields: ctx, enterpriseID, poolID
|
|
func (_m *Store) GetEnterprisePool(ctx context.Context, enterpriseID string, poolID string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, enterpriseID, poolID)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok {
|
|
return rf(ctx, enterpriseID, poolID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok {
|
|
r0 = rf(ctx, enterpriseID, poolID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, enterpriseID, poolID)
|
|
} 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)
|
|
|
|
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)
|
|
|
|
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
|
|
func (_m *Store) GetOrganization(ctx context.Context, name string) (params.Organization, error) {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
var r0 params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.Organization, error)); ok {
|
|
return rf(ctx, name)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.Organization); ok {
|
|
r0 = rf(ctx, name)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Organization)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, name)
|
|
} 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)
|
|
|
|
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
|
|
}
|
|
|
|
// GetOrganizationPool provides a mock function with given fields: ctx, orgID, poolID
|
|
func (_m *Store) GetOrganizationPool(ctx context.Context, orgID string, poolID string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, orgID, poolID)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok {
|
|
return rf(ctx, orgID, poolID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok {
|
|
r0 = rf(ctx, orgID, poolID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, orgID, poolID)
|
|
} 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)
|
|
|
|
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)
|
|
|
|
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
|
|
func (_m *Store) GetRepository(ctx context.Context, owner string, name string) (params.Repository, error) {
|
|
ret := _m.Called(ctx, owner, name)
|
|
|
|
var r0 params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Repository, error)); ok {
|
|
return rf(ctx, owner, name)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Repository); ok {
|
|
r0 = rf(ctx, owner, name)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Repository)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, owner, name)
|
|
} 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)
|
|
|
|
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
|
|
}
|
|
|
|
// GetRepositoryPool provides a mock function with given fields: ctx, repoID, poolID
|
|
func (_m *Store) GetRepositoryPool(ctx context.Context, repoID string, poolID string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, repoID, poolID)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok {
|
|
return rf(ctx, repoID, poolID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok {
|
|
r0 = rf(ctx, repoID, poolID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, repoID, poolID)
|
|
} 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)
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
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 given fields:
|
|
func (_m *Store) InitController() (params.ControllerInfo, error) {
|
|
ret := _m.Called()
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// ListEnterpriseInstances provides a mock function with given fields: ctx, enterpriseID
|
|
func (_m *Store) ListEnterpriseInstances(ctx context.Context, enterpriseID string) ([]params.Instance, error) {
|
|
ret := _m.Called(ctx, enterpriseID)
|
|
|
|
var r0 []params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Instance, error)); ok {
|
|
return rf(ctx, enterpriseID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []params.Instance); ok {
|
|
r0 = rf(ctx, enterpriseID)
|
|
} 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, enterpriseID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEnterprisePools provides a mock function with given fields: ctx, enterpriseID
|
|
func (_m *Store) ListEnterprisePools(ctx context.Context, enterpriseID string) ([]params.Pool, error) {
|
|
ret := _m.Called(ctx, enterpriseID)
|
|
|
|
var r0 []params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Pool, error)); ok {
|
|
return rf(ctx, enterpriseID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []params.Pool); ok {
|
|
r0 = rf(ctx, enterpriseID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Pool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, enterpriseID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEnterprises provides a mock function with given fields: ctx
|
|
func (_m *Store) ListEnterprises(ctx context.Context) ([]params.Enterprise, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 []params.Enterprise
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.Enterprise, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.Enterprise); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Enterprise)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} 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.PoolType, entityID string, status params.JobStatus) ([]params.Job, error) {
|
|
ret := _m.Called(ctx, entityType, entityID, status)
|
|
|
|
var r0 []params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.PoolType, string, params.JobStatus) ([]params.Job, error)); ok {
|
|
return rf(ctx, entityType, entityID, status)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.PoolType, 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.PoolType, string, params.JobStatus) error); ok {
|
|
r1 = rf(ctx, entityType, entityID, status)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListInstanceEvents provides a mock function with given fields: ctx, instanceID, eventType, eventLevel
|
|
func (_m *Store) ListInstanceEvents(ctx context.Context, instanceID string, eventType params.EventType, eventLevel params.EventLevel) ([]params.StatusMessage, error) {
|
|
ret := _m.Called(ctx, instanceID, eventType, eventLevel)
|
|
|
|
var r0 []params.StatusMessage
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.EventType, params.EventLevel) ([]params.StatusMessage, error)); ok {
|
|
return rf(ctx, instanceID, eventType, eventLevel)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.EventType, params.EventLevel) []params.StatusMessage); ok {
|
|
r0 = rf(ctx, instanceID, eventType, eventLevel)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.StatusMessage)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.EventType, params.EventLevel) error); ok {
|
|
r1 = rf(ctx, instanceID, eventType, eventLevel)
|
|
} 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)
|
|
|
|
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
|
|
}
|
|
|
|
// ListOrgInstances provides a mock function with given fields: ctx, orgID
|
|
func (_m *Store) ListOrgInstances(ctx context.Context, orgID string) ([]params.Instance, error) {
|
|
ret := _m.Called(ctx, orgID)
|
|
|
|
var r0 []params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Instance, error)); ok {
|
|
return rf(ctx, orgID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []params.Instance); ok {
|
|
r0 = rf(ctx, orgID)
|
|
} 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, orgID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListOrgPools provides a mock function with given fields: ctx, orgID
|
|
func (_m *Store) ListOrgPools(ctx context.Context, orgID string) ([]params.Pool, error) {
|
|
ret := _m.Called(ctx, orgID)
|
|
|
|
var r0 []params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Pool, error)); ok {
|
|
return rf(ctx, orgID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []params.Pool); ok {
|
|
r0 = rf(ctx, orgID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Pool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, orgID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListOrganizations provides a mock function with given fields: ctx
|
|
func (_m *Store) ListOrganizations(ctx context.Context) ([]params.Organization, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 []params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.Organization, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.Organization); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Organization)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} 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)
|
|
|
|
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
|
|
}
|
|
|
|
// ListRepoInstances provides a mock function with given fields: ctx, repoID
|
|
func (_m *Store) ListRepoInstances(ctx context.Context, repoID string) ([]params.Instance, error) {
|
|
ret := _m.Called(ctx, repoID)
|
|
|
|
var r0 []params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Instance, error)); ok {
|
|
return rf(ctx, repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []params.Instance); ok {
|
|
r0 = rf(ctx, repoID)
|
|
} 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, repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListRepoPools provides a mock function with given fields: ctx, repoID
|
|
func (_m *Store) ListRepoPools(ctx context.Context, repoID string) ([]params.Pool, error) {
|
|
ret := _m.Called(ctx, repoID)
|
|
|
|
var r0 []params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Pool, error)); ok {
|
|
return rf(ctx, repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []params.Pool); ok {
|
|
r0 = rf(ctx, repoID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Pool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListRepositories provides a mock function with given fields: ctx
|
|
func (_m *Store) ListRepositories(ctx context.Context) ([]params.Repository, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
var r0 []params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.Repository, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.Repository); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Repository)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} 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)
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
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
|
|
}
|
|
|
|
// UpdateEnterprisePool provides a mock function with given fields: ctx, enterpriseID, poolID, param
|
|
func (_m *Store) UpdateEnterprisePool(ctx context.Context, enterpriseID string, poolID string, param params.UpdatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, enterpriseID, poolID, param)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, enterpriseID, poolID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, enterpriseID, poolID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, params.UpdatePoolParams) error); ok {
|
|
r1 = rf(ctx, enterpriseID, poolID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateInstance provides a mock function with given fields: ctx, instanceID, param
|
|
func (_m *Store) UpdateInstance(ctx context.Context, instanceID string, param params.UpdateInstanceParams) (params.Instance, error) {
|
|
ret := _m.Called(ctx, instanceID, param)
|
|
|
|
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, instanceID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateInstanceParams) params.Instance); ok {
|
|
r0 = rf(ctx, instanceID, 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, instanceID, 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)
|
|
|
|
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
|
|
}
|
|
|
|
// UpdateOrganizationPool provides a mock function with given fields: ctx, orgID, poolID, param
|
|
func (_m *Store) UpdateOrganizationPool(ctx context.Context, orgID string, poolID string, param params.UpdatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, orgID, poolID, param)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, orgID, poolID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, orgID, poolID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, params.UpdatePoolParams) error); ok {
|
|
r1 = rf(ctx, orgID, poolID, 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)
|
|
|
|
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
|
|
}
|
|
|
|
// UpdateRepositoryPool provides a mock function with given fields: ctx, repoID, poolID, param
|
|
func (_m *Store) UpdateRepositoryPool(ctx context.Context, repoID string, poolID string, param params.UpdatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, repoID, poolID, param)
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, repoID, poolID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, repoID, poolID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, params.UpdatePoolParams) error); ok {
|
|
r1 = rf(ctx, repoID, poolID, 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)
|
|
|
|
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
|
|
}
|
|
|
|
type mockConstructorTestingTNewStore interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}
|
|
|
|
// 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.
|
|
func NewStore(t mockConstructorTestingTNewStore) *Store {
|
|
mock := &Store{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|