90870c11be
Add database models that deal with github credentials. This change adds models for github endpoints (github.com, GHES, etc). This change also adds code to migrate config credntials to the DB. Tests need to be fixed and new tests need to be written. This will come in a later commit. Signed-off-by: Gabriel Adrian Samfira <gsamfira@cloudbasesolutions.com>
1755 lines
48 KiB
Go
1755 lines
48 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, instanceName, event, eventLevel, eventMessage
|
|
func (_m *Store) AddInstanceEvent(ctx context.Context, instanceName string, event params.EventType, eventLevel params.EventLevel, eventMessage string) error {
|
|
ret := _m.Called(ctx, instanceName, event, eventLevel, eventMessage)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddInstanceEvent")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.EventType, params.EventLevel, string) error); ok {
|
|
r0 = rf(ctx, instanceName, event, eventLevel, eventMessage)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// BreakLockJobIsQueued provides a mock function with given fields: ctx, jobID
|
|
func (_m *Store) BreakLockJobIsQueued(ctx context.Context, jobID int64) error {
|
|
ret := _m.Called(ctx, jobID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for BreakLockJobIsQueued")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok {
|
|
r0 = rf(ctx, jobID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ControllerInfo provides a mock function with 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
|
|
}
|
|
|
|
// CreateEntityPool provides a mock function with given fields: ctx, entity, param
|
|
func (_m *Store) CreateEntityPool(ctx context.Context, entity params.GithubEntity, param params.CreatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, entity, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateEntityPool")
|
|
}
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, params.CreatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, entity, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, params.CreatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, entity, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity, params.CreatePoolParams) error); ok {
|
|
r1 = rf(ctx, entity, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateGithubCredentials provides a mock function with given fields: ctx, endpointName, param
|
|
func (_m *Store) CreateGithubCredentials(ctx context.Context, endpointName string, param params.CreateGithubCredentialsParams) (params.GithubCredentials, error) {
|
|
ret := _m.Called(ctx, endpointName, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateGithubCredentials")
|
|
}
|
|
|
|
var r0 params.GithubCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreateGithubCredentialsParams) (params.GithubCredentials, error)); ok {
|
|
return rf(ctx, endpointName, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreateGithubCredentialsParams) params.GithubCredentials); ok {
|
|
r0 = rf(ctx, endpointName, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.GithubCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.CreateGithubCredentialsParams) error); ok {
|
|
r1 = rf(ctx, endpointName, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateGithubEndpoint provides a mock function with given fields: ctx, param
|
|
func (_m *Store) CreateGithubEndpoint(ctx context.Context, param params.CreateGithubEndpointParams) (params.GithubEndpoint, error) {
|
|
ret := _m.Called(ctx, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateGithubEndpoint")
|
|
}
|
|
|
|
var r0 params.GithubEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGithubEndpointParams) (params.GithubEndpoint, error)); ok {
|
|
return rf(ctx, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.CreateGithubEndpointParams) params.GithubEndpoint); ok {
|
|
r0 = rf(ctx, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.GithubEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.CreateGithubEndpointParams) error); ok {
|
|
r1 = rf(ctx, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateInstance provides a mock function with given fields: ctx, poolID, param
|
|
func (_m *Store) CreateInstance(ctx context.Context, poolID string, param params.CreateInstanceParams) (params.Instance, error) {
|
|
ret := _m.Called(ctx, poolID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateInstance")
|
|
}
|
|
|
|
var r0 params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreateInstanceParams) (params.Instance, error)); ok {
|
|
return rf(ctx, poolID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.CreateInstanceParams) params.Instance); ok {
|
|
r0 = rf(ctx, poolID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Instance)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.CreateInstanceParams) error); ok {
|
|
r1 = rf(ctx, poolID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateOrUpdateJob provides a mock function with given fields: ctx, job
|
|
func (_m *Store) CreateOrUpdateJob(ctx context.Context, job params.Job) (params.Job, error) {
|
|
ret := _m.Called(ctx, job)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateOrUpdateJob")
|
|
}
|
|
|
|
var r0 params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.Job) (params.Job, error)); ok {
|
|
return rf(ctx, job)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.Job) params.Job); ok {
|
|
r0 = rf(ctx, job)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Job)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.Job) error); ok {
|
|
r1 = rf(ctx, job)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateOrganization provides a mock function with given fields: ctx, name, 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// CreateUser provides a mock function with given fields: ctx, user
|
|
func (_m *Store) CreateUser(ctx context.Context, user params.NewUserParams) (params.User, error) {
|
|
ret := _m.Called(ctx, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateUser")
|
|
}
|
|
|
|
var r0 params.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.NewUserParams) (params.User, error)); ok {
|
|
return rf(ctx, user)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.NewUserParams) params.User); ok {
|
|
r0 = rf(ctx, user)
|
|
} else {
|
|
r0 = ret.Get(0).(params.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.NewUserParams) error); ok {
|
|
r1 = rf(ctx, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteCompletedJobs provides a mock function with given fields: ctx
|
|
func (_m *Store) DeleteCompletedJobs(ctx context.Context) error {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteCompletedJobs")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) error); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteEnterprise provides a mock function with given fields: ctx, enterpriseID
|
|
func (_m *Store) DeleteEnterprise(ctx context.Context, enterpriseID string) error {
|
|
ret := _m.Called(ctx, enterpriseID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteEnterprise")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, enterpriseID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteEntityPool provides a mock function with given fields: ctx, entity, poolID
|
|
func (_m *Store) DeleteEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) error {
|
|
ret := _m.Called(ctx, entity, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteEntityPool")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string) error); ok {
|
|
r0 = rf(ctx, entity, poolID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteGithubCredentials provides a mock function with given fields: ctx, id
|
|
func (_m *Store) DeleteGithubCredentials(ctx context.Context, id uint) error {
|
|
ret := _m.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteGithubCredentials")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint) error); ok {
|
|
r0 = rf(ctx, id)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteGithubEndpoint provides a mock function with given fields: ctx, name
|
|
func (_m *Store) DeleteGithubEndpoint(ctx context.Context, name string) error {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteGithubEndpoint")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, name)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteInstance provides a mock function with given fields: ctx, poolID, instanceName
|
|
func (_m *Store) DeleteInstance(ctx context.Context, poolID string, instanceName string) error {
|
|
ret := _m.Called(ctx, poolID, instanceName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteInstance")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, poolID, instanceName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteJob provides a mock function with given fields: ctx, jobID
|
|
func (_m *Store) DeleteJob(ctx context.Context, jobID int64) error {
|
|
ret := _m.Called(ctx, jobID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteJob")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok {
|
|
r0 = rf(ctx, jobID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteOrganization provides a mock function with given fields: ctx, orgID
|
|
func (_m *Store) DeleteOrganization(ctx context.Context, orgID string) error {
|
|
ret := _m.Called(ctx, orgID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteOrganization")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, orgID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeletePoolByID provides a mock function with given fields: ctx, poolID
|
|
func (_m *Store) DeletePoolByID(ctx context.Context, poolID string) error {
|
|
ret := _m.Called(ctx, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeletePoolByID")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, poolID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteRepository provides a mock function with given fields: ctx, repoID
|
|
func (_m *Store) DeleteRepository(ctx context.Context, repoID string) error {
|
|
ret := _m.Called(ctx, repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteRepository")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, repoID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// GetAdminUser provides a mock function with given fields: ctx
|
|
func (_m *Store) GetAdminUser(ctx context.Context) (params.User, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAdminUser")
|
|
}
|
|
|
|
var r0 params.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) (params.User, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) params.User); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Get(0).(params.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetEnterprise provides a mock function with given fields: ctx, name
|
|
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
|
|
}
|
|
|
|
// GetEntityPool provides a mock function with given fields: ctx, entity, poolID
|
|
func (_m *Store) GetEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) (params.Pool, error) {
|
|
ret := _m.Called(ctx, entity, poolID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEntityPool")
|
|
}
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string) (params.Pool, error)); ok {
|
|
return rf(ctx, entity, poolID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string) params.Pool); ok {
|
|
r0 = rf(ctx, entity, poolID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity, string) error); ok {
|
|
r1 = rf(ctx, entity, poolID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGithubCredentials provides a mock function with given fields: ctx, id, detailed
|
|
func (_m *Store) GetGithubCredentials(ctx context.Context, id uint, detailed bool) (params.GithubCredentials, error) {
|
|
ret := _m.Called(ctx, id, detailed)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGithubCredentials")
|
|
}
|
|
|
|
var r0 params.GithubCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, bool) (params.GithubCredentials, error)); ok {
|
|
return rf(ctx, id, detailed)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, bool) params.GithubCredentials); ok {
|
|
r0 = rf(ctx, id, detailed)
|
|
} else {
|
|
r0 = ret.Get(0).(params.GithubCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint, bool) error); ok {
|
|
r1 = rf(ctx, id, detailed)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGithubCredentialsByName provides a mock function with given fields: ctx, name, detailed
|
|
func (_m *Store) GetGithubCredentialsByName(ctx context.Context, name string, detailed bool) (params.GithubCredentials, error) {
|
|
ret := _m.Called(ctx, name, detailed)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGithubCredentialsByName")
|
|
}
|
|
|
|
var r0 params.GithubCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, bool) (params.GithubCredentials, error)); ok {
|
|
return rf(ctx, name, detailed)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, bool) params.GithubCredentials); ok {
|
|
r0 = rf(ctx, name, detailed)
|
|
} else {
|
|
r0 = ret.Get(0).(params.GithubCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
|
|
r1 = rf(ctx, name, detailed)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetGithubEndpoint provides a mock function with given fields: ctx, name
|
|
func (_m *Store) GetGithubEndpoint(ctx context.Context, name string) (params.GithubEndpoint, error) {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGithubEndpoint")
|
|
}
|
|
|
|
var r0 params.GithubEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.GithubEndpoint, error)); ok {
|
|
return rf(ctx, name)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.GithubEndpoint); ok {
|
|
r0 = rf(ctx, name)
|
|
} else {
|
|
r0 = ret.Get(0).(params.GithubEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetInstanceByName provides a mock function with given fields: ctx, instanceName
|
|
func (_m *Store) GetInstanceByName(ctx context.Context, instanceName string) (params.Instance, error) {
|
|
ret := _m.Called(ctx, instanceName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetInstanceByName")
|
|
}
|
|
|
|
var r0 params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (params.Instance, error)); ok {
|
|
return rf(ctx, instanceName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) params.Instance); ok {
|
|
r0 = rf(ctx, instanceName)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Instance)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, instanceName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetJobByID provides a mock function with given fields: ctx, jobID
|
|
func (_m *Store) GetJobByID(ctx context.Context, jobID int64) (params.Job, error) {
|
|
ret := _m.Called(ctx, jobID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetJobByID")
|
|
}
|
|
|
|
var r0 params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) (params.Job, error)); ok {
|
|
return rf(ctx, jobID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) params.Job); ok {
|
|
r0 = rf(ctx, jobID)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Job)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
|
|
r1 = rf(ctx, jobID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetOrganization provides a mock function with given fields: ctx, name
|
|
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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// ListEntityInstances provides a mock function with given fields: ctx, entity
|
|
func (_m *Store) ListEntityInstances(ctx context.Context, entity params.GithubEntity) ([]params.Instance, error) {
|
|
ret := _m.Called(ctx, entity)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEntityInstances")
|
|
}
|
|
|
|
var r0 []params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity) ([]params.Instance, error)); ok {
|
|
return rf(ctx, entity)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity) []params.Instance); ok {
|
|
r0 = rf(ctx, entity)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Instance)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity) error); ok {
|
|
r1 = rf(ctx, entity)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEntityJobsByStatus provides a mock function with given fields: ctx, entityType, entityID, status
|
|
func (_m *Store) ListEntityJobsByStatus(ctx context.Context, entityType params.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
|
|
}
|
|
|
|
// ListEntityPools provides a mock function with given fields: ctx, entity
|
|
func (_m *Store) ListEntityPools(ctx context.Context, entity params.GithubEntity) ([]params.Pool, error) {
|
|
ret := _m.Called(ctx, entity)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListEntityPools")
|
|
}
|
|
|
|
var r0 []params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity) ([]params.Pool, error)); ok {
|
|
return rf(ctx, entity)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity) []params.Pool); ok {
|
|
r0 = rf(ctx, entity)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Pool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity) error); ok {
|
|
r1 = rf(ctx, entity)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListGithubCredentials provides a mock function with given fields: ctx
|
|
func (_m *Store) ListGithubCredentials(ctx context.Context) ([]params.GithubCredentials, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListGithubCredentials")
|
|
}
|
|
|
|
var r0 []params.GithubCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.GithubCredentials, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.GithubCredentials); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.GithubCredentials)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListGithubEndpoints provides a mock function with given fields: ctx
|
|
func (_m *Store) ListGithubEndpoints(ctx context.Context) ([]params.GithubEndpoint, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListGithubEndpoints")
|
|
}
|
|
|
|
var r0 []params.GithubEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]params.GithubEndpoint, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []params.GithubEndpoint); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.GithubEndpoint)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListJobsByStatus provides a mock function with given fields: ctx, status
|
|
func (_m *Store) ListJobsByStatus(ctx context.Context, status params.JobStatus) ([]params.Job, error) {
|
|
ret := _m.Called(ctx, status)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListJobsByStatus")
|
|
}
|
|
|
|
var r0 []params.Job
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.JobStatus) ([]params.Job, error)); ok {
|
|
return rf(ctx, status)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.JobStatus) []params.Job); ok {
|
|
r0 = rf(ctx, status)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]params.Job)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.JobStatus) error); ok {
|
|
r1 = rf(ctx, status)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListOrganizations provides a mock function with given fields: ctx
|
|
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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// UpdateEntityPool provides a mock function with given fields: ctx, entity, poolID, param
|
|
func (_m *Store) UpdateEntityPool(ctx context.Context, entity params.GithubEntity, poolID string, param params.UpdatePoolParams) (params.Pool, error) {
|
|
ret := _m.Called(ctx, entity, poolID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEntityPool")
|
|
}
|
|
|
|
var r0 params.Pool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string, params.UpdatePoolParams) (params.Pool, error)); ok {
|
|
return rf(ctx, entity, poolID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string, params.UpdatePoolParams) params.Pool); ok {
|
|
r0 = rf(ctx, entity, poolID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Pool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity, string, params.UpdatePoolParams) error); ok {
|
|
r1 = rf(ctx, entity, poolID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateGithubCredentials provides a mock function with given fields: ctx, id, param
|
|
func (_m *Store) UpdateGithubCredentials(ctx context.Context, id uint, param params.UpdateGithubCredentialsParams) (params.GithubCredentials, error) {
|
|
ret := _m.Called(ctx, id, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateGithubCredentials")
|
|
}
|
|
|
|
var r0 params.GithubCredentials
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, params.UpdateGithubCredentialsParams) (params.GithubCredentials, error)); ok {
|
|
return rf(ctx, id, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, uint, params.UpdateGithubCredentialsParams) params.GithubCredentials); ok {
|
|
r0 = rf(ctx, id, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.GithubCredentials)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, uint, params.UpdateGithubCredentialsParams) error); ok {
|
|
r1 = rf(ctx, id, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateGithubEndpoint provides a mock function with given fields: ctx, name, param
|
|
func (_m *Store) UpdateGithubEndpoint(ctx context.Context, name string, param params.UpdateGithubEndpointParams) (params.GithubEndpoint, error) {
|
|
ret := _m.Called(ctx, name, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateGithubEndpoint")
|
|
}
|
|
|
|
var r0 params.GithubEndpoint
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateGithubEndpointParams) (params.GithubEndpoint, error)); ok {
|
|
return rf(ctx, name, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateGithubEndpointParams) params.GithubEndpoint); ok {
|
|
r0 = rf(ctx, name, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.GithubEndpoint)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateGithubEndpointParams) error); ok {
|
|
r1 = rf(ctx, name, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateInstance provides a mock function with given fields: ctx, instanceName, param
|
|
func (_m *Store) UpdateInstance(ctx context.Context, instanceName string, param params.UpdateInstanceParams) (params.Instance, error) {
|
|
ret := _m.Called(ctx, instanceName, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateInstance")
|
|
}
|
|
|
|
var r0 params.Instance
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateInstanceParams) (params.Instance, error)); ok {
|
|
return rf(ctx, instanceName, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateInstanceParams) params.Instance); ok {
|
|
r0 = rf(ctx, instanceName, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Instance)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateInstanceParams) error); ok {
|
|
r1 = rf(ctx, instanceName, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateOrganization provides a mock function with given fields: ctx, orgID, param
|
|
func (_m *Store) UpdateOrganization(ctx context.Context, orgID string, param params.UpdateEntityParams) (params.Organization, error) {
|
|
ret := _m.Called(ctx, orgID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateOrganization")
|
|
}
|
|
|
|
var r0 params.Organization
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) (params.Organization, error)); ok {
|
|
return rf(ctx, orgID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) params.Organization); ok {
|
|
r0 = rf(ctx, orgID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Organization)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateEntityParams) error); ok {
|
|
r1 = rf(ctx, orgID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateRepository provides a mock function with given fields: ctx, repoID, param
|
|
func (_m *Store) UpdateRepository(ctx context.Context, repoID string, param params.UpdateEntityParams) (params.Repository, error) {
|
|
ret := _m.Called(ctx, repoID, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateRepository")
|
|
}
|
|
|
|
var r0 params.Repository
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) (params.Repository, error)); ok {
|
|
return rf(ctx, repoID, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) params.Repository); ok {
|
|
r0 = rf(ctx, repoID, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.Repository)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateEntityParams) error); ok {
|
|
r1 = rf(ctx, repoID, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateUser provides a mock function with given fields: ctx, user, param
|
|
func (_m *Store) UpdateUser(ctx context.Context, user string, param params.UpdateUserParams) (params.User, error) {
|
|
ret := _m.Called(ctx, user, param)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateUser")
|
|
}
|
|
|
|
var r0 params.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateUserParams) (params.User, error)); ok {
|
|
return rf(ctx, user, param)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateUserParams) params.User); ok {
|
|
r0 = rf(ctx, user, param)
|
|
} else {
|
|
r0 = ret.Get(0).(params.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateUserParams) error); ok {
|
|
r1 = rf(ctx, user, param)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// NewStore creates a new instance of Store. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewStore(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *Store {
|
|
mock := &Store{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|