mirror of
https://github.com/woodpecker-ci/woodpecker.git
synced 2024-06-13 02:49:37 +00:00
1852 lines
42 KiB
Go
1852 lines
42 KiB
Go
// Code generated by mockery. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
http "net/http"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
woodpecker "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker"
|
|
)
|
|
|
|
// Client is an autogenerated mock type for the Client type
|
|
type Client struct {
|
|
mock.Mock
|
|
}
|
|
|
|
// Agent provides a mock function with given fields: _a0
|
|
func (_m *Client) Agent(_a0 int64) (*woodpecker.Agent, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Agent")
|
|
}
|
|
|
|
var r0 *woodpecker.Agent
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Agent, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *woodpecker.Agent); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Agent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AgentCreate provides a mock function with given fields: _a0
|
|
func (_m *Client) AgentCreate(_a0 *woodpecker.Agent) (*woodpecker.Agent, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentCreate")
|
|
}
|
|
|
|
var r0 *woodpecker.Agent
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.Agent) (*woodpecker.Agent, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.Agent) *woodpecker.Agent); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Agent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*woodpecker.Agent) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AgentDelete provides a mock function with given fields: _a0
|
|
func (_m *Client) AgentDelete(_a0 int64) 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(int64) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// AgentList provides a mock function with given fields:
|
|
func (_m *Client) AgentList() ([]*woodpecker.Agent, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Agent
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*woodpecker.Agent, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*woodpecker.Agent); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Agent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AgentTasksList provides a mock function with given fields: _a0
|
|
func (_m *Client) AgentTasksList(_a0 int64) ([]*woodpecker.Task, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentTasksList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Task
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Task, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Task); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Task)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AgentUpdate provides a mock function with given fields: _a0
|
|
func (_m *Client) AgentUpdate(_a0 *woodpecker.Agent) (*woodpecker.Agent, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AgentUpdate")
|
|
}
|
|
|
|
var r0 *woodpecker.Agent
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.Agent) (*woodpecker.Agent, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.Agent) *woodpecker.Agent); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Agent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*woodpecker.Agent) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CronCreate provides a mock function with given fields: repoID, cron
|
|
func (_m *Client) CronCreate(repoID int64, cron *woodpecker.Cron) (*woodpecker.Cron, error) {
|
|
ret := _m.Called(repoID, cron)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronCreate")
|
|
}
|
|
|
|
var r0 *woodpecker.Cron
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Cron) (*woodpecker.Cron, error)); ok {
|
|
return rf(repoID, cron)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Cron) *woodpecker.Cron); ok {
|
|
r0 = rf(repoID, cron)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Cron)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.Cron) error); ok {
|
|
r1 = rf(repoID, cron)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CronDelete provides a mock function with given fields: repoID, cronID
|
|
func (_m *Client) CronDelete(repoID int64, cronID int64) error {
|
|
ret := _m.Called(repoID, cronID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) error); ok {
|
|
r0 = rf(repoID, cronID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// CronGet provides a mock function with given fields: repoID, cronID
|
|
func (_m *Client) CronGet(repoID int64, cronID int64) (*woodpecker.Cron, error) {
|
|
ret := _m.Called(repoID, cronID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronGet")
|
|
}
|
|
|
|
var r0 *woodpecker.Cron
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Cron, error)); ok {
|
|
return rf(repoID, cronID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, int64) *woodpecker.Cron); ok {
|
|
r0 = rf(repoID, cronID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Cron)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
|
|
r1 = rf(repoID, cronID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CronList provides a mock function with given fields: repoID
|
|
func (_m *Client) CronList(repoID int64) ([]*woodpecker.Cron, error) {
|
|
ret := _m.Called(repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Cron
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Cron, error)); ok {
|
|
return rf(repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Cron); ok {
|
|
r0 = rf(repoID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Cron)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CronUpdate provides a mock function with given fields: repoID, cron
|
|
func (_m *Client) CronUpdate(repoID int64, cron *woodpecker.Cron) (*woodpecker.Cron, error) {
|
|
ret := _m.Called(repoID, cron)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CronUpdate")
|
|
}
|
|
|
|
var r0 *woodpecker.Cron
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Cron) (*woodpecker.Cron, error)); ok {
|
|
return rf(repoID, cron)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Cron) *woodpecker.Cron); ok {
|
|
r0 = rf(repoID, cron)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Cron)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.Cron) error); ok {
|
|
r1 = rf(repoID, cron)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Deploy provides a mock function with given fields: repoID, pipeline, env, params
|
|
func (_m *Client) Deploy(repoID int64, pipeline int64, env string, params map[string]string) (*woodpecker.Pipeline, error) {
|
|
ret := _m.Called(repoID, pipeline, env, params)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Deploy")
|
|
}
|
|
|
|
var r0 *woodpecker.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64, string, map[string]string) (*woodpecker.Pipeline, error)); ok {
|
|
return rf(repoID, pipeline, env, params)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, int64, string, map[string]string) *woodpecker.Pipeline); ok {
|
|
r0 = rf(repoID, pipeline, env, params)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, int64, string, map[string]string) error); ok {
|
|
r1 = rf(repoID, pipeline, env, params)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GlobalSecret provides a mock function with given fields: secret
|
|
func (_m *Client) GlobalSecret(secret string) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalSecret")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*woodpecker.Secret, error)); ok {
|
|
return rf(secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *woodpecker.Secret); ok {
|
|
r0 = rf(secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GlobalSecretCreate provides a mock function with given fields: secret
|
|
func (_m *Client) GlobalSecretCreate(secret *woodpecker.Secret) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalSecretCreate")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.Secret) (*woodpecker.Secret, error)); ok {
|
|
return rf(secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.Secret) *woodpecker.Secret); ok {
|
|
r0 = rf(secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*woodpecker.Secret) error); ok {
|
|
r1 = rf(secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GlobalSecretDelete provides a mock function with given fields: secret
|
|
func (_m *Client) GlobalSecretDelete(secret string) error {
|
|
ret := _m.Called(secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalSecretDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(secret)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// GlobalSecretList provides a mock function with given fields:
|
|
func (_m *Client) GlobalSecretList() ([]*woodpecker.Secret, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalSecretList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*woodpecker.Secret, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*woodpecker.Secret); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GlobalSecretUpdate provides a mock function with given fields: secret
|
|
func (_m *Client) GlobalSecretUpdate(secret *woodpecker.Secret) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GlobalSecretUpdate")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.Secret) (*woodpecker.Secret, error)); ok {
|
|
return rf(secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.Secret) *woodpecker.Secret); ok {
|
|
r0 = rf(secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*woodpecker.Secret) error); ok {
|
|
r1 = rf(secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// LogLevel provides a mock function with given fields:
|
|
func (_m *Client) LogLevel() (*woodpecker.LogLevel, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LogLevel")
|
|
}
|
|
|
|
var r0 *woodpecker.LogLevel
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (*woodpecker.LogLevel, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() *woodpecker.LogLevel); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.LogLevel)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// LogsPurge provides a mock function with given fields: repoID, pipeline
|
|
func (_m *Client) LogsPurge(repoID int64, pipeline int64) error {
|
|
ret := _m.Called(repoID, pipeline)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for LogsPurge")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) error); ok {
|
|
r0 = rf(repoID, pipeline)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Org provides a mock function with given fields: orgID
|
|
func (_m *Client) Org(orgID int64) (*woodpecker.Org, error) {
|
|
ret := _m.Called(orgID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Org")
|
|
}
|
|
|
|
var r0 *woodpecker.Org
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Org, error)); ok {
|
|
return rf(orgID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *woodpecker.Org); ok {
|
|
r0 = rf(orgID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Org)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(orgID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgLookup provides a mock function with given fields: orgName
|
|
func (_m *Client) OrgLookup(orgName string) (*woodpecker.Org, error) {
|
|
ret := _m.Called(orgName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgLookup")
|
|
}
|
|
|
|
var r0 *woodpecker.Org
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*woodpecker.Org, error)); ok {
|
|
return rf(orgName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *woodpecker.Org); ok {
|
|
r0 = rf(orgName)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Org)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(orgName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgSecret provides a mock function with given fields: orgID, secret
|
|
func (_m *Client) OrgSecret(orgID int64, secret string) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(orgID, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgSecret")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) (*woodpecker.Secret, error)); ok {
|
|
return rf(orgID, secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, string) *woodpecker.Secret); ok {
|
|
r0 = rf(orgID, secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, string) error); ok {
|
|
r1 = rf(orgID, secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgSecretCreate provides a mock function with given fields: orgID, secret
|
|
func (_m *Client) OrgSecretCreate(orgID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(orgID, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgSecretCreate")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) (*woodpecker.Secret, error)); ok {
|
|
return rf(orgID, secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) *woodpecker.Secret); ok {
|
|
r0 = rf(orgID, secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.Secret) error); ok {
|
|
r1 = rf(orgID, secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgSecretDelete provides a mock function with given fields: orgID, secret
|
|
func (_m *Client) OrgSecretDelete(orgID int64, secret string) error {
|
|
ret := _m.Called(orgID, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgSecretDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) error); ok {
|
|
r0 = rf(orgID, secret)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// OrgSecretList provides a mock function with given fields: orgID
|
|
func (_m *Client) OrgSecretList(orgID int64) ([]*woodpecker.Secret, error) {
|
|
ret := _m.Called(orgID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgSecretList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Secret, error)); ok {
|
|
return rf(orgID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Secret); ok {
|
|
r0 = rf(orgID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(orgID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// OrgSecretUpdate provides a mock function with given fields: orgID, secret
|
|
func (_m *Client) OrgSecretUpdate(orgID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(orgID, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OrgSecretUpdate")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) (*woodpecker.Secret, error)); ok {
|
|
return rf(orgID, secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) *woodpecker.Secret); ok {
|
|
r0 = rf(orgID, secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.Secret) error); ok {
|
|
r1 = rf(orgID, secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Pipeline provides a mock function with given fields: repoID, pipeline
|
|
func (_m *Client) Pipeline(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) {
|
|
ret := _m.Called(repoID, pipeline)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Pipeline")
|
|
}
|
|
|
|
var r0 *woodpecker.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok {
|
|
return rf(repoID, pipeline)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok {
|
|
r0 = rf(repoID, pipeline)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
|
|
r1 = rf(repoID, pipeline)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PipelineApprove provides a mock function with given fields: repoID, pipeline
|
|
func (_m *Client) PipelineApprove(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) {
|
|
ret := _m.Called(repoID, pipeline)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineApprove")
|
|
}
|
|
|
|
var r0 *woodpecker.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok {
|
|
return rf(repoID, pipeline)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok {
|
|
r0 = rf(repoID, pipeline)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
|
|
r1 = rf(repoID, pipeline)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PipelineCreate provides a mock function with given fields: repoID, opts
|
|
func (_m *Client) PipelineCreate(repoID int64, opts *woodpecker.PipelineOptions) (*woodpecker.Pipeline, error) {
|
|
ret := _m.Called(repoID, opts)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineCreate")
|
|
}
|
|
|
|
var r0 *woodpecker.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.PipelineOptions) (*woodpecker.Pipeline, error)); ok {
|
|
return rf(repoID, opts)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.PipelineOptions) *woodpecker.Pipeline); ok {
|
|
r0 = rf(repoID, opts)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.PipelineOptions) error); ok {
|
|
r1 = rf(repoID, opts)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PipelineDecline provides a mock function with given fields: repoID, pipeline
|
|
func (_m *Client) PipelineDecline(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) {
|
|
ret := _m.Called(repoID, pipeline)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineDecline")
|
|
}
|
|
|
|
var r0 *woodpecker.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok {
|
|
return rf(repoID, pipeline)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok {
|
|
r0 = rf(repoID, pipeline)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
|
|
r1 = rf(repoID, pipeline)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PipelineKill provides a mock function with given fields: repoID, pipeline
|
|
func (_m *Client) PipelineKill(repoID int64, pipeline int64) error {
|
|
ret := _m.Called(repoID, pipeline)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineKill")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) error); ok {
|
|
r0 = rf(repoID, pipeline)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PipelineLast provides a mock function with given fields: repoID, branch
|
|
func (_m *Client) PipelineLast(repoID int64, branch string) (*woodpecker.Pipeline, error) {
|
|
ret := _m.Called(repoID, branch)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineLast")
|
|
}
|
|
|
|
var r0 *woodpecker.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) (*woodpecker.Pipeline, error)); ok {
|
|
return rf(repoID, branch)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, string) *woodpecker.Pipeline); ok {
|
|
r0 = rf(repoID, branch)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, string) error); ok {
|
|
r1 = rf(repoID, branch)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PipelineList provides a mock function with given fields: repoID
|
|
func (_m *Client) PipelineList(repoID int64) ([]*woodpecker.Pipeline, error) {
|
|
ret := _m.Called(repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Pipeline, error)); ok {
|
|
return rf(repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Pipeline); ok {
|
|
r0 = rf(repoID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PipelineQueue provides a mock function with given fields:
|
|
func (_m *Client) PipelineQueue() ([]*woodpecker.Feed, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineQueue")
|
|
}
|
|
|
|
var r0 []*woodpecker.Feed
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*woodpecker.Feed, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*woodpecker.Feed); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Feed)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PipelineStart provides a mock function with given fields: repoID, num, params
|
|
func (_m *Client) PipelineStart(repoID int64, num int64, params map[string]string) (*woodpecker.Pipeline, error) {
|
|
ret := _m.Called(repoID, num, params)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineStart")
|
|
}
|
|
|
|
var r0 *woodpecker.Pipeline
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64, map[string]string) (*woodpecker.Pipeline, error)); ok {
|
|
return rf(repoID, num, params)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, int64, map[string]string) *woodpecker.Pipeline); ok {
|
|
r0 = rf(repoID, num, params)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Pipeline)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, int64, map[string]string) error); ok {
|
|
r1 = rf(repoID, num, params)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PipelineStop provides a mock function with given fields: repoID, pipeline
|
|
func (_m *Client) PipelineStop(repoID int64, pipeline int64) error {
|
|
ret := _m.Called(repoID, pipeline)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PipelineStop")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64) error); ok {
|
|
r0 = rf(repoID, pipeline)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// QueueInfo provides a mock function with given fields:
|
|
func (_m *Client) QueueInfo() (*woodpecker.Info, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for QueueInfo")
|
|
}
|
|
|
|
var r0 *woodpecker.Info
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (*woodpecker.Info, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() *woodpecker.Info); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Info)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Registry provides a mock function with given fields: repoID, hostname
|
|
func (_m *Client) Registry(repoID int64, hostname string) (*woodpecker.Registry, error) {
|
|
ret := _m.Called(repoID, hostname)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Registry")
|
|
}
|
|
|
|
var r0 *woodpecker.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) (*woodpecker.Registry, error)); ok {
|
|
return rf(repoID, hostname)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, string) *woodpecker.Registry); ok {
|
|
r0 = rf(repoID, hostname)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, string) error); ok {
|
|
r1 = rf(repoID, hostname)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RegistryCreate provides a mock function with given fields: repoID, registry
|
|
func (_m *Client) RegistryCreate(repoID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error) {
|
|
ret := _m.Called(repoID, registry)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryCreate")
|
|
}
|
|
|
|
var r0 *woodpecker.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Registry) (*woodpecker.Registry, error)); ok {
|
|
return rf(repoID, registry)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Registry) *woodpecker.Registry); ok {
|
|
r0 = rf(repoID, registry)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.Registry) error); ok {
|
|
r1 = rf(repoID, registry)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RegistryDelete provides a mock function with given fields: repoID, hostname
|
|
func (_m *Client) RegistryDelete(repoID int64, hostname string) error {
|
|
ret := _m.Called(repoID, hostname)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) error); ok {
|
|
r0 = rf(repoID, hostname)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RegistryList provides a mock function with given fields: repoID
|
|
func (_m *Client) RegistryList(repoID int64) ([]*woodpecker.Registry, error) {
|
|
ret := _m.Called(repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Registry, error)); ok {
|
|
return rf(repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Registry); ok {
|
|
r0 = rf(repoID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RegistryUpdate provides a mock function with given fields: repoID, registry
|
|
func (_m *Client) RegistryUpdate(repoID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error) {
|
|
ret := _m.Called(repoID, registry)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegistryUpdate")
|
|
}
|
|
|
|
var r0 *woodpecker.Registry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Registry) (*woodpecker.Registry, error)); ok {
|
|
return rf(repoID, registry)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Registry) *woodpecker.Registry); ok {
|
|
r0 = rf(repoID, registry)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Registry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.Registry) error); ok {
|
|
r1 = rf(repoID, registry)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Repo provides a mock function with given fields: repoID
|
|
func (_m *Client) Repo(repoID int64) (*woodpecker.Repo, error) {
|
|
ret := _m.Called(repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Repo")
|
|
}
|
|
|
|
var r0 *woodpecker.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Repo, error)); ok {
|
|
return rf(repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *woodpecker.Repo); ok {
|
|
r0 = rf(repoID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoChown provides a mock function with given fields: repoID
|
|
func (_m *Client) RepoChown(repoID int64) (*woodpecker.Repo, error) {
|
|
ret := _m.Called(repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoChown")
|
|
}
|
|
|
|
var r0 *woodpecker.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Repo, error)); ok {
|
|
return rf(repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *woodpecker.Repo); ok {
|
|
r0 = rf(repoID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoDel provides a mock function with given fields: repoID
|
|
func (_m *Client) RepoDel(repoID int64) error {
|
|
ret := _m.Called(repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoDel")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64) error); ok {
|
|
r0 = rf(repoID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RepoList provides a mock function with given fields:
|
|
func (_m *Client) RepoList() ([]*woodpecker.Repo, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*woodpecker.Repo, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*woodpecker.Repo); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoListOpts provides a mock function with given fields: _a0
|
|
func (_m *Client) RepoListOpts(_a0 bool) ([]*woodpecker.Repo, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoListOpts")
|
|
}
|
|
|
|
var r0 []*woodpecker.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(bool) ([]*woodpecker.Repo, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(bool) []*woodpecker.Repo); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(bool) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoLookup provides a mock function with given fields: repoFullName
|
|
func (_m *Client) RepoLookup(repoFullName string) (*woodpecker.Repo, error) {
|
|
ret := _m.Called(repoFullName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoLookup")
|
|
}
|
|
|
|
var r0 *woodpecker.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*woodpecker.Repo, error)); ok {
|
|
return rf(repoFullName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *woodpecker.Repo); ok {
|
|
r0 = rf(repoFullName)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(repoFullName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoMove provides a mock function with given fields: repoID, dst
|
|
func (_m *Client) RepoMove(repoID int64, dst string) error {
|
|
ret := _m.Called(repoID, dst)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoMove")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) error); ok {
|
|
r0 = rf(repoID, dst)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// RepoPatch provides a mock function with given fields: repoID, repo
|
|
func (_m *Client) RepoPatch(repoID int64, repo *woodpecker.RepoPatch) (*woodpecker.Repo, error) {
|
|
ret := _m.Called(repoID, repo)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoPatch")
|
|
}
|
|
|
|
var r0 *woodpecker.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.RepoPatch) (*woodpecker.Repo, error)); ok {
|
|
return rf(repoID, repo)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.RepoPatch) *woodpecker.Repo); ok {
|
|
r0 = rf(repoID, repo)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.RepoPatch) error); ok {
|
|
r1 = rf(repoID, repo)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoPost provides a mock function with given fields: forgeRemoteID
|
|
func (_m *Client) RepoPost(forgeRemoteID int64) (*woodpecker.Repo, error) {
|
|
ret := _m.Called(forgeRemoteID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoPost")
|
|
}
|
|
|
|
var r0 *woodpecker.Repo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Repo, error)); ok {
|
|
return rf(forgeRemoteID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) *woodpecker.Repo); ok {
|
|
r0 = rf(forgeRemoteID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Repo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(forgeRemoteID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RepoRepair provides a mock function with given fields: repoID
|
|
func (_m *Client) RepoRepair(repoID int64) error {
|
|
ret := _m.Called(repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoRepair")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64) error); ok {
|
|
r0 = rf(repoID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Secret provides a mock function with given fields: repoID, secret
|
|
func (_m *Client) Secret(repoID int64, secret string) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(repoID, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Secret")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) (*woodpecker.Secret, error)); ok {
|
|
return rf(repoID, secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, string) *woodpecker.Secret); ok {
|
|
r0 = rf(repoID, secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, string) error); ok {
|
|
r1 = rf(repoID, secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SecretCreate provides a mock function with given fields: repoID, secret
|
|
func (_m *Client) SecretCreate(repoID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(repoID, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretCreate")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) (*woodpecker.Secret, error)); ok {
|
|
return rf(repoID, secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) *woodpecker.Secret); ok {
|
|
r0 = rf(repoID, secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.Secret) error); ok {
|
|
r1 = rf(repoID, secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SecretDelete provides a mock function with given fields: repoID, secret
|
|
func (_m *Client) SecretDelete(repoID int64, secret string) error {
|
|
ret := _m.Called(repoID, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretDelete")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, string) error); ok {
|
|
r0 = rf(repoID, secret)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// SecretList provides a mock function with given fields: repoID
|
|
func (_m *Client) SecretList(repoID int64) ([]*woodpecker.Secret, error) {
|
|
ret := _m.Called(repoID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretList")
|
|
}
|
|
|
|
var r0 []*woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Secret, error)); ok {
|
|
return rf(repoID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Secret); ok {
|
|
r0 = rf(repoID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64) error); ok {
|
|
r1 = rf(repoID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SecretUpdate provides a mock function with given fields: repoID, secret
|
|
func (_m *Client) SecretUpdate(repoID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) {
|
|
ret := _m.Called(repoID, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SecretUpdate")
|
|
}
|
|
|
|
var r0 *woodpecker.Secret
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) (*woodpecker.Secret, error)); ok {
|
|
return rf(repoID, secret)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) *woodpecker.Secret); ok {
|
|
r0 = rf(repoID, secret)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.Secret)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, *woodpecker.Secret) error); ok {
|
|
r1 = rf(repoID, secret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Self provides a mock function with given fields:
|
|
func (_m *Client) Self() (*woodpecker.User, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Self")
|
|
}
|
|
|
|
var r0 *woodpecker.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (*woodpecker.User, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() *woodpecker.User); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SetAddress provides a mock function with given fields: _a0
|
|
func (_m *Client) SetAddress(_a0 string) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// SetClient provides a mock function with given fields: _a0
|
|
func (_m *Client) SetClient(_a0 *http.Client) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// SetLogLevel provides a mock function with given fields: logLevel
|
|
func (_m *Client) SetLogLevel(logLevel *woodpecker.LogLevel) (*woodpecker.LogLevel, error) {
|
|
ret := _m.Called(logLevel)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetLogLevel")
|
|
}
|
|
|
|
var r0 *woodpecker.LogLevel
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.LogLevel) (*woodpecker.LogLevel, error)); ok {
|
|
return rf(logLevel)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.LogLevel) *woodpecker.LogLevel); ok {
|
|
r0 = rf(logLevel)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.LogLevel)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*woodpecker.LogLevel) error); ok {
|
|
r1 = rf(logLevel)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// StepLogEntries provides a mock function with given fields: repoID, pipeline, stepID
|
|
func (_m *Client) StepLogEntries(repoID int64, pipeline int64, stepID int64) ([]*woodpecker.LogEntry, error) {
|
|
ret := _m.Called(repoID, pipeline, stepID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepLogEntries")
|
|
}
|
|
|
|
var r0 []*woodpecker.LogEntry
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64, int64) ([]*woodpecker.LogEntry, error)); ok {
|
|
return rf(repoID, pipeline, stepID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(int64, int64, int64) []*woodpecker.LogEntry); ok {
|
|
r0 = rf(repoID, pipeline, stepID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.LogEntry)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(int64, int64, int64) error); ok {
|
|
r1 = rf(repoID, pipeline, stepID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// StepLogsPurge provides a mock function with given fields: repoID, pipelineNumber, stepID
|
|
func (_m *Client) StepLogsPurge(repoID int64, pipelineNumber int64, stepID int64) error {
|
|
ret := _m.Called(repoID, pipelineNumber, stepID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StepLogsPurge")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(int64, int64, int64) error); ok {
|
|
r0 = rf(repoID, pipelineNumber, stepID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// User provides a mock function with given fields: _a0
|
|
func (_m *Client) User(_a0 string) (*woodpecker.User, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for User")
|
|
}
|
|
|
|
var r0 *woodpecker.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*woodpecker.User, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *woodpecker.User); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UserDel provides a mock function with given fields: _a0
|
|
func (_m *Client) UserDel(_a0 string) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UserDel")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// UserList provides a mock function with given fields:
|
|
func (_m *Client) UserList() ([]*woodpecker.User, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UserList")
|
|
}
|
|
|
|
var r0 []*woodpecker.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]*woodpecker.User, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []*woodpecker.User); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*woodpecker.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UserPatch provides a mock function with given fields: _a0
|
|
func (_m *Client) UserPatch(_a0 *woodpecker.User) (*woodpecker.User, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UserPatch")
|
|
}
|
|
|
|
var r0 *woodpecker.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.User) (*woodpecker.User, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.User) *woodpecker.User); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*woodpecker.User) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UserPost provides a mock function with given fields: _a0
|
|
func (_m *Client) UserPost(_a0 *woodpecker.User) (*woodpecker.User, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UserPost")
|
|
}
|
|
|
|
var r0 *woodpecker.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.User) (*woodpecker.User, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*woodpecker.User) *woodpecker.User); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*woodpecker.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*woodpecker.User) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// NewClient creates a new instance of Client. 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 NewClient(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *Client {
|
|
mock := &Client{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|