234f71d9d1
We'll use GithubEntityType throughout the codebase to determine the type of operation that is about to take place, so this won't belimited to determining only pool type. We'll also use this to dedupe the label scope as well. Signed-off-by: Gabriel Adrian Samfira <gsamfira@cloudbasesolutions.com>
1873 lines
52 KiB
Go
1873 lines
52 KiB
Go
// Code generated by mockery v2.42.0. 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)
|
|
|
|
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, 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)
|
|
|
|
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 given 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 string, 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, string, string, params.PoolBalancerType) (params.Enterprise, error)); ok {
|
|
return rf(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, 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, string, string, params.PoolBalancerType) error); ok {
|
|
r1 = rf(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
} 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateEnterprisePool")
|
|
}
|
|
|
|
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)
|
|
|
|
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, credentialsName, webhookSecret, poolBalancerType
|
|
func (_m *Store) CreateOrganization(ctx context.Context, name string, credentialsName string, webhookSecret string, poolBalancerType params.PoolBalancerType) (params.Organization, error) {
|
|
ret := _m.Called(ctx, name, credentialsName, 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, string, string, params.PoolBalancerType) (params.Organization, error)); ok {
|
|
return rf(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, params.PoolBalancerType) params.Organization); ok {
|
|
r0 = rf(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Organization)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string, params.PoolBalancerType) error); ok {
|
|
r1 = rf(ctx, name, credentialsName, webhookSecret, poolBalancerType)
|
|
} 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateOrganizationPool")
|
|
}
|
|
|
|
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, poolBalancerType
|
|
func (_m *Store) CreateRepository(ctx context.Context, owner string, name string, credentialsName string, webhookSecret string, poolBalancerType params.PoolBalancerType) (params.Repository, error) {
|
|
ret := _m.Called(ctx, owner, name, credentialsName, 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, string, string, params.PoolBalancerType) (params.Repository, error)); ok {
|
|
return rf(ctx, owner, name, credentialsName, webhookSecret, poolBalancerType)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, params.PoolBalancerType) params.Repository); ok {
|
|
r0 = rf(ctx, owner, name, credentialsName, webhookSecret, poolBalancerType)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Repository)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, params.PoolBalancerType) error); ok {
|
|
r1 = rf(ctx, owner, name, credentialsName, webhookSecret, poolBalancerType)
|
|
} 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRepositoryPool")
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteEnterprisePool")
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteOrganizationPool")
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteRepositoryPool")
|
|
}
|
|
|
|
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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for FindEnterprisePoolByTags")
|
|
}
|
|
|
|
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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for FindOrganizationPoolByTags")
|
|
}
|
|
|
|
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.GithubEntityType, 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.GithubEntityType, string, []string) ([]params.Pool, error)); ok {
|
|
return rf(ctx, entityType, entityID, tags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntityType, 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.GithubEntityType, 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for FindRepositoryPoolByTags")
|
|
}
|
|
|
|
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)
|
|
|
|
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) (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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEnterprisePool")
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
func (_m *Store) GetOrganization(ctx context.Context, name string) (params.Organization, error) {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
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) (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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetOrganizationPool")
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
func (_m *Store) GetRepository(ctx context.Context, owner string, name string) (params.Repository, error) {
|
|
ret := _m.Called(ctx, owner, name)
|
|
|
|
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) (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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepositoryPool")
|
|
}
|
|
|
|
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)
|
|
|
|
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 given 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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEnterpriseInstances")
|
|
}
|
|
|
|
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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEnterprisePools")
|
|
}
|
|
|
|
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)
|
|
|
|
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.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.GithubEntityType, 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.GithubEntityType, string, params.JobStatus) ([]params.Job, error)); ok {
|
|
return rf(ctx, entityType, entityID, status)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntityType, 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.GithubEntityType, 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListInstanceEvents")
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListOrgInstances")
|
|
}
|
|
|
|
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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListOrgPools")
|
|
}
|
|
|
|
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)
|
|
|
|
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.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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListRepoInstances")
|
|
}
|
|
|
|
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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListRepoPools")
|
|
}
|
|
|
|
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)
|
|
|
|
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.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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEnterprisePool")
|
|
}
|
|
|
|
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)
|
|
|
|
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, 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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateOrganizationPool")
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
// 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)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateRepositoryPool")
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
}
|