diff --git a/core/template.go b/core/template.go index d752fcca9..d29fb227f 100644 --- a/core/template.go +++ b/core/template.go @@ -20,10 +20,10 @@ import ( ) var ( - errTemplateNameInvalid = errors.New("Invalid Template Name") - errTemplateDataInvalid = errors.New("Invalid Template Data") - errTemplateCreatedInvalid = errors.New("Invalid Template Created Value") - errTemplateUpdatedInvalid = errors.New("Invalid Template Updated Value") + errTemplateNameInvalid = errors.New("No Template Name Provided") + errTemplateDataInvalid = errors.New("No Template Data Provided") + //errTemplateCreatedInvalid = errors.New("Invalid Template Created Value") + //errTemplateUpdatedInvalid = errors.New("Invalid Template Updated Value") ) type ( @@ -70,10 +70,10 @@ func (s *Template) Validate() error { return errTemplateNameInvalid case len(s.Data) == 0: return errTemplateDataInvalid - case s.Created == 0: - return errTemplateCreatedInvalid - case s.Updated == 0: - return errTemplateUpdatedInvalid + //case s.Created == 0: + // return errTemplateCreatedInvalid + //case s.Updated == 0: + // return errTemplateUpdatedInvalid default: return nil } diff --git a/handler/api/api.go b/handler/api/api.go index cfedfcfdd..9384cad72 100644 --- a/handler/api/api.go +++ b/handler/api/api.go @@ -15,6 +15,7 @@ package api import ( + "github.com/drone/drone/handler/api/template" "net/http" "os" @@ -40,7 +41,6 @@ import ( "github.com/drone/drone/handler/api/repos/sign" globalsecrets "github.com/drone/drone/handler/api/secrets" "github.com/drone/drone/handler/api/system" - "github.com/drone/drone/handler/api/template" "github.com/drone/drone/handler/api/user" "github.com/drone/drone/handler/api/user/remote" "github.com/drone/drone/handler/api/users" @@ -257,15 +257,6 @@ func (s Server) Handler() http.Handler { r.Delete("/{secret}", secrets.HandleDelete(s.Repos, s.Secrets)) }) - r.Route("/templates", func(r chi.Router) { - r.Use(acl.CheckWriteAccess()) - r.Get("/", template.HandleList(s.Template)) - r.Post("/", template.HandleCreate(s.Template)) - r.Get("/{name}", template.HandleFind(s.Template)) - r.Patch("/{name}", template.HandleUpdate(s.Template)) - r.Delete("/{name}", template.HandleDelete(s.Template)) - }) - r.Route("/sign", func(r chi.Router) { r.Use(acl.CheckWriteAccess()) r.Post("/", sign.HandleSign(s.Repos)) @@ -366,6 +357,16 @@ func (s Server) Handler() http.Handler { r.With(acl.CheckMembership(s.Orgs, true)).Delete("/{namespace}/{name}", globalsecrets.HandleDelete(s.Globals)) }) + r.Route("/templates", func(r chi.Router) { + r.With(acl.AuthorizeAdmin).Get("/", template.HandleAll(s.Template)) + r.With(acl.CheckMembership(s.Orgs, false)).Get("/{namespace}", template.HandleList(s.Template)) + r.With(acl.CheckMembership(s.Orgs, true)).Post("/{namespace}", template.HandleCreate(s.Template)) + r.With(acl.CheckMembership(s.Orgs, false)).Get("/{namespace}/{name}", template.HandleFind(s.Template)) + r.With(acl.CheckMembership(s.Orgs, true)).Post("/{namespace}/{name}", template.HandleUpdate(s.Template)) + r.With(acl.CheckMembership(s.Orgs, true)).Patch("/{namespace}/{name}", template.HandleUpdate(s.Template)) + r.With(acl.CheckMembership(s.Orgs, true)).Delete("/{namespace}/{name}", template.HandleDelete(s.Template)) + }) + r.Route("/system", func(r chi.Router) { r.Use(acl.AuthorizeAdmin) // r.Get("/license", system.HandleLicense()) diff --git a/handler/api/template/all_test.go b/handler/api/template/all_test.go index 6a1ac34a1..0bfb9ee1b 100644 --- a/handler/api/template/all_test.go +++ b/handler/api/template/all_test.go @@ -6,24 +6,26 @@ package template -//func TestHandleAll(t *testing.T) { -// controller := gomock.NewController(t) -// defer controller.Finish() -// -// secrets := mock.NewMockGlobalSecretStore(controller) -// secrets.EXPECT().ListAll(gomock.Any()).Return(dummySecretList, nil) -// -// w := httptest.NewRecorder() -// r := httptest.NewRequest("GET", "/", nil) -// -// HandleAll(secrets).ServeHTTP(w, r) -// if got, want := w.Code, http.StatusOK; want != got { -// t.Errorf("Want response code %d, got %d", want, got) -// } -// -// got, want := []*core.Secret{}, dummySecretListScrubbed -// json.NewDecoder(w.Body).Decode(&got) -// if diff := cmp.Diff(got, want); len(diff) != 0 { -// t.Errorf(diff) -// } -//} +import ( + "github.com/drone/drone/mock" + "github.com/golang/mock/gomock" + "net/http" + "net/http/httptest" + "testing" +) + +func TestHandleAll(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + templates := mock.NewMockTemplateStore(controller) + templates.EXPECT().ListAll(gomock.Any()).Return(dummyTemplateList, nil) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", nil) + + HandleAll(templates).ServeHTTP(w, r) + if got, want := w.Code, http.StatusOK; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } +} diff --git a/handler/api/template/create_test.go b/handler/api/template/create_test.go new file mode 100644 index 000000000..1a27e1a8c --- /dev/null +++ b/handler/api/template/create_test.go @@ -0,0 +1,151 @@ +// Copyright 2019 Drone.IO Inc. All rights reserved. +// Use of this source code is governed by the Drone Non-Commercial License +// that can be found in the LICENSE file. + +// +build !oss + +package template + +import ( + "bytes" + "context" + "encoding/json" + "github.com/drone/drone/core" + "github.com/drone/drone/handler/api/errors" + "github.com/drone/drone/mock" + "github.com/go-chi/chi" + "github.com/golang/mock/gomock" + "github.com/google/go-cmp/cmp" + "net/http" + "net/http/httptest" + "testing" +) + +func TestHandleCreate(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + templates := mock.NewMockTemplateStore(controller) + templates.EXPECT().Create(gomock.Any(), gomock.Any()).Return(nil) + + c := new(chi.Context) + + in := new(bytes.Buffer) + json.NewEncoder(in).Encode(dummyTemplate) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", in) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleCreate(templates).ServeHTTP(w, r) + if got, want := w.Code, http.StatusOK; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } +} + +func TestHandleCreate_ValidationErrorName(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + c := new(chi.Context) + in := new(bytes.Buffer) + json.NewEncoder(in).Encode(&core.Template{Name: "", Data: "my_data"}) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", in) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleCreate(nil).ServeHTTP(w, r) + if got, want := w.Code, http.StatusBadRequest; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := &errors.Error{}, &errors.Error{Message: "No Template Name Provided"} + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} + +func TestHandleCreate_ValidationErrorData(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + c := new(chi.Context) + in := new(bytes.Buffer) + json.NewEncoder(in).Encode(&core.Template{Name: "my_template", Data: ""}) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", in) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleCreate(nil).ServeHTTP(w, r) + if got, want := w.Code, http.StatusBadRequest; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := &errors.Error{}, &errors.Error{Message: "No Template Data Provided"} + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} + +func TestHandleCreate_BadRequest(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + c := new(chi.Context) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", nil) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleCreate(nil).ServeHTTP(w, r) + if got, want := w.Code, http.StatusBadRequest; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := &errors.Error{}, &errors.Error{Message: "EOF"} + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} + +func TestHandleCreate_CreateError(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + templates := mock.NewMockTemplateStore(controller) + templates.EXPECT().Create(gomock.Any(), gomock.Any()).Return(errors.ErrNotFound) + + c := new(chi.Context) + in := new(bytes.Buffer) + json.NewEncoder(in).Encode(dummyTemplate) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", in) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleCreate(templates).ServeHTTP(w, r) + if got, want := w.Code, http.StatusInternalServerError; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := new(errors.Error), errors.ErrNotFound + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} diff --git a/handler/api/template/delete_test.go b/handler/api/template/delete_test.go new file mode 100644 index 000000000..cf36a7f27 --- /dev/null +++ b/handler/api/template/delete_test.go @@ -0,0 +1,100 @@ +// Copyright 2019 Drone.IO Inc. All rights reserved. +// Use of this source code is governed by the Drone Non-Commercial License +// that can be found in the LICENSE file. + +// +build !oss + +package template + +import ( + "context" + "encoding/json" + "github.com/drone/drone/handler/api/errors" + "github.com/drone/drone/mock" + "github.com/go-chi/chi" + "github.com/golang/mock/gomock" + "github.com/google/go-cmp/cmp" + "net/http" + "net/http/httptest" + "testing" +) + +func TestHandleDelete(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + template := mock.NewMockTemplateStore(controller) + template.EXPECT().FindName(gomock.Any(), dummyTemplate.Name).Return(dummyTemplate, nil) + template.EXPECT().Delete(gomock.Any(), dummyTemplate).Return(nil) + + c := new(chi.Context) + c.URLParams.Add("name", "my_template") + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", nil) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleDelete(template).ServeHTTP(w, r) + if got, want := w.Code, http.StatusNoContent; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } +} + +func TestHandleDelete_TemplateNotFound(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + template := mock.NewMockTemplateStore(controller) + template.EXPECT().FindName(gomock.Any(), dummyTemplate.Name).Return(nil, errors.ErrNotFound) + + c := new(chi.Context) + c.URLParams.Add("name", "my_template") + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", nil) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleDelete(template).ServeHTTP(w, r) + if got, want := w.Code, http.StatusNotFound; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := new(errors.Error), errors.ErrNotFound + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} + +func TestHandleDelete_DeleteError(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + template := mock.NewMockTemplateStore(controller) + template.EXPECT().FindName(gomock.Any(), dummyTemplate.Name).Return(dummyTemplate, nil) + template.EXPECT().Delete(gomock.Any(), dummyTemplate).Return(errors.ErrNotFound) + + c := new(chi.Context) + c.URLParams.Add("name", "my_template") + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", nil) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleDelete(template).ServeHTTP(w, r) + if got, want := w.Code, http.StatusInternalServerError; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := new(errors.Error), errors.ErrNotFound + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} diff --git a/handler/api/template/list_test.go b/handler/api/template/list_test.go new file mode 100644 index 000000000..79a05e753 --- /dev/null +++ b/handler/api/template/list_test.go @@ -0,0 +1,21 @@ +// Copyright 2019 Drone.IO Inc. All rights reserved. +// Use of this source code is governed by the Drone Non-Commercial License +// that can be found in the LICENSE file. + +// +build !oss + +package template + +import "github.com/drone/drone/core" + +var ( + dummyTemplate = &core.Template{ + Name: "my_template", + Data: "my_data", + Created: 1, + Updated: 2, + } + dummyTemplateList = []*core.Template{ + dummyTemplate, + } +) diff --git a/handler/api/template/update_test.go b/handler/api/template/update_test.go new file mode 100644 index 000000000..6036eb8cc --- /dev/null +++ b/handler/api/template/update_test.go @@ -0,0 +1,142 @@ +// Copyright 2019 Drone.IO Inc. All rights reserved. +// Use of this source code is governed by the Drone Non-Commercial License +// that can be found in the LICENSE file. + +// +build !oss + +package template + +import ( + "bytes" + "context" + "encoding/json" + "github.com/drone/drone/core" + "github.com/drone/drone/handler/api/errors" + "github.com/drone/drone/mock" + "github.com/go-chi/chi" + "github.com/golang/mock/gomock" + "github.com/google/go-cmp/cmp" + "net/http" + "net/http/httptest" + "testing" +) + +func TestHandleUpdate(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + template := mock.NewMockTemplateStore(controller) + template.EXPECT().FindName(gomock.Any(), dummyTemplate.Name).Return(dummyTemplate, nil) + template.EXPECT().Update(gomock.Any(), gomock.Any()).Return(nil) + + c := new(chi.Context) + c.URLParams.Add("name", "my_template") + + in := new(bytes.Buffer) + json.NewEncoder(in).Encode(dummyTemplate) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", in) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleUpdate(template).ServeHTTP(w, r) + if got, want := w.Code, http.StatusOK; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } +} + +func TestHandleUpdate_ValidationErrorData(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + template := mock.NewMockTemplateStore(controller) + template.EXPECT().FindName(gomock.Any(), dummyTemplate.Name).Return(&core.Template{Name: "my_template"}, nil) + + c := new(chi.Context) + c.URLParams.Add("name", "my_template") + + in := new(bytes.Buffer) + json.NewEncoder(in).Encode(&core.Secret{Data: ""}) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", in) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleUpdate(template).ServeHTTP(w, r) + if got, want := w.Code, http.StatusBadRequest; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := new(errors.Error), &errors.Error{Message: "No Template Data Provided"} + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} + +func TestHandleUpdate_TemplateNotFound(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + template := mock.NewMockTemplateStore(controller) + template.EXPECT().FindName(gomock.Any(), dummyTemplate.Name).Return(nil, errors.ErrNotFound) + + c := new(chi.Context) + c.URLParams.Add("name", "my_template") + + in := new(bytes.Buffer) + json.NewEncoder(in).Encode(&core.Secret{}) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", in) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleUpdate(template).ServeHTTP(w, r) + if got, want := w.Code, http.StatusNotFound; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := new(errors.Error), errors.ErrNotFound + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} + +func TestHandleUpdate_UpdateError(t *testing.T) { + controller := gomock.NewController(t) + defer controller.Finish() + + template := mock.NewMockTemplateStore(controller) + template.EXPECT().FindName(gomock.Any(), dummyTemplate.Name).Return(&core.Template{Name: "my_template"}, nil) + template.EXPECT().Update(gomock.Any(), gomock.Any()).Return(errors.ErrNotFound) + + c := new(chi.Context) + c.URLParams.Add("name", "my_template") + + in := new(bytes.Buffer) + json.NewEncoder(in).Encode(&core.Template{Data: "my_data"}) + + w := httptest.NewRecorder() + r := httptest.NewRequest("GET", "/", in) + r = r.WithContext( + context.WithValue(context.Background(), chi.RouteCtxKey, c), + ) + + HandleUpdate(template).ServeHTTP(w, r) + if got, want := w.Code, http.StatusInternalServerError; want != got { + t.Errorf("Want response code %d, got %d", want, got) + } + + got, want := new(errors.Error), errors.ErrNotFound + json.NewDecoder(w.Body).Decode(got) + if diff := cmp.Diff(got, want); len(diff) != 0 { + t.Errorf(diff) + } +} diff --git a/mock/mock.go b/mock/mock.go index 68c8c03f7..9528323e0 100644 --- a/mock/mock.go +++ b/mock/mock.go @@ -6,4 +6,4 @@ package mock -//go:generate mockgen -package=mock -destination=mock_gen.go github.com/drone/drone/core Pubsub,Canceler,ConvertService,ValidateService,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,Transferer,Triggerer,Syncer,LogStream,WebhookSender,LicenseService +//go:generate mockgen -package=mock -destination=mock_gen.go github.com/drone/drone/core Pubsub,Canceler,ConvertService,ValidateService,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,Transferer,Triggerer,Syncer,LogStream,WebhookSender,LicenseService,TemplateStore diff --git a/mock/mock_gen.go b/mock/mock_gen.go index 82c0614d7..97ca37123 100644 --- a/mock/mock_gen.go +++ b/mock/mock_gen.go @@ -1,42 +1,43 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/drone/drone/core (interfaces: Pubsub,Canceler,ConvertService,ValidateService,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,Transferer,Triggerer,Syncer,LogStream,WebhookSender,LicenseService) +// Source: github.com/drone/drone/core (interfaces: Pubsub,Canceler,ConvertService,ValidateService,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,Transferer,Triggerer,Syncer,LogStream,WebhookSender,LicenseService,TemplateStore) // 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" + + core "github.com/drone/drone/core" + gomock "github.com/golang/mock/gomock" ) -// MockPubsub is a mock of Pubsub interface +// MockPubsub is a mock of Pubsub interface. type MockPubsub struct { ctrl *gomock.Controller recorder *MockPubsubMockRecorder } -// MockPubsubMockRecorder is the mock recorder for MockPubsub +// MockPubsubMockRecorder is the mock recorder for MockPubsub. type MockPubsubMockRecorder struct { mock *MockPubsub } -// NewMockPubsub creates a new mock instance +// NewMockPubsub creates a new mock instance. func NewMockPubsub(ctrl *gomock.Controller) *MockPubsub { mock := &MockPubsub{ctrl: ctrl} mock.recorder = &MockPubsubMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockPubsub) EXPECT() *MockPubsubMockRecorder { return m.recorder } -// Publish mocks base method +// Publish mocks base method. func (m *MockPubsub) Publish(arg0 context.Context, arg1 *core.Message) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Publish", arg0, arg1) @@ -44,13 +45,13 @@ func (m *MockPubsub) Publish(arg0 context.Context, arg1 *core.Message) error { return ret0 } -// Publish indicates an expected call of Publish +// Publish indicates an expected call of Publish. func (mr *MockPubsubMockRecorder) Publish(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockPubsub)(nil).Publish), arg0, arg1) } -// Subscribe mocks base method +// Subscribe mocks base method. func (m *MockPubsub) Subscribe(arg0 context.Context) (<-chan *core.Message, <-chan error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Subscribe", arg0) @@ -59,13 +60,13 @@ func (m *MockPubsub) Subscribe(arg0 context.Context) (<-chan *core.Message, <-ch return ret0, ret1 } -// Subscribe indicates an expected call of Subscribe +// Subscribe indicates an expected call of Subscribe. func (mr *MockPubsubMockRecorder) Subscribe(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockPubsub)(nil).Subscribe), arg0) } -// Subscribers mocks base method +// Subscribers mocks base method. func (m *MockPubsub) Subscribers() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Subscribers") @@ -73,36 +74,36 @@ func (m *MockPubsub) Subscribers() int { return ret0 } -// Subscribers indicates an expected call of Subscribers +// Subscribers indicates an expected call of Subscribers. func (mr *MockPubsubMockRecorder) Subscribers() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribers", reflect.TypeOf((*MockPubsub)(nil).Subscribers)) } -// MockCanceler is a mock of Canceler interface +// MockCanceler is a mock of Canceler interface. type MockCanceler struct { ctrl *gomock.Controller recorder *MockCancelerMockRecorder } -// MockCancelerMockRecorder is the mock recorder for MockCanceler +// MockCancelerMockRecorder is the mock recorder for MockCanceler. type MockCancelerMockRecorder struct { mock *MockCanceler } -// NewMockCanceler creates a new mock instance +// NewMockCanceler creates a new mock instance. func NewMockCanceler(ctrl *gomock.Controller) *MockCanceler { mock := &MockCanceler{ctrl: ctrl} mock.recorder = &MockCancelerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockCanceler) EXPECT() *MockCancelerMockRecorder { return m.recorder } -// Cancel mocks base method +// Cancel mocks base method. func (m *MockCanceler) Cancel(arg0 context.Context, arg1 *core.Repository, arg2 *core.Build) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Cancel", arg0, arg1, arg2) @@ -110,13 +111,13 @@ func (m *MockCanceler) Cancel(arg0 context.Context, arg1 *core.Repository, arg2 return ret0 } -// Cancel indicates an expected call of Cancel +// Cancel indicates an expected call of Cancel. func (mr *MockCancelerMockRecorder) Cancel(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockCanceler)(nil).Cancel), arg0, arg1, arg2) } -// CancelPending mocks base method +// CancelPending mocks base method. func (m *MockCanceler) CancelPending(arg0 context.Context, arg1 *core.Repository, arg2 *core.Build) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CancelPending", arg0, arg1, arg2) @@ -124,36 +125,36 @@ func (m *MockCanceler) CancelPending(arg0 context.Context, arg1 *core.Repository return ret0 } -// CancelPending indicates an expected call of CancelPending +// CancelPending indicates an expected call of CancelPending. func (mr *MockCancelerMockRecorder) CancelPending(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelPending", reflect.TypeOf((*MockCanceler)(nil).CancelPending), arg0, arg1, arg2) } -// MockConvertService is a mock of ConvertService interface +// MockConvertService is a mock of ConvertService interface. type MockConvertService struct { ctrl *gomock.Controller recorder *MockConvertServiceMockRecorder } -// MockConvertServiceMockRecorder is the mock recorder for MockConvertService +// MockConvertServiceMockRecorder is the mock recorder for MockConvertService. type MockConvertServiceMockRecorder struct { mock *MockConvertService } -// NewMockConvertService creates a new mock instance +// NewMockConvertService creates a new mock instance. func NewMockConvertService(ctrl *gomock.Controller) *MockConvertService { mock := &MockConvertService{ctrl: ctrl} mock.recorder = &MockConvertServiceMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockConvertService) EXPECT() *MockConvertServiceMockRecorder { return m.recorder } -// Convert mocks base method +// Convert mocks base method. func (m *MockConvertService) Convert(arg0 context.Context, arg1 *core.ConvertArgs) (*core.Config, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Convert", arg0, arg1) @@ -162,36 +163,36 @@ func (m *MockConvertService) Convert(arg0 context.Context, arg1 *core.ConvertArg return ret0, ret1 } -// Convert indicates an expected call of Convert +// Convert indicates an expected call of Convert. func (mr *MockConvertServiceMockRecorder) Convert(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Convert", reflect.TypeOf((*MockConvertService)(nil).Convert), arg0, arg1) } -// MockValidateService is a mock of ValidateService interface +// MockValidateService is a mock of ValidateService interface. type MockValidateService struct { ctrl *gomock.Controller recorder *MockValidateServiceMockRecorder } -// MockValidateServiceMockRecorder is the mock recorder for MockValidateService +// MockValidateServiceMockRecorder is the mock recorder for MockValidateService. type MockValidateServiceMockRecorder struct { mock *MockValidateService } -// NewMockValidateService creates a new mock instance +// NewMockValidateService creates a new mock instance. func NewMockValidateService(ctrl *gomock.Controller) *MockValidateService { mock := &MockValidateService{ctrl: ctrl} mock.recorder = &MockValidateServiceMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockValidateService) EXPECT() *MockValidateServiceMockRecorder { return m.recorder } -// Validate mocks base method +// Validate mocks base method. func (m *MockValidateService) Validate(arg0 context.Context, arg1 *core.ValidateArgs) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Validate", arg0, arg1) @@ -199,36 +200,36 @@ func (m *MockValidateService) Validate(arg0 context.Context, arg1 *core.Validate return ret0 } -// Validate indicates an expected call of Validate +// Validate indicates an expected call of Validate. func (mr *MockValidateServiceMockRecorder) Validate(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validate", reflect.TypeOf((*MockValidateService)(nil).Validate), arg0, arg1) } -// MockNetrcService is a mock of NetrcService interface +// MockNetrcService is a mock of NetrcService interface. type MockNetrcService struct { ctrl *gomock.Controller recorder *MockNetrcServiceMockRecorder } -// MockNetrcServiceMockRecorder is the mock recorder for MockNetrcService +// MockNetrcServiceMockRecorder is the mock recorder for MockNetrcService. type MockNetrcServiceMockRecorder struct { mock *MockNetrcService } -// NewMockNetrcService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockNetrcService) EXPECT() *MockNetrcServiceMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockNetrcService) Create(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) (*core.Netrc, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2) @@ -237,36 +238,36 @@ func (m *MockNetrcService) Create(arg0 context.Context, arg1 *core.User, arg2 *c return ret0, ret1 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockNetrcServiceMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockNetrcService)(nil).Create), arg0, arg1, arg2) } -// MockRenewer is a mock of Renewer interface +// MockRenewer is a mock of Renewer interface. type MockRenewer struct { ctrl *gomock.Controller recorder *MockRenewerMockRecorder } -// MockRenewerMockRecorder is the mock recorder for MockRenewer +// MockRenewerMockRecorder is the mock recorder for MockRenewer. type MockRenewerMockRecorder struct { mock *MockRenewer } -// NewMockRenewer creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockRenewer) EXPECT() *MockRenewerMockRecorder { return m.recorder } -// Renew mocks base method +// Renew mocks base method. func (m *MockRenewer) Renew(arg0 context.Context, arg1 *core.User, arg2 bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Renew", arg0, arg1, arg2) @@ -274,36 +275,36 @@ func (m *MockRenewer) Renew(arg0 context.Context, arg1 *core.User, arg2 bool) er return ret0 } -// Renew indicates an expected call of Renew +// Renew indicates an expected call of Renew. func (mr *MockRenewerMockRecorder) Renew(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Renew", reflect.TypeOf((*MockRenewer)(nil).Renew), arg0, arg1, arg2) } -// MockHookParser is a mock of HookParser interface +// MockHookParser is a mock of HookParser interface. type MockHookParser struct { ctrl *gomock.Controller recorder *MockHookParserMockRecorder } -// MockHookParserMockRecorder is the mock recorder for MockHookParser +// MockHookParserMockRecorder is the mock recorder for MockHookParser. type MockHookParserMockRecorder struct { mock *MockHookParser } -// NewMockHookParser creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockHookParser) EXPECT() *MockHookParserMockRecorder { return m.recorder } -// Parse mocks base method +// Parse mocks base method. func (m *MockHookParser) Parse(arg0 *http.Request, arg1 func(string) string) (*core.Hook, *core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Parse", arg0, arg1) @@ -313,36 +314,36 @@ func (m *MockHookParser) Parse(arg0 *http.Request, arg1 func(string) string) (*c return ret0, ret1, ret2 } -// Parse indicates an expected call of Parse +// Parse indicates an expected call of Parse. func (mr *MockHookParserMockRecorder) Parse(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parse", reflect.TypeOf((*MockHookParser)(nil).Parse), arg0, arg1) } -// MockUserService is a mock of UserService interface +// MockUserService is a mock of UserService interface. type MockUserService struct { ctrl *gomock.Controller recorder *MockUserServiceMockRecorder } -// MockUserServiceMockRecorder is the mock recorder for MockUserService +// MockUserServiceMockRecorder is the mock recorder for MockUserService. type MockUserServiceMockRecorder struct { mock *MockUserService } -// NewMockUserService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockUserService) EXPECT() *MockUserServiceMockRecorder { return m.recorder } -// Find mocks base method +// Find mocks base method. func (m *MockUserService) Find(arg0 context.Context, arg1, arg2 string) (*core.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2) @@ -351,13 +352,13 @@ func (m *MockUserService) Find(arg0 context.Context, arg1, arg2 string) (*core.U return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockUserServiceMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockUserService)(nil).Find), arg0, arg1, arg2) } -// FindLogin mocks base method +// FindLogin mocks base method. func (m *MockUserService) FindLogin(arg0 context.Context, arg1 *core.User, arg2 string) (*core.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindLogin", arg0, arg1, arg2) @@ -366,36 +367,36 @@ func (m *MockUserService) FindLogin(arg0 context.Context, arg1 *core.User, arg2 return ret0, ret1 } -// FindLogin indicates an expected call of FindLogin +// FindLogin indicates an expected call of FindLogin. func (mr *MockUserServiceMockRecorder) FindLogin(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindLogin", reflect.TypeOf((*MockUserService)(nil).FindLogin), arg0, arg1, arg2) } -// MockRepositoryService is a mock of RepositoryService interface +// MockRepositoryService is a mock of RepositoryService interface. type MockRepositoryService struct { ctrl *gomock.Controller recorder *MockRepositoryServiceMockRecorder } -// MockRepositoryServiceMockRecorder is the mock recorder for MockRepositoryService +// MockRepositoryServiceMockRecorder is the mock recorder for MockRepositoryService. type MockRepositoryServiceMockRecorder struct { mock *MockRepositoryService } -// NewMockRepositoryService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockRepositoryService) EXPECT() *MockRepositoryServiceMockRecorder { return m.recorder } -// Find mocks base method +// Find mocks base method. func (m *MockRepositoryService) Find(arg0 context.Context, arg1 *core.User, arg2 string) (*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2) @@ -404,13 +405,13 @@ func (m *MockRepositoryService) Find(arg0 context.Context, arg1 *core.User, arg2 return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockRepositoryServiceMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockRepositoryService)(nil).Find), arg0, arg1, arg2) } -// FindPerm mocks base method +// FindPerm mocks base method. func (m *MockRepositoryService) FindPerm(arg0 context.Context, arg1 *core.User, arg2 string) (*core.Perm, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindPerm", arg0, arg1, arg2) @@ -419,13 +420,13 @@ func (m *MockRepositoryService) FindPerm(arg0 context.Context, arg1 *core.User, return ret0, ret1 } -// FindPerm indicates an expected call of FindPerm +// FindPerm indicates an expected call of FindPerm. func (mr *MockRepositoryServiceMockRecorder) FindPerm(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPerm", reflect.TypeOf((*MockRepositoryService)(nil).FindPerm), arg0, arg1, arg2) } -// List mocks base method +// List mocks base method. func (m *MockRepositoryService) List(arg0 context.Context, arg1 *core.User) ([]*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -434,36 +435,36 @@ func (m *MockRepositoryService) List(arg0 context.Context, arg1 *core.User) ([]* return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockRepositoryServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepositoryService)(nil).List), arg0, arg1) } -// MockCommitService is a mock of CommitService interface +// MockCommitService is a mock of CommitService interface. type MockCommitService struct { ctrl *gomock.Controller recorder *MockCommitServiceMockRecorder } -// MockCommitServiceMockRecorder is the mock recorder for MockCommitService +// MockCommitServiceMockRecorder is the mock recorder for MockCommitService. type MockCommitServiceMockRecorder struct { mock *MockCommitService } -// NewMockCommitService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockCommitService) EXPECT() *MockCommitServiceMockRecorder { return m.recorder } -// Find mocks base method +// Find mocks base method. func (m *MockCommitService) Find(arg0 context.Context, arg1 *core.User, arg2, arg3 string) (*core.Commit, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2, arg3) @@ -472,13 +473,13 @@ func (m *MockCommitService) Find(arg0 context.Context, arg1 *core.User, arg2, ar return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockCommitServiceMockRecorder) Find(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCommitService)(nil).Find), arg0, arg1, arg2, arg3) } -// FindRef mocks base method +// FindRef mocks base method. func (m *MockCommitService) FindRef(arg0 context.Context, arg1 *core.User, arg2, arg3 string) (*core.Commit, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindRef", arg0, arg1, arg2, arg3) @@ -487,13 +488,13 @@ func (m *MockCommitService) FindRef(arg0 context.Context, arg1 *core.User, arg2, return ret0, ret1 } -// FindRef indicates an expected call of FindRef +// FindRef indicates an expected call of FindRef. func (mr *MockCommitServiceMockRecorder) FindRef(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRef", reflect.TypeOf((*MockCommitService)(nil).FindRef), arg0, arg1, arg2, arg3) } -// ListChanges mocks base method +// ListChanges mocks base method. func (m *MockCommitService) ListChanges(arg0 context.Context, arg1 *core.User, arg2, arg3, arg4 string) ([]*core.Change, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListChanges", arg0, arg1, arg2, arg3, arg4) @@ -502,36 +503,36 @@ func (m *MockCommitService) ListChanges(arg0 context.Context, arg1 *core.User, a return ret0, ret1 } -// ListChanges indicates an expected call of ListChanges +// ListChanges indicates an expected call of ListChanges. func (mr *MockCommitServiceMockRecorder) ListChanges(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() 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 +// MockStatusService is a mock of StatusService interface. type MockStatusService struct { ctrl *gomock.Controller recorder *MockStatusServiceMockRecorder } -// MockStatusServiceMockRecorder is the mock recorder for MockStatusService +// MockStatusServiceMockRecorder is the mock recorder for MockStatusService. type MockStatusServiceMockRecorder struct { mock *MockStatusService } -// NewMockStatusService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStatusService) EXPECT() *MockStatusServiceMockRecorder { return m.recorder } -// Send mocks base method +// Send mocks base method. func (m *MockStatusService) Send(arg0 context.Context, arg1 *core.User, arg2 *core.StatusInput) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Send", arg0, arg1, arg2) @@ -539,36 +540,36 @@ func (m *MockStatusService) Send(arg0 context.Context, arg1 *core.User, arg2 *co return ret0 } -// Send indicates an expected call of Send +// Send indicates an expected call of Send. func (mr *MockStatusServiceMockRecorder) Send(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockStatusService)(nil).Send), arg0, arg1, arg2) } -// MockHookService is a mock of HookService interface +// MockHookService is a mock of HookService interface. type MockHookService struct { ctrl *gomock.Controller recorder *MockHookServiceMockRecorder } -// MockHookServiceMockRecorder is the mock recorder for MockHookService +// MockHookServiceMockRecorder is the mock recorder for MockHookService. type MockHookServiceMockRecorder struct { mock *MockHookService } -// NewMockHookService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockHookService) EXPECT() *MockHookServiceMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockHookService) Create(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2) @@ -576,13 +577,13 @@ func (m *MockHookService) Create(arg0 context.Context, arg1 *core.User, arg2 *co return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockHookServiceMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockHookService)(nil).Create), arg0, arg1, arg2) } -// Delete mocks base method +// Delete mocks base method. func (m *MockHookService) Delete(arg0 context.Context, arg1 *core.User, arg2 *core.Repository) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2) @@ -590,36 +591,36 @@ func (m *MockHookService) Delete(arg0 context.Context, arg1 *core.User, arg2 *co return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockHookServiceMockRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockHookService)(nil).Delete), arg0, arg1, arg2) } -// MockFileService is a mock of FileService interface +// MockFileService is a mock of FileService interface. type MockFileService struct { ctrl *gomock.Controller recorder *MockFileServiceMockRecorder } -// MockFileServiceMockRecorder is the mock recorder for MockFileService +// MockFileServiceMockRecorder is the mock recorder for MockFileService. type MockFileServiceMockRecorder struct { mock *MockFileService } -// NewMockFileService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockFileService) EXPECT() *MockFileServiceMockRecorder { return m.recorder } -// Find mocks base method +// Find mocks base method. func (m *MockFileService) Find(arg0 context.Context, arg1 *core.User, arg2, arg3, arg4, arg5 string) (*core.File, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2, arg3, arg4, arg5) @@ -628,36 +629,36 @@ func (m *MockFileService) Find(arg0 context.Context, arg1 *core.User, arg2, arg3 return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockFileServiceMockRecorder) Find(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() 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 +// MockBatcher is a mock of Batcher interface. type MockBatcher struct { ctrl *gomock.Controller recorder *MockBatcherMockRecorder } -// MockBatcherMockRecorder is the mock recorder for MockBatcher +// MockBatcherMockRecorder is the mock recorder for MockBatcher. type MockBatcherMockRecorder struct { mock *MockBatcher } -// NewMockBatcher creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockBatcher) EXPECT() *MockBatcherMockRecorder { return m.recorder } -// Batch mocks base method +// Batch mocks base method. func (m *MockBatcher) Batch(arg0 context.Context, arg1 *core.User, arg2 *core.Batch) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Batch", arg0, arg1, arg2) @@ -665,36 +666,36 @@ func (m *MockBatcher) Batch(arg0 context.Context, arg1 *core.User, arg2 *core.Ba return ret0 } -// Batch indicates an expected call of Batch +// Batch indicates an expected call of Batch. func (mr *MockBatcherMockRecorder) Batch(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Batch", reflect.TypeOf((*MockBatcher)(nil).Batch), arg0, arg1, arg2) } -// MockBuildStore is a mock of BuildStore interface +// MockBuildStore is a mock of BuildStore interface. type MockBuildStore struct { ctrl *gomock.Controller recorder *MockBuildStoreMockRecorder } -// MockBuildStoreMockRecorder is the mock recorder for MockBuildStore +// MockBuildStoreMockRecorder is the mock recorder for MockBuildStore. type MockBuildStoreMockRecorder struct { mock *MockBuildStore } -// NewMockBuildStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockBuildStore) EXPECT() *MockBuildStoreMockRecorder { return m.recorder } -// Count mocks base method +// Count mocks base method. func (m *MockBuildStore) Count(arg0 context.Context) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Count", arg0) @@ -703,13 +704,13 @@ func (m *MockBuildStore) Count(arg0 context.Context) (int64, error) { return ret0, ret1 } -// Count indicates an expected call of Count +// Count indicates an expected call of Count. func (mr *MockBuildStoreMockRecorder) Count(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockBuildStore)(nil).Count), arg0) } -// Create mocks base method +// Create mocks base method. func (m *MockBuildStore) Create(arg0 context.Context, arg1 *core.Build, arg2 []*core.Stage) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2) @@ -717,13 +718,13 @@ func (m *MockBuildStore) Create(arg0 context.Context, arg1 *core.Build, arg2 []* return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockBuildStoreMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockBuildStore)(nil).Create), arg0, arg1, arg2) } -// Delete mocks base method +// Delete mocks base method. func (m *MockBuildStore) Delete(arg0 context.Context, arg1 *core.Build) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -731,13 +732,13 @@ func (m *MockBuildStore) Delete(arg0 context.Context, arg1 *core.Build) error { return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockBuildStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockBuildStore)(nil).Delete), arg0, arg1) } -// DeleteBranch mocks base method +// DeleteBranch mocks base method. func (m *MockBuildStore) DeleteBranch(arg0 context.Context, arg1 int64, arg2 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteBranch", arg0, arg1, arg2) @@ -745,13 +746,13 @@ func (m *MockBuildStore) DeleteBranch(arg0 context.Context, arg1 int64, arg2 str return ret0 } -// DeleteBranch indicates an expected call of DeleteBranch +// DeleteBranch indicates an expected call of DeleteBranch. func (mr *MockBuildStoreMockRecorder) DeleteBranch(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBranch", reflect.TypeOf((*MockBuildStore)(nil).DeleteBranch), arg0, arg1, arg2) } -// DeleteDeploy mocks base method +// DeleteDeploy mocks base method. func (m *MockBuildStore) DeleteDeploy(arg0 context.Context, arg1 int64, arg2 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteDeploy", arg0, arg1, arg2) @@ -759,13 +760,13 @@ func (m *MockBuildStore) DeleteDeploy(arg0 context.Context, arg1 int64, arg2 str return ret0 } -// DeleteDeploy indicates an expected call of DeleteDeploy +// DeleteDeploy indicates an expected call of DeleteDeploy. func (mr *MockBuildStoreMockRecorder) DeleteDeploy(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeploy", reflect.TypeOf((*MockBuildStore)(nil).DeleteDeploy), arg0, arg1, arg2) } -// DeletePull mocks base method +// DeletePull mocks base method. func (m *MockBuildStore) DeletePull(arg0 context.Context, arg1 int64, arg2 int) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeletePull", arg0, arg1, arg2) @@ -773,13 +774,13 @@ func (m *MockBuildStore) DeletePull(arg0 context.Context, arg1 int64, arg2 int) return ret0 } -// DeletePull indicates an expected call of DeletePull +// DeletePull indicates an expected call of DeletePull. func (mr *MockBuildStoreMockRecorder) DeletePull(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePull", reflect.TypeOf((*MockBuildStore)(nil).DeletePull), arg0, arg1, arg2) } -// Find mocks base method +// Find mocks base method. func (m *MockBuildStore) Find(arg0 context.Context, arg1 int64) (*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -788,13 +789,13 @@ func (m *MockBuildStore) Find(arg0 context.Context, arg1 int64) (*core.Build, er return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockBuildStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockBuildStore)(nil).Find), arg0, arg1) } -// FindNumber mocks base method +// FindNumber mocks base method. func (m *MockBuildStore) FindNumber(arg0 context.Context, arg1, arg2 int64) (*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2) @@ -803,13 +804,13 @@ func (m *MockBuildStore) FindNumber(arg0 context.Context, arg1, arg2 int64) (*co return ret0, ret1 } -// FindNumber indicates an expected call of FindNumber +// FindNumber indicates an expected call of FindNumber. func (mr *MockBuildStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockBuildStore)(nil).FindNumber), arg0, arg1, arg2) } -// FindRef mocks base method +// FindRef mocks base method. func (m *MockBuildStore) FindRef(arg0 context.Context, arg1 int64, arg2 string) (*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindRef", arg0, arg1, arg2) @@ -818,13 +819,13 @@ func (m *MockBuildStore) FindRef(arg0 context.Context, arg1 int64, arg2 string) return ret0, ret1 } -// FindRef indicates an expected call of FindRef +// FindRef indicates an expected call of FindRef. func (mr *MockBuildStoreMockRecorder) FindRef(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindRef", reflect.TypeOf((*MockBuildStore)(nil).FindRef), arg0, arg1, arg2) } -// LatestBranches mocks base method +// LatestBranches mocks base method. func (m *MockBuildStore) LatestBranches(arg0 context.Context, arg1 int64) ([]*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LatestBranches", arg0, arg1) @@ -833,13 +834,13 @@ func (m *MockBuildStore) LatestBranches(arg0 context.Context, arg1 int64) ([]*co return ret0, ret1 } -// LatestBranches indicates an expected call of LatestBranches +// LatestBranches indicates an expected call of LatestBranches. func (mr *MockBuildStoreMockRecorder) LatestBranches(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestBranches", reflect.TypeOf((*MockBuildStore)(nil).LatestBranches), arg0, arg1) } -// LatestDeploys mocks base method +// LatestDeploys mocks base method. func (m *MockBuildStore) LatestDeploys(arg0 context.Context, arg1 int64) ([]*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LatestDeploys", arg0, arg1) @@ -848,13 +849,13 @@ func (m *MockBuildStore) LatestDeploys(arg0 context.Context, arg1 int64) ([]*cor return ret0, ret1 } -// LatestDeploys indicates an expected call of LatestDeploys +// LatestDeploys indicates an expected call of LatestDeploys. func (mr *MockBuildStoreMockRecorder) LatestDeploys(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestDeploys", reflect.TypeOf((*MockBuildStore)(nil).LatestDeploys), arg0, arg1) } -// LatestPulls mocks base method +// LatestPulls mocks base method. func (m *MockBuildStore) LatestPulls(arg0 context.Context, arg1 int64) ([]*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LatestPulls", arg0, arg1) @@ -863,13 +864,13 @@ func (m *MockBuildStore) LatestPulls(arg0 context.Context, arg1 int64) ([]*core. return ret0, ret1 } -// LatestPulls indicates an expected call of LatestPulls +// LatestPulls indicates an expected call of LatestPulls. func (mr *MockBuildStoreMockRecorder) LatestPulls(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestPulls", reflect.TypeOf((*MockBuildStore)(nil).LatestPulls), arg0, arg1) } -// List mocks base method +// List mocks base method. func (m *MockBuildStore) List(arg0 context.Context, arg1 int64, arg2, arg3 int) ([]*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1, arg2, arg3) @@ -878,13 +879,13 @@ func (m *MockBuildStore) List(arg0 context.Context, arg1 int64, arg2, arg3 int) return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockBuildStoreMockRecorder) List(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockBuildStore)(nil).List), arg0, arg1, arg2, arg3) } -// ListRef mocks base method +// ListRef mocks base method. func (m *MockBuildStore) ListRef(arg0 context.Context, arg1 int64, arg2 string, arg3, arg4 int) ([]*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListRef", arg0, arg1, arg2, arg3, arg4) @@ -893,13 +894,13 @@ func (m *MockBuildStore) ListRef(arg0 context.Context, arg1 int64, arg2 string, return ret0, ret1 } -// ListRef indicates an expected call of ListRef +// ListRef indicates an expected call of ListRef. func (mr *MockBuildStoreMockRecorder) ListRef(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRef", reflect.TypeOf((*MockBuildStore)(nil).ListRef), arg0, arg1, arg2, arg3, arg4) } -// Pending mocks base method +// Pending mocks base method. func (m *MockBuildStore) Pending(arg0 context.Context) ([]*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Pending", arg0) @@ -908,13 +909,13 @@ func (m *MockBuildStore) Pending(arg0 context.Context) ([]*core.Build, error) { return ret0, ret1 } -// Pending indicates an expected call of Pending +// Pending indicates an expected call of Pending. func (mr *MockBuildStoreMockRecorder) Pending(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pending", reflect.TypeOf((*MockBuildStore)(nil).Pending), arg0) } -// Purge mocks base method +// Purge mocks base method. func (m *MockBuildStore) Purge(arg0 context.Context, arg1, arg2 int64) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Purge", arg0, arg1, arg2) @@ -922,13 +923,13 @@ func (m *MockBuildStore) Purge(arg0 context.Context, arg1, arg2 int64) error { return ret0 } -// Purge indicates an expected call of Purge +// Purge indicates an expected call of Purge. func (mr *MockBuildStoreMockRecorder) Purge(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Purge", reflect.TypeOf((*MockBuildStore)(nil).Purge), arg0, arg1, arg2) } -// Running mocks base method +// Running mocks base method. func (m *MockBuildStore) Running(arg0 context.Context) ([]*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Running", arg0) @@ -937,13 +938,13 @@ func (m *MockBuildStore) Running(arg0 context.Context) ([]*core.Build, error) { return ret0, ret1 } -// Running indicates an expected call of Running +// Running indicates an expected call of Running. func (mr *MockBuildStoreMockRecorder) Running(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Running", reflect.TypeOf((*MockBuildStore)(nil).Running), arg0) } -// Update mocks base method +// Update mocks base method. func (m *MockBuildStore) Update(arg0 context.Context, arg1 *core.Build) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -951,36 +952,36 @@ func (m *MockBuildStore) Update(arg0 context.Context, arg1 *core.Build) error { return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockBuildStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockBuildStore)(nil).Update), arg0, arg1) } -// MockCronStore is a mock of CronStore interface +// MockCronStore is a mock of CronStore interface. type MockCronStore struct { ctrl *gomock.Controller recorder *MockCronStoreMockRecorder } -// MockCronStoreMockRecorder is the mock recorder for MockCronStore +// MockCronStoreMockRecorder is the mock recorder for MockCronStore. type MockCronStoreMockRecorder struct { mock *MockCronStore } -// NewMockCronStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockCronStore) EXPECT() *MockCronStoreMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockCronStore) Create(arg0 context.Context, arg1 *core.Cron) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -988,13 +989,13 @@ func (m *MockCronStore) Create(arg0 context.Context, arg1 *core.Cron) error { return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockCronStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockCronStore)(nil).Create), arg0, arg1) } -// Delete mocks base method +// Delete mocks base method. func (m *MockCronStore) Delete(arg0 context.Context, arg1 *core.Cron) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -1002,13 +1003,13 @@ func (m *MockCronStore) Delete(arg0 context.Context, arg1 *core.Cron) error { return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockCronStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCronStore)(nil).Delete), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockCronStore) Find(arg0 context.Context, arg1 int64) (*core.Cron, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -1017,13 +1018,13 @@ func (m *MockCronStore) Find(arg0 context.Context, arg1 int64) (*core.Cron, erro return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockCronStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCronStore)(nil).Find), arg0, arg1) } -// FindName mocks base method +// FindName mocks base method. func (m *MockCronStore) FindName(arg0 context.Context, arg1 int64, arg2 string) (*core.Cron, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2) @@ -1032,13 +1033,13 @@ func (m *MockCronStore) FindName(arg0 context.Context, arg1 int64, arg2 string) return ret0, ret1 } -// FindName indicates an expected call of FindName +// FindName indicates an expected call of FindName. func (mr *MockCronStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockCronStore)(nil).FindName), arg0, arg1, arg2) } -// List mocks base method +// List mocks base method. func (m *MockCronStore) List(arg0 context.Context, arg1 int64) ([]*core.Cron, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -1047,13 +1048,13 @@ func (m *MockCronStore) List(arg0 context.Context, arg1 int64) ([]*core.Cron, er return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockCronStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockCronStore)(nil).List), arg0, arg1) } -// Ready mocks base method +// Ready mocks base method. func (m *MockCronStore) Ready(arg0 context.Context, arg1 int64) ([]*core.Cron, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Ready", arg0, arg1) @@ -1062,13 +1063,13 @@ func (m *MockCronStore) Ready(arg0 context.Context, arg1 int64) ([]*core.Cron, e return ret0, ret1 } -// Ready indicates an expected call of Ready +// Ready indicates an expected call of Ready. func (mr *MockCronStoreMockRecorder) Ready(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockCronStore)(nil).Ready), arg0, arg1) } -// Update mocks base method +// Update mocks base method. func (m *MockCronStore) Update(arg0 context.Context, arg1 *core.Cron) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -1076,36 +1077,36 @@ func (m *MockCronStore) Update(arg0 context.Context, arg1 *core.Cron) error { return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockCronStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCronStore)(nil).Update), arg0, arg1) } -// MockLogStore is a mock of LogStore interface +// MockLogStore is a mock of LogStore interface. type MockLogStore struct { ctrl *gomock.Controller recorder *MockLogStoreMockRecorder } -// MockLogStoreMockRecorder is the mock recorder for MockLogStore +// MockLogStoreMockRecorder is the mock recorder for MockLogStore. type MockLogStoreMockRecorder struct { mock *MockLogStore } -// NewMockLogStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockLogStore) EXPECT() *MockLogStoreMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockLogStore) Create(arg0 context.Context, arg1 int64, arg2 io.Reader) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2) @@ -1113,13 +1114,13 @@ func (m *MockLogStore) Create(arg0 context.Context, arg1 int64, arg2 io.Reader) return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockLogStoreMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLogStore)(nil).Create), arg0, arg1, arg2) } -// Delete mocks base method +// Delete mocks base method. func (m *MockLogStore) Delete(arg0 context.Context, arg1 int64) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -1127,13 +1128,13 @@ func (m *MockLogStore) Delete(arg0 context.Context, arg1 int64) error { return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockLogStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLogStore)(nil).Delete), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockLogStore) Find(arg0 context.Context, arg1 int64) (io.ReadCloser, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -1142,13 +1143,13 @@ func (m *MockLogStore) Find(arg0 context.Context, arg1 int64) (io.ReadCloser, er return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockLogStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockLogStore)(nil).Find), arg0, arg1) } -// Update mocks base method +// Update mocks base method. func (m *MockLogStore) Update(arg0 context.Context, arg1 int64, arg2 io.Reader) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2) @@ -1156,36 +1157,36 @@ func (m *MockLogStore) Update(arg0 context.Context, arg1 int64, arg2 io.Reader) return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockLogStoreMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLogStore)(nil).Update), arg0, arg1, arg2) } -// MockPermStore is a mock of PermStore interface +// MockPermStore is a mock of PermStore interface. type MockPermStore struct { ctrl *gomock.Controller recorder *MockPermStoreMockRecorder } -// MockPermStoreMockRecorder is the mock recorder for MockPermStore +// MockPermStoreMockRecorder is the mock recorder for MockPermStore. type MockPermStoreMockRecorder struct { mock *MockPermStore } -// NewMockPermStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockPermStore) EXPECT() *MockPermStoreMockRecorder { return m.recorder } -// Delete mocks base method +// Delete mocks base method. func (m *MockPermStore) Delete(arg0 context.Context, arg1 *core.Perm) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -1193,13 +1194,13 @@ func (m *MockPermStore) Delete(arg0 context.Context, arg1 *core.Perm) error { return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockPermStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPermStore)(nil).Delete), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockPermStore) Find(arg0 context.Context, arg1 string, arg2 int64) (*core.Perm, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1, arg2) @@ -1208,13 +1209,13 @@ func (m *MockPermStore) Find(arg0 context.Context, arg1 string, arg2 int64) (*co return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockPermStoreMockRecorder) Find(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockPermStore)(nil).Find), arg0, arg1, arg2) } -// List mocks base method +// List mocks base method. func (m *MockPermStore) List(arg0 context.Context, arg1 string) ([]*core.Collaborator, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -1223,13 +1224,13 @@ func (m *MockPermStore) List(arg0 context.Context, arg1 string) ([]*core.Collabo return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockPermStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPermStore)(nil).List), arg0, arg1) } -// Update mocks base method +// Update mocks base method. func (m *MockPermStore) Update(arg0 context.Context, arg1 *core.Perm) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -1237,36 +1238,36 @@ func (m *MockPermStore) Update(arg0 context.Context, arg1 *core.Perm) error { return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockPermStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockPermStore)(nil).Update), arg0, arg1) } -// MockSecretStore is a mock of SecretStore interface +// MockSecretStore is a mock of SecretStore interface. type MockSecretStore struct { ctrl *gomock.Controller recorder *MockSecretStoreMockRecorder } -// MockSecretStoreMockRecorder is the mock recorder for MockSecretStore +// MockSecretStoreMockRecorder is the mock recorder for MockSecretStore. type MockSecretStoreMockRecorder struct { mock *MockSecretStore } -// NewMockSecretStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockSecretStore) EXPECT() *MockSecretStoreMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockSecretStore) Create(arg0 context.Context, arg1 *core.Secret) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -1274,13 +1275,13 @@ func (m *MockSecretStore) Create(arg0 context.Context, arg1 *core.Secret) error return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockSecretStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSecretStore)(nil).Create), arg0, arg1) } -// Delete mocks base method +// Delete mocks base method. func (m *MockSecretStore) Delete(arg0 context.Context, arg1 *core.Secret) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -1288,13 +1289,13 @@ func (m *MockSecretStore) Delete(arg0 context.Context, arg1 *core.Secret) error return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockSecretStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSecretStore)(nil).Delete), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockSecretStore) Find(arg0 context.Context, arg1 int64) (*core.Secret, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -1303,13 +1304,13 @@ func (m *MockSecretStore) Find(arg0 context.Context, arg1 int64) (*core.Secret, return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockSecretStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockSecretStore)(nil).Find), arg0, arg1) } -// FindName mocks base method +// FindName mocks base method. func (m *MockSecretStore) FindName(arg0 context.Context, arg1 int64, arg2 string) (*core.Secret, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2) @@ -1318,13 +1319,13 @@ func (m *MockSecretStore) FindName(arg0 context.Context, arg1 int64, arg2 string return ret0, ret1 } -// FindName indicates an expected call of FindName +// FindName indicates an expected call of FindName. func (mr *MockSecretStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockSecretStore)(nil).FindName), arg0, arg1, arg2) } -// List mocks base method +// List mocks base method. func (m *MockSecretStore) List(arg0 context.Context, arg1 int64) ([]*core.Secret, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -1333,13 +1334,13 @@ func (m *MockSecretStore) List(arg0 context.Context, arg1 int64) ([]*core.Secret return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockSecretStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSecretStore)(nil).List), arg0, arg1) } -// Update mocks base method +// Update mocks base method. func (m *MockSecretStore) Update(arg0 context.Context, arg1 *core.Secret) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -1347,36 +1348,36 @@ func (m *MockSecretStore) Update(arg0 context.Context, arg1 *core.Secret) error return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockSecretStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSecretStore)(nil).Update), arg0, arg1) } -// MockGlobalSecretStore is a mock of GlobalSecretStore interface +// MockGlobalSecretStore is a mock of GlobalSecretStore interface. type MockGlobalSecretStore struct { ctrl *gomock.Controller recorder *MockGlobalSecretStoreMockRecorder } -// MockGlobalSecretStoreMockRecorder is the mock recorder for MockGlobalSecretStore +// MockGlobalSecretStoreMockRecorder is the mock recorder for MockGlobalSecretStore. type MockGlobalSecretStoreMockRecorder struct { mock *MockGlobalSecretStore } -// NewMockGlobalSecretStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockGlobalSecretStore) EXPECT() *MockGlobalSecretStoreMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockGlobalSecretStore) Create(arg0 context.Context, arg1 *core.Secret) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -1384,13 +1385,13 @@ func (m *MockGlobalSecretStore) Create(arg0 context.Context, arg1 *core.Secret) return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockGlobalSecretStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockGlobalSecretStore)(nil).Create), arg0, arg1) } -// Delete mocks base method +// Delete mocks base method. func (m *MockGlobalSecretStore) Delete(arg0 context.Context, arg1 *core.Secret) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -1398,13 +1399,13 @@ func (m *MockGlobalSecretStore) Delete(arg0 context.Context, arg1 *core.Secret) return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockGlobalSecretStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockGlobalSecretStore)(nil).Delete), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockGlobalSecretStore) Find(arg0 context.Context, arg1 int64) (*core.Secret, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -1413,13 +1414,13 @@ func (m *MockGlobalSecretStore) Find(arg0 context.Context, arg1 int64) (*core.Se return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockGlobalSecretStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockGlobalSecretStore)(nil).Find), arg0, arg1) } -// FindName mocks base method +// FindName mocks base method. func (m *MockGlobalSecretStore) FindName(arg0 context.Context, arg1, arg2 string) (*core.Secret, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2) @@ -1428,13 +1429,13 @@ func (m *MockGlobalSecretStore) FindName(arg0 context.Context, arg1, arg2 string return ret0, ret1 } -// FindName indicates an expected call of FindName +// FindName indicates an expected call of FindName. func (mr *MockGlobalSecretStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockGlobalSecretStore)(nil).FindName), arg0, arg1, arg2) } -// List mocks base method +// List mocks base method. func (m *MockGlobalSecretStore) List(arg0 context.Context, arg1 string) ([]*core.Secret, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -1443,13 +1444,13 @@ func (m *MockGlobalSecretStore) List(arg0 context.Context, arg1 string) ([]*core return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockGlobalSecretStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockGlobalSecretStore)(nil).List), arg0, arg1) } -// ListAll mocks base method +// ListAll mocks base method. func (m *MockGlobalSecretStore) ListAll(arg0 context.Context) ([]*core.Secret, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListAll", arg0) @@ -1458,13 +1459,13 @@ func (m *MockGlobalSecretStore) ListAll(arg0 context.Context) ([]*core.Secret, e return ret0, ret1 } -// ListAll indicates an expected call of ListAll +// ListAll indicates an expected call of ListAll. func (mr *MockGlobalSecretStoreMockRecorder) ListAll(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAll", reflect.TypeOf((*MockGlobalSecretStore)(nil).ListAll), arg0) } -// Update mocks base method +// Update mocks base method. func (m *MockGlobalSecretStore) Update(arg0 context.Context, arg1 *core.Secret) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -1472,36 +1473,36 @@ func (m *MockGlobalSecretStore) Update(arg0 context.Context, arg1 *core.Secret) return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockGlobalSecretStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockGlobalSecretStore)(nil).Update), arg0, arg1) } -// MockStageStore is a mock of StageStore interface +// MockStageStore is a mock of StageStore interface. type MockStageStore struct { ctrl *gomock.Controller recorder *MockStageStoreMockRecorder } -// MockStageStoreMockRecorder is the mock recorder for MockStageStore +// MockStageStoreMockRecorder is the mock recorder for MockStageStore. type MockStageStoreMockRecorder struct { mock *MockStageStore } -// NewMockStageStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStageStore) EXPECT() *MockStageStoreMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockStageStore) Create(arg0 context.Context, arg1 *core.Stage) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -1509,13 +1510,13 @@ func (m *MockStageStore) Create(arg0 context.Context, arg1 *core.Stage) error { return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockStageStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStageStore)(nil).Create), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockStageStore) Find(arg0 context.Context, arg1 int64) (*core.Stage, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -1524,13 +1525,13 @@ func (m *MockStageStore) Find(arg0 context.Context, arg1 int64) (*core.Stage, er return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockStageStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockStageStore)(nil).Find), arg0, arg1) } -// FindNumber mocks base method +// FindNumber mocks base method. func (m *MockStageStore) FindNumber(arg0 context.Context, arg1 int64, arg2 int) (*core.Stage, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2) @@ -1539,13 +1540,13 @@ func (m *MockStageStore) FindNumber(arg0 context.Context, arg1 int64, arg2 int) return ret0, ret1 } -// FindNumber indicates an expected call of FindNumber +// FindNumber indicates an expected call of FindNumber. func (mr *MockStageStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockStageStore)(nil).FindNumber), arg0, arg1, arg2) } -// List mocks base method +// List mocks base method. func (m *MockStageStore) List(arg0 context.Context, arg1 int64) ([]*core.Stage, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -1554,13 +1555,13 @@ func (m *MockStageStore) List(arg0 context.Context, arg1 int64) ([]*core.Stage, return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockStageStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStageStore)(nil).List), arg0, arg1) } -// ListIncomplete mocks base method +// ListIncomplete mocks base method. func (m *MockStageStore) ListIncomplete(arg0 context.Context) ([]*core.Stage, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListIncomplete", arg0) @@ -1569,13 +1570,13 @@ func (m *MockStageStore) ListIncomplete(arg0 context.Context) ([]*core.Stage, er return ret0, ret1 } -// ListIncomplete indicates an expected call of ListIncomplete +// ListIncomplete indicates an expected call of ListIncomplete. func (mr *MockStageStoreMockRecorder) ListIncomplete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncomplete", reflect.TypeOf((*MockStageStore)(nil).ListIncomplete), arg0) } -// ListState mocks base method +// ListState mocks base method. func (m *MockStageStore) ListState(arg0 context.Context, arg1 string) ([]*core.Stage, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListState", arg0, arg1) @@ -1584,13 +1585,13 @@ func (m *MockStageStore) ListState(arg0 context.Context, arg1 string) ([]*core.S return ret0, ret1 } -// ListState indicates an expected call of ListState +// ListState indicates an expected call of ListState. func (mr *MockStageStoreMockRecorder) ListState(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListState", reflect.TypeOf((*MockStageStore)(nil).ListState), arg0, arg1) } -// ListSteps mocks base method +// ListSteps mocks base method. func (m *MockStageStore) ListSteps(arg0 context.Context, arg1 int64) ([]*core.Stage, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListSteps", arg0, arg1) @@ -1599,13 +1600,13 @@ func (m *MockStageStore) ListSteps(arg0 context.Context, arg1 int64) ([]*core.St return ret0, ret1 } -// ListSteps indicates an expected call of ListSteps +// ListSteps indicates an expected call of ListSteps. func (mr *MockStageStoreMockRecorder) ListSteps(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSteps", reflect.TypeOf((*MockStageStore)(nil).ListSteps), arg0, arg1) } -// Update mocks base method +// Update mocks base method. func (m *MockStageStore) Update(arg0 context.Context, arg1 *core.Stage) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -1613,36 +1614,36 @@ func (m *MockStageStore) Update(arg0 context.Context, arg1 *core.Stage) error { return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockStageStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStageStore)(nil).Update), arg0, arg1) } -// MockStepStore is a mock of StepStore interface +// MockStepStore is a mock of StepStore interface. type MockStepStore struct { ctrl *gomock.Controller recorder *MockStepStoreMockRecorder } -// MockStepStoreMockRecorder is the mock recorder for MockStepStore +// MockStepStoreMockRecorder is the mock recorder for MockStepStore. type MockStepStoreMockRecorder struct { mock *MockStepStore } -// NewMockStepStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStepStore) EXPECT() *MockStepStoreMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockStepStore) Create(arg0 context.Context, arg1 *core.Step) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -1650,13 +1651,13 @@ func (m *MockStepStore) Create(arg0 context.Context, arg1 *core.Step) error { return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockStepStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStepStore)(nil).Create), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockStepStore) Find(arg0 context.Context, arg1 int64) (*core.Step, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -1665,13 +1666,13 @@ func (m *MockStepStore) Find(arg0 context.Context, arg1 int64) (*core.Step, erro return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockStepStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockStepStore)(nil).Find), arg0, arg1) } -// FindNumber mocks base method +// FindNumber mocks base method. func (m *MockStepStore) FindNumber(arg0 context.Context, arg1 int64, arg2 int) (*core.Step, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindNumber", arg0, arg1, arg2) @@ -1680,13 +1681,13 @@ func (m *MockStepStore) FindNumber(arg0 context.Context, arg1 int64, arg2 int) ( return ret0, ret1 } -// FindNumber indicates an expected call of FindNumber +// FindNumber indicates an expected call of FindNumber. func (mr *MockStepStoreMockRecorder) FindNumber(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindNumber", reflect.TypeOf((*MockStepStore)(nil).FindNumber), arg0, arg1, arg2) } -// List mocks base method +// List mocks base method. func (m *MockStepStore) List(arg0 context.Context, arg1 int64) ([]*core.Step, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -1695,13 +1696,13 @@ func (m *MockStepStore) List(arg0 context.Context, arg1 int64) ([]*core.Step, er return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockStepStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStepStore)(nil).List), arg0, arg1) } -// Update mocks base method +// Update mocks base method. func (m *MockStepStore) Update(arg0 context.Context, arg1 *core.Step) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -1709,36 +1710,36 @@ func (m *MockStepStore) Update(arg0 context.Context, arg1 *core.Step) error { return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockStepStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStepStore)(nil).Update), arg0, arg1) } -// MockRepositoryStore is a mock of RepositoryStore interface +// MockRepositoryStore is a mock of RepositoryStore interface. type MockRepositoryStore struct { ctrl *gomock.Controller recorder *MockRepositoryStoreMockRecorder } -// MockRepositoryStoreMockRecorder is the mock recorder for MockRepositoryStore +// MockRepositoryStoreMockRecorder is the mock recorder for MockRepositoryStore. type MockRepositoryStoreMockRecorder struct { mock *MockRepositoryStore } -// NewMockRepositoryStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockRepositoryStore) EXPECT() *MockRepositoryStoreMockRecorder { return m.recorder } -// Activate mocks base method +// Activate mocks base method. func (m *MockRepositoryStore) Activate(arg0 context.Context, arg1 *core.Repository) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Activate", arg0, arg1) @@ -1746,13 +1747,13 @@ func (m *MockRepositoryStore) Activate(arg0 context.Context, arg1 *core.Reposito return ret0 } -// Activate indicates an expected call of Activate +// Activate indicates an expected call of Activate. func (mr *MockRepositoryStoreMockRecorder) Activate(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Activate", reflect.TypeOf((*MockRepositoryStore)(nil).Activate), arg0, arg1) } -// Count mocks base method +// Count mocks base method. func (m *MockRepositoryStore) Count(arg0 context.Context) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Count", arg0) @@ -1761,13 +1762,13 @@ func (m *MockRepositoryStore) Count(arg0 context.Context) (int64, error) { return ret0, ret1 } -// Count indicates an expected call of Count +// Count indicates an expected call of Count. func (mr *MockRepositoryStoreMockRecorder) Count(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockRepositoryStore)(nil).Count), arg0) } -// Create mocks base method +// Create mocks base method. func (m *MockRepositoryStore) Create(arg0 context.Context, arg1 *core.Repository) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -1775,13 +1776,13 @@ func (m *MockRepositoryStore) Create(arg0 context.Context, arg1 *core.Repository return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockRepositoryStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRepositoryStore)(nil).Create), arg0, arg1) } -// Delete mocks base method +// Delete mocks base method. func (m *MockRepositoryStore) Delete(arg0 context.Context, arg1 *core.Repository) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -1789,13 +1790,13 @@ func (m *MockRepositoryStore) Delete(arg0 context.Context, arg1 *core.Repository return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockRepositoryStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepositoryStore)(nil).Delete), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockRepositoryStore) Find(arg0 context.Context, arg1 int64) (*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -1804,13 +1805,13 @@ func (m *MockRepositoryStore) Find(arg0 context.Context, arg1 int64) (*core.Repo return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockRepositoryStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockRepositoryStore)(nil).Find), arg0, arg1) } -// FindName mocks base method +// FindName mocks base method. func (m *MockRepositoryStore) FindName(arg0 context.Context, arg1, arg2 string) (*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindName", arg0, arg1, arg2) @@ -1819,13 +1820,13 @@ func (m *MockRepositoryStore) FindName(arg0 context.Context, arg1, arg2 string) return ret0, ret1 } -// FindName indicates an expected call of FindName +// FindName indicates an expected call of FindName. func (mr *MockRepositoryStoreMockRecorder) FindName(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockRepositoryStore)(nil).FindName), arg0, arg1, arg2) } -// Increment mocks base method +// Increment mocks base method. func (m *MockRepositoryStore) Increment(arg0 context.Context, arg1 *core.Repository) (*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Increment", arg0, arg1) @@ -1834,13 +1835,13 @@ func (m *MockRepositoryStore) Increment(arg0 context.Context, arg1 *core.Reposit return ret0, ret1 } -// Increment indicates an expected call of Increment +// Increment indicates an expected call of Increment. func (mr *MockRepositoryStoreMockRecorder) Increment(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Increment", reflect.TypeOf((*MockRepositoryStore)(nil).Increment), arg0, arg1) } -// List mocks base method +// List mocks base method. func (m *MockRepositoryStore) List(arg0 context.Context, arg1 int64) ([]*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -1849,13 +1850,13 @@ func (m *MockRepositoryStore) List(arg0 context.Context, arg1 int64) ([]*core.Re return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockRepositoryStoreMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepositoryStore)(nil).List), arg0, arg1) } -// ListAll mocks base method +// ListAll mocks base method. func (m *MockRepositoryStore) ListAll(arg0 context.Context, arg1, arg2 int) ([]*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListAll", arg0, arg1, arg2) @@ -1864,13 +1865,13 @@ func (m *MockRepositoryStore) ListAll(arg0 context.Context, arg1, arg2 int) ([]* return ret0, ret1 } -// ListAll indicates an expected call of ListAll +// ListAll indicates an expected call of ListAll. func (mr *MockRepositoryStoreMockRecorder) ListAll(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAll", reflect.TypeOf((*MockRepositoryStore)(nil).ListAll), arg0, arg1, arg2) } -// ListIncomplete mocks base method +// ListIncomplete mocks base method. func (m *MockRepositoryStore) ListIncomplete(arg0 context.Context) ([]*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListIncomplete", arg0) @@ -1879,13 +1880,13 @@ func (m *MockRepositoryStore) ListIncomplete(arg0 context.Context) ([]*core.Repo return ret0, ret1 } -// ListIncomplete indicates an expected call of ListIncomplete +// ListIncomplete indicates an expected call of ListIncomplete. func (mr *MockRepositoryStoreMockRecorder) ListIncomplete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncomplete", reflect.TypeOf((*MockRepositoryStore)(nil).ListIncomplete), arg0) } -// ListLatest mocks base method +// ListLatest mocks base method. func (m *MockRepositoryStore) ListLatest(arg0 context.Context, arg1 int64) ([]*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListLatest", arg0, arg1) @@ -1894,13 +1895,13 @@ func (m *MockRepositoryStore) ListLatest(arg0 context.Context, arg1 int64) ([]*c return ret0, ret1 } -// ListLatest indicates an expected call of ListLatest +// ListLatest indicates an expected call of ListLatest. func (mr *MockRepositoryStoreMockRecorder) ListLatest(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLatest", reflect.TypeOf((*MockRepositoryStore)(nil).ListLatest), arg0, arg1) } -// ListRecent mocks base method +// ListRecent mocks base method. func (m *MockRepositoryStore) ListRecent(arg0 context.Context, arg1 int64) ([]*core.Repository, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListRecent", arg0, arg1) @@ -1909,13 +1910,13 @@ func (m *MockRepositoryStore) ListRecent(arg0 context.Context, arg1 int64) ([]*c return ret0, ret1 } -// ListRecent indicates an expected call of ListRecent +// ListRecent indicates an expected call of ListRecent. func (mr *MockRepositoryStoreMockRecorder) ListRecent(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRecent", reflect.TypeOf((*MockRepositoryStore)(nil).ListRecent), arg0, arg1) } -// Update mocks base method +// Update mocks base method. func (m *MockRepositoryStore) Update(arg0 context.Context, arg1 *core.Repository) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -1923,36 +1924,36 @@ func (m *MockRepositoryStore) Update(arg0 context.Context, arg1 *core.Repository return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockRepositoryStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRepositoryStore)(nil).Update), arg0, arg1) } -// MockUserStore is a mock of UserStore interface +// MockUserStore is a mock of UserStore interface. type MockUserStore struct { ctrl *gomock.Controller recorder *MockUserStoreMockRecorder } -// MockUserStoreMockRecorder is the mock recorder for MockUserStore +// MockUserStoreMockRecorder is the mock recorder for MockUserStore. type MockUserStoreMockRecorder struct { mock *MockUserStore } -// NewMockUserStore creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockUserStore) EXPECT() *MockUserStoreMockRecorder { return m.recorder } -// Count mocks base method +// Count mocks base method. func (m *MockUserStore) Count(arg0 context.Context) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Count", arg0) @@ -1961,13 +1962,13 @@ func (m *MockUserStore) Count(arg0 context.Context) (int64, error) { return ret0, ret1 } -// Count indicates an expected call of Count +// Count indicates an expected call of Count. func (mr *MockUserStoreMockRecorder) Count(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockUserStore)(nil).Count), arg0) } -// CountHuman mocks base method +// CountHuman mocks base method. func (m *MockUserStore) CountHuman(arg0 context.Context) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CountHuman", arg0) @@ -1976,13 +1977,13 @@ func (m *MockUserStore) CountHuman(arg0 context.Context) (int64, error) { return ret0, ret1 } -// CountHuman indicates an expected call of CountHuman +// CountHuman indicates an expected call of CountHuman. func (mr *MockUserStoreMockRecorder) CountHuman(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountHuman", reflect.TypeOf((*MockUserStore)(nil).CountHuman), arg0) } -// Create mocks base method +// Create mocks base method. func (m *MockUserStore) Create(arg0 context.Context, arg1 *core.User) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -1990,13 +1991,13 @@ func (m *MockUserStore) Create(arg0 context.Context, arg1 *core.User) error { return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockUserStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockUserStore)(nil).Create), arg0, arg1) } -// Delete mocks base method +// Delete mocks base method. func (m *MockUserStore) Delete(arg0 context.Context, arg1 *core.User) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -2004,13 +2005,13 @@ func (m *MockUserStore) Delete(arg0 context.Context, arg1 *core.User) error { return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockUserStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockUserStore)(nil).Delete), arg0, arg1) } -// Find mocks base method +// Find mocks base method. func (m *MockUserStore) Find(arg0 context.Context, arg1 int64) (*core.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -2019,13 +2020,13 @@ func (m *MockUserStore) Find(arg0 context.Context, arg1 int64) (*core.User, erro return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockUserStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockUserStore)(nil).Find), arg0, arg1) } -// FindLogin mocks base method +// FindLogin mocks base method. func (m *MockUserStore) FindLogin(arg0 context.Context, arg1 string) (*core.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindLogin", arg0, arg1) @@ -2034,13 +2035,13 @@ func (m *MockUserStore) FindLogin(arg0 context.Context, arg1 string) (*core.User return ret0, ret1 } -// FindLogin indicates an expected call of FindLogin +// FindLogin indicates an expected call of FindLogin. func (mr *MockUserStoreMockRecorder) FindLogin(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindLogin", reflect.TypeOf((*MockUserStore)(nil).FindLogin), arg0, arg1) } -// FindToken mocks base method +// FindToken mocks base method. func (m *MockUserStore) FindToken(arg0 context.Context, arg1 string) (*core.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FindToken", arg0, arg1) @@ -2049,13 +2050,13 @@ func (m *MockUserStore) FindToken(arg0 context.Context, arg1 string) (*core.User return ret0, ret1 } -// FindToken indicates an expected call of FindToken +// FindToken indicates an expected call of FindToken. func (mr *MockUserStoreMockRecorder) FindToken(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindToken", reflect.TypeOf((*MockUserStore)(nil).FindToken), arg0, arg1) } -// List mocks base method +// List mocks base method. func (m *MockUserStore) List(arg0 context.Context) ([]*core.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0) @@ -2064,13 +2065,13 @@ func (m *MockUserStore) List(arg0 context.Context) ([]*core.User, error) { return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockUserStoreMockRecorder) List(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockUserStore)(nil).List), arg0) } -// ListRange mocks base method +// ListRange mocks base method. func (m *MockUserStore) ListRange(arg0 context.Context, arg1 core.UserParams) ([]*core.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListRange", arg0, arg1) @@ -2079,13 +2080,13 @@ func (m *MockUserStore) ListRange(arg0 context.Context, arg1 core.UserParams) ([ return ret0, ret1 } -// ListRange indicates an expected call of ListRange +// ListRange indicates an expected call of ListRange. func (mr *MockUserStoreMockRecorder) ListRange(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRange", reflect.TypeOf((*MockUserStore)(nil).ListRange), arg0, arg1) } -// Update mocks base method +// Update mocks base method. func (m *MockUserStore) Update(arg0 context.Context, arg1 *core.User) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Update", arg0, arg1) @@ -2093,36 +2094,36 @@ func (m *MockUserStore) Update(arg0 context.Context, arg1 *core.User) error { return ret0 } -// Update indicates an expected call of Update +// Update indicates an expected call of Update. func (mr *MockUserStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserStore)(nil).Update), arg0, arg1) } -// MockScheduler is a mock of Scheduler interface +// MockScheduler is a mock of Scheduler interface. type MockScheduler struct { ctrl *gomock.Controller recorder *MockSchedulerMockRecorder } -// MockSchedulerMockRecorder is the mock recorder for MockScheduler +// MockSchedulerMockRecorder is the mock recorder for MockScheduler. type MockSchedulerMockRecorder struct { mock *MockScheduler } -// NewMockScheduler creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockScheduler) EXPECT() *MockSchedulerMockRecorder { return m.recorder } -// Cancel mocks base method +// Cancel mocks base method. func (m *MockScheduler) Cancel(arg0 context.Context, arg1 int64) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Cancel", arg0, arg1) @@ -2130,13 +2131,13 @@ func (m *MockScheduler) Cancel(arg0 context.Context, arg1 int64) error { return ret0 } -// Cancel indicates an expected call of Cancel +// Cancel indicates an expected call of Cancel. func (mr *MockSchedulerMockRecorder) Cancel(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockScheduler)(nil).Cancel), arg0, arg1) } -// Cancelled mocks base method +// Cancelled mocks base method. func (m *MockScheduler) Cancelled(arg0 context.Context, arg1 int64) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Cancelled", arg0, arg1) @@ -2145,13 +2146,13 @@ func (m *MockScheduler) Cancelled(arg0 context.Context, arg1 int64) (bool, error return ret0, ret1 } -// Cancelled indicates an expected call of Cancelled +// Cancelled indicates an expected call of Cancelled. func (mr *MockSchedulerMockRecorder) Cancelled(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancelled", reflect.TypeOf((*MockScheduler)(nil).Cancelled), arg0, arg1) } -// Pause mocks base method +// Pause mocks base method. func (m *MockScheduler) Pause(arg0 context.Context) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Pause", arg0) @@ -2159,13 +2160,13 @@ func (m *MockScheduler) Pause(arg0 context.Context) error { return ret0 } -// Pause indicates an expected call of Pause +// Pause indicates an expected call of Pause. func (mr *MockSchedulerMockRecorder) Pause(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pause", reflect.TypeOf((*MockScheduler)(nil).Pause), arg0) } -// Request mocks base method +// Request mocks base method. func (m *MockScheduler) Request(arg0 context.Context, arg1 core.Filter) (*core.Stage, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Request", arg0, arg1) @@ -2174,13 +2175,13 @@ func (m *MockScheduler) Request(arg0 context.Context, arg1 core.Filter) (*core.S return ret0, ret1 } -// Request indicates an expected call of Request +// Request indicates an expected call of Request. func (mr *MockSchedulerMockRecorder) Request(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Request", reflect.TypeOf((*MockScheduler)(nil).Request), arg0, arg1) } -// Resume mocks base method +// Resume mocks base method. func (m *MockScheduler) Resume(arg0 context.Context) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Resume", arg0) @@ -2188,13 +2189,13 @@ func (m *MockScheduler) Resume(arg0 context.Context) error { return ret0 } -// Resume indicates an expected call of Resume +// Resume indicates an expected call of Resume. func (mr *MockSchedulerMockRecorder) Resume(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resume", reflect.TypeOf((*MockScheduler)(nil).Resume), arg0) } -// Schedule mocks base method +// Schedule mocks base method. func (m *MockScheduler) Schedule(arg0 context.Context, arg1 *core.Stage) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Schedule", arg0, arg1) @@ -2202,13 +2203,13 @@ func (m *MockScheduler) Schedule(arg0 context.Context, arg1 *core.Stage) error { return ret0 } -// Schedule indicates an expected call of Schedule +// Schedule indicates an expected call of Schedule. func (mr *MockSchedulerMockRecorder) Schedule(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Schedule", reflect.TypeOf((*MockScheduler)(nil).Schedule), arg0, arg1) } -// Stats mocks base method +// Stats mocks base method. func (m *MockScheduler) Stats(arg0 context.Context) (interface{}, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Stats", arg0) @@ -2217,36 +2218,36 @@ func (m *MockScheduler) Stats(arg0 context.Context) (interface{}, error) { return ret0, ret1 } -// Stats indicates an expected call of Stats +// Stats indicates an expected call of Stats. func (mr *MockSchedulerMockRecorder) Stats(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockScheduler)(nil).Stats), arg0) } -// MockSession is a mock of Session interface +// MockSession is a mock of Session interface. type MockSession struct { ctrl *gomock.Controller recorder *MockSessionMockRecorder } -// MockSessionMockRecorder is the mock recorder for MockSession +// MockSessionMockRecorder is the mock recorder for MockSession. type MockSessionMockRecorder struct { mock *MockSession } -// NewMockSession creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockSession) EXPECT() *MockSessionMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockSession) Create(arg0 http.ResponseWriter, arg1 *core.User) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -2254,13 +2255,13 @@ func (m *MockSession) Create(arg0 http.ResponseWriter, arg1 *core.User) error { return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockSessionMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSession)(nil).Create), arg0, arg1) } -// Delete mocks base method +// Delete mocks base method. func (m *MockSession) Delete(arg0 http.ResponseWriter) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0) @@ -2268,13 +2269,13 @@ func (m *MockSession) Delete(arg0 http.ResponseWriter) error { return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockSessionMockRecorder) Delete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSession)(nil).Delete), arg0) } -// Get mocks base method +// Get mocks base method. func (m *MockSession) Get(arg0 *http.Request) (*core.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Get", arg0) @@ -2283,36 +2284,36 @@ func (m *MockSession) Get(arg0 *http.Request) (*core.User, error) { return ret0, ret1 } -// Get indicates an expected call of Get +// Get indicates an expected call of Get. func (mr *MockSessionMockRecorder) Get(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSession)(nil).Get), arg0) } -// MockOrganizationService is a mock of OrganizationService interface +// MockOrganizationService is a mock of OrganizationService interface. type MockOrganizationService struct { ctrl *gomock.Controller recorder *MockOrganizationServiceMockRecorder } -// MockOrganizationServiceMockRecorder is the mock recorder for MockOrganizationService +// MockOrganizationServiceMockRecorder is the mock recorder for MockOrganizationService. type MockOrganizationServiceMockRecorder struct { mock *MockOrganizationService } -// NewMockOrganizationService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockOrganizationService) EXPECT() *MockOrganizationServiceMockRecorder { return m.recorder } -// List mocks base method +// List mocks base method. func (m *MockOrganizationService) List(arg0 context.Context, arg1 *core.User) ([]*core.Organization, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -2321,13 +2322,13 @@ func (m *MockOrganizationService) List(arg0 context.Context, arg1 *core.User) ([ return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockOrganizationServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockOrganizationService)(nil).List), arg0, arg1) } -// Membership mocks base method +// Membership mocks base method. func (m *MockOrganizationService) Membership(arg0 context.Context, arg1 *core.User, arg2 string) (bool, bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Membership", arg0, arg1, arg2) @@ -2337,36 +2338,36 @@ func (m *MockOrganizationService) Membership(arg0 context.Context, arg1 *core.Us return ret0, ret1, ret2 } -// Membership indicates an expected call of Membership +// Membership indicates an expected call of Membership. func (mr *MockOrganizationServiceMockRecorder) Membership(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Membership", reflect.TypeOf((*MockOrganizationService)(nil).Membership), arg0, arg1, arg2) } -// MockSecretService is a mock of SecretService interface +// MockSecretService is a mock of SecretService interface. type MockSecretService struct { ctrl *gomock.Controller recorder *MockSecretServiceMockRecorder } -// MockSecretServiceMockRecorder is the mock recorder for MockSecretService +// MockSecretServiceMockRecorder is the mock recorder for MockSecretService. type MockSecretServiceMockRecorder struct { mock *MockSecretService } -// NewMockSecretService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockSecretService) EXPECT() *MockSecretServiceMockRecorder { return m.recorder } -// Find mocks base method +// Find mocks base method. func (m *MockSecretService) Find(arg0 context.Context, arg1 *core.SecretArgs) (*core.Secret, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -2375,36 +2376,36 @@ func (m *MockSecretService) Find(arg0 context.Context, arg1 *core.SecretArgs) (* return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockSecretServiceMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockSecretService)(nil).Find), arg0, arg1) } -// MockRegistryService is a mock of RegistryService interface +// MockRegistryService is a mock of RegistryService interface. type MockRegistryService struct { ctrl *gomock.Controller recorder *MockRegistryServiceMockRecorder } -// MockRegistryServiceMockRecorder is the mock recorder for MockRegistryService +// MockRegistryServiceMockRecorder is the mock recorder for MockRegistryService. type MockRegistryServiceMockRecorder struct { mock *MockRegistryService } -// NewMockRegistryService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockRegistryService) EXPECT() *MockRegistryServiceMockRecorder { return m.recorder } -// List mocks base method +// List mocks base method. func (m *MockRegistryService) List(arg0 context.Context, arg1 *core.RegistryArgs) ([]*core.Registry, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1) @@ -2413,36 +2414,36 @@ func (m *MockRegistryService) List(arg0 context.Context, arg1 *core.RegistryArgs return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockRegistryServiceMockRecorder) List(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRegistryService)(nil).List), arg0, arg1) } -// MockConfigService is a mock of ConfigService interface +// MockConfigService is a mock of ConfigService interface. type MockConfigService struct { ctrl *gomock.Controller recorder *MockConfigServiceMockRecorder } -// MockConfigServiceMockRecorder is the mock recorder for MockConfigService +// MockConfigServiceMockRecorder is the mock recorder for MockConfigService. type MockConfigServiceMockRecorder struct { mock *MockConfigService } -// NewMockConfigService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockConfigService) EXPECT() *MockConfigServiceMockRecorder { return m.recorder } -// Find mocks base method +// Find mocks base method. func (m *MockConfigService) Find(arg0 context.Context, arg1 *core.ConfigArgs) (*core.Config, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0, arg1) @@ -2451,36 +2452,36 @@ func (m *MockConfigService) Find(arg0 context.Context, arg1 *core.ConfigArgs) (* return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockConfigServiceMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockConfigService)(nil).Find), arg0, arg1) } -// MockTransferer is a mock of Transferer interface +// MockTransferer is a mock of Transferer interface. type MockTransferer struct { ctrl *gomock.Controller recorder *MockTransfererMockRecorder } -// MockTransfererMockRecorder is the mock recorder for MockTransferer +// MockTransfererMockRecorder is the mock recorder for MockTransferer. type MockTransfererMockRecorder struct { mock *MockTransferer } -// NewMockTransferer creates a new mock instance +// NewMockTransferer creates a new mock instance. func NewMockTransferer(ctrl *gomock.Controller) *MockTransferer { mock := &MockTransferer{ctrl: ctrl} mock.recorder = &MockTransfererMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockTransferer) EXPECT() *MockTransfererMockRecorder { return m.recorder } -// Transfer mocks base method +// Transfer mocks base method. func (m *MockTransferer) Transfer(arg0 context.Context, arg1 *core.User) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Transfer", arg0, arg1) @@ -2488,36 +2489,36 @@ func (m *MockTransferer) Transfer(arg0 context.Context, arg1 *core.User) error { return ret0 } -// Transfer indicates an expected call of Transfer +// Transfer indicates an expected call of Transfer. func (mr *MockTransfererMockRecorder) Transfer(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transfer", reflect.TypeOf((*MockTransferer)(nil).Transfer), arg0, arg1) } -// MockTriggerer is a mock of Triggerer interface +// MockTriggerer is a mock of Triggerer interface. type MockTriggerer struct { ctrl *gomock.Controller recorder *MockTriggererMockRecorder } -// MockTriggererMockRecorder is the mock recorder for MockTriggerer +// MockTriggererMockRecorder is the mock recorder for MockTriggerer. type MockTriggererMockRecorder struct { mock *MockTriggerer } -// NewMockTriggerer creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockTriggerer) EXPECT() *MockTriggererMockRecorder { return m.recorder } -// Trigger mocks base method +// Trigger mocks base method. func (m *MockTriggerer) Trigger(arg0 context.Context, arg1 *core.Repository, arg2 *core.Hook) (*core.Build, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Trigger", arg0, arg1, arg2) @@ -2526,36 +2527,36 @@ func (m *MockTriggerer) Trigger(arg0 context.Context, arg1 *core.Repository, arg return ret0, ret1 } -// Trigger indicates an expected call of Trigger +// Trigger indicates an expected call of Trigger. func (mr *MockTriggererMockRecorder) Trigger(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trigger", reflect.TypeOf((*MockTriggerer)(nil).Trigger), arg0, arg1, arg2) } -// MockSyncer is a mock of Syncer interface +// MockSyncer is a mock of Syncer interface. type MockSyncer struct { ctrl *gomock.Controller recorder *MockSyncerMockRecorder } -// MockSyncerMockRecorder is the mock recorder for MockSyncer +// MockSyncerMockRecorder is the mock recorder for MockSyncer. type MockSyncerMockRecorder struct { mock *MockSyncer } -// NewMockSyncer creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockSyncer) EXPECT() *MockSyncerMockRecorder { return m.recorder } -// Sync mocks base method +// Sync mocks base method. func (m *MockSyncer) Sync(arg0 context.Context, arg1 *core.User) (*core.Batch, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Sync", arg0, arg1) @@ -2564,36 +2565,36 @@ func (m *MockSyncer) Sync(arg0 context.Context, arg1 *core.User) (*core.Batch, e return ret0, ret1 } -// Sync indicates an expected call of Sync +// Sync indicates an expected call of Sync. func (mr *MockSyncerMockRecorder) Sync(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockSyncer)(nil).Sync), arg0, arg1) } -// MockLogStream is a mock of LogStream interface +// MockLogStream is a mock of LogStream interface. type MockLogStream struct { ctrl *gomock.Controller recorder *MockLogStreamMockRecorder } -// MockLogStreamMockRecorder is the mock recorder for MockLogStream +// MockLogStreamMockRecorder is the mock recorder for MockLogStream. type MockLogStreamMockRecorder struct { mock *MockLogStream } -// NewMockLogStream creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockLogStream) EXPECT() *MockLogStreamMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockLogStream) Create(arg0 context.Context, arg1 int64) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -2601,13 +2602,13 @@ func (m *MockLogStream) Create(arg0 context.Context, arg1 int64) error { return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockLogStreamMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLogStream)(nil).Create), arg0, arg1) } -// Delete mocks base method +// Delete mocks base method. func (m *MockLogStream) Delete(arg0 context.Context, arg1 int64) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0, arg1) @@ -2615,13 +2616,13 @@ func (m *MockLogStream) Delete(arg0 context.Context, arg1 int64) error { return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockLogStreamMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLogStream)(nil).Delete), arg0, arg1) } -// Info mocks base method +// Info mocks base method. func (m *MockLogStream) Info(arg0 context.Context) *core.LogStreamInfo { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Info", arg0) @@ -2629,13 +2630,13 @@ func (m *MockLogStream) Info(arg0 context.Context) *core.LogStreamInfo { return ret0 } -// Info indicates an expected call of Info +// Info indicates an expected call of Info. func (mr *MockLogStreamMockRecorder) Info(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogStream)(nil).Info), arg0) } -// Tail mocks base method +// Tail mocks base method. func (m *MockLogStream) Tail(arg0 context.Context, arg1 int64) (<-chan *core.Line, <-chan error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Tail", arg0, arg1) @@ -2644,13 +2645,13 @@ func (m *MockLogStream) Tail(arg0 context.Context, arg1 int64) (<-chan *core.Lin return ret0, ret1 } -// Tail indicates an expected call of Tail +// Tail indicates an expected call of Tail. func (mr *MockLogStreamMockRecorder) Tail(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tail", reflect.TypeOf((*MockLogStream)(nil).Tail), arg0, arg1) } -// Write mocks base method +// Write mocks base method. func (m *MockLogStream) Write(arg0 context.Context, arg1 int64, arg2 *core.Line) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Write", arg0, arg1, arg2) @@ -2658,36 +2659,36 @@ func (m *MockLogStream) Write(arg0 context.Context, arg1 int64, arg2 *core.Line) return ret0 } -// Write indicates an expected call of Write +// Write indicates an expected call of Write. func (mr *MockLogStreamMockRecorder) Write(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockLogStream)(nil).Write), arg0, arg1, arg2) } -// MockWebhookSender is a mock of WebhookSender interface +// MockWebhookSender is a mock of WebhookSender interface. type MockWebhookSender struct { ctrl *gomock.Controller recorder *MockWebhookSenderMockRecorder } -// MockWebhookSenderMockRecorder is the mock recorder for MockWebhookSender +// MockWebhookSenderMockRecorder is the mock recorder for MockWebhookSender. type MockWebhookSenderMockRecorder struct { mock *MockWebhookSender } -// NewMockWebhookSender creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockWebhookSender) EXPECT() *MockWebhookSenderMockRecorder { return m.recorder } -// Send mocks base method +// Send mocks base method. func (m *MockWebhookSender) Send(arg0 context.Context, arg1 *core.WebhookData) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Send", arg0, arg1) @@ -2695,36 +2696,36 @@ func (m *MockWebhookSender) Send(arg0 context.Context, arg1 *core.WebhookData) e return ret0 } -// Send indicates an expected call of Send +// Send indicates an expected call of Send. func (mr *MockWebhookSenderMockRecorder) Send(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockWebhookSender)(nil).Send), arg0, arg1) } -// MockLicenseService is a mock of LicenseService interface +// MockLicenseService is a mock of LicenseService interface. type MockLicenseService struct { ctrl *gomock.Controller recorder *MockLicenseServiceMockRecorder } -// MockLicenseServiceMockRecorder is the mock recorder for MockLicenseService +// MockLicenseServiceMockRecorder is the mock recorder for MockLicenseService. type MockLicenseServiceMockRecorder struct { mock *MockLicenseService } -// NewMockLicenseService creates a new mock instance +// 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 +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockLicenseService) EXPECT() *MockLicenseServiceMockRecorder { return m.recorder } -// Exceeded mocks base method +// Exceeded mocks base method. func (m *MockLicenseService) Exceeded(arg0 context.Context) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Exceeded", arg0) @@ -2733,13 +2734,13 @@ func (m *MockLicenseService) Exceeded(arg0 context.Context) (bool, error) { return ret0, ret1 } -// Exceeded indicates an expected call of Exceeded +// Exceeded indicates an expected call of Exceeded. func (mr *MockLicenseServiceMockRecorder) Exceeded(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exceeded", reflect.TypeOf((*MockLicenseService)(nil).Exceeded), arg0) } -// Expired mocks base method +// Expired mocks base method. func (m *MockLicenseService) Expired(arg0 context.Context) bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Expired", arg0) @@ -2747,8 +2748,118 @@ func (m *MockLicenseService) Expired(arg0 context.Context) bool { return ret0 } -// Expired indicates an expected call of Expired +// Expired indicates an expected call of Expired. func (mr *MockLicenseServiceMockRecorder) Expired(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockLicenseService)(nil).Expired), arg0) } + +// MockTemplateStore is a mock of TemplateStore interface. +type MockTemplateStore struct { + ctrl *gomock.Controller + recorder *MockTemplateStoreMockRecorder +} + +// MockTemplateStoreMockRecorder is the mock recorder for MockTemplateStore. +type MockTemplateStoreMockRecorder struct { + mock *MockTemplateStore +} + +// NewMockTemplateStore creates a new mock instance. +func NewMockTemplateStore(ctrl *gomock.Controller) *MockTemplateStore { + mock := &MockTemplateStore{ctrl: ctrl} + mock.recorder = &MockTemplateStoreMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTemplateStore) EXPECT() *MockTemplateStoreMockRecorder { + return m.recorder +} + +// Create mocks base method. +func (m *MockTemplateStore) Create(arg0 context.Context, arg1 *core.Template) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// Create indicates an expected call of Create. +func (mr *MockTemplateStoreMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockTemplateStore)(nil).Create), arg0, arg1) +} + +// Delete mocks base method. +func (m *MockTemplateStore) Delete(arg0 context.Context, arg1 *core.Template) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockTemplateStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockTemplateStore)(nil).Delete), arg0, arg1) +} + +// Find mocks base method. +func (m *MockTemplateStore) Find(arg0 context.Context, arg1 int64) (*core.Template, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Find", arg0, arg1) + ret0, _ := ret[0].(*core.Template) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Find indicates an expected call of Find. +func (mr *MockTemplateStoreMockRecorder) Find(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockTemplateStore)(nil).Find), arg0, arg1) +} + +// FindName mocks base method. +func (m *MockTemplateStore) FindName(arg0 context.Context, arg1 string) (*core.Template, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FindName", arg0, arg1) + ret0, _ := ret[0].(*core.Template) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FindName indicates an expected call of FindName. +func (mr *MockTemplateStoreMockRecorder) FindName(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindName", reflect.TypeOf((*MockTemplateStore)(nil).FindName), arg0, arg1) +} + +// ListAll mocks base method. +func (m *MockTemplateStore) ListAll(arg0 context.Context) ([]*core.Template, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAll", arg0) + ret0, _ := ret[0].([]*core.Template) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAll indicates an expected call of ListAll. +func (mr *MockTemplateStoreMockRecorder) ListAll(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAll", reflect.TypeOf((*MockTemplateStore)(nil).ListAll), arg0) +} + +// Update mocks base method. +func (m *MockTemplateStore) Update(arg0 context.Context, arg1 *core.Template) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// Update indicates an expected call of Update. +func (mr *MockTemplateStoreMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockTemplateStore)(nil).Update), arg0, arg1) +}