2138 lines
76 KiB
Go
2138 lines
76 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: github.com/drone/drone/core (interfaces: NetrcService,Renewer,HookParser,UserService,RepositoryService,CommitService,StatusService,HookService,FileService,Batcher,BuildStore,CronStore,LogStore,PermStore,SecretStore,GlobalSecretStore,StageStore,StepStore,RepositoryStore,UserStore,Scheduler,Session,OrganizationService,SecretService,RegistryService,ConfigService,Triggerer,Syncer,LogStream,WebhookSender,LicenseService)
|
|
|
|
// Package mock is a generated GoMock package.
|
|
package mock
|
|
|
|
import (
|
|
context "context"
|
|
core "github.com/drone/drone/core"
|
|
gomock "github.com/golang/mock/gomock"
|
|
io "io"
|
|
http "net/http"
|
|
reflect "reflect"
|
|
)
|
|
|
|
// MockNetrcService is a mock of NetrcService interface
|
|
type MockNetrcService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockNetrcServiceMockRecorder
|
|
}
|
|
|
|
// MockNetrcServiceMockRecorder is the mock recorder for MockNetrcService
|
|
type MockNetrcServiceMockRecorder struct {
|
|
mock *MockNetrcService
|
|
}
|
|
|
|
// NewMockNetrcService creates a new mock instance
|
|
func NewMockNetrcService(ctrl *gomock.Controller) *MockNetrcService {
|
|
mock := &MockNetrcService{ctrl: ctrl}
|
|
mock.recorder = &MockNetrcServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockNetrcService) EXPECT() *MockNetrcServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockNetrcService) Create(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) (*core.Netrc, error) {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Netrc)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockNetrcServiceMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockNetrcService)(nil).Create), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockRenewer is a mock of Renewer interface
|
|
type MockRenewer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockRenewerMockRecorder
|
|
}
|
|
|
|
// MockRenewerMockRecorder is the mock recorder for MockRenewer
|
|
type MockRenewerMockRecorder struct {
|
|
mock *MockRenewer
|
|
}
|
|
|
|
// NewMockRenewer creates a new mock instance
|
|
func NewMockRenewer(ctrl *gomock.Controller) *MockRenewer {
|
|
mock := &MockRenewer{ctrl: ctrl}
|
|
mock.recorder = &MockRenewerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockRenewer) EXPECT() *MockRenewerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Renew mocks base method
|
|
func (m *MockRenewer) Renew(arg0 context.Context, arg1 *core.User, arg2 bool) error {
|
|
ret := m.ctrl.Call(m, "Renew", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Renew indicates an expected call of Renew
|
|
func (mr *MockRenewerMockRecorder) Renew(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Renew", reflect.TypeOf((*MockRenewer)(nil).Renew), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockHookParser is a mock of HookParser interface
|
|
type MockHookParser struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockHookParserMockRecorder
|
|
}
|
|
|
|
// MockHookParserMockRecorder is the mock recorder for MockHookParser
|
|
type MockHookParserMockRecorder struct {
|
|
mock *MockHookParser
|
|
}
|
|
|
|
// NewMockHookParser creates a new mock instance
|
|
func NewMockHookParser(ctrl *gomock.Controller) *MockHookParser {
|
|
mock := &MockHookParser{ctrl: ctrl}
|
|
mock.recorder = &MockHookParserMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockHookParser) EXPECT() *MockHookParserMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Parse mocks base method
|
|
func (m *MockHookParser) Parse(arg0 *http.Request, arg1 func(string) string) (*core.Hook, *core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "Parse", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Hook)
|
|
ret1, _ := ret[1].(*core.Repository)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// Parse indicates an expected call of Parse
|
|
func (mr *MockHookParserMockRecorder) Parse(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parse", reflect.TypeOf((*MockHookParser)(nil).Parse), arg0, arg1)
|
|
}
|
|
|
|
// MockUserService is a mock of UserService interface
|
|
type MockUserService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockUserServiceMockRecorder
|
|
}
|
|
|
|
// MockUserServiceMockRecorder is the mock recorder for MockUserService
|
|
type MockUserServiceMockRecorder struct {
|
|
mock *MockUserService
|
|
}
|
|
|
|
// NewMockUserService creates a new mock instance
|
|
func NewMockUserService(ctrl *gomock.Controller) *MockUserService {
|
|
mock := &MockUserService{ctrl: ctrl}
|
|
mock.recorder = &MockUserServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockUserService) EXPECT() *MockUserServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockUserService) Find(arg0 context.Context, arg1, arg2 string) (*core.User, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockUserServiceMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockUserService)(nil).Find), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockRepositoryService is a mock of RepositoryService interface
|
|
type MockRepositoryService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockRepositoryServiceMockRecorder
|
|
}
|
|
|
|
// MockRepositoryServiceMockRecorder is the mock recorder for MockRepositoryService
|
|
type MockRepositoryServiceMockRecorder struct {
|
|
mock *MockRepositoryService
|
|
}
|
|
|
|
// NewMockRepositoryService creates a new mock instance
|
|
func NewMockRepositoryService(ctrl *gomock.Controller) *MockRepositoryService {
|
|
mock := &MockRepositoryService{ctrl: ctrl}
|
|
mock.recorder = &MockRepositoryServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockRepositoryService) EXPECT() *MockRepositoryServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockRepositoryService) Find(arg0 context.Context, arg1 *core.User, arg2 string) (*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockRepositoryServiceMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockRepositoryService)(nil).Find), arg0, arg1, arg2)
|
|
}
|
|
|
|
// FindPerm mocks base method
|
|
func (m *MockRepositoryService) FindPerm(arg0 context.Context, arg1 *core.User, arg2 string) (*core.Perm, error) {
|
|
ret := m.ctrl.Call(m, "FindPerm", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Perm)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindPerm indicates an expected call of FindPerm
|
|
func (mr *MockRepositoryServiceMockRecorder) FindPerm(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPerm", reflect.TypeOf((*MockRepositoryService)(nil).FindPerm), arg0, arg1, arg2)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockRepositoryService) List(arg0 context.Context, arg1 *core.User) ([]*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockRepositoryServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepositoryService)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// MockCommitService is a mock of CommitService interface
|
|
type MockCommitService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockCommitServiceMockRecorder
|
|
}
|
|
|
|
// MockCommitServiceMockRecorder is the mock recorder for MockCommitService
|
|
type MockCommitServiceMockRecorder struct {
|
|
mock *MockCommitService
|
|
}
|
|
|
|
// NewMockCommitService creates a new mock instance
|
|
func NewMockCommitService(ctrl *gomock.Controller) *MockCommitService {
|
|
mock := &MockCommitService{ctrl: ctrl}
|
|
mock.recorder = &MockCommitServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockCommitService) EXPECT() *MockCommitServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockCommitService) Find(arg0 context.Context, arg1 *core.User, arg2, arg3 string) (*core.Commit, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(*core.Commit)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockCommitServiceMockRecorder) Find(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCommitService)(nil).Find), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// FindRef mocks base method
|
|
func (m *MockCommitService) FindRef(arg0 context.Context, arg1 *core.User, arg2, arg3 string) (*core.Commit, error) {
|
|
ret := m.ctrl.Call(m, "FindRef", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(*core.Commit)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindRef indicates an expected call of FindRef
|
|
func (mr *MockCommitServiceMockRecorder) FindRef(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRef", reflect.TypeOf((*MockCommitService)(nil).FindRef), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// ListChanges mocks base method
|
|
func (m *MockCommitService) ListChanges(arg0 context.Context, arg1 *core.User, arg2, arg3, arg4 string) ([]*core.Change, error) {
|
|
ret := m.ctrl.Call(m, "ListChanges", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].([]*core.Change)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListChanges indicates an expected call of ListChanges
|
|
func (mr *MockCommitServiceMockRecorder) ListChanges(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChanges", reflect.TypeOf((*MockCommitService)(nil).ListChanges), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// MockStatusService is a mock of StatusService interface
|
|
type MockStatusService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockStatusServiceMockRecorder
|
|
}
|
|
|
|
// MockStatusServiceMockRecorder is the mock recorder for MockStatusService
|
|
type MockStatusServiceMockRecorder struct {
|
|
mock *MockStatusService
|
|
}
|
|
|
|
// NewMockStatusService creates a new mock instance
|
|
func NewMockStatusService(ctrl *gomock.Controller) *MockStatusService {
|
|
mock := &MockStatusService{ctrl: ctrl}
|
|
mock.recorder = &MockStatusServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockStatusService) EXPECT() *MockStatusServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Send mocks base method
|
|
func (m *MockStatusService) Send(arg0 context.Context, arg1 *core.User, arg2 *core.StatusInput) error {
|
|
ret := m.ctrl.Call(m, "Send", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Send indicates an expected call of Send
|
|
func (mr *MockStatusServiceMockRecorder) Send(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockStatusService)(nil).Send), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockHookService is a mock of HookService interface
|
|
type MockHookService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockHookServiceMockRecorder
|
|
}
|
|
|
|
// MockHookServiceMockRecorder is the mock recorder for MockHookService
|
|
type MockHookServiceMockRecorder struct {
|
|
mock *MockHookService
|
|
}
|
|
|
|
// NewMockHookService creates a new mock instance
|
|
func NewMockHookService(ctrl *gomock.Controller) *MockHookService {
|
|
mock := &MockHookService{ctrl: ctrl}
|
|
mock.recorder = &MockHookServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockHookService) EXPECT() *MockHookServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockHookService) Create(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockHookServiceMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockHookService)(nil).Create), arg0, arg1, arg2)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockHookService) Delete(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockHookServiceMockRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockHookService)(nil).Delete), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockFileService is a mock of FileService interface
|
|
type MockFileService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockFileServiceMockRecorder
|
|
}
|
|
|
|
// MockFileServiceMockRecorder is the mock recorder for MockFileService
|
|
type MockFileServiceMockRecorder struct {
|
|
mock *MockFileService
|
|
}
|
|
|
|
// NewMockFileService creates a new mock instance
|
|
func NewMockFileService(ctrl *gomock.Controller) *MockFileService {
|
|
mock := &MockFileService{ctrl: ctrl}
|
|
mock.recorder = &MockFileServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockFileService) EXPECT() *MockFileServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockFileService) Find(arg0 context.Context, arg1 *core.User, arg2, arg3, arg4, arg5 string) (*core.File, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2, arg3, arg4, arg5)
|
|
ret0, _ := ret[0].(*core.File)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockFileServiceMockRecorder) Find(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockFileService)(nil).Find), arg0, arg1, arg2, arg3, arg4, arg5)
|
|
}
|
|
|
|
// MockBatcher is a mock of Batcher interface
|
|
type MockBatcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockBatcherMockRecorder
|
|
}
|
|
|
|
// MockBatcherMockRecorder is the mock recorder for MockBatcher
|
|
type MockBatcherMockRecorder struct {
|
|
mock *MockBatcher
|
|
}
|
|
|
|
// NewMockBatcher creates a new mock instance
|
|
func NewMockBatcher(ctrl *gomock.Controller) *MockBatcher {
|
|
mock := &MockBatcher{ctrl: ctrl}
|
|
mock.recorder = &MockBatcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockBatcher) EXPECT() *MockBatcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Batch mocks base method
|
|
func (m *MockBatcher) Batch(arg0 context.Context, arg1 *core.User, arg2 *core.Batch) error {
|
|
ret := m.ctrl.Call(m, "Batch", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Batch indicates an expected call of Batch
|
|
func (mr *MockBatcherMockRecorder) Batch(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Batch", reflect.TypeOf((*MockBatcher)(nil).Batch), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockBuildStore is a mock of BuildStore interface
|
|
type MockBuildStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockBuildStoreMockRecorder
|
|
}
|
|
|
|
// MockBuildStoreMockRecorder is the mock recorder for MockBuildStore
|
|
type MockBuildStoreMockRecorder struct {
|
|
mock *MockBuildStore
|
|
}
|
|
|
|
// NewMockBuildStore creates a new mock instance
|
|
func NewMockBuildStore(ctrl *gomock.Controller) *MockBuildStore {
|
|
mock := &MockBuildStore{ctrl: ctrl}
|
|
mock.recorder = &MockBuildStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockBuildStore) EXPECT() *MockBuildStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Count mocks base method
|
|
func (m *MockBuildStore) Count(arg0 context.Context) (int64, error) {
|
|
ret := m.ctrl.Call(m, "Count", arg0)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Count indicates an expected call of Count
|
|
func (mr *MockBuildStoreMockRecorder) Count(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockBuildStore)(nil).Count), arg0)
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockBuildStore) Create(arg0 context.Context, arg1 *core.Build, arg2 []*core.Stage) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockBuildStoreMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockBuildStore)(nil).Create), arg0, arg1, arg2)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockBuildStore) Delete(arg0 context.Context, arg1 *core.Build) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockBuildStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockBuildStore)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockBuildStore) Find(arg0 context.Context, arg1 int64) (*core.Build, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Build)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockBuildStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockBuildStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// FindNumber mocks base method
|
|
func (m *MockBuildStore) FindNumber(arg0 context.Context, arg1, arg2 int64) (*core.Build, error) {
|
|
ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Build)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindNumber indicates an expected call of FindNumber
|
|
func (mr *MockBuildStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockBuildStore)(nil).FindNumber), arg0, arg1, arg2)
|
|
}
|
|
|
|
// FindRef mocks base method
|
|
func (m *MockBuildStore) FindRef(arg0 context.Context, arg1 int64, arg2 string) (*core.Build, error) {
|
|
ret := m.ctrl.Call(m, "FindRef", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Build)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindRef indicates an expected call of FindRef
|
|
func (mr *MockBuildStoreMockRecorder) FindRef(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRef", reflect.TypeOf((*MockBuildStore)(nil).FindRef), arg0, arg1, arg2)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockBuildStore) List(arg0 context.Context, arg1 int64, arg2, arg3 int) ([]*core.Build, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].([]*core.Build)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockBuildStoreMockRecorder) List(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockBuildStore)(nil).List), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// ListRef mocks base method
|
|
func (m *MockBuildStore) ListRef(arg0 context.Context, arg1 int64, arg2 string, arg3, arg4 int) ([]*core.Build, error) {
|
|
ret := m.ctrl.Call(m, "ListRef", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].([]*core.Build)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListRef indicates an expected call of ListRef
|
|
func (mr *MockBuildStoreMockRecorder) ListRef(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRef", reflect.TypeOf((*MockBuildStore)(nil).ListRef), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// Pending mocks base method
|
|
func (m *MockBuildStore) Pending(arg0 context.Context) ([]*core.Build, error) {
|
|
ret := m.ctrl.Call(m, "Pending", arg0)
|
|
ret0, _ := ret[0].([]*core.Build)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Pending indicates an expected call of Pending
|
|
func (mr *MockBuildStoreMockRecorder) Pending(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pending", reflect.TypeOf((*MockBuildStore)(nil).Pending), arg0)
|
|
}
|
|
|
|
// Purge mocks base method
|
|
func (m *MockBuildStore) Purge(arg0 context.Context, arg1, arg2 int64) error {
|
|
ret := m.ctrl.Call(m, "Purge", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Purge indicates an expected call of Purge
|
|
func (mr *MockBuildStoreMockRecorder) Purge(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Purge", reflect.TypeOf((*MockBuildStore)(nil).Purge), arg0, arg1, arg2)
|
|
}
|
|
|
|
// Running mocks base method
|
|
func (m *MockBuildStore) Running(arg0 context.Context) ([]*core.Build, error) {
|
|
ret := m.ctrl.Call(m, "Running", arg0)
|
|
ret0, _ := ret[0].([]*core.Build)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Running indicates an expected call of Running
|
|
func (mr *MockBuildStoreMockRecorder) Running(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Running", reflect.TypeOf((*MockBuildStore)(nil).Running), arg0)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockBuildStore) Update(arg0 context.Context, arg1 *core.Build) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockBuildStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockBuildStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockCronStore is a mock of CronStore interface
|
|
type MockCronStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockCronStoreMockRecorder
|
|
}
|
|
|
|
// MockCronStoreMockRecorder is the mock recorder for MockCronStore
|
|
type MockCronStoreMockRecorder struct {
|
|
mock *MockCronStore
|
|
}
|
|
|
|
// NewMockCronStore creates a new mock instance
|
|
func NewMockCronStore(ctrl *gomock.Controller) *MockCronStore {
|
|
mock := &MockCronStore{ctrl: ctrl}
|
|
mock.recorder = &MockCronStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockCronStore) EXPECT() *MockCronStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockCronStore) Create(arg0 context.Context, arg1 *core.Cron) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockCronStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockCronStore)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockCronStore) Delete(arg0 context.Context, arg1 *core.Cron) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockCronStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCronStore)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockCronStore) Find(arg0 context.Context, arg1 int64) (*core.Cron, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Cron)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockCronStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCronStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// FindName mocks base method
|
|
func (m *MockCronStore) FindName(arg0 context.Context, arg1 int64, arg2 string) (*core.Cron, error) {
|
|
ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Cron)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindName indicates an expected call of FindName
|
|
func (mr *MockCronStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockCronStore)(nil).FindName), arg0, arg1, arg2)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockCronStore) List(arg0 context.Context, arg1 int64) ([]*core.Cron, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Cron)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockCronStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockCronStore)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// Ready mocks base method
|
|
func (m *MockCronStore) Ready(arg0 context.Context, arg1 int64) ([]*core.Cron, error) {
|
|
ret := m.ctrl.Call(m, "Ready", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Cron)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Ready indicates an expected call of Ready
|
|
func (mr *MockCronStoreMockRecorder) Ready(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockCronStore)(nil).Ready), arg0, arg1)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockCronStore) Update(arg0 context.Context, arg1 *core.Cron) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockCronStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCronStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockLogStore is a mock of LogStore interface
|
|
type MockLogStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockLogStoreMockRecorder
|
|
}
|
|
|
|
// MockLogStoreMockRecorder is the mock recorder for MockLogStore
|
|
type MockLogStoreMockRecorder struct {
|
|
mock *MockLogStore
|
|
}
|
|
|
|
// NewMockLogStore creates a new mock instance
|
|
func NewMockLogStore(ctrl *gomock.Controller) *MockLogStore {
|
|
mock := &MockLogStore{ctrl: ctrl}
|
|
mock.recorder = &MockLogStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockLogStore) EXPECT() *MockLogStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockLogStore) Create(arg0 context.Context, arg1 int64, arg2 io.Reader) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockLogStoreMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLogStore)(nil).Create), arg0, arg1, arg2)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockLogStore) Delete(arg0 context.Context, arg1 int64) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockLogStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLogStore)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockLogStore) Find(arg0 context.Context, arg1 int64) (io.ReadCloser, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(io.ReadCloser)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockLogStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockLogStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockLogStore) Update(arg0 context.Context, arg1 int64, arg2 io.Reader) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockLogStoreMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLogStore)(nil).Update), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockPermStore is a mock of PermStore interface
|
|
type MockPermStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockPermStoreMockRecorder
|
|
}
|
|
|
|
// MockPermStoreMockRecorder is the mock recorder for MockPermStore
|
|
type MockPermStoreMockRecorder struct {
|
|
mock *MockPermStore
|
|
}
|
|
|
|
// NewMockPermStore creates a new mock instance
|
|
func NewMockPermStore(ctrl *gomock.Controller) *MockPermStore {
|
|
mock := &MockPermStore{ctrl: ctrl}
|
|
mock.recorder = &MockPermStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockPermStore) EXPECT() *MockPermStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockPermStore) Delete(arg0 context.Context, arg1 *core.Perm) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockPermStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPermStore)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockPermStore) Find(arg0 context.Context, arg1 string, arg2 int64) (*core.Perm, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Perm)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockPermStoreMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockPermStore)(nil).Find), arg0, arg1, arg2)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockPermStore) List(arg0 context.Context, arg1 string) ([]*core.Collaborator, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Collaborator)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockPermStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPermStore)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockPermStore) Update(arg0 context.Context, arg1 *core.Perm) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockPermStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockPermStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockSecretStore is a mock of SecretStore interface
|
|
type MockSecretStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockSecretStoreMockRecorder
|
|
}
|
|
|
|
// MockSecretStoreMockRecorder is the mock recorder for MockSecretStore
|
|
type MockSecretStoreMockRecorder struct {
|
|
mock *MockSecretStore
|
|
}
|
|
|
|
// NewMockSecretStore creates a new mock instance
|
|
func NewMockSecretStore(ctrl *gomock.Controller) *MockSecretStore {
|
|
mock := &MockSecretStore{ctrl: ctrl}
|
|
mock.recorder = &MockSecretStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockSecretStore) EXPECT() *MockSecretStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockSecretStore) Create(arg0 context.Context, arg1 *core.Secret) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockSecretStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSecretStore)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockSecretStore) Delete(arg0 context.Context, arg1 *core.Secret) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockSecretStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSecretStore)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockSecretStore) Find(arg0 context.Context, arg1 int64) (*core.Secret, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Secret)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockSecretStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockSecretStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// FindName mocks base method
|
|
func (m *MockSecretStore) FindName(arg0 context.Context, arg1 int64, arg2 string) (*core.Secret, error) {
|
|
ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Secret)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindName indicates an expected call of FindName
|
|
func (mr *MockSecretStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockSecretStore)(nil).FindName), arg0, arg1, arg2)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockSecretStore) List(arg0 context.Context, arg1 int64) ([]*core.Secret, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Secret)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockSecretStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSecretStore)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockSecretStore) Update(arg0 context.Context, arg1 *core.Secret) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockSecretStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSecretStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockGlobalSecretStore is a mock of GlobalSecretStore interface
|
|
type MockGlobalSecretStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGlobalSecretStoreMockRecorder
|
|
}
|
|
|
|
// MockGlobalSecretStoreMockRecorder is the mock recorder for MockGlobalSecretStore
|
|
type MockGlobalSecretStoreMockRecorder struct {
|
|
mock *MockGlobalSecretStore
|
|
}
|
|
|
|
// NewMockGlobalSecretStore creates a new mock instance
|
|
func NewMockGlobalSecretStore(ctrl *gomock.Controller) *MockGlobalSecretStore {
|
|
mock := &MockGlobalSecretStore{ctrl: ctrl}
|
|
mock.recorder = &MockGlobalSecretStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockGlobalSecretStore) EXPECT() *MockGlobalSecretStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockGlobalSecretStore) Create(arg0 context.Context, arg1 *core.Secret) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockGlobalSecretStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockGlobalSecretStore)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockGlobalSecretStore) Delete(arg0 context.Context, arg1 *core.Secret) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockGlobalSecretStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockGlobalSecretStore)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockGlobalSecretStore) Find(arg0 context.Context, arg1 int64) (*core.Secret, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Secret)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockGlobalSecretStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockGlobalSecretStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// FindName mocks base method
|
|
func (m *MockGlobalSecretStore) FindName(arg0 context.Context, arg1, arg2 string) (*core.Secret, error) {
|
|
ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Secret)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindName indicates an expected call of FindName
|
|
func (mr *MockGlobalSecretStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockGlobalSecretStore)(nil).FindName), arg0, arg1, arg2)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockGlobalSecretStore) List(arg0 context.Context, arg1 string) ([]*core.Secret, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Secret)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockGlobalSecretStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockGlobalSecretStore)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// ListAll mocks base method
|
|
func (m *MockGlobalSecretStore) ListAll(arg0 context.Context) ([]*core.Secret, error) {
|
|
ret := m.ctrl.Call(m, "ListAll", arg0)
|
|
ret0, _ := ret[0].([]*core.Secret)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListAll indicates an expected call of ListAll
|
|
func (mr *MockGlobalSecretStoreMockRecorder) ListAll(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAll", reflect.TypeOf((*MockGlobalSecretStore)(nil).ListAll), arg0)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockGlobalSecretStore) Update(arg0 context.Context, arg1 *core.Secret) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockGlobalSecretStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockGlobalSecretStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockStageStore is a mock of StageStore interface
|
|
type MockStageStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockStageStoreMockRecorder
|
|
}
|
|
|
|
// MockStageStoreMockRecorder is the mock recorder for MockStageStore
|
|
type MockStageStoreMockRecorder struct {
|
|
mock *MockStageStore
|
|
}
|
|
|
|
// NewMockStageStore creates a new mock instance
|
|
func NewMockStageStore(ctrl *gomock.Controller) *MockStageStore {
|
|
mock := &MockStageStore{ctrl: ctrl}
|
|
mock.recorder = &MockStageStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockStageStore) EXPECT() *MockStageStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockStageStore) Create(arg0 context.Context, arg1 *core.Stage) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockStageStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStageStore)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockStageStore) Find(arg0 context.Context, arg1 int64) (*core.Stage, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Stage)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockStageStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockStageStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// FindNumber mocks base method
|
|
func (m *MockStageStore) FindNumber(arg0 context.Context, arg1 int64, arg2 int) (*core.Stage, error) {
|
|
ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Stage)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindNumber indicates an expected call of FindNumber
|
|
func (mr *MockStageStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockStageStore)(nil).FindNumber), arg0, arg1, arg2)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockStageStore) List(arg0 context.Context, arg1 int64) ([]*core.Stage, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Stage)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockStageStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStageStore)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// ListIncomplete mocks base method
|
|
func (m *MockStageStore) ListIncomplete(arg0 context.Context) ([]*core.Stage, error) {
|
|
ret := m.ctrl.Call(m, "ListIncomplete", arg0)
|
|
ret0, _ := ret[0].([]*core.Stage)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListIncomplete indicates an expected call of ListIncomplete
|
|
func (mr *MockStageStoreMockRecorder) ListIncomplete(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncomplete", reflect.TypeOf((*MockStageStore)(nil).ListIncomplete), arg0)
|
|
}
|
|
|
|
// ListState mocks base method
|
|
func (m *MockStageStore) ListState(arg0 context.Context, arg1 string) ([]*core.Stage, error) {
|
|
ret := m.ctrl.Call(m, "ListState", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Stage)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListState indicates an expected call of ListState
|
|
func (mr *MockStageStoreMockRecorder) ListState(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListState", reflect.TypeOf((*MockStageStore)(nil).ListState), arg0, arg1)
|
|
}
|
|
|
|
// ListSteps mocks base method
|
|
func (m *MockStageStore) ListSteps(arg0 context.Context, arg1 int64) ([]*core.Stage, error) {
|
|
ret := m.ctrl.Call(m, "ListSteps", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Stage)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListSteps indicates an expected call of ListSteps
|
|
func (mr *MockStageStoreMockRecorder) ListSteps(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSteps", reflect.TypeOf((*MockStageStore)(nil).ListSteps), arg0, arg1)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockStageStore) Update(arg0 context.Context, arg1 *core.Stage) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockStageStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStageStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockStepStore is a mock of StepStore interface
|
|
type MockStepStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockStepStoreMockRecorder
|
|
}
|
|
|
|
// MockStepStoreMockRecorder is the mock recorder for MockStepStore
|
|
type MockStepStoreMockRecorder struct {
|
|
mock *MockStepStore
|
|
}
|
|
|
|
// NewMockStepStore creates a new mock instance
|
|
func NewMockStepStore(ctrl *gomock.Controller) *MockStepStore {
|
|
mock := &MockStepStore{ctrl: ctrl}
|
|
mock.recorder = &MockStepStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockStepStore) EXPECT() *MockStepStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockStepStore) Create(arg0 context.Context, arg1 *core.Step) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockStepStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStepStore)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockStepStore) Find(arg0 context.Context, arg1 int64) (*core.Step, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Step)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockStepStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockStepStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// FindNumber mocks base method
|
|
func (m *MockStepStore) FindNumber(arg0 context.Context, arg1 int64, arg2 int) (*core.Step, error) {
|
|
ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Step)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindNumber indicates an expected call of FindNumber
|
|
func (mr *MockStepStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockStepStore)(nil).FindNumber), arg0, arg1, arg2)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockStepStore) List(arg0 context.Context, arg1 int64) ([]*core.Step, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Step)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockStepStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStepStore)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockStepStore) Update(arg0 context.Context, arg1 *core.Step) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockStepStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStepStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockRepositoryStore is a mock of RepositoryStore interface
|
|
type MockRepositoryStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockRepositoryStoreMockRecorder
|
|
}
|
|
|
|
// MockRepositoryStoreMockRecorder is the mock recorder for MockRepositoryStore
|
|
type MockRepositoryStoreMockRecorder struct {
|
|
mock *MockRepositoryStore
|
|
}
|
|
|
|
// NewMockRepositoryStore creates a new mock instance
|
|
func NewMockRepositoryStore(ctrl *gomock.Controller) *MockRepositoryStore {
|
|
mock := &MockRepositoryStore{ctrl: ctrl}
|
|
mock.recorder = &MockRepositoryStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockRepositoryStore) EXPECT() *MockRepositoryStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Activate mocks base method
|
|
func (m *MockRepositoryStore) Activate(arg0 context.Context, arg1 *core.Repository) error {
|
|
ret := m.ctrl.Call(m, "Activate", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Activate indicates an expected call of Activate
|
|
func (mr *MockRepositoryStoreMockRecorder) Activate(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Activate", reflect.TypeOf((*MockRepositoryStore)(nil).Activate), arg0, arg1)
|
|
}
|
|
|
|
// Count mocks base method
|
|
func (m *MockRepositoryStore) Count(arg0 context.Context) (int64, error) {
|
|
ret := m.ctrl.Call(m, "Count", arg0)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Count indicates an expected call of Count
|
|
func (mr *MockRepositoryStoreMockRecorder) Count(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockRepositoryStore)(nil).Count), arg0)
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockRepositoryStore) Create(arg0 context.Context, arg1 *core.Repository) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockRepositoryStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRepositoryStore)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockRepositoryStore) Delete(arg0 context.Context, arg1 *core.Repository) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockRepositoryStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepositoryStore)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockRepositoryStore) Find(arg0 context.Context, arg1 int64) (*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockRepositoryStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockRepositoryStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// FindName mocks base method
|
|
func (m *MockRepositoryStore) FindName(arg0 context.Context, arg1, arg2 string) (*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindName indicates an expected call of FindName
|
|
func (mr *MockRepositoryStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockRepositoryStore)(nil).FindName), arg0, arg1, arg2)
|
|
}
|
|
|
|
// Increment mocks base method
|
|
func (m *MockRepositoryStore) Increment(arg0 context.Context, arg1 *core.Repository) (*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "Increment", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Increment indicates an expected call of Increment
|
|
func (mr *MockRepositoryStoreMockRecorder) Increment(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Increment", reflect.TypeOf((*MockRepositoryStore)(nil).Increment), arg0, arg1)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockRepositoryStore) List(arg0 context.Context, arg1 int64) ([]*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockRepositoryStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepositoryStore)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// ListIncomplete mocks base method
|
|
func (m *MockRepositoryStore) ListIncomplete(arg0 context.Context) ([]*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "ListIncomplete", arg0)
|
|
ret0, _ := ret[0].([]*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListIncomplete indicates an expected call of ListIncomplete
|
|
func (mr *MockRepositoryStoreMockRecorder) ListIncomplete(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncomplete", reflect.TypeOf((*MockRepositoryStore)(nil).ListIncomplete), arg0)
|
|
}
|
|
|
|
// ListLatest mocks base method
|
|
func (m *MockRepositoryStore) ListLatest(arg0 context.Context, arg1 int64) ([]*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "ListLatest", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListLatest indicates an expected call of ListLatest
|
|
func (mr *MockRepositoryStoreMockRecorder) ListLatest(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLatest", reflect.TypeOf((*MockRepositoryStore)(nil).ListLatest), arg0, arg1)
|
|
}
|
|
|
|
// ListRecent mocks base method
|
|
func (m *MockRepositoryStore) ListRecent(arg0 context.Context, arg1 int64) ([]*core.Repository, error) {
|
|
ret := m.ctrl.Call(m, "ListRecent", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListRecent indicates an expected call of ListRecent
|
|
func (mr *MockRepositoryStoreMockRecorder) ListRecent(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRecent", reflect.TypeOf((*MockRepositoryStore)(nil).ListRecent), arg0, arg1)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockRepositoryStore) Update(arg0 context.Context, arg1 *core.Repository) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockRepositoryStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRepositoryStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockUserStore is a mock of UserStore interface
|
|
type MockUserStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockUserStoreMockRecorder
|
|
}
|
|
|
|
// MockUserStoreMockRecorder is the mock recorder for MockUserStore
|
|
type MockUserStoreMockRecorder struct {
|
|
mock *MockUserStore
|
|
}
|
|
|
|
// NewMockUserStore creates a new mock instance
|
|
func NewMockUserStore(ctrl *gomock.Controller) *MockUserStore {
|
|
mock := &MockUserStore{ctrl: ctrl}
|
|
mock.recorder = &MockUserStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockUserStore) EXPECT() *MockUserStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Count mocks base method
|
|
func (m *MockUserStore) Count(arg0 context.Context) (int64, error) {
|
|
ret := m.ctrl.Call(m, "Count", arg0)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Count indicates an expected call of Count
|
|
func (mr *MockUserStoreMockRecorder) Count(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockUserStore)(nil).Count), arg0)
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockUserStore) Create(arg0 context.Context, arg1 *core.User) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockUserStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockUserStore)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockUserStore) Delete(arg0 context.Context, arg1 *core.User) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockUserStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockUserStore)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockUserStore) Find(arg0 context.Context, arg1 int64) (*core.User, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockUserStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockUserStore)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// FindLogin mocks base method
|
|
func (m *MockUserStore) FindLogin(arg0 context.Context, arg1 string) (*core.User, error) {
|
|
ret := m.ctrl.Call(m, "FindLogin", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindLogin indicates an expected call of FindLogin
|
|
func (mr *MockUserStoreMockRecorder) FindLogin(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindLogin", reflect.TypeOf((*MockUserStore)(nil).FindLogin), arg0, arg1)
|
|
}
|
|
|
|
// FindToken mocks base method
|
|
func (m *MockUserStore) FindToken(arg0 context.Context, arg1 string) (*core.User, error) {
|
|
ret := m.ctrl.Call(m, "FindToken", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindToken indicates an expected call of FindToken
|
|
func (mr *MockUserStoreMockRecorder) FindToken(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindToken", reflect.TypeOf((*MockUserStore)(nil).FindToken), arg0, arg1)
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockUserStore) List(arg0 context.Context) ([]*core.User, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0)
|
|
ret0, _ := ret[0].([]*core.User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockUserStoreMockRecorder) List(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockUserStore)(nil).List), arg0)
|
|
}
|
|
|
|
// Update mocks base method
|
|
func (m *MockUserStore) Update(arg0 context.Context, arg1 *core.User) error {
|
|
ret := m.ctrl.Call(m, "Update", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Update indicates an expected call of Update
|
|
func (mr *MockUserStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserStore)(nil).Update), arg0, arg1)
|
|
}
|
|
|
|
// MockScheduler is a mock of Scheduler interface
|
|
type MockScheduler struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockSchedulerMockRecorder
|
|
}
|
|
|
|
// MockSchedulerMockRecorder is the mock recorder for MockScheduler
|
|
type MockSchedulerMockRecorder struct {
|
|
mock *MockScheduler
|
|
}
|
|
|
|
// NewMockScheduler creates a new mock instance
|
|
func NewMockScheduler(ctrl *gomock.Controller) *MockScheduler {
|
|
mock := &MockScheduler{ctrl: ctrl}
|
|
mock.recorder = &MockSchedulerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockScheduler) EXPECT() *MockSchedulerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Cancel mocks base method
|
|
func (m *MockScheduler) Cancel(arg0 context.Context, arg1 int64) error {
|
|
ret := m.ctrl.Call(m, "Cancel", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Cancel indicates an expected call of Cancel
|
|
func (mr *MockSchedulerMockRecorder) Cancel(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockScheduler)(nil).Cancel), arg0, arg1)
|
|
}
|
|
|
|
// Cancelled mocks base method
|
|
func (m *MockScheduler) Cancelled(arg0 context.Context, arg1 int64) (bool, error) {
|
|
ret := m.ctrl.Call(m, "Cancelled", arg0, arg1)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Cancelled indicates an expected call of Cancelled
|
|
func (mr *MockSchedulerMockRecorder) Cancelled(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancelled", reflect.TypeOf((*MockScheduler)(nil).Cancelled), arg0, arg1)
|
|
}
|
|
|
|
// Pause mocks base method
|
|
func (m *MockScheduler) Pause(arg0 context.Context) error {
|
|
ret := m.ctrl.Call(m, "Pause", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Pause indicates an expected call of Pause
|
|
func (mr *MockSchedulerMockRecorder) Pause(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pause", reflect.TypeOf((*MockScheduler)(nil).Pause), arg0)
|
|
}
|
|
|
|
// Request mocks base method
|
|
func (m *MockScheduler) Request(arg0 context.Context, arg1 core.Filter) (*core.Stage, error) {
|
|
ret := m.ctrl.Call(m, "Request", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Stage)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Request indicates an expected call of Request
|
|
func (mr *MockSchedulerMockRecorder) Request(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Request", reflect.TypeOf((*MockScheduler)(nil).Request), arg0, arg1)
|
|
}
|
|
|
|
// Resume mocks base method
|
|
func (m *MockScheduler) Resume(arg0 context.Context) error {
|
|
ret := m.ctrl.Call(m, "Resume", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Resume indicates an expected call of Resume
|
|
func (mr *MockSchedulerMockRecorder) Resume(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resume", reflect.TypeOf((*MockScheduler)(nil).Resume), arg0)
|
|
}
|
|
|
|
// Schedule mocks base method
|
|
func (m *MockScheduler) Schedule(arg0 context.Context, arg1 *core.Stage) error {
|
|
ret := m.ctrl.Call(m, "Schedule", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Schedule indicates an expected call of Schedule
|
|
func (mr *MockSchedulerMockRecorder) Schedule(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Schedule", reflect.TypeOf((*MockScheduler)(nil).Schedule), arg0, arg1)
|
|
}
|
|
|
|
// Stats mocks base method
|
|
func (m *MockScheduler) Stats(arg0 context.Context) (interface{}, error) {
|
|
ret := m.ctrl.Call(m, "Stats", arg0)
|
|
ret0, _ := ret[0].(interface{})
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Stats indicates an expected call of Stats
|
|
func (mr *MockSchedulerMockRecorder) Stats(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockScheduler)(nil).Stats), arg0)
|
|
}
|
|
|
|
// MockSession is a mock of Session interface
|
|
type MockSession struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockSessionMockRecorder
|
|
}
|
|
|
|
// MockSessionMockRecorder is the mock recorder for MockSession
|
|
type MockSessionMockRecorder struct {
|
|
mock *MockSession
|
|
}
|
|
|
|
// NewMockSession creates a new mock instance
|
|
func NewMockSession(ctrl *gomock.Controller) *MockSession {
|
|
mock := &MockSession{ctrl: ctrl}
|
|
mock.recorder = &MockSessionMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockSession) EXPECT() *MockSessionMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockSession) Create(arg0 http.ResponseWriter, arg1 *core.User) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockSessionMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSession)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockSession) Delete(arg0 http.ResponseWriter) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockSessionMockRecorder) Delete(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSession)(nil).Delete), arg0)
|
|
}
|
|
|
|
// Get mocks base method
|
|
func (m *MockSession) Get(arg0 *http.Request) (*core.User, error) {
|
|
ret := m.ctrl.Call(m, "Get", arg0)
|
|
ret0, _ := ret[0].(*core.User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Get indicates an expected call of Get
|
|
func (mr *MockSessionMockRecorder) Get(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSession)(nil).Get), arg0)
|
|
}
|
|
|
|
// MockOrganizationService is a mock of OrganizationService interface
|
|
type MockOrganizationService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockOrganizationServiceMockRecorder
|
|
}
|
|
|
|
// MockOrganizationServiceMockRecorder is the mock recorder for MockOrganizationService
|
|
type MockOrganizationServiceMockRecorder struct {
|
|
mock *MockOrganizationService
|
|
}
|
|
|
|
// NewMockOrganizationService creates a new mock instance
|
|
func NewMockOrganizationService(ctrl *gomock.Controller) *MockOrganizationService {
|
|
mock := &MockOrganizationService{ctrl: ctrl}
|
|
mock.recorder = &MockOrganizationServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockOrganizationService) EXPECT() *MockOrganizationServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockOrganizationService) List(arg0 context.Context, arg1 *core.User) ([]*core.Organization, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Organization)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockOrganizationServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockOrganizationService)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// MockSecretService is a mock of SecretService interface
|
|
type MockSecretService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockSecretServiceMockRecorder
|
|
}
|
|
|
|
// MockSecretServiceMockRecorder is the mock recorder for MockSecretService
|
|
type MockSecretServiceMockRecorder struct {
|
|
mock *MockSecretService
|
|
}
|
|
|
|
// NewMockSecretService creates a new mock instance
|
|
func NewMockSecretService(ctrl *gomock.Controller) *MockSecretService {
|
|
mock := &MockSecretService{ctrl: ctrl}
|
|
mock.recorder = &MockSecretServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockSecretService) EXPECT() *MockSecretServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockSecretService) Find(arg0 context.Context, arg1 *core.SecretArgs) (*core.Secret, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Secret)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockSecretServiceMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockSecretService)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// MockRegistryService is a mock of RegistryService interface
|
|
type MockRegistryService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockRegistryServiceMockRecorder
|
|
}
|
|
|
|
// MockRegistryServiceMockRecorder is the mock recorder for MockRegistryService
|
|
type MockRegistryServiceMockRecorder struct {
|
|
mock *MockRegistryService
|
|
}
|
|
|
|
// NewMockRegistryService creates a new mock instance
|
|
func NewMockRegistryService(ctrl *gomock.Controller) *MockRegistryService {
|
|
mock := &MockRegistryService{ctrl: ctrl}
|
|
mock.recorder = &MockRegistryServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockRegistryService) EXPECT() *MockRegistryServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// List mocks base method
|
|
func (m *MockRegistryService) List(arg0 context.Context, arg1 *core.RegistryArgs) ([]*core.Registry, error) {
|
|
ret := m.ctrl.Call(m, "List", arg0, arg1)
|
|
ret0, _ := ret[0].([]*core.Registry)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List
|
|
func (mr *MockRegistryServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRegistryService)(nil).List), arg0, arg1)
|
|
}
|
|
|
|
// MockConfigService is a mock of ConfigService interface
|
|
type MockConfigService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockConfigServiceMockRecorder
|
|
}
|
|
|
|
// MockConfigServiceMockRecorder is the mock recorder for MockConfigService
|
|
type MockConfigServiceMockRecorder struct {
|
|
mock *MockConfigService
|
|
}
|
|
|
|
// NewMockConfigService creates a new mock instance
|
|
func NewMockConfigService(ctrl *gomock.Controller) *MockConfigService {
|
|
mock := &MockConfigService{ctrl: ctrl}
|
|
mock.recorder = &MockConfigServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockConfigService) EXPECT() *MockConfigServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Find mocks base method
|
|
func (m *MockConfigService) Find(arg0 context.Context, arg1 *core.ConfigArgs) (*core.Config, error) {
|
|
ret := m.ctrl.Call(m, "Find", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Config)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Find indicates an expected call of Find
|
|
func (mr *MockConfigServiceMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockConfigService)(nil).Find), arg0, arg1)
|
|
}
|
|
|
|
// MockTriggerer is a mock of Triggerer interface
|
|
type MockTriggerer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockTriggererMockRecorder
|
|
}
|
|
|
|
// MockTriggererMockRecorder is the mock recorder for MockTriggerer
|
|
type MockTriggererMockRecorder struct {
|
|
mock *MockTriggerer
|
|
}
|
|
|
|
// NewMockTriggerer creates a new mock instance
|
|
func NewMockTriggerer(ctrl *gomock.Controller) *MockTriggerer {
|
|
mock := &MockTriggerer{ctrl: ctrl}
|
|
mock.recorder = &MockTriggererMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockTriggerer) EXPECT() *MockTriggererMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Trigger mocks base method
|
|
func (m *MockTriggerer) Trigger(arg0 context.Context, arg1 *core.Repository, arg2 *core.Hook) (*core.Build, error) {
|
|
ret := m.ctrl.Call(m, "Trigger", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*core.Build)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Trigger indicates an expected call of Trigger
|
|
func (mr *MockTriggererMockRecorder) Trigger(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trigger", reflect.TypeOf((*MockTriggerer)(nil).Trigger), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockSyncer is a mock of Syncer interface
|
|
type MockSyncer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockSyncerMockRecorder
|
|
}
|
|
|
|
// MockSyncerMockRecorder is the mock recorder for MockSyncer
|
|
type MockSyncerMockRecorder struct {
|
|
mock *MockSyncer
|
|
}
|
|
|
|
// NewMockSyncer creates a new mock instance
|
|
func NewMockSyncer(ctrl *gomock.Controller) *MockSyncer {
|
|
mock := &MockSyncer{ctrl: ctrl}
|
|
mock.recorder = &MockSyncerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockSyncer) EXPECT() *MockSyncerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Sync mocks base method
|
|
func (m *MockSyncer) Sync(arg0 context.Context, arg1 *core.User) (*core.Batch, error) {
|
|
ret := m.ctrl.Call(m, "Sync", arg0, arg1)
|
|
ret0, _ := ret[0].(*core.Batch)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Sync indicates an expected call of Sync
|
|
func (mr *MockSyncerMockRecorder) Sync(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockSyncer)(nil).Sync), arg0, arg1)
|
|
}
|
|
|
|
// MockLogStream is a mock of LogStream interface
|
|
type MockLogStream struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockLogStreamMockRecorder
|
|
}
|
|
|
|
// MockLogStreamMockRecorder is the mock recorder for MockLogStream
|
|
type MockLogStreamMockRecorder struct {
|
|
mock *MockLogStream
|
|
}
|
|
|
|
// NewMockLogStream creates a new mock instance
|
|
func NewMockLogStream(ctrl *gomock.Controller) *MockLogStream {
|
|
mock := &MockLogStream{ctrl: ctrl}
|
|
mock.recorder = &MockLogStreamMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockLogStream) EXPECT() *MockLogStreamMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method
|
|
func (m *MockLogStream) Create(arg0 context.Context, arg1 int64) error {
|
|
ret := m.ctrl.Call(m, "Create", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Create indicates an expected call of Create
|
|
func (mr *MockLogStreamMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLogStream)(nil).Create), arg0, arg1)
|
|
}
|
|
|
|
// Delete mocks base method
|
|
func (m *MockLogStream) Delete(arg0 context.Context, arg1 int64) error {
|
|
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete
|
|
func (mr *MockLogStreamMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLogStream)(nil).Delete), arg0, arg1)
|
|
}
|
|
|
|
// Info mocks base method
|
|
func (m *MockLogStream) Info(arg0 context.Context) *core.LogStreamInfo {
|
|
ret := m.ctrl.Call(m, "Info", arg0)
|
|
ret0, _ := ret[0].(*core.LogStreamInfo)
|
|
return ret0
|
|
}
|
|
|
|
// Info indicates an expected call of Info
|
|
func (mr *MockLogStreamMockRecorder) Info(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogStream)(nil).Info), arg0)
|
|
}
|
|
|
|
// Tail mocks base method
|
|
func (m *MockLogStream) Tail(arg0 context.Context, arg1 int64) (<-chan *core.Line, <-chan error) {
|
|
ret := m.ctrl.Call(m, "Tail", arg0, arg1)
|
|
ret0, _ := ret[0].(<-chan *core.Line)
|
|
ret1, _ := ret[1].(<-chan error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Tail indicates an expected call of Tail
|
|
func (mr *MockLogStreamMockRecorder) Tail(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tail", reflect.TypeOf((*MockLogStream)(nil).Tail), arg0, arg1)
|
|
}
|
|
|
|
// Write mocks base method
|
|
func (m *MockLogStream) Write(arg0 context.Context, arg1 int64, arg2 *core.Line) error {
|
|
ret := m.ctrl.Call(m, "Write", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Write indicates an expected call of Write
|
|
func (mr *MockLogStreamMockRecorder) Write(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockLogStream)(nil).Write), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockWebhookSender is a mock of WebhookSender interface
|
|
type MockWebhookSender struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockWebhookSenderMockRecorder
|
|
}
|
|
|
|
// MockWebhookSenderMockRecorder is the mock recorder for MockWebhookSender
|
|
type MockWebhookSenderMockRecorder struct {
|
|
mock *MockWebhookSender
|
|
}
|
|
|
|
// NewMockWebhookSender creates a new mock instance
|
|
func NewMockWebhookSender(ctrl *gomock.Controller) *MockWebhookSender {
|
|
mock := &MockWebhookSender{ctrl: ctrl}
|
|
mock.recorder = &MockWebhookSenderMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockWebhookSender) EXPECT() *MockWebhookSenderMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Send mocks base method
|
|
func (m *MockWebhookSender) Send(arg0 context.Context, arg1 *core.WebhookData) error {
|
|
ret := m.ctrl.Call(m, "Send", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Send indicates an expected call of Send
|
|
func (mr *MockWebhookSenderMockRecorder) Send(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockWebhookSender)(nil).Send), arg0, arg1)
|
|
}
|
|
|
|
// MockLicenseService is a mock of LicenseService interface
|
|
type MockLicenseService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockLicenseServiceMockRecorder
|
|
}
|
|
|
|
// MockLicenseServiceMockRecorder is the mock recorder for MockLicenseService
|
|
type MockLicenseServiceMockRecorder struct {
|
|
mock *MockLicenseService
|
|
}
|
|
|
|
// NewMockLicenseService creates a new mock instance
|
|
func NewMockLicenseService(ctrl *gomock.Controller) *MockLicenseService {
|
|
mock := &MockLicenseService{ctrl: ctrl}
|
|
mock.recorder = &MockLicenseServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockLicenseService) EXPECT() *MockLicenseServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Exceeded mocks base method
|
|
func (m *MockLicenseService) Exceeded(arg0 context.Context) (bool, error) {
|
|
ret := m.ctrl.Call(m, "Exceeded", arg0)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Exceeded indicates an expected call of Exceeded
|
|
func (mr *MockLicenseServiceMockRecorder) Exceeded(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exceeded", reflect.TypeOf((*MockLicenseService)(nil).Exceeded), arg0)
|
|
}
|
|
|
|
// Expired mocks base method
|
|
func (m *MockLicenseService) Expired(arg0 context.Context) bool {
|
|
ret := m.ctrl.Call(m, "Expired", arg0)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// Expired indicates an expected call of Expired
|
|
func (mr *MockLicenseServiceMockRecorder) Expired(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockLicenseService)(nil).Expired), arg0)
|
|
}
|