mirror of
https://github.com/woodpecker-ci/woodpecker.git
synced 2024-12-05 08:06:30 +00:00
2721 lines
58 KiB
Go
2721 lines
58 KiB
Go
// Code generated by mockery. DO NOT EDIT.
|
|
|
|
//go:build test
|
|
// +build test
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
model "go.woodpecker-ci.org/woodpecker/v2/server/model"
|
|
)
|
|
|
|
// Store is an autogenerated mock type for the Store type
|
|
type Store struct {
|
|
mock.Mock
|
|
}
|
|
|
|
// AgentCreate provides a mock function with given fields: _a0
|
|
func (_m *Store) AgentCreate(_a0 *model.Agent) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentCreate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// AgentDelete provides a mock function with given fields: _a0
|
|
func (_m *Store) AgentDelete(_a0 *model.Agent) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// AgentFind provides a mock function with given fields: _a0
|
|
func (_m *Store) AgentFind(_a0 int64) (*model.Agent, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentFind")
|
|
}
|
|
|
|
var r0 *model.Agent
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*model.Agent, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *model.Agent); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Agent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AgentFindByToken provides a mock function with given fields: _a0
|
|
func (_m *Store) AgentFindByToken(_a0 string) (*model.Agent, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentFindByToken")
|
|
}
|
|
|
|
var r0 *model.Agent
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*model.Agent, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *model.Agent); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Agent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AgentList provides a mock function with given fields: p
|
|
func (_m *Store) AgentList(p *model.ListOptions) ([]*model.Agent, error) {
|
|
ret := _m.Called(p)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentList")
|
|
}
|
|
|
|
var r0 []*model.Agent
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Agent, error)); ok {
|
|
return rf(p)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Agent); ok {
|
|
r0 = rf(p)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Agent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
|
|
r1 = rf(p)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AgentUpdate provides a mock function with given fields: _a0
|
|
func (_m *Store) AgentUpdate(_a0 *model.Agent) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentUpdate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Agent) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Close provides a mock function with given fields:
|
|
func (_m *Store) Close() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Close")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ConfigPersist provides a mock function with given fields: _a0
|
|
func (_m *Store) ConfigPersist(_a0 *model.Config) (*model.Config, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ConfigPersist")
|
|
}
|
|
|
|
var r0 *model.Config
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Config) (*model.Config, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Config) *model.Config); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Config)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Config) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ConfigsForPipeline provides a mock function with given fields: pipelineID
|
|
func (_m *Store) ConfigsForPipeline(pipelineID int64) ([]*model.Config, error) {
|
|
ret := _m.Called(pipelineID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ConfigsForPipeline")
|
|
}
|
|
|
|
var r0 []*model.Config
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) ([]*model.Config, error)); ok {
|
|
return rf(pipelineID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) []*model.Config); ok {
|
|
r0 = rf(pipelineID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Config)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(pipelineID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreatePipeline provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) CreatePipeline(_a0 *model.Pipeline, _a1 ...*model.Step) error {
|
|
_va := make([]interface{}, len(_a1))
|
|
for _i := range _a1 {
|
|
_va[_i] = _a1[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreatePipeline")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline, ...*model.Step) error); ok {
|
|
r0 = rf(_a0, _a1...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// CreateRedirection provides a mock function with given fields: redirection
|
|
func (_m *Store) CreateRedirection(redirection *model.Redirection) error {
|
|
ret := _m.Called(redirection)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRedirection")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Redirection) error); ok {
|
|
r0 = rf(redirection)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// CreateRepo provides a mock function with given fields: _a0
|
|
func (_m *Store) CreateRepo(_a0 *model.Repo) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRepo")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// CreateUser provides a mock function with given fields: _a0
|
|
func (_m *Store) CreateUser(_a0 *model.User) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateUser")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.User) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// CronCreate provides a mock function with given fields: _a0
|
|
func (_m *Store) CronCreate(_a0 *model.Cron) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronCreate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Cron) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// CronDelete provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) CronDelete(_a0 *model.Repo, _a1 int64) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, int64) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// CronFind provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) CronFind(_a0 *model.Repo, _a1 int64) (*model.Cron, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronFind")
|
|
}
|
|
|
|
var r0 *model.Cron
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, int64) (*model.Cron, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, int64) *model.Cron); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Cron)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, int64) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CronGetLock provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) CronGetLock(_a0 *model.Cron, _a1 int64) (bool, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronGetLock")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Cron, int64) (bool, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Cron, int64) bool); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Cron, int64) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CronList provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) CronList(_a0 *model.Repo, _a1 *model.ListOptions) ([]*model.Cron, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronList")
|
|
}
|
|
|
|
var r0 []*model.Cron
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) ([]*model.Cron, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions) []*model.Cron); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Cron)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CronListNextExecute provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) CronListNextExecute(_a0 int64, _a1 int64) ([]*model.Cron, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronListNextExecute")
|
|
}
|
|
|
|
var r0 []*model.Cron
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) ([]*model.Cron, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, int64) []*model.Cron); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Cron)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CronUpdate provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) CronUpdate(_a0 *model.Repo, _a1 *model.Cron) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronUpdate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, *model.Cron) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeletePipeline provides a mock function with given fields: _a0
|
|
func (_m *Store) DeletePipeline(_a0 *model.Pipeline) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeletePipeline")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteRepo provides a mock function with given fields: _a0
|
|
func (_m *Store) DeleteRepo(_a0 *model.Repo) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteRepo")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// DeleteUser provides a mock function with given fields: _a0
|
|
func (_m *Store) DeleteUser(_a0 *model.User) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteUser")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.User) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ForgeCreate provides a mock function with given fields: _a0
|
|
func (_m *Store) ForgeCreate(_a0 *model.Forge) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ForgeCreate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ForgeDelete provides a mock function with given fields: _a0
|
|
func (_m *Store) ForgeDelete(_a0 *model.Forge) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ForgeDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ForgeGet provides a mock function with given fields: _a0
|
|
func (_m *Store) ForgeGet(_a0 int64) (*model.Forge, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ForgeGet")
|
|
}
|
|
|
|
var r0 *model.Forge
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*model.Forge, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *model.Forge); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Forge)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ForgeList provides a mock function with given fields: p
|
|
func (_m *Store) ForgeList(p *model.ListOptions) ([]*model.Forge, error) {
|
|
ret := _m.Called(p)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ForgeList")
|
|
}
|
|
|
|
var r0 []*model.Forge
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Forge, error)); ok {
|
|
return rf(p)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Forge); ok {
|
|
r0 = rf(p)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Forge)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
|
|
r1 = rf(p)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ForgeUpdate provides a mock function with given fields: _a0
|
|
func (_m *Store) ForgeUpdate(_a0 *model.Forge) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ForgeUpdate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Forge) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// GetActivePipelineList provides a mock function with given fields: repo
|
|
func (_m *Store) GetActivePipelineList(repo *model.Repo) ([]*model.Pipeline, error) {
|
|
ret := _m.Called(repo)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetActivePipelineList")
|
|
}
|
|
|
|
var r0 []*model.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo) ([]*model.Pipeline, error)); ok {
|
|
return rf(repo)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo) []*model.Pipeline); ok {
|
|
r0 = rf(repo)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo) error); ok {
|
|
r1 = rf(repo)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPipeline provides a mock function with given fields: _a0
|
|
func (_m *Store) GetPipeline(_a0 int64) (*model.Pipeline, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPipeline")
|
|
}
|
|
|
|
var r0 *model.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*model.Pipeline, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *model.Pipeline); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPipelineCount provides a mock function with given fields:
|
|
func (_m *Store) GetPipelineCount() (int64, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPipelineCount")
|
|
}
|
|
|
|
var r0 int64
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (int64, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPipelineLast provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) GetPipelineLast(_a0 *model.Repo, _a1 string) (*model.Pipeline, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPipelineLast")
|
|
}
|
|
|
|
var r0 *model.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Pipeline, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Pipeline); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPipelineLastBefore provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *Store) GetPipelineLastBefore(_a0 *model.Repo, _a1 string, _a2 int64) (*model.Pipeline, error) {
|
|
ret := _m.Called(_a0, _a1, _a2)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPipelineLastBefore")
|
|
}
|
|
|
|
var r0 *model.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, string, int64) (*model.Pipeline, error)); ok {
|
|
return rf(_a0, _a1, _a2)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, string, int64) *model.Pipeline); ok {
|
|
r0 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, string, int64) error); ok {
|
|
r1 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPipelineList provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *Store) GetPipelineList(_a0 *model.Repo, _a1 *model.ListOptions, _a2 *model.PipelineFilter) ([]*model.Pipeline, error) {
|
|
ret := _m.Called(_a0, _a1, _a2)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPipelineList")
|
|
}
|
|
|
|
var r0 []*model.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) ([]*model.Pipeline, error)); ok {
|
|
return rf(_a0, _a1, _a2)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) []*model.Pipeline); ok {
|
|
r0 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, *model.ListOptions, *model.PipelineFilter) error); ok {
|
|
r1 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPipelineNumber provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) GetPipelineNumber(_a0 *model.Repo, _a1 int64) (*model.Pipeline, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPipelineNumber")
|
|
}
|
|
|
|
var r0 *model.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, int64) (*model.Pipeline, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, int64) *model.Pipeline); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, int64) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPipelineQueue provides a mock function with given fields:
|
|
func (_m *Store) GetPipelineQueue() ([]*model.Feed, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPipelineQueue")
|
|
}
|
|
|
|
var r0 []*model.Feed
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*model.Feed, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*model.Feed); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Feed)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetRepo provides a mock function with given fields: _a0
|
|
func (_m *Store) GetRepo(_a0 int64) (*model.Repo, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepo")
|
|
}
|
|
|
|
var r0 *model.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*model.Repo, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *model.Repo); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetRepoCount provides a mock function with given fields:
|
|
func (_m *Store) GetRepoCount() (int64, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepoCount")
|
|
}
|
|
|
|
var r0 int64
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (int64, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetRepoForgeID provides a mock function with given fields: _a0
|
|
func (_m *Store) GetRepoForgeID(_a0 model.ForgeRemoteID) (*model.Repo, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepoForgeID")
|
|
}
|
|
|
|
var r0 *model.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(model.ForgeRemoteID) (*model.Repo, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(model.ForgeRemoteID) *model.Repo); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(model.ForgeRemoteID) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetRepoName provides a mock function with given fields: _a0
|
|
func (_m *Store) GetRepoName(_a0 string) (*model.Repo, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepoName")
|
|
}
|
|
|
|
var r0 *model.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*model.Repo, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *model.Repo); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetRepoNameFallback provides a mock function with given fields: remoteID, fullName
|
|
func (_m *Store) GetRepoNameFallback(remoteID model.ForgeRemoteID, fullName string) (*model.Repo, error) {
|
|
ret := _m.Called(remoteID, fullName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRepoNameFallback")
|
|
}
|
|
|
|
var r0 *model.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) (*model.Repo, error)); ok {
|
|
return rf(remoteID, fullName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) *model.Repo); ok {
|
|
r0 = rf(remoteID, fullName)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(model.ForgeRemoteID, string) error); ok {
|
|
r1 = rf(remoteID, fullName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetUser provides a mock function with given fields: _a0
|
|
func (_m *Store) GetUser(_a0 int64) (*model.User, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUser")
|
|
}
|
|
|
|
var r0 *model.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*model.User, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *model.User); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetUserCount provides a mock function with given fields:
|
|
func (_m *Store) GetUserCount() (int64, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserCount")
|
|
}
|
|
|
|
var r0 int64
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (int64, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetUserList provides a mock function with given fields: p
|
|
func (_m *Store) GetUserList(p *model.ListOptions) ([]*model.User, error) {
|
|
ret := _m.Called(p)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserList")
|
|
}
|
|
|
|
var r0 []*model.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.User, error)); ok {
|
|
return rf(p)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.User); ok {
|
|
r0 = rf(p)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
|
|
r1 = rf(p)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetUserLogin provides a mock function with given fields: _a0
|
|
func (_m *Store) GetUserLogin(_a0 string) (*model.User, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserLogin")
|
|
}
|
|
|
|
var r0 *model.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*model.User, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *model.User); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetUserRemoteID provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) GetUserRemoteID(_a0 model.ForgeRemoteID, _a1 string) (*model.User, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserRemoteID")
|
|
}
|
|
|
|
var r0 *model.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) (*model.User, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(model.ForgeRemoteID, string) *model.User); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(model.ForgeRemoteID, string) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GlobalRegistryFind provides a mock function with given fields: _a0
|
|
func (_m *Store) GlobalRegistryFind(_a0 string) (*model.Registry, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalRegistryFind")
|
|
}
|
|
|
|
var r0 *model.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*model.Registry, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *model.Registry); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GlobalRegistryList provides a mock function with given fields: _a0
|
|
func (_m *Store) GlobalRegistryList(_a0 *model.ListOptions) ([]*model.Registry, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalRegistryList")
|
|
}
|
|
|
|
var r0 []*model.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Registry, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Registry); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GlobalSecretFind provides a mock function with given fields: _a0
|
|
func (_m *Store) GlobalSecretFind(_a0 string) (*model.Secret, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalSecretFind")
|
|
}
|
|
|
|
var r0 *model.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*model.Secret, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *model.Secret); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GlobalSecretList provides a mock function with given fields: _a0
|
|
func (_m *Store) GlobalSecretList(_a0 *model.ListOptions) ([]*model.Secret, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalSecretList")
|
|
}
|
|
|
|
var r0 []*model.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Secret, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Secret); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// HasRedirectionForRepo provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) HasRedirectionForRepo(_a0 int64, _a1 string) (bool, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for HasRedirectionForRepo")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) (bool, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, string) bool); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, string) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// LogAppend provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) LogAppend(_a0 *model.Step, _a1 []*model.LogEntry) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LogAppend")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Step, []*model.LogEntry) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// LogDelete provides a mock function with given fields: _a0
|
|
func (_m *Store) LogDelete(_a0 *model.Step) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LogDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Step) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// LogFind provides a mock function with given fields: _a0
|
|
func (_m *Store) LogFind(_a0 *model.Step) ([]*model.LogEntry, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LogFind")
|
|
}
|
|
|
|
var r0 []*model.LogEntry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Step) ([]*model.LogEntry, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Step) []*model.LogEntry); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.LogEntry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Step) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Migrate provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) Migrate(_a0 context.Context, _a1 bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Migrate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// OrgCreate provides a mock function with given fields: _a0
|
|
func (_m *Store) OrgCreate(_a0 *model.Org) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgCreate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Org) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// OrgDelete provides a mock function with given fields: _a0
|
|
func (_m *Store) OrgDelete(_a0 int64) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// OrgFindByName provides a mock function with given fields: _a0
|
|
func (_m *Store) OrgFindByName(_a0 string) (*model.Org, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgFindByName")
|
|
}
|
|
|
|
var r0 *model.Org
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*model.Org, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *model.Org); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Org)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgGet provides a mock function with given fields: _a0
|
|
func (_m *Store) OrgGet(_a0 int64) (*model.Org, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgGet")
|
|
}
|
|
|
|
var r0 *model.Org
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*model.Org, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *model.Org); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Org)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgList provides a mock function with given fields: _a0
|
|
func (_m *Store) OrgList(_a0 *model.ListOptions) ([]*model.Org, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgList")
|
|
}
|
|
|
|
var r0 []*model.Org
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) ([]*model.Org, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.ListOptions) []*model.Org); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Org)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.ListOptions) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgRegistryFind provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) OrgRegistryFind(_a0 int64, _a1 string) (*model.Registry, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgRegistryFind")
|
|
}
|
|
|
|
var r0 *model.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) (*model.Registry, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, string) *model.Registry); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, string) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgRegistryList provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) OrgRegistryList(_a0 int64, _a1 *model.ListOptions) ([]*model.Registry, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgRegistryList")
|
|
}
|
|
|
|
var r0 []*model.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Registry, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Registry); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgRepoList provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) OrgRepoList(_a0 *model.Org, _a1 *model.ListOptions) ([]*model.Repo, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgRepoList")
|
|
}
|
|
|
|
var r0 []*model.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Org, *model.ListOptions) ([]*model.Repo, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Org, *model.ListOptions) []*model.Repo); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Org, *model.ListOptions) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgSecretFind provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) OrgSecretFind(_a0 int64, _a1 string) (*model.Secret, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgSecretFind")
|
|
}
|
|
|
|
var r0 *model.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) (*model.Secret, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, string) *model.Secret); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, string) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgSecretList provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) OrgSecretList(_a0 int64, _a1 *model.ListOptions) ([]*model.Secret, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgSecretList")
|
|
}
|
|
|
|
var r0 []*model.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) ([]*model.Secret, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *model.ListOptions) []*model.Secret); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *model.ListOptions) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgUpdate provides a mock function with given fields: _a0
|
|
func (_m *Store) OrgUpdate(_a0 *model.Org) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgUpdate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Org) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PermFind provides a mock function with given fields: user, repo
|
|
func (_m *Store) PermFind(user *model.User, repo *model.Repo) (*model.Perm, error) {
|
|
ret := _m.Called(user, repo)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PermFind")
|
|
}
|
|
|
|
var r0 *model.Perm
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.User, *model.Repo) (*model.Perm, error)); ok {
|
|
return rf(user, repo)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.User, *model.Repo) *model.Perm); ok {
|
|
r0 = rf(user, repo)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Perm)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.User, *model.Repo) error); ok {
|
|
r1 = rf(user, repo)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PermUpsert provides a mock function with given fields: perm
|
|
func (_m *Store) PermUpsert(perm *model.Perm) error {
|
|
ret := _m.Called(perm)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PermUpsert")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Perm) error); ok {
|
|
r0 = rf(perm)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Ping provides a mock function with given fields:
|
|
func (_m *Store) Ping() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Ping")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PipelineConfigCreate provides a mock function with given fields: _a0
|
|
func (_m *Store) PipelineConfigCreate(_a0 *model.PipelineConfig) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineConfigCreate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.PipelineConfig) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RegistryCreate provides a mock function with given fields: _a0
|
|
func (_m *Store) RegistryCreate(_a0 *model.Registry) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryCreate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RegistryDelete provides a mock function with given fields: _a0
|
|
func (_m *Store) RegistryDelete(_a0 *model.Registry) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RegistryFind provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) RegistryFind(_a0 *model.Repo, _a1 string) (*model.Registry, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryFind")
|
|
}
|
|
|
|
var r0 *model.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Registry, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Registry); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RegistryList provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *Store) RegistryList(_a0 *model.Repo, _a1 bool, _a2 *model.ListOptions) ([]*model.Registry, error) {
|
|
ret := _m.Called(_a0, _a1, _a2)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryList")
|
|
}
|
|
|
|
var r0 []*model.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) ([]*model.Registry, error)); ok {
|
|
return rf(_a0, _a1, _a2)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) []*model.Registry); ok {
|
|
r0 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, bool, *model.ListOptions) error); ok {
|
|
r1 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RegistryListAll provides a mock function with given fields:
|
|
func (_m *Store) RegistryListAll() ([]*model.Registry, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryListAll")
|
|
}
|
|
|
|
var r0 []*model.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*model.Registry, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*model.Registry); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RegistryUpdate provides a mock function with given fields: _a0
|
|
func (_m *Store) RegistryUpdate(_a0 *model.Registry) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryUpdate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Registry) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RepoList provides a mock function with given fields: user, owned, active
|
|
func (_m *Store) RepoList(user *model.User, owned bool, active bool) ([]*model.Repo, error) {
|
|
ret := _m.Called(user, owned, active)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoList")
|
|
}
|
|
|
|
var r0 []*model.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.User, bool, bool) ([]*model.Repo, error)); ok {
|
|
return rf(user, owned, active)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.User, bool, bool) []*model.Repo); ok {
|
|
r0 = rf(user, owned, active)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.User, bool, bool) error); ok {
|
|
r1 = rf(user, owned, active)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoListAll provides a mock function with given fields: active, p
|
|
func (_m *Store) RepoListAll(active bool, p *model.ListOptions) ([]*model.Repo, error) {
|
|
ret := _m.Called(active, p)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoListAll")
|
|
}
|
|
|
|
var r0 []*model.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(bool, *model.ListOptions) ([]*model.Repo, error)); ok {
|
|
return rf(active, p)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(bool, *model.ListOptions) []*model.Repo); ok {
|
|
r0 = rf(active, p)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(bool, *model.ListOptions) error); ok {
|
|
r1 = rf(active, p)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoListLatest provides a mock function with given fields: _a0
|
|
func (_m *Store) RepoListLatest(_a0 *model.User) ([]*model.Feed, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoListLatest")
|
|
}
|
|
|
|
var r0 []*model.Feed
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.User) ([]*model.Feed, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.User) []*model.Feed); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Feed)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.User) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SecretCreate provides a mock function with given fields: _a0
|
|
func (_m *Store) SecretCreate(_a0 *model.Secret) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretCreate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Secret) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// SecretDelete provides a mock function with given fields: _a0
|
|
func (_m *Store) SecretDelete(_a0 *model.Secret) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Secret) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// SecretFind provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) SecretFind(_a0 *model.Repo, _a1 string) (*model.Secret, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretFind")
|
|
}
|
|
|
|
var r0 *model.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, string) (*model.Secret, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, string) *model.Secret); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, string) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SecretList provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *Store) SecretList(_a0 *model.Repo, _a1 bool, _a2 *model.ListOptions) ([]*model.Secret, error) {
|
|
ret := _m.Called(_a0, _a1, _a2)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretList")
|
|
}
|
|
|
|
var r0 []*model.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) ([]*model.Secret, error)); ok {
|
|
return rf(_a0, _a1, _a2)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Repo, bool, *model.ListOptions) []*model.Secret); ok {
|
|
r0 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Repo, bool, *model.ListOptions) error); ok {
|
|
r1 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SecretListAll provides a mock function with given fields:
|
|
func (_m *Store) SecretListAll() ([]*model.Secret, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretListAll")
|
|
}
|
|
|
|
var r0 []*model.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*model.Secret, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*model.Secret); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SecretUpdate provides a mock function with given fields: _a0
|
|
func (_m *Store) SecretUpdate(_a0 *model.Secret) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretUpdate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Secret) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ServerConfigDelete provides a mock function with given fields: _a0
|
|
func (_m *Store) ServerConfigDelete(_a0 string) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ServerConfigDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ServerConfigGet provides a mock function with given fields: _a0
|
|
func (_m *Store) ServerConfigGet(_a0 string) (string, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ServerConfigGet")
|
|
}
|
|
|
|
var r0 string
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (string, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) string); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ServerConfigSet provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) ServerConfigSet(_a0 string, _a1 string) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ServerConfigSet")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, string) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// StepByUUID provides a mock function with given fields: _a0
|
|
func (_m *Store) StepByUUID(_a0 string) (*model.Step, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepByUUID")
|
|
}
|
|
|
|
var r0 *model.Step
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*model.Step, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *model.Step); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Step)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// StepChild provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *Store) StepChild(_a0 *model.Pipeline, _a1 int, _a2 string) (*model.Step, error) {
|
|
ret := _m.Called(_a0, _a1, _a2)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepChild")
|
|
}
|
|
|
|
var r0 *model.Step
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline, int, string) (*model.Step, error)); ok {
|
|
return rf(_a0, _a1, _a2)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline, int, string) *model.Step); ok {
|
|
r0 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Step)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Pipeline, int, string) error); ok {
|
|
r1 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// StepFind provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) StepFind(_a0 *model.Pipeline, _a1 int) (*model.Step, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepFind")
|
|
}
|
|
|
|
var r0 *model.Step
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline, int) (*model.Step, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline, int) *model.Step); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Step)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Pipeline, int) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// StepList provides a mock function with given fields: _a0
|
|
func (_m *Store) StepList(_a0 *model.Pipeline) ([]*model.Step, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepList")
|
|
}
|
|
|
|
var r0 []*model.Step
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline) ([]*model.Step, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline) []*model.Step); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Step)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Pipeline) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// StepListFromWorkflowFind provides a mock function with given fields: _a0
|
|
func (_m *Store) StepListFromWorkflowFind(_a0 *model.Workflow) ([]*model.Step, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepListFromWorkflowFind")
|
|
}
|
|
|
|
var r0 []*model.Step
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Workflow) ([]*model.Step, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Workflow) []*model.Step); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Step)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Workflow) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// StepLoad provides a mock function with given fields: _a0
|
|
func (_m *Store) StepLoad(_a0 int64) (*model.Step, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepLoad")
|
|
}
|
|
|
|
var r0 *model.Step
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*model.Step, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *model.Step); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Step)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// StepUpdate provides a mock function with given fields: _a0
|
|
func (_m *Store) StepUpdate(_a0 *model.Step) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepUpdate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Step) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// TaskDelete provides a mock function with given fields: _a0
|
|
func (_m *Store) TaskDelete(_a0 string) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TaskDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// TaskInsert provides a mock function with given fields: _a0
|
|
func (_m *Store) TaskInsert(_a0 *model.Task) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TaskInsert")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Task) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// TaskList provides a mock function with given fields:
|
|
func (_m *Store) TaskList() ([]*model.Task, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TaskList")
|
|
}
|
|
|
|
var r0 []*model.Task
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*model.Task, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*model.Task); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Task)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdatePipeline provides a mock function with given fields: _a0
|
|
func (_m *Store) UpdatePipeline(_a0 *model.Pipeline) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdatePipeline")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// UpdateRepo provides a mock function with given fields: _a0
|
|
func (_m *Store) UpdateRepo(_a0 *model.Repo) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateRepo")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Repo) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// UpdateUser provides a mock function with given fields: _a0
|
|
func (_m *Store) UpdateUser(_a0 *model.User) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateUser")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.User) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// UserFeed provides a mock function with given fields: _a0
|
|
func (_m *Store) UserFeed(_a0 *model.User) ([]*model.Feed, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UserFeed")
|
|
}
|
|
|
|
var r0 []*model.Feed
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.User) ([]*model.Feed, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.User) []*model.Feed); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Feed)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.User) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// WorkflowGetTree provides a mock function with given fields: _a0
|
|
func (_m *Store) WorkflowGetTree(_a0 *model.Pipeline) ([]*model.Workflow, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WorkflowGetTree")
|
|
}
|
|
|
|
var r0 []*model.Workflow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline) ([]*model.Workflow, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline) []*model.Workflow); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*model.Workflow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*model.Pipeline) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// WorkflowLoad provides a mock function with given fields: _a0
|
|
func (_m *Store) WorkflowLoad(_a0 int64) (*model.Workflow, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WorkflowLoad")
|
|
}
|
|
|
|
var r0 *model.Workflow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*model.Workflow, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *model.Workflow); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*model.Workflow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// WorkflowUpdate provides a mock function with given fields: _a0
|
|
func (_m *Store) WorkflowUpdate(_a0 *model.Workflow) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WorkflowUpdate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Workflow) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WorkflowsCreate provides a mock function with given fields: _a0
|
|
func (_m *Store) WorkflowsCreate(_a0 []*model.Workflow) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WorkflowsCreate")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func([]*model.Workflow) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WorkflowsReplace provides a mock function with given fields: _a0, _a1
|
|
func (_m *Store) WorkflowsReplace(_a0 *model.Pipeline, _a1 []*model.Workflow) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WorkflowsReplace")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*model.Pipeline, []*model.Workflow) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// NewStore creates a new instance of Store. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewStore(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *Store {
|
|
mock := &Store{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|