mirror of
https://github.com/hanzoai/deploy.git
synced 2026-10-07 08:44:50 +00:00
zeekayandHanzo Dev
1ab6e799c1
go.mod still declared `module github.com/hanzoai/deploy` after the repo was renamed. A Go module path is not cosmetic — it is the resolvable location. So `go get github.com/hanzoai/cd` could not work, and anything importing this module had to spell a name that no longer exists at that address. The build log of v3.6.0 is where it surfaced: the compiler was still emitting github.com/hanzoai/deploy/cmd/cd/commands. 3541 import paths across 690 .go, 19 .proto, 4 .yaml, 3 .sh, 2 .mod, Procfile and Makefile. Plus the 62 ghcr.io/hanzoai/deploy image references, moved to ghcr.io/hanzoai/cd to match hanzo.yml's build target — a distinct string from the module path, replaced separately so neither could clobber the other. go mod tidy clean, CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build ./... clean. Co-authored-by: Hanzo Dev <[email protected]>
2850 lines
89 KiB
Go
Generated
2850 lines
89 KiB
Go
Generated
// Code generated by mockery; DO NOT EDIT.
|
|
// github.com/vektra/mockery
|
|
// template: testify
|
|
|
|
package mocks
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/hanzoai/cd/pkg/apis/application/v1alpha1"
|
|
"github.com/hanzoai/cd/util/db"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// NewArgoDB creates a new instance of DB. 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 NewArgoDB(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *DB {
|
|
mock := &DB{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|
|
|
|
// DB is an autogenerated mock type for the DB type
|
|
type DB struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type ArgoDB_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *DB) EXPECT() *ArgoDB_Expecter {
|
|
return &ArgoDB_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// AddGPGPublicKey provides a mock function for the type DB
|
|
func (_mock *DB) AddGPGPublicKey(ctx context.Context, keyData string) (map[string]*v1alpha1.GnuPGPublicKey, []string, error) {
|
|
ret := _mock.Called(ctx, keyData)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddGPGPublicKey")
|
|
}
|
|
|
|
var r0 map[string]*v1alpha1.GnuPGPublicKey
|
|
var r1 []string
|
|
var r2 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) (map[string]*v1alpha1.GnuPGPublicKey, []string, error)); ok {
|
|
return returnFunc(ctx, keyData)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) map[string]*v1alpha1.GnuPGPublicKey); ok {
|
|
r0 = returnFunc(ctx, keyData)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[string]*v1alpha1.GnuPGPublicKey)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) []string); ok {
|
|
r1 = returnFunc(ctx, keyData)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).([]string)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
|
|
r2 = returnFunc(ctx, keyData)
|
|
} else {
|
|
r2 = ret.Error(2)
|
|
}
|
|
return r0, r1, r2
|
|
}
|
|
|
|
// ArgoDB_AddGPGPublicKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddGPGPublicKey'
|
|
type ArgoDB_AddGPGPublicKey_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddGPGPublicKey is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - keyData string
|
|
func (_e *ArgoDB_Expecter) AddGPGPublicKey(ctx any, keyData any) *ArgoDB_AddGPGPublicKey_Call {
|
|
return &ArgoDB_AddGPGPublicKey_Call{Call: _e.mock.On("AddGPGPublicKey", ctx, keyData)}
|
|
}
|
|
|
|
func (_c *ArgoDB_AddGPGPublicKey_Call) Run(run func(ctx context.Context, keyData string)) *ArgoDB_AddGPGPublicKey_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_AddGPGPublicKey_Call) Return(stringToGnuPGPublicKey map[string]*v1alpha1.GnuPGPublicKey, strings []string, err error) *ArgoDB_AddGPGPublicKey_Call {
|
|
_c.Call.Return(stringToGnuPGPublicKey, strings, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_AddGPGPublicKey_Call) RunAndReturn(run func(ctx context.Context, keyData string) (map[string]*v1alpha1.GnuPGPublicKey, []string, error)) *ArgoDB_AddGPGPublicKey_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateCluster provides a mock function for the type DB
|
|
func (_mock *DB) CreateCluster(ctx context.Context, c *v1alpha1.Cluster) (*v1alpha1.Cluster, error) {
|
|
ret := _mock.Called(ctx, c)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateCluster")
|
|
}
|
|
|
|
var r0 *v1alpha1.Cluster
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Cluster) (*v1alpha1.Cluster, error)); ok {
|
|
return returnFunc(ctx, c)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Cluster) *v1alpha1.Cluster); ok {
|
|
r0 = returnFunc(ctx, c)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Cluster)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.Cluster) error); ok {
|
|
r1 = returnFunc(ctx, c)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_CreateCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCluster'
|
|
type ArgoDB_CreateCluster_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateCluster is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - c *v1alpha1.Cluster
|
|
func (_e *ArgoDB_Expecter) CreateCluster(ctx any, c any) *ArgoDB_CreateCluster_Call {
|
|
return &ArgoDB_CreateCluster_Call{Call: _e.mock.On("CreateCluster", ctx, c)}
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateCluster_Call) Run(run func(ctx context.Context, c *v1alpha1.Cluster)) *ArgoDB_CreateCluster_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.Cluster
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.Cluster)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateCluster_Call) Return(cluster *v1alpha1.Cluster, err error) *ArgoDB_CreateCluster_Call {
|
|
_c.Call.Return(cluster, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateCluster_Call) RunAndReturn(run func(ctx context.Context, c *v1alpha1.Cluster) (*v1alpha1.Cluster, error)) *ArgoDB_CreateCluster_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateRepoCertificate provides a mock function for the type DB
|
|
func (_mock *DB) CreateRepoCertificate(ctx context.Context, certificate *v1alpha1.RepositoryCertificateList, upsert bool) (*v1alpha1.RepositoryCertificateList, error) {
|
|
ret := _mock.Called(ctx, certificate, upsert)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRepoCertificate")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepositoryCertificateList
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepositoryCertificateList, bool) (*v1alpha1.RepositoryCertificateList, error)); ok {
|
|
return returnFunc(ctx, certificate, upsert)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepositoryCertificateList, bool) *v1alpha1.RepositoryCertificateList); ok {
|
|
r0 = returnFunc(ctx, certificate, upsert)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepositoryCertificateList)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.RepositoryCertificateList, bool) error); ok {
|
|
r1 = returnFunc(ctx, certificate, upsert)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_CreateRepoCertificate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRepoCertificate'
|
|
type ArgoDB_CreateRepoCertificate_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateRepoCertificate is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - certificate *v1alpha1.RepositoryCertificateList
|
|
// - upsert bool
|
|
func (_e *ArgoDB_Expecter) CreateRepoCertificate(ctx any, certificate any, upsert any) *ArgoDB_CreateRepoCertificate_Call {
|
|
return &ArgoDB_CreateRepoCertificate_Call{Call: _e.mock.On("CreateRepoCertificate", ctx, certificate, upsert)}
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepoCertificate_Call) Run(run func(ctx context.Context, certificate *v1alpha1.RepositoryCertificateList, upsert bool)) *ArgoDB_CreateRepoCertificate_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.RepositoryCertificateList
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.RepositoryCertificateList)
|
|
}
|
|
var arg2 bool
|
|
if args[2] != nil {
|
|
arg2 = args[2].(bool)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepoCertificate_Call) Return(repositoryCertificateList *v1alpha1.RepositoryCertificateList, err error) *ArgoDB_CreateRepoCertificate_Call {
|
|
_c.Call.Return(repositoryCertificateList, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepoCertificate_Call) RunAndReturn(run func(ctx context.Context, certificate *v1alpha1.RepositoryCertificateList, upsert bool) (*v1alpha1.RepositoryCertificateList, error)) *ArgoDB_CreateRepoCertificate_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateRepository provides a mock function for the type DB
|
|
func (_mock *DB) CreateRepository(ctx context.Context, r *v1alpha1.Repository) (*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx, r)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRepository")
|
|
}
|
|
|
|
var r0 *v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Repository) (*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx, r)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Repository) *v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx, r)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.Repository) error); ok {
|
|
r1 = returnFunc(ctx, r)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_CreateRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRepository'
|
|
type ArgoDB_CreateRepository_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateRepository is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - r *v1alpha1.Repository
|
|
func (_e *ArgoDB_Expecter) CreateRepository(ctx any, r any) *ArgoDB_CreateRepository_Call {
|
|
return &ArgoDB_CreateRepository_Call{Call: _e.mock.On("CreateRepository", ctx, r)}
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepository_Call) Run(run func(ctx context.Context, r *v1alpha1.Repository)) *ArgoDB_CreateRepository_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.Repository
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.Repository)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepository_Call) Return(repository *v1alpha1.Repository, err error) *ArgoDB_CreateRepository_Call {
|
|
_c.Call.Return(repository, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepository_Call) RunAndReturn(run func(ctx context.Context, r *v1alpha1.Repository) (*v1alpha1.Repository, error)) *ArgoDB_CreateRepository_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) CreateRepositoryCredentials(ctx context.Context, r *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error) {
|
|
ret := _mock.Called(ctx, r)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRepositoryCredentials")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepoCreds
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error)); ok {
|
|
return returnFunc(ctx, r)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepoCreds) *v1alpha1.RepoCreds); ok {
|
|
r0 = returnFunc(ctx, r)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepoCreds)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.RepoCreds) error); ok {
|
|
r1 = returnFunc(ctx, r)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_CreateRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRepositoryCredentials'
|
|
type ArgoDB_CreateRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - r *v1alpha1.RepoCreds
|
|
func (_e *ArgoDB_Expecter) CreateRepositoryCredentials(ctx any, r any) *ArgoDB_CreateRepositoryCredentials_Call {
|
|
return &ArgoDB_CreateRepositoryCredentials_Call{Call: _e.mock.On("CreateRepositoryCredentials", ctx, r)}
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepositoryCredentials_Call) Run(run func(ctx context.Context, r *v1alpha1.RepoCreds)) *ArgoDB_CreateRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.RepoCreds
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.RepoCreds)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepositoryCredentials_Call) Return(repoCreds *v1alpha1.RepoCreds, err error) *ArgoDB_CreateRepositoryCredentials_Call {
|
|
_c.Call.Return(repoCreds, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context, r *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error)) *ArgoDB_CreateRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateWriteRepository provides a mock function for the type DB
|
|
func (_mock *DB) CreateWriteRepository(ctx context.Context, r *v1alpha1.Repository) (*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx, r)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateWriteRepository")
|
|
}
|
|
|
|
var r0 *v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Repository) (*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx, r)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Repository) *v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx, r)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.Repository) error); ok {
|
|
r1 = returnFunc(ctx, r)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_CreateWriteRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateWriteRepository'
|
|
type ArgoDB_CreateWriteRepository_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateWriteRepository is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - r *v1alpha1.Repository
|
|
func (_e *ArgoDB_Expecter) CreateWriteRepository(ctx any, r any) *ArgoDB_CreateWriteRepository_Call {
|
|
return &ArgoDB_CreateWriteRepository_Call{Call: _e.mock.On("CreateWriteRepository", ctx, r)}
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateWriteRepository_Call) Run(run func(ctx context.Context, r *v1alpha1.Repository)) *ArgoDB_CreateWriteRepository_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.Repository
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.Repository)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateWriteRepository_Call) Return(repository *v1alpha1.Repository, err error) *ArgoDB_CreateWriteRepository_Call {
|
|
_c.Call.Return(repository, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateWriteRepository_Call) RunAndReturn(run func(ctx context.Context, r *v1alpha1.Repository) (*v1alpha1.Repository, error)) *ArgoDB_CreateWriteRepository_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateWriteRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) CreateWriteRepositoryCredentials(ctx context.Context, r *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error) {
|
|
ret := _mock.Called(ctx, r)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateWriteRepositoryCredentials")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepoCreds
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error)); ok {
|
|
return returnFunc(ctx, r)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepoCreds) *v1alpha1.RepoCreds); ok {
|
|
r0 = returnFunc(ctx, r)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepoCreds)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.RepoCreds) error); ok {
|
|
r1 = returnFunc(ctx, r)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_CreateWriteRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateWriteRepositoryCredentials'
|
|
type ArgoDB_CreateWriteRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateWriteRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - r *v1alpha1.RepoCreds
|
|
func (_e *ArgoDB_Expecter) CreateWriteRepositoryCredentials(ctx any, r any) *ArgoDB_CreateWriteRepositoryCredentials_Call {
|
|
return &ArgoDB_CreateWriteRepositoryCredentials_Call{Call: _e.mock.On("CreateWriteRepositoryCredentials", ctx, r)}
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateWriteRepositoryCredentials_Call) Run(run func(ctx context.Context, r *v1alpha1.RepoCreds)) *ArgoDB_CreateWriteRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.RepoCreds
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.RepoCreds)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateWriteRepositoryCredentials_Call) Return(repoCreds *v1alpha1.RepoCreds, err error) *ArgoDB_CreateWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(repoCreds, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_CreateWriteRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context, r *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error)) *ArgoDB_CreateWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteCluster provides a mock function for the type DB
|
|
func (_mock *DB) DeleteCluster(ctx context.Context, server string) error {
|
|
ret := _mock.Called(ctx, server)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteCluster")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = returnFunc(ctx, server)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// ArgoDB_DeleteCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCluster'
|
|
type ArgoDB_DeleteCluster_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteCluster is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - server string
|
|
func (_e *ArgoDB_Expecter) DeleteCluster(ctx any, server any) *ArgoDB_DeleteCluster_Call {
|
|
return &ArgoDB_DeleteCluster_Call{Call: _e.mock.On("DeleteCluster", ctx, server)}
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteCluster_Call) Run(run func(ctx context.Context, server string)) *ArgoDB_DeleteCluster_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteCluster_Call) Return(err error) *ArgoDB_DeleteCluster_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteCluster_Call) RunAndReturn(run func(ctx context.Context, server string) error) *ArgoDB_DeleteCluster_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteGPGPublicKey provides a mock function for the type DB
|
|
func (_mock *DB) DeleteGPGPublicKey(ctx context.Context, keyID string) error {
|
|
ret := _mock.Called(ctx, keyID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteGPGPublicKey")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = returnFunc(ctx, keyID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// ArgoDB_DeleteGPGPublicKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteGPGPublicKey'
|
|
type ArgoDB_DeleteGPGPublicKey_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteGPGPublicKey is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - keyID string
|
|
func (_e *ArgoDB_Expecter) DeleteGPGPublicKey(ctx any, keyID any) *ArgoDB_DeleteGPGPublicKey_Call {
|
|
return &ArgoDB_DeleteGPGPublicKey_Call{Call: _e.mock.On("DeleteGPGPublicKey", ctx, keyID)}
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteGPGPublicKey_Call) Run(run func(ctx context.Context, keyID string)) *ArgoDB_DeleteGPGPublicKey_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteGPGPublicKey_Call) Return(err error) *ArgoDB_DeleteGPGPublicKey_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteGPGPublicKey_Call) RunAndReturn(run func(ctx context.Context, keyID string) error) *ArgoDB_DeleteGPGPublicKey_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteRepository provides a mock function for the type DB
|
|
func (_mock *DB) DeleteRepository(ctx context.Context, name string, project string) error {
|
|
ret := _mock.Called(ctx, name, project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteRepository")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = returnFunc(ctx, name, project)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// ArgoDB_DeleteRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRepository'
|
|
type ArgoDB_DeleteRepository_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteRepository is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) DeleteRepository(ctx any, name any, project any) *ArgoDB_DeleteRepository_Call {
|
|
return &ArgoDB_DeleteRepository_Call{Call: _e.mock.On("DeleteRepository", ctx, name, project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteRepository_Call) Run(run func(ctx context.Context, name string, project string)) *ArgoDB_DeleteRepository_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteRepository_Call) Return(err error) *ArgoDB_DeleteRepository_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteRepository_Call) RunAndReturn(run func(ctx context.Context, name string, project string) error) *ArgoDB_DeleteRepository_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) DeleteRepositoryCredentials(ctx context.Context, name string) error {
|
|
ret := _mock.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteRepositoryCredentials")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = returnFunc(ctx, name)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// ArgoDB_DeleteRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRepositoryCredentials'
|
|
type ArgoDB_DeleteRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
func (_e *ArgoDB_Expecter) DeleteRepositoryCredentials(ctx any, name any) *ArgoDB_DeleteRepositoryCredentials_Call {
|
|
return &ArgoDB_DeleteRepositoryCredentials_Call{Call: _e.mock.On("DeleteRepositoryCredentials", ctx, name)}
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteRepositoryCredentials_Call) Run(run func(ctx context.Context, name string)) *ArgoDB_DeleteRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteRepositoryCredentials_Call) Return(err error) *ArgoDB_DeleteRepositoryCredentials_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context, name string) error) *ArgoDB_DeleteRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteWriteRepository provides a mock function for the type DB
|
|
func (_mock *DB) DeleteWriteRepository(ctx context.Context, name string, project string) error {
|
|
ret := _mock.Called(ctx, name, project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteWriteRepository")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = returnFunc(ctx, name, project)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// ArgoDB_DeleteWriteRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteWriteRepository'
|
|
type ArgoDB_DeleteWriteRepository_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteWriteRepository is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) DeleteWriteRepository(ctx any, name any, project any) *ArgoDB_DeleteWriteRepository_Call {
|
|
return &ArgoDB_DeleteWriteRepository_Call{Call: _e.mock.On("DeleteWriteRepository", ctx, name, project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteWriteRepository_Call) Run(run func(ctx context.Context, name string, project string)) *ArgoDB_DeleteWriteRepository_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteWriteRepository_Call) Return(err error) *ArgoDB_DeleteWriteRepository_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteWriteRepository_Call) RunAndReturn(run func(ctx context.Context, name string, project string) error) *ArgoDB_DeleteWriteRepository_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteWriteRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) DeleteWriteRepositoryCredentials(ctx context.Context, name string) error {
|
|
ret := _mock.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteWriteRepositoryCredentials")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = returnFunc(ctx, name)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// ArgoDB_DeleteWriteRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteWriteRepositoryCredentials'
|
|
type ArgoDB_DeleteWriteRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteWriteRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
func (_e *ArgoDB_Expecter) DeleteWriteRepositoryCredentials(ctx any, name any) *ArgoDB_DeleteWriteRepositoryCredentials_Call {
|
|
return &ArgoDB_DeleteWriteRepositoryCredentials_Call{Call: _e.mock.On("DeleteWriteRepositoryCredentials", ctx, name)}
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteWriteRepositoryCredentials_Call) Run(run func(ctx context.Context, name string)) *ArgoDB_DeleteWriteRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteWriteRepositoryCredentials_Call) Return(err error) *ArgoDB_DeleteWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_DeleteWriteRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context, name string) error) *ArgoDB_DeleteWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAllHelmRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) GetAllHelmRepositoryCredentials(ctx context.Context) ([]*v1alpha1.RepoCreds, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAllHelmRepositoryCredentials")
|
|
}
|
|
|
|
var r0 []*v1alpha1.RepoCreds
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*v1alpha1.RepoCreds, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []*v1alpha1.RepoCreds); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.RepoCreds)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetAllHelmRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllHelmRepositoryCredentials'
|
|
type ArgoDB_GetAllHelmRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAllHelmRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) GetAllHelmRepositoryCredentials(ctx any) *ArgoDB_GetAllHelmRepositoryCredentials_Call {
|
|
return &ArgoDB_GetAllHelmRepositoryCredentials_Call{Call: _e.mock.On("GetAllHelmRepositoryCredentials", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetAllHelmRepositoryCredentials_Call) Run(run func(ctx context.Context)) *ArgoDB_GetAllHelmRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetAllHelmRepositoryCredentials_Call) Return(repoCredss []*v1alpha1.RepoCreds, err error) *ArgoDB_GetAllHelmRepositoryCredentials_Call {
|
|
_c.Call.Return(repoCredss, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetAllHelmRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context) ([]*v1alpha1.RepoCreds, error)) *ArgoDB_GetAllHelmRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAllOCIRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) GetAllOCIRepositoryCredentials(ctx context.Context) ([]*v1alpha1.RepoCreds, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAllOCIRepositoryCredentials")
|
|
}
|
|
|
|
var r0 []*v1alpha1.RepoCreds
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*v1alpha1.RepoCreds, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []*v1alpha1.RepoCreds); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.RepoCreds)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetAllOCIRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllOCIRepositoryCredentials'
|
|
type ArgoDB_GetAllOCIRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAllOCIRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) GetAllOCIRepositoryCredentials(ctx any) *ArgoDB_GetAllOCIRepositoryCredentials_Call {
|
|
return &ArgoDB_GetAllOCIRepositoryCredentials_Call{Call: _e.mock.On("GetAllOCIRepositoryCredentials", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetAllOCIRepositoryCredentials_Call) Run(run func(ctx context.Context)) *ArgoDB_GetAllOCIRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetAllOCIRepositoryCredentials_Call) Return(repoCredss []*v1alpha1.RepoCreds, err error) *ArgoDB_GetAllOCIRepositoryCredentials_Call {
|
|
_c.Call.Return(repoCredss, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetAllOCIRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context) ([]*v1alpha1.RepoCreds, error)) *ArgoDB_GetAllOCIRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetApplicationControllerReplicas provides a mock function for the type DB
|
|
func (_mock *DB) GetApplicationControllerReplicas() int {
|
|
ret := _mock.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetApplicationControllerReplicas")
|
|
}
|
|
|
|
var r0 int
|
|
if returnFunc, ok := ret.Get(0).(func() int); ok {
|
|
r0 = returnFunc()
|
|
} else {
|
|
r0 = ret.Get(0).(int)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// ArgoDB_GetApplicationControllerReplicas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApplicationControllerReplicas'
|
|
type ArgoDB_GetApplicationControllerReplicas_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetApplicationControllerReplicas is a helper method to define mock.On call
|
|
func (_e *ArgoDB_Expecter) GetApplicationControllerReplicas() *ArgoDB_GetApplicationControllerReplicas_Call {
|
|
return &ArgoDB_GetApplicationControllerReplicas_Call{Call: _e.mock.On("GetApplicationControllerReplicas")}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetApplicationControllerReplicas_Call) Run(run func()) *ArgoDB_GetApplicationControllerReplicas_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetApplicationControllerReplicas_Call) Return(n int) *ArgoDB_GetApplicationControllerReplicas_Call {
|
|
_c.Call.Return(n)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetApplicationControllerReplicas_Call) RunAndReturn(run func() int) *ArgoDB_GetApplicationControllerReplicas_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCluster provides a mock function for the type DB
|
|
func (_mock *DB) GetCluster(ctx context.Context, server string) (*v1alpha1.Cluster, error) {
|
|
ret := _mock.Called(ctx, server)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCluster")
|
|
}
|
|
|
|
var r0 *v1alpha1.Cluster
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*v1alpha1.Cluster, error)); ok {
|
|
return returnFunc(ctx, server)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) *v1alpha1.Cluster); ok {
|
|
r0 = returnFunc(ctx, server)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Cluster)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(ctx, server)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCluster'
|
|
type ArgoDB_GetCluster_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCluster is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - server string
|
|
func (_e *ArgoDB_Expecter) GetCluster(ctx any, server any) *ArgoDB_GetCluster_Call {
|
|
return &ArgoDB_GetCluster_Call{Call: _e.mock.On("GetCluster", ctx, server)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetCluster_Call) Run(run func(ctx context.Context, server string)) *ArgoDB_GetCluster_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetCluster_Call) Return(cluster *v1alpha1.Cluster, err error) *ArgoDB_GetCluster_Call {
|
|
_c.Call.Return(cluster, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetCluster_Call) RunAndReturn(run func(ctx context.Context, server string) (*v1alpha1.Cluster, error)) *ArgoDB_GetCluster_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetClusterServersByName provides a mock function for the type DB
|
|
func (_mock *DB) GetClusterServersByName(ctx context.Context, name string) ([]string, error) {
|
|
ret := _mock.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetClusterServersByName")
|
|
}
|
|
|
|
var r0 []string
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
|
|
return returnFunc(ctx, name)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
|
|
r0 = returnFunc(ctx, name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]string)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(ctx, name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetClusterServersByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterServersByName'
|
|
type ArgoDB_GetClusterServersByName_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetClusterServersByName is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
func (_e *ArgoDB_Expecter) GetClusterServersByName(ctx any, name any) *ArgoDB_GetClusterServersByName_Call {
|
|
return &ArgoDB_GetClusterServersByName_Call{Call: _e.mock.On("GetClusterServersByName", ctx, name)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetClusterServersByName_Call) Run(run func(ctx context.Context, name string)) *ArgoDB_GetClusterServersByName_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetClusterServersByName_Call) Return(strings []string, err error) *ArgoDB_GetClusterServersByName_Call {
|
|
_c.Call.Return(strings, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetClusterServersByName_Call) RunAndReturn(run func(ctx context.Context, name string) ([]string, error)) *ArgoDB_GetClusterServersByName_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetProjectClusters provides a mock function for the type DB
|
|
func (_mock *DB) GetProjectClusters(ctx context.Context, project string) ([]*v1alpha1.Cluster, error) {
|
|
ret := _mock.Called(ctx, project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetProjectClusters")
|
|
}
|
|
|
|
var r0 []*v1alpha1.Cluster
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*v1alpha1.Cluster, error)); ok {
|
|
return returnFunc(ctx, project)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*v1alpha1.Cluster); ok {
|
|
r0 = returnFunc(ctx, project)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.Cluster)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(ctx, project)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetProjectClusters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectClusters'
|
|
type ArgoDB_GetProjectClusters_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetProjectClusters is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) GetProjectClusters(ctx any, project any) *ArgoDB_GetProjectClusters_Call {
|
|
return &ArgoDB_GetProjectClusters_Call{Call: _e.mock.On("GetProjectClusters", ctx, project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectClusters_Call) Run(run func(ctx context.Context, project string)) *ArgoDB_GetProjectClusters_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectClusters_Call) Return(clusters []*v1alpha1.Cluster, err error) *ArgoDB_GetProjectClusters_Call {
|
|
_c.Call.Return(clusters, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectClusters_Call) RunAndReturn(run func(ctx context.Context, project string) ([]*v1alpha1.Cluster, error)) *ArgoDB_GetProjectClusters_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetProjectRepositories provides a mock function for the type DB
|
|
func (_mock *DB) GetProjectRepositories(project string) ([]*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetProjectRepositories")
|
|
}
|
|
|
|
var r0 []*v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(string) ([]*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(project)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(string) []*v1alpha1.Repository); ok {
|
|
r0 = returnFunc(project)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = returnFunc(project)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetProjectRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectRepositories'
|
|
type ArgoDB_GetProjectRepositories_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetProjectRepositories is a helper method to define mock.On call
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) GetProjectRepositories(project any) *ArgoDB_GetProjectRepositories_Call {
|
|
return &ArgoDB_GetProjectRepositories_Call{Call: _e.mock.On("GetProjectRepositories", project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectRepositories_Call) Run(run func(project string)) *ArgoDB_GetProjectRepositories_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 string
|
|
if args[0] != nil {
|
|
arg0 = args[0].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectRepositories_Call) Return(repositorys []*v1alpha1.Repository, err error) *ArgoDB_GetProjectRepositories_Call {
|
|
_c.Call.Return(repositorys, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectRepositories_Call) RunAndReturn(run func(project string) ([]*v1alpha1.Repository, error)) *ArgoDB_GetProjectRepositories_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetProjectWriteRepositories provides a mock function for the type DB
|
|
func (_mock *DB) GetProjectWriteRepositories(project string) ([]*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetProjectWriteRepositories")
|
|
}
|
|
|
|
var r0 []*v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(string) ([]*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(project)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(string) []*v1alpha1.Repository); ok {
|
|
r0 = returnFunc(project)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = returnFunc(project)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetProjectWriteRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectWriteRepositories'
|
|
type ArgoDB_GetProjectWriteRepositories_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetProjectWriteRepositories is a helper method to define mock.On call
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) GetProjectWriteRepositories(project any) *ArgoDB_GetProjectWriteRepositories_Call {
|
|
return &ArgoDB_GetProjectWriteRepositories_Call{Call: _e.mock.On("GetProjectWriteRepositories", project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectWriteRepositories_Call) Run(run func(project string)) *ArgoDB_GetProjectWriteRepositories_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 string
|
|
if args[0] != nil {
|
|
arg0 = args[0].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectWriteRepositories_Call) Return(repositorys []*v1alpha1.Repository, err error) *ArgoDB_GetProjectWriteRepositories_Call {
|
|
_c.Call.Return(repositorys, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetProjectWriteRepositories_Call) RunAndReturn(run func(project string) ([]*v1alpha1.Repository, error)) *ArgoDB_GetProjectWriteRepositories_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRepository provides a mock function for the type DB
|
|
func (_mock *DB) GetRepository(ctx context.Context, url string, project string) (*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx, url, project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepository")
|
|
}
|
|
|
|
var r0 *v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx, url, project)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx, url, project)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = returnFunc(ctx, url, project)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepository'
|
|
type ArgoDB_GetRepository_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRepository is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - url string
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) GetRepository(ctx any, url any, project any) *ArgoDB_GetRepository_Call {
|
|
return &ArgoDB_GetRepository_Call{Call: _e.mock.On("GetRepository", ctx, url, project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetRepository_Call) Run(run func(ctx context.Context, url string, project string)) *ArgoDB_GetRepository_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetRepository_Call) Return(repository *v1alpha1.Repository, err error) *ArgoDB_GetRepository_Call {
|
|
_c.Call.Return(repository, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetRepository_Call) RunAndReturn(run func(ctx context.Context, url string, project string) (*v1alpha1.Repository, error)) *ArgoDB_GetRepository_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) GetRepositoryCredentials(ctx context.Context, name string) (*v1alpha1.RepoCreds, error) {
|
|
ret := _mock.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepositoryCredentials")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepoCreds
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*v1alpha1.RepoCreds, error)); ok {
|
|
return returnFunc(ctx, name)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) *v1alpha1.RepoCreds); ok {
|
|
r0 = returnFunc(ctx, name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepoCreds)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(ctx, name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepositoryCredentials'
|
|
type ArgoDB_GetRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
func (_e *ArgoDB_Expecter) GetRepositoryCredentials(ctx any, name any) *ArgoDB_GetRepositoryCredentials_Call {
|
|
return &ArgoDB_GetRepositoryCredentials_Call{Call: _e.mock.On("GetRepositoryCredentials", ctx, name)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetRepositoryCredentials_Call) Run(run func(ctx context.Context, name string)) *ArgoDB_GetRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetRepositoryCredentials_Call) Return(repoCreds *v1alpha1.RepoCreds, err error) *ArgoDB_GetRepositoryCredentials_Call {
|
|
_c.Call.Return(repoCreds, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context, name string) (*v1alpha1.RepoCreds, error)) *ArgoDB_GetRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetWriteRepository provides a mock function for the type DB
|
|
func (_mock *DB) GetWriteRepository(ctx context.Context, url string, project string) (*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx, url, project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetWriteRepository")
|
|
}
|
|
|
|
var r0 *v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx, url, project)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx, url, project)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = returnFunc(ctx, url, project)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetWriteRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWriteRepository'
|
|
type ArgoDB_GetWriteRepository_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetWriteRepository is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - url string
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) GetWriteRepository(ctx any, url any, project any) *ArgoDB_GetWriteRepository_Call {
|
|
return &ArgoDB_GetWriteRepository_Call{Call: _e.mock.On("GetWriteRepository", ctx, url, project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetWriteRepository_Call) Run(run func(ctx context.Context, url string, project string)) *ArgoDB_GetWriteRepository_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetWriteRepository_Call) Return(repository *v1alpha1.Repository, err error) *ArgoDB_GetWriteRepository_Call {
|
|
_c.Call.Return(repository, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetWriteRepository_Call) RunAndReturn(run func(ctx context.Context, url string, project string) (*v1alpha1.Repository, error)) *ArgoDB_GetWriteRepository_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetWriteRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) GetWriteRepositoryCredentials(ctx context.Context, name string) (*v1alpha1.RepoCreds, error) {
|
|
ret := _mock.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetWriteRepositoryCredentials")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepoCreds
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*v1alpha1.RepoCreds, error)); ok {
|
|
return returnFunc(ctx, name)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) *v1alpha1.RepoCreds); ok {
|
|
r0 = returnFunc(ctx, name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepoCreds)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(ctx, name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_GetWriteRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWriteRepositoryCredentials'
|
|
type ArgoDB_GetWriteRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetWriteRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
func (_e *ArgoDB_Expecter) GetWriteRepositoryCredentials(ctx any, name any) *ArgoDB_GetWriteRepositoryCredentials_Call {
|
|
return &ArgoDB_GetWriteRepositoryCredentials_Call{Call: _e.mock.On("GetWriteRepositoryCredentials", ctx, name)}
|
|
}
|
|
|
|
func (_c *ArgoDB_GetWriteRepositoryCredentials_Call) Run(run func(ctx context.Context, name string)) *ArgoDB_GetWriteRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetWriteRepositoryCredentials_Call) Return(repoCreds *v1alpha1.RepoCreds, err error) *ArgoDB_GetWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(repoCreds, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_GetWriteRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context, name string) (*v1alpha1.RepoCreds, error)) *ArgoDB_GetWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListClusters provides a mock function for the type DB
|
|
func (_mock *DB) ListClusters(ctx context.Context) (*v1alpha1.ClusterList, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListClusters")
|
|
}
|
|
|
|
var r0 *v1alpha1.ClusterList
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) (*v1alpha1.ClusterList, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) *v1alpha1.ClusterList); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.ClusterList)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListClusters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClusters'
|
|
type ArgoDB_ListClusters_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListClusters is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) ListClusters(ctx any) *ArgoDB_ListClusters_Call {
|
|
return &ArgoDB_ListClusters_Call{Call: _e.mock.On("ListClusters", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListClusters_Call) Run(run func(ctx context.Context)) *ArgoDB_ListClusters_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListClusters_Call) Return(clusterList *v1alpha1.ClusterList, err error) *ArgoDB_ListClusters_Call {
|
|
_c.Call.Return(clusterList, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListClusters_Call) RunAndReturn(run func(ctx context.Context) (*v1alpha1.ClusterList, error)) *ArgoDB_ListClusters_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListConfiguredGPGPublicKeys provides a mock function for the type DB
|
|
func (_mock *DB) ListConfiguredGPGPublicKeys(ctx context.Context) (map[string]*v1alpha1.GnuPGPublicKey, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListConfiguredGPGPublicKeys")
|
|
}
|
|
|
|
var r0 map[string]*v1alpha1.GnuPGPublicKey
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) (map[string]*v1alpha1.GnuPGPublicKey, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) map[string]*v1alpha1.GnuPGPublicKey); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[string]*v1alpha1.GnuPGPublicKey)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListConfiguredGPGPublicKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfiguredGPGPublicKeys'
|
|
type ArgoDB_ListConfiguredGPGPublicKeys_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListConfiguredGPGPublicKeys is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) ListConfiguredGPGPublicKeys(ctx any) *ArgoDB_ListConfiguredGPGPublicKeys_Call {
|
|
return &ArgoDB_ListConfiguredGPGPublicKeys_Call{Call: _e.mock.On("ListConfiguredGPGPublicKeys", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListConfiguredGPGPublicKeys_Call) Run(run func(ctx context.Context)) *ArgoDB_ListConfiguredGPGPublicKeys_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListConfiguredGPGPublicKeys_Call) Return(stringToGnuPGPublicKey map[string]*v1alpha1.GnuPGPublicKey, err error) *ArgoDB_ListConfiguredGPGPublicKeys_Call {
|
|
_c.Call.Return(stringToGnuPGPublicKey, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListConfiguredGPGPublicKeys_Call) RunAndReturn(run func(ctx context.Context) (map[string]*v1alpha1.GnuPGPublicKey, error)) *ArgoDB_ListConfiguredGPGPublicKeys_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListHelmRepositories provides a mock function for the type DB
|
|
func (_mock *DB) ListHelmRepositories(ctx context.Context) ([]*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListHelmRepositories")
|
|
}
|
|
|
|
var r0 []*v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []*v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListHelmRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListHelmRepositories'
|
|
type ArgoDB_ListHelmRepositories_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListHelmRepositories is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) ListHelmRepositories(ctx any) *ArgoDB_ListHelmRepositories_Call {
|
|
return &ArgoDB_ListHelmRepositories_Call{Call: _e.mock.On("ListHelmRepositories", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListHelmRepositories_Call) Run(run func(ctx context.Context)) *ArgoDB_ListHelmRepositories_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListHelmRepositories_Call) Return(repositorys []*v1alpha1.Repository, err error) *ArgoDB_ListHelmRepositories_Call {
|
|
_c.Call.Return(repositorys, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListHelmRepositories_Call) RunAndReturn(run func(ctx context.Context) ([]*v1alpha1.Repository, error)) *ArgoDB_ListHelmRepositories_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListOCIRepositories provides a mock function for the type DB
|
|
func (_mock *DB) ListOCIRepositories(ctx context.Context) ([]*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListOCIRepositories")
|
|
}
|
|
|
|
var r0 []*v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []*v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListOCIRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOCIRepositories'
|
|
type ArgoDB_ListOCIRepositories_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListOCIRepositories is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) ListOCIRepositories(ctx any) *ArgoDB_ListOCIRepositories_Call {
|
|
return &ArgoDB_ListOCIRepositories_Call{Call: _e.mock.On("ListOCIRepositories", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListOCIRepositories_Call) Run(run func(ctx context.Context)) *ArgoDB_ListOCIRepositories_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListOCIRepositories_Call) Return(repositorys []*v1alpha1.Repository, err error) *ArgoDB_ListOCIRepositories_Call {
|
|
_c.Call.Return(repositorys, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListOCIRepositories_Call) RunAndReturn(run func(ctx context.Context) ([]*v1alpha1.Repository, error)) *ArgoDB_ListOCIRepositories_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListRepoCertificates provides a mock function for the type DB
|
|
func (_mock *DB) ListRepoCertificates(ctx context.Context, selector *db.CertificateListSelector) (*v1alpha1.RepositoryCertificateList, error) {
|
|
ret := _mock.Called(ctx, selector)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListRepoCertificates")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepositoryCertificateList
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *db.CertificateListSelector) (*v1alpha1.RepositoryCertificateList, error)); ok {
|
|
return returnFunc(ctx, selector)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *db.CertificateListSelector) *v1alpha1.RepositoryCertificateList); ok {
|
|
r0 = returnFunc(ctx, selector)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepositoryCertificateList)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *db.CertificateListSelector) error); ok {
|
|
r1 = returnFunc(ctx, selector)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListRepoCertificates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepoCertificates'
|
|
type ArgoDB_ListRepoCertificates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListRepoCertificates is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - selector *db.CertificateListSelector
|
|
func (_e *ArgoDB_Expecter) ListRepoCertificates(ctx any, selector any) *ArgoDB_ListRepoCertificates_Call {
|
|
return &ArgoDB_ListRepoCertificates_Call{Call: _e.mock.On("ListRepoCertificates", ctx, selector)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepoCertificates_Call) Run(run func(ctx context.Context, selector *db.CertificateListSelector)) *ArgoDB_ListRepoCertificates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *db.CertificateListSelector
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*db.CertificateListSelector)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepoCertificates_Call) Return(repositoryCertificateList *v1alpha1.RepositoryCertificateList, err error) *ArgoDB_ListRepoCertificates_Call {
|
|
_c.Call.Return(repositoryCertificateList, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepoCertificates_Call) RunAndReturn(run func(ctx context.Context, selector *db.CertificateListSelector) (*v1alpha1.RepositoryCertificateList, error)) *ArgoDB_ListRepoCertificates_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListRepositories provides a mock function for the type DB
|
|
func (_mock *DB) ListRepositories(ctx context.Context) ([]*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListRepositories")
|
|
}
|
|
|
|
var r0 []*v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []*v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepositories'
|
|
type ArgoDB_ListRepositories_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListRepositories is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) ListRepositories(ctx any) *ArgoDB_ListRepositories_Call {
|
|
return &ArgoDB_ListRepositories_Call{Call: _e.mock.On("ListRepositories", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepositories_Call) Run(run func(ctx context.Context)) *ArgoDB_ListRepositories_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepositories_Call) Return(repositorys []*v1alpha1.Repository, err error) *ArgoDB_ListRepositories_Call {
|
|
_c.Call.Return(repositorys, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepositories_Call) RunAndReturn(run func(ctx context.Context) ([]*v1alpha1.Repository, error)) *ArgoDB_ListRepositories_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) ListRepositoryCredentials(ctx context.Context) ([]string, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListRepositoryCredentials")
|
|
}
|
|
|
|
var r0 []string
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]string)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepositoryCredentials'
|
|
type ArgoDB_ListRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) ListRepositoryCredentials(ctx any) *ArgoDB_ListRepositoryCredentials_Call {
|
|
return &ArgoDB_ListRepositoryCredentials_Call{Call: _e.mock.On("ListRepositoryCredentials", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepositoryCredentials_Call) Run(run func(ctx context.Context)) *ArgoDB_ListRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepositoryCredentials_Call) Return(strings []string, err error) *ArgoDB_ListRepositoryCredentials_Call {
|
|
_c.Call.Return(strings, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *ArgoDB_ListRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListWriteRepositories provides a mock function for the type DB
|
|
func (_mock *DB) ListWriteRepositories(ctx context.Context) ([]*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListWriteRepositories")
|
|
}
|
|
|
|
var r0 []*v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []*v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListWriteRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWriteRepositories'
|
|
type ArgoDB_ListWriteRepositories_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListWriteRepositories is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) ListWriteRepositories(ctx any) *ArgoDB_ListWriteRepositories_Call {
|
|
return &ArgoDB_ListWriteRepositories_Call{Call: _e.mock.On("ListWriteRepositories", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListWriteRepositories_Call) Run(run func(ctx context.Context)) *ArgoDB_ListWriteRepositories_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListWriteRepositories_Call) Return(repositorys []*v1alpha1.Repository, err error) *ArgoDB_ListWriteRepositories_Call {
|
|
_c.Call.Return(repositorys, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListWriteRepositories_Call) RunAndReturn(run func(ctx context.Context) ([]*v1alpha1.Repository, error)) *ArgoDB_ListWriteRepositories_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListWriteRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) ListWriteRepositoryCredentials(ctx context.Context) ([]string, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListWriteRepositoryCredentials")
|
|
}
|
|
|
|
var r0 []string
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]string)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_ListWriteRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWriteRepositoryCredentials'
|
|
type ArgoDB_ListWriteRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListWriteRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *ArgoDB_Expecter) ListWriteRepositoryCredentials(ctx any) *ArgoDB_ListWriteRepositoryCredentials_Call {
|
|
return &ArgoDB_ListWriteRepositoryCredentials_Call{Call: _e.mock.On("ListWriteRepositoryCredentials", ctx)}
|
|
}
|
|
|
|
func (_c *ArgoDB_ListWriteRepositoryCredentials_Call) Run(run func(ctx context.Context)) *ArgoDB_ListWriteRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListWriteRepositoryCredentials_Call) Return(strings []string, err error) *ArgoDB_ListWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(strings, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_ListWriteRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *ArgoDB_ListWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemoveRepoCertificates provides a mock function for the type DB
|
|
func (_mock *DB) RemoveRepoCertificates(ctx context.Context, selector *db.CertificateListSelector) (*v1alpha1.RepositoryCertificateList, error) {
|
|
ret := _mock.Called(ctx, selector)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RemoveRepoCertificates")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepositoryCertificateList
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *db.CertificateListSelector) (*v1alpha1.RepositoryCertificateList, error)); ok {
|
|
return returnFunc(ctx, selector)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *db.CertificateListSelector) *v1alpha1.RepositoryCertificateList); ok {
|
|
r0 = returnFunc(ctx, selector)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepositoryCertificateList)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *db.CertificateListSelector) error); ok {
|
|
r1 = returnFunc(ctx, selector)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_RemoveRepoCertificates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRepoCertificates'
|
|
type ArgoDB_RemoveRepoCertificates_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemoveRepoCertificates is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - selector *db.CertificateListSelector
|
|
func (_e *ArgoDB_Expecter) RemoveRepoCertificates(ctx any, selector any) *ArgoDB_RemoveRepoCertificates_Call {
|
|
return &ArgoDB_RemoveRepoCertificates_Call{Call: _e.mock.On("RemoveRepoCertificates", ctx, selector)}
|
|
}
|
|
|
|
func (_c *ArgoDB_RemoveRepoCertificates_Call) Run(run func(ctx context.Context, selector *db.CertificateListSelector)) *ArgoDB_RemoveRepoCertificates_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *db.CertificateListSelector
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*db.CertificateListSelector)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_RemoveRepoCertificates_Call) Return(repositoryCertificateList *v1alpha1.RepositoryCertificateList, err error) *ArgoDB_RemoveRepoCertificates_Call {
|
|
_c.Call.Return(repositoryCertificateList, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_RemoveRepoCertificates_Call) RunAndReturn(run func(ctx context.Context, selector *db.CertificateListSelector) (*v1alpha1.RepositoryCertificateList, error)) *ArgoDB_RemoveRepoCertificates_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RepositoryExists provides a mock function for the type DB
|
|
func (_mock *DB) RepositoryExists(ctx context.Context, repoURL string, project string) (bool, error) {
|
|
ret := _mock.Called(ctx, repoURL, project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepositoryExists")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok {
|
|
return returnFunc(ctx, repoURL, project)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) bool); ok {
|
|
r0 = returnFunc(ctx, repoURL, project)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = returnFunc(ctx, repoURL, project)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_RepositoryExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RepositoryExists'
|
|
type ArgoDB_RepositoryExists_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RepositoryExists is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - repoURL string
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) RepositoryExists(ctx any, repoURL any, project any) *ArgoDB_RepositoryExists_Call {
|
|
return &ArgoDB_RepositoryExists_Call{Call: _e.mock.On("RepositoryExists", ctx, repoURL, project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_RepositoryExists_Call) Run(run func(ctx context.Context, repoURL string, project string)) *ArgoDB_RepositoryExists_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_RepositoryExists_Call) Return(b bool, err error) *ArgoDB_RepositoryExists_Call {
|
|
_c.Call.Return(b, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_RepositoryExists_Call) RunAndReturn(run func(ctx context.Context, repoURL string, project string) (bool, error)) *ArgoDB_RepositoryExists_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateCluster provides a mock function for the type DB
|
|
func (_mock *DB) UpdateCluster(ctx context.Context, c *v1alpha1.Cluster) (*v1alpha1.Cluster, error) {
|
|
ret := _mock.Called(ctx, c)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateCluster")
|
|
}
|
|
|
|
var r0 *v1alpha1.Cluster
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Cluster) (*v1alpha1.Cluster, error)); ok {
|
|
return returnFunc(ctx, c)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Cluster) *v1alpha1.Cluster); ok {
|
|
r0 = returnFunc(ctx, c)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Cluster)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.Cluster) error); ok {
|
|
r1 = returnFunc(ctx, c)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_UpdateCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCluster'
|
|
type ArgoDB_UpdateCluster_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateCluster is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - c *v1alpha1.Cluster
|
|
func (_e *ArgoDB_Expecter) UpdateCluster(ctx any, c any) *ArgoDB_UpdateCluster_Call {
|
|
return &ArgoDB_UpdateCluster_Call{Call: _e.mock.On("UpdateCluster", ctx, c)}
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateCluster_Call) Run(run func(ctx context.Context, c *v1alpha1.Cluster)) *ArgoDB_UpdateCluster_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.Cluster
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.Cluster)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateCluster_Call) Return(cluster *v1alpha1.Cluster, err error) *ArgoDB_UpdateCluster_Call {
|
|
_c.Call.Return(cluster, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateCluster_Call) RunAndReturn(run func(ctx context.Context, c *v1alpha1.Cluster) (*v1alpha1.Cluster, error)) *ArgoDB_UpdateCluster_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateRepository provides a mock function for the type DB
|
|
func (_mock *DB) UpdateRepository(ctx context.Context, r *v1alpha1.Repository) (*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx, r)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateRepository")
|
|
}
|
|
|
|
var r0 *v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Repository) (*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx, r)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Repository) *v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx, r)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.Repository) error); ok {
|
|
r1 = returnFunc(ctx, r)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_UpdateRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRepository'
|
|
type ArgoDB_UpdateRepository_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateRepository is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - r *v1alpha1.Repository
|
|
func (_e *ArgoDB_Expecter) UpdateRepository(ctx any, r any) *ArgoDB_UpdateRepository_Call {
|
|
return &ArgoDB_UpdateRepository_Call{Call: _e.mock.On("UpdateRepository", ctx, r)}
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateRepository_Call) Run(run func(ctx context.Context, r *v1alpha1.Repository)) *ArgoDB_UpdateRepository_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.Repository
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.Repository)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateRepository_Call) Return(repository *v1alpha1.Repository, err error) *ArgoDB_UpdateRepository_Call {
|
|
_c.Call.Return(repository, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateRepository_Call) RunAndReturn(run func(ctx context.Context, r *v1alpha1.Repository) (*v1alpha1.Repository, error)) *ArgoDB_UpdateRepository_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) UpdateRepositoryCredentials(ctx context.Context, r *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error) {
|
|
ret := _mock.Called(ctx, r)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateRepositoryCredentials")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepoCreds
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error)); ok {
|
|
return returnFunc(ctx, r)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepoCreds) *v1alpha1.RepoCreds); ok {
|
|
r0 = returnFunc(ctx, r)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepoCreds)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.RepoCreds) error); ok {
|
|
r1 = returnFunc(ctx, r)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_UpdateRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRepositoryCredentials'
|
|
type ArgoDB_UpdateRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - r *v1alpha1.RepoCreds
|
|
func (_e *ArgoDB_Expecter) UpdateRepositoryCredentials(ctx any, r any) *ArgoDB_UpdateRepositoryCredentials_Call {
|
|
return &ArgoDB_UpdateRepositoryCredentials_Call{Call: _e.mock.On("UpdateRepositoryCredentials", ctx, r)}
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateRepositoryCredentials_Call) Run(run func(ctx context.Context, r *v1alpha1.RepoCreds)) *ArgoDB_UpdateRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.RepoCreds
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.RepoCreds)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateRepositoryCredentials_Call) Return(repoCreds *v1alpha1.RepoCreds, err error) *ArgoDB_UpdateRepositoryCredentials_Call {
|
|
_c.Call.Return(repoCreds, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context, r *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error)) *ArgoDB_UpdateRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateWriteRepository provides a mock function for the type DB
|
|
func (_mock *DB) UpdateWriteRepository(ctx context.Context, r *v1alpha1.Repository) (*v1alpha1.Repository, error) {
|
|
ret := _mock.Called(ctx, r)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateWriteRepository")
|
|
}
|
|
|
|
var r0 *v1alpha1.Repository
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Repository) (*v1alpha1.Repository, error)); ok {
|
|
return returnFunc(ctx, r)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.Repository) *v1alpha1.Repository); ok {
|
|
r0 = returnFunc(ctx, r)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.Repository)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.Repository) error); ok {
|
|
r1 = returnFunc(ctx, r)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_UpdateWriteRepository_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWriteRepository'
|
|
type ArgoDB_UpdateWriteRepository_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateWriteRepository is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - r *v1alpha1.Repository
|
|
func (_e *ArgoDB_Expecter) UpdateWriteRepository(ctx any, r any) *ArgoDB_UpdateWriteRepository_Call {
|
|
return &ArgoDB_UpdateWriteRepository_Call{Call: _e.mock.On("UpdateWriteRepository", ctx, r)}
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateWriteRepository_Call) Run(run func(ctx context.Context, r *v1alpha1.Repository)) *ArgoDB_UpdateWriteRepository_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.Repository
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.Repository)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateWriteRepository_Call) Return(repository *v1alpha1.Repository, err error) *ArgoDB_UpdateWriteRepository_Call {
|
|
_c.Call.Return(repository, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateWriteRepository_Call) RunAndReturn(run func(ctx context.Context, r *v1alpha1.Repository) (*v1alpha1.Repository, error)) *ArgoDB_UpdateWriteRepository_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateWriteRepositoryCredentials provides a mock function for the type DB
|
|
func (_mock *DB) UpdateWriteRepositoryCredentials(ctx context.Context, r *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error) {
|
|
ret := _mock.Called(ctx, r)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateWriteRepositoryCredentials")
|
|
}
|
|
|
|
var r0 *v1alpha1.RepoCreds
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error)); ok {
|
|
return returnFunc(ctx, r)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *v1alpha1.RepoCreds) *v1alpha1.RepoCreds); ok {
|
|
r0 = returnFunc(ctx, r)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1alpha1.RepoCreds)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *v1alpha1.RepoCreds) error); ok {
|
|
r1 = returnFunc(ctx, r)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_UpdateWriteRepositoryCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWriteRepositoryCredentials'
|
|
type ArgoDB_UpdateWriteRepositoryCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateWriteRepositoryCredentials is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - r *v1alpha1.RepoCreds
|
|
func (_e *ArgoDB_Expecter) UpdateWriteRepositoryCredentials(ctx any, r any) *ArgoDB_UpdateWriteRepositoryCredentials_Call {
|
|
return &ArgoDB_UpdateWriteRepositoryCredentials_Call{Call: _e.mock.On("UpdateWriteRepositoryCredentials", ctx, r)}
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateWriteRepositoryCredentials_Call) Run(run func(ctx context.Context, r *v1alpha1.RepoCreds)) *ArgoDB_UpdateWriteRepositoryCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *v1alpha1.RepoCreds
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*v1alpha1.RepoCreds)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateWriteRepositoryCredentials_Call) Return(repoCreds *v1alpha1.RepoCreds, err error) *ArgoDB_UpdateWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(repoCreds, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_UpdateWriteRepositoryCredentials_Call) RunAndReturn(run func(ctx context.Context, r *v1alpha1.RepoCreds) (*v1alpha1.RepoCreds, error)) *ArgoDB_UpdateWriteRepositoryCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// WatchClusters provides a mock function for the type DB
|
|
func (_mock *DB) WatchClusters(ctx context.Context, handleAddEvent func(cluster *v1alpha1.Cluster), handleModEvent func(oldCluster *v1alpha1.Cluster, newCluster *v1alpha1.Cluster), handleDeleteEvent func(clusterServer string)) error {
|
|
ret := _mock.Called(ctx, handleAddEvent, handleModEvent, handleDeleteEvent)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WatchClusters")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, func(cluster *v1alpha1.Cluster), func(oldCluster *v1alpha1.Cluster, newCluster *v1alpha1.Cluster), func(clusterServer string)) error); ok {
|
|
r0 = returnFunc(ctx, handleAddEvent, handleModEvent, handleDeleteEvent)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// ArgoDB_WatchClusters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchClusters'
|
|
type ArgoDB_WatchClusters_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// WatchClusters is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - handleAddEvent func(cluster *v1alpha1.Cluster)
|
|
// - handleModEvent func(oldCluster *v1alpha1.Cluster, newCluster *v1alpha1.Cluster)
|
|
// - handleDeleteEvent func(clusterServer string)
|
|
func (_e *ArgoDB_Expecter) WatchClusters(ctx any, handleAddEvent any, handleModEvent any, handleDeleteEvent any) *ArgoDB_WatchClusters_Call {
|
|
return &ArgoDB_WatchClusters_Call{Call: _e.mock.On("WatchClusters", ctx, handleAddEvent, handleModEvent, handleDeleteEvent)}
|
|
}
|
|
|
|
func (_c *ArgoDB_WatchClusters_Call) Run(run func(ctx context.Context, handleAddEvent func(cluster *v1alpha1.Cluster), handleModEvent func(oldCluster *v1alpha1.Cluster, newCluster *v1alpha1.Cluster), handleDeleteEvent func(clusterServer string))) *ArgoDB_WatchClusters_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 func(cluster *v1alpha1.Cluster)
|
|
if args[1] != nil {
|
|
arg1 = args[1].(func(cluster *v1alpha1.Cluster))
|
|
}
|
|
var arg2 func(oldCluster *v1alpha1.Cluster, newCluster *v1alpha1.Cluster)
|
|
if args[2] != nil {
|
|
arg2 = args[2].(func(oldCluster *v1alpha1.Cluster, newCluster *v1alpha1.Cluster))
|
|
}
|
|
var arg3 func(clusterServer string)
|
|
if args[3] != nil {
|
|
arg3 = args[3].(func(clusterServer string))
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_WatchClusters_Call) Return(err error) *ArgoDB_WatchClusters_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_WatchClusters_Call) RunAndReturn(run func(ctx context.Context, handleAddEvent func(cluster *v1alpha1.Cluster), handleModEvent func(oldCluster *v1alpha1.Cluster, newCluster *v1alpha1.Cluster), handleDeleteEvent func(clusterServer string)) error) *ArgoDB_WatchClusters_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// WriteRepositoryExists provides a mock function for the type DB
|
|
func (_mock *DB) WriteRepositoryExists(ctx context.Context, repoURL string, project string) (bool, error) {
|
|
ret := _mock.Called(ctx, repoURL, project)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WriteRepositoryExists")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok {
|
|
return returnFunc(ctx, repoURL, project)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) bool); ok {
|
|
r0 = returnFunc(ctx, repoURL, project)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = returnFunc(ctx, repoURL, project)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// ArgoDB_WriteRepositoryExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteRepositoryExists'
|
|
type ArgoDB_WriteRepositoryExists_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// WriteRepositoryExists is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - repoURL string
|
|
// - project string
|
|
func (_e *ArgoDB_Expecter) WriteRepositoryExists(ctx any, repoURL any, project any) *ArgoDB_WriteRepositoryExists_Call {
|
|
return &ArgoDB_WriteRepositoryExists_Call{Call: _e.mock.On("WriteRepositoryExists", ctx, repoURL, project)}
|
|
}
|
|
|
|
func (_c *ArgoDB_WriteRepositoryExists_Call) Run(run func(ctx context.Context, repoURL string, project string)) *ArgoDB_WriteRepositoryExists_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_WriteRepositoryExists_Call) Return(b bool, err error) *ArgoDB_WriteRepositoryExists_Call {
|
|
_c.Call.Return(b, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *ArgoDB_WriteRepositoryExists_Call) RunAndReturn(run func(ctx context.Context, repoURL string, project string) (bool, error)) *ArgoDB_WriteRepositoryExists_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|