2954 lines
113 KiB
Go
2954 lines
113 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: gitea_utils.go
|
|
//
|
|
// Generated by this command:
|
|
//
|
|
// mockgen -source=gitea_utils.go -destination=mock/gitea_utils.go -typed
|
|
//
|
|
|
|
// Package mock_common is a generated GoMock package.
|
|
package mock_common
|
|
|
|
import (
|
|
reflect "reflect"
|
|
time "time"
|
|
|
|
gomock "go.uber.org/mock/gomock"
|
|
common "src.opensuse.org/autogits/common"
|
|
models "src.opensuse.org/autogits/common/gitea-generated/models"
|
|
)
|
|
|
|
// MockGiteaTimelineFetcher is a mock of GiteaTimelineFetcher interface.
|
|
type MockGiteaTimelineFetcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaTimelineFetcherMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaTimelineFetcherMockRecorder is the mock recorder for MockGiteaTimelineFetcher.
|
|
type MockGiteaTimelineFetcherMockRecorder struct {
|
|
mock *MockGiteaTimelineFetcher
|
|
}
|
|
|
|
// NewMockGiteaTimelineFetcher creates a new mock instance.
|
|
func NewMockGiteaTimelineFetcher(ctrl *gomock.Controller) *MockGiteaTimelineFetcher {
|
|
mock := &MockGiteaTimelineFetcher{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaTimelineFetcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaTimelineFetcher) EXPECT() *MockGiteaTimelineFetcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetTimeline mocks base method.
|
|
func (m *MockGiteaTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
|
|
ret0, _ := ret[0].([]*models.TimelineComment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTimeline indicates an expected call of GetTimeline.
|
|
func (mr *MockGiteaTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaTimelineFetcherGetTimelineCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaTimelineFetcher)(nil).GetTimeline), org, repo, idx)
|
|
return &MockGiteaTimelineFetcherGetTimelineCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaTimelineFetcherGetTimelineCall wrap *gomock.Call
|
|
type MockGiteaTimelineFetcherGetTimelineCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaComment is a mock of GiteaComment interface.
|
|
type MockGiteaComment struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaCommentMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaCommentMockRecorder is the mock recorder for MockGiteaComment.
|
|
type MockGiteaCommentMockRecorder struct {
|
|
mock *MockGiteaComment
|
|
}
|
|
|
|
// NewMockGiteaComment creates a new mock instance.
|
|
func NewMockGiteaComment(ctrl *gomock.Controller) *MockGiteaComment {
|
|
mock := &MockGiteaComment{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaCommentMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaComment) EXPECT() *MockGiteaCommentMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddComment mocks base method.
|
|
func (m *MockGiteaComment) AddComment(pr *models.PullRequest, comment string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddComment", pr, comment)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AddComment indicates an expected call of AddComment.
|
|
func (mr *MockGiteaCommentMockRecorder) AddComment(pr, comment any) *MockGiteaCommentAddCommentCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddComment", reflect.TypeOf((*MockGiteaComment)(nil).AddComment), pr, comment)
|
|
return &MockGiteaCommentAddCommentCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaCommentAddCommentCall wrap *gomock.Call
|
|
type MockGiteaCommentAddCommentCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaCommentAddCommentCall) Return(arg0 error) *MockGiteaCommentAddCommentCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaCommentAddCommentCall) Do(f func(*models.PullRequest, string) error) *MockGiteaCommentAddCommentCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaCommentAddCommentCall) DoAndReturn(f func(*models.PullRequest, string) error) *MockGiteaCommentAddCommentCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaSetRepoOptions is a mock of GiteaSetRepoOptions interface.
|
|
type MockGiteaSetRepoOptions struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaSetRepoOptionsMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaSetRepoOptionsMockRecorder is the mock recorder for MockGiteaSetRepoOptions.
|
|
type MockGiteaSetRepoOptionsMockRecorder struct {
|
|
mock *MockGiteaSetRepoOptions
|
|
}
|
|
|
|
// NewMockGiteaSetRepoOptions creates a new mock instance.
|
|
func NewMockGiteaSetRepoOptions(ctrl *gomock.Controller) *MockGiteaSetRepoOptions {
|
|
mock := &MockGiteaSetRepoOptions{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaSetRepoOptionsMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaSetRepoOptions) EXPECT() *MockGiteaSetRepoOptionsMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// SetRepoOptions mocks base method.
|
|
func (m *MockGiteaSetRepoOptions) SetRepoOptions(owner, repo string, manual_merge bool) (*models.Repository, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetRepoOptions", owner, repo, manual_merge)
|
|
ret0, _ := ret[0].(*models.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetRepoOptions indicates an expected call of SetRepoOptions.
|
|
func (mr *MockGiteaSetRepoOptionsMockRecorder) SetRepoOptions(owner, repo, manual_merge any) *MockGiteaSetRepoOptionsSetRepoOptionsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepoOptions", reflect.TypeOf((*MockGiteaSetRepoOptions)(nil).SetRepoOptions), owner, repo, manual_merge)
|
|
return &MockGiteaSetRepoOptionsSetRepoOptionsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaSetRepoOptionsSetRepoOptionsCall wrap *gomock.Call
|
|
type MockGiteaSetRepoOptionsSetRepoOptionsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaSetRepoOptionsSetRepoOptionsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) Do(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsSetRepoOptionsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) DoAndReturn(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsSetRepoOptionsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaMaintainershipReader is a mock of GiteaMaintainershipReader interface.
|
|
type MockGiteaMaintainershipReader struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaMaintainershipReaderMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaMaintainershipReaderMockRecorder is the mock recorder for MockGiteaMaintainershipReader.
|
|
type MockGiteaMaintainershipReaderMockRecorder struct {
|
|
mock *MockGiteaMaintainershipReader
|
|
}
|
|
|
|
// NewMockGiteaMaintainershipReader creates a new mock instance.
|
|
func NewMockGiteaMaintainershipReader(ctrl *gomock.Controller) *MockGiteaMaintainershipReader {
|
|
mock := &MockGiteaMaintainershipReader{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaMaintainershipReaderMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaMaintainershipReader) EXPECT() *MockGiteaMaintainershipReaderMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// FetchMaintainershipDirFile mocks base method.
|
|
func (m *MockGiteaMaintainershipReader) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile.
|
|
func (mr *MockGiteaMaintainershipReaderMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGiteaMaintainershipReader)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg)
|
|
return &MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall wrap *gomock.Call
|
|
type MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// FetchMaintainershipFile mocks base method.
|
|
func (m *MockGiteaMaintainershipReader) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile.
|
|
func (mr *MockGiteaMaintainershipReaderMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGiteaMaintainershipReader)(nil).FetchMaintainershipFile), org, prjGit, branch)
|
|
return &MockGiteaMaintainershipReaderFetchMaintainershipFileCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaMaintainershipReaderFetchMaintainershipFileCall wrap *gomock.Call
|
|
type MockGiteaMaintainershipReaderFetchMaintainershipFileCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaPRFetcher is a mock of GiteaPRFetcher interface.
|
|
type MockGiteaPRFetcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaPRFetcherMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaPRFetcherMockRecorder is the mock recorder for MockGiteaPRFetcher.
|
|
type MockGiteaPRFetcherMockRecorder struct {
|
|
mock *MockGiteaPRFetcher
|
|
}
|
|
|
|
// NewMockGiteaPRFetcher creates a new mock instance.
|
|
func NewMockGiteaPRFetcher(ctrl *gomock.Controller) *MockGiteaPRFetcher {
|
|
mock := &MockGiteaPRFetcher{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaPRFetcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaPRFetcher) EXPECT() *MockGiteaPRFetcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetPullRequest mocks base method.
|
|
func (m *MockGiteaPRFetcher) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequest", org, project, num)
|
|
ret0, _ := ret[0].(*models.PullRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequest indicates an expected call of GetPullRequest.
|
|
func (mr *MockGiteaPRFetcherMockRecorder) GetPullRequest(org, project, num any) *MockGiteaPRFetcherGetPullRequestCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGiteaPRFetcher)(nil).GetPullRequest), org, project, num)
|
|
return &MockGiteaPRFetcherGetPullRequestCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRFetcherGetPullRequestCall wrap *gomock.Call
|
|
type MockGiteaPRFetcherGetPullRequestCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRFetcherGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRFetcherGetPullRequestCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRFetcherGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRFetcherGetPullRequestCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRFetcherGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRFetcherGetPullRequestCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaPRUpdater is a mock of GiteaPRUpdater interface.
|
|
type MockGiteaPRUpdater struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaPRUpdaterMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaPRUpdaterMockRecorder is the mock recorder for MockGiteaPRUpdater.
|
|
type MockGiteaPRUpdaterMockRecorder struct {
|
|
mock *MockGiteaPRUpdater
|
|
}
|
|
|
|
// NewMockGiteaPRUpdater creates a new mock instance.
|
|
func NewMockGiteaPRUpdater(ctrl *gomock.Controller) *MockGiteaPRUpdater {
|
|
mock := &MockGiteaPRUpdater{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaPRUpdaterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaPRUpdater) EXPECT() *MockGiteaPRUpdaterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// UpdatePullRequest mocks base method.
|
|
func (m *MockGiteaPRUpdater) UpdatePullRequest(org, repo string, num int64, options *models.EditPullRequestOption) (*models.PullRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdatePullRequest", org, repo, num, options)
|
|
ret0, _ := ret[0].(*models.PullRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdatePullRequest indicates an expected call of UpdatePullRequest.
|
|
func (mr *MockGiteaPRUpdaterMockRecorder) UpdatePullRequest(org, repo, num, options any) *MockGiteaPRUpdaterUpdatePullRequestCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequest", reflect.TypeOf((*MockGiteaPRUpdater)(nil).UpdatePullRequest), org, repo, num, options)
|
|
return &MockGiteaPRUpdaterUpdatePullRequestCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRUpdaterUpdatePullRequestCall wrap *gomock.Call
|
|
type MockGiteaPRUpdaterUpdatePullRequestCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRUpdaterUpdatePullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRUpdaterUpdatePullRequestCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRUpdaterUpdatePullRequestCall) Do(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaPRUpdaterUpdatePullRequestCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRUpdaterUpdatePullRequestCall) DoAndReturn(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaPRUpdaterUpdatePullRequestCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaPRTimelineFetcher is a mock of GiteaPRTimelineFetcher interface.
|
|
type MockGiteaPRTimelineFetcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaPRTimelineFetcherMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaPRTimelineFetcherMockRecorder is the mock recorder for MockGiteaPRTimelineFetcher.
|
|
type MockGiteaPRTimelineFetcherMockRecorder struct {
|
|
mock *MockGiteaPRTimelineFetcher
|
|
}
|
|
|
|
// NewMockGiteaPRTimelineFetcher creates a new mock instance.
|
|
func NewMockGiteaPRTimelineFetcher(ctrl *gomock.Controller) *MockGiteaPRTimelineFetcher {
|
|
mock := &MockGiteaPRTimelineFetcher{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaPRTimelineFetcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaPRTimelineFetcher) EXPECT() *MockGiteaPRTimelineFetcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetPullRequest mocks base method.
|
|
func (m *MockGiteaPRTimelineFetcher) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequest", org, project, num)
|
|
ret0, _ := ret[0].(*models.PullRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequest indicates an expected call of GetPullRequest.
|
|
func (mr *MockGiteaPRTimelineFetcherMockRecorder) GetPullRequest(org, project, num any) *MockGiteaPRTimelineFetcherGetPullRequestCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGiteaPRTimelineFetcher)(nil).GetPullRequest), org, project, num)
|
|
return &MockGiteaPRTimelineFetcherGetPullRequestCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRTimelineFetcherGetPullRequestCall wrap *gomock.Call
|
|
type MockGiteaPRTimelineFetcherGetPullRequestCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRTimelineFetcherGetPullRequestCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRTimelineFetcherGetPullRequestCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRTimelineFetcherGetPullRequestCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetTimeline mocks base method.
|
|
func (m *MockGiteaPRTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
|
|
ret0, _ := ret[0].([]*models.TimelineComment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTimeline indicates an expected call of GetTimeline.
|
|
func (mr *MockGiteaPRTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaPRTimelineFetcherGetTimelineCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaPRTimelineFetcher)(nil).GetTimeline), org, repo, idx)
|
|
return &MockGiteaPRTimelineFetcherGetTimelineCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRTimelineFetcherGetTimelineCall wrap *gomock.Call
|
|
type MockGiteaPRTimelineFetcherGetTimelineCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaPRTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaCommitFetcher is a mock of GiteaCommitFetcher interface.
|
|
type MockGiteaCommitFetcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaCommitFetcherMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaCommitFetcherMockRecorder is the mock recorder for MockGiteaCommitFetcher.
|
|
type MockGiteaCommitFetcherMockRecorder struct {
|
|
mock *MockGiteaCommitFetcher
|
|
}
|
|
|
|
// NewMockGiteaCommitFetcher creates a new mock instance.
|
|
func NewMockGiteaCommitFetcher(ctrl *gomock.Controller) *MockGiteaCommitFetcher {
|
|
mock := &MockGiteaCommitFetcher{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaCommitFetcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaCommitFetcher) EXPECT() *MockGiteaCommitFetcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetCommit mocks base method.
|
|
func (m *MockGiteaCommitFetcher) GetCommit(org, repo, sha string) (*models.Commit, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCommit", org, repo, sha)
|
|
ret0, _ := ret[0].(*models.Commit)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetCommit indicates an expected call of GetCommit.
|
|
func (mr *MockGiteaCommitFetcherMockRecorder) GetCommit(org, repo, sha any) *MockGiteaCommitFetcherGetCommitCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockGiteaCommitFetcher)(nil).GetCommit), org, repo, sha)
|
|
return &MockGiteaCommitFetcherGetCommitCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaCommitFetcherGetCommitCall wrap *gomock.Call
|
|
type MockGiteaCommitFetcherGetCommitCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaCommitFetcherGetCommitCall) Return(arg0 *models.Commit, arg1 error) *MockGiteaCommitFetcherGetCommitCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaCommitFetcherGetCommitCall) Do(f func(string, string, string) (*models.Commit, error)) *MockGiteaCommitFetcherGetCommitCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaCommitFetcherGetCommitCall) DoAndReturn(f func(string, string, string) (*models.Commit, error)) *MockGiteaCommitFetcherGetCommitCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaReviewFetcher is a mock of GiteaReviewFetcher interface.
|
|
type MockGiteaReviewFetcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaReviewFetcherMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaReviewFetcherMockRecorder is the mock recorder for MockGiteaReviewFetcher.
|
|
type MockGiteaReviewFetcherMockRecorder struct {
|
|
mock *MockGiteaReviewFetcher
|
|
}
|
|
|
|
// NewMockGiteaReviewFetcher creates a new mock instance.
|
|
func NewMockGiteaReviewFetcher(ctrl *gomock.Controller) *MockGiteaReviewFetcher {
|
|
mock := &MockGiteaReviewFetcher{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaReviewFetcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaReviewFetcher) EXPECT() *MockGiteaReviewFetcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetPullRequestReviews mocks base method.
|
|
func (m *MockGiteaReviewFetcher) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
|
|
ret0, _ := ret[0].([]*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
|
|
func (mr *MockGiteaReviewFetcherMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewFetcherGetPullRequestReviewsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewFetcher)(nil).GetPullRequestReviews), org, project, PRnum)
|
|
return &MockGiteaReviewFetcherGetPullRequestReviewsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewFetcherGetPullRequestReviewsCall wrap *gomock.Call
|
|
type MockGiteaReviewFetcherGetPullRequestReviewsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherGetPullRequestReviewsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaCommentFetcher is a mock of GiteaCommentFetcher interface.
|
|
type MockGiteaCommentFetcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaCommentFetcherMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaCommentFetcherMockRecorder is the mock recorder for MockGiteaCommentFetcher.
|
|
type MockGiteaCommentFetcherMockRecorder struct {
|
|
mock *MockGiteaCommentFetcher
|
|
}
|
|
|
|
// NewMockGiteaCommentFetcher creates a new mock instance.
|
|
func NewMockGiteaCommentFetcher(ctrl *gomock.Controller) *MockGiteaCommentFetcher {
|
|
mock := &MockGiteaCommentFetcher{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaCommentFetcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaCommentFetcher) EXPECT() *MockGiteaCommentFetcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetIssueComments mocks base method.
|
|
func (m *MockGiteaCommentFetcher) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo)
|
|
ret0, _ := ret[0].([]*models.Comment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetIssueComments indicates an expected call of GetIssueComments.
|
|
func (mr *MockGiteaCommentFetcherMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaCommentFetcherGetIssueCommentsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaCommentFetcher)(nil).GetIssueComments), org, project, issueNo)
|
|
return &MockGiteaCommentFetcherGetIssueCommentsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaCommentFetcherGetIssueCommentsCall wrap *gomock.Call
|
|
type MockGiteaCommentFetcherGetIssueCommentsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaCommentFetcherGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaCommentFetcherGetIssueCommentsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaCommentFetcherGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaCommentFetcherGetIssueCommentsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaCommentFetcherGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaCommentFetcherGetIssueCommentsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaReviewTimelineFetcher is a mock of GiteaReviewTimelineFetcher interface.
|
|
type MockGiteaReviewTimelineFetcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaReviewTimelineFetcherMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaReviewTimelineFetcherMockRecorder is the mock recorder for MockGiteaReviewTimelineFetcher.
|
|
type MockGiteaReviewTimelineFetcherMockRecorder struct {
|
|
mock *MockGiteaReviewTimelineFetcher
|
|
}
|
|
|
|
// NewMockGiteaReviewTimelineFetcher creates a new mock instance.
|
|
func NewMockGiteaReviewTimelineFetcher(ctrl *gomock.Controller) *MockGiteaReviewTimelineFetcher {
|
|
mock := &MockGiteaReviewTimelineFetcher{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaReviewTimelineFetcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaReviewTimelineFetcher) EXPECT() *MockGiteaReviewTimelineFetcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetPullRequestReviews mocks base method.
|
|
func (m *MockGiteaReviewTimelineFetcher) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
|
|
ret0, _ := ret[0].([]*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
|
|
func (mr *MockGiteaReviewTimelineFetcherMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewTimelineFetcher)(nil).GetPullRequestReviews), org, project, PRnum)
|
|
return &MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall wrap *gomock.Call
|
|
type MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetTimeline mocks base method.
|
|
func (m *MockGiteaReviewTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
|
|
ret0, _ := ret[0].([]*models.TimelineComment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTimeline indicates an expected call of GetTimeline.
|
|
func (mr *MockGiteaReviewTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaReviewTimelineFetcherGetTimelineCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaReviewTimelineFetcher)(nil).GetTimeline), org, repo, idx)
|
|
return &MockGiteaReviewTimelineFetcherGetTimelineCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewTimelineFetcherGetTimelineCall wrap *gomock.Call
|
|
type MockGiteaReviewTimelineFetcherGetTimelineCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaReviewTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewTimelineFetcherGetTimelineCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaPRChecker is a mock of GiteaPRChecker interface.
|
|
type MockGiteaPRChecker struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaPRCheckerMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaPRCheckerMockRecorder is the mock recorder for MockGiteaPRChecker.
|
|
type MockGiteaPRCheckerMockRecorder struct {
|
|
mock *MockGiteaPRChecker
|
|
}
|
|
|
|
// NewMockGiteaPRChecker creates a new mock instance.
|
|
func NewMockGiteaPRChecker(ctrl *gomock.Controller) *MockGiteaPRChecker {
|
|
mock := &MockGiteaPRChecker{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaPRCheckerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaPRChecker) EXPECT() *MockGiteaPRCheckerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// FetchMaintainershipDirFile mocks base method.
|
|
func (m *MockGiteaPRChecker) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile.
|
|
func (mr *MockGiteaPRCheckerMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaPRCheckerFetchMaintainershipDirFileCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGiteaPRChecker)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg)
|
|
return &MockGiteaPRCheckerFetchMaintainershipDirFileCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRCheckerFetchMaintainershipDirFileCall wrap *gomock.Call
|
|
type MockGiteaPRCheckerFetchMaintainershipDirFileCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaPRCheckerFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// FetchMaintainershipFile mocks base method.
|
|
func (m *MockGiteaPRChecker) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile.
|
|
func (mr *MockGiteaPRCheckerMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaPRCheckerFetchMaintainershipFileCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGiteaPRChecker)(nil).FetchMaintainershipFile), org, prjGit, branch)
|
|
return &MockGiteaPRCheckerFetchMaintainershipFileCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRCheckerFetchMaintainershipFileCall wrap *gomock.Call
|
|
type MockGiteaPRCheckerFetchMaintainershipFileCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaPRCheckerFetchMaintainershipFileCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipFileCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipFileCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetIssueComments mocks base method.
|
|
func (m *MockGiteaPRChecker) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo)
|
|
ret0, _ := ret[0].([]*models.Comment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetIssueComments indicates an expected call of GetIssueComments.
|
|
func (mr *MockGiteaPRCheckerMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaPRCheckerGetIssueCommentsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetIssueComments), org, project, issueNo)
|
|
return &MockGiteaPRCheckerGetIssueCommentsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRCheckerGetIssueCommentsCall wrap *gomock.Call
|
|
type MockGiteaPRCheckerGetIssueCommentsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRCheckerGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaPRCheckerGetIssueCommentsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRCheckerGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaPRCheckerGetIssueCommentsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRCheckerGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaPRCheckerGetIssueCommentsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetPullRequestReviews mocks base method.
|
|
func (m *MockGiteaPRChecker) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
|
|
ret0, _ := ret[0].([]*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
|
|
func (mr *MockGiteaPRCheckerMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaPRCheckerGetPullRequestReviewsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetPullRequestReviews), org, project, PRnum)
|
|
return &MockGiteaPRCheckerGetPullRequestReviewsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRCheckerGetPullRequestReviewsCall wrap *gomock.Call
|
|
type MockGiteaPRCheckerGetPullRequestReviewsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaPRCheckerGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaPRCheckerGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaPRCheckerGetPullRequestReviewsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetTimeline mocks base method.
|
|
func (m *MockGiteaPRChecker) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
|
|
ret0, _ := ret[0].([]*models.TimelineComment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTimeline indicates an expected call of GetTimeline.
|
|
func (mr *MockGiteaPRCheckerMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaPRCheckerGetTimelineCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetTimeline), org, repo, idx)
|
|
return &MockGiteaPRCheckerGetTimelineCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaPRCheckerGetTimelineCall wrap *gomock.Call
|
|
type MockGiteaPRCheckerGetTimelineCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaPRCheckerGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaPRCheckerGetTimelineCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaPRCheckerGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRCheckerGetTimelineCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaPRCheckerGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRCheckerGetTimelineCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaReviewFetcherAndRequester is a mock of GiteaReviewFetcherAndRequester interface.
|
|
type MockGiteaReviewFetcherAndRequester struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaReviewFetcherAndRequesterMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaReviewFetcherAndRequesterMockRecorder is the mock recorder for MockGiteaReviewFetcherAndRequester.
|
|
type MockGiteaReviewFetcherAndRequesterMockRecorder struct {
|
|
mock *MockGiteaReviewFetcherAndRequester
|
|
}
|
|
|
|
// NewMockGiteaReviewFetcherAndRequester creates a new mock instance.
|
|
func NewMockGiteaReviewFetcherAndRequester(ctrl *gomock.Controller) *MockGiteaReviewFetcherAndRequester {
|
|
mock := &MockGiteaReviewFetcherAndRequester{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaReviewFetcherAndRequesterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaReviewFetcherAndRequester) EXPECT() *MockGiteaReviewFetcherAndRequesterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetIssueComments mocks base method.
|
|
func (m *MockGiteaReviewFetcherAndRequester) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo)
|
|
ret0, _ := ret[0].([]*models.Comment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetIssueComments indicates an expected call of GetIssueComments.
|
|
func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetIssueComments), org, project, issueNo)
|
|
return &MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall wrap *gomock.Call
|
|
type MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetPullRequestReviews mocks base method.
|
|
func (m *MockGiteaReviewFetcherAndRequester) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
|
|
ret0, _ := ret[0].([]*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
|
|
func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetPullRequestReviews), org, project, PRnum)
|
|
return &MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall wrap *gomock.Call
|
|
type MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetTimeline mocks base method.
|
|
func (m *MockGiteaReviewFetcherAndRequester) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
|
|
ret0, _ := ret[0].([]*models.TimelineComment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTimeline indicates an expected call of GetTimeline.
|
|
func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaReviewFetcherAndRequesterGetTimelineCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetTimeline), org, repo, idx)
|
|
return &MockGiteaReviewFetcherAndRequesterGetTimelineCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewFetcherAndRequesterGetTimelineCall wrap *gomock.Call
|
|
type MockGiteaReviewFetcherAndRequesterGetTimelineCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaReviewFetcherAndRequesterGetTimelineCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewFetcherAndRequesterGetTimelineCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewFetcherAndRequesterGetTimelineCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// RequestReviews mocks base method.
|
|
func (m *MockGiteaReviewFetcherAndRequester) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{pr}
|
|
for _, a := range reviewer {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RequestReviews", varargs...)
|
|
ret0, _ := ret[0].([]*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RequestReviews indicates an expected call of RequestReviews.
|
|
func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{pr}, reviewer...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).RequestReviews), varargs...)
|
|
return &MockGiteaReviewFetcherAndRequesterRequestReviewsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewFetcherAndRequesterRequestReviewsCall wrap *gomock.Call
|
|
type MockGiteaReviewFetcherAndRequesterRequestReviewsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaReviewRequester is a mock of GiteaReviewRequester interface.
|
|
type MockGiteaReviewRequester struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaReviewRequesterMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaReviewRequesterMockRecorder is the mock recorder for MockGiteaReviewRequester.
|
|
type MockGiteaReviewRequesterMockRecorder struct {
|
|
mock *MockGiteaReviewRequester
|
|
}
|
|
|
|
// NewMockGiteaReviewRequester creates a new mock instance.
|
|
func NewMockGiteaReviewRequester(ctrl *gomock.Controller) *MockGiteaReviewRequester {
|
|
mock := &MockGiteaReviewRequester{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaReviewRequesterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaReviewRequester) EXPECT() *MockGiteaReviewRequesterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// RequestReviews mocks base method.
|
|
func (m *MockGiteaReviewRequester) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{pr}
|
|
for _, a := range reviewer {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RequestReviews", varargs...)
|
|
ret0, _ := ret[0].([]*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RequestReviews indicates an expected call of RequestReviews.
|
|
func (mr *MockGiteaReviewRequesterMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaReviewRequesterRequestReviewsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{pr}, reviewer...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGiteaReviewRequester)(nil).RequestReviews), varargs...)
|
|
return &MockGiteaReviewRequesterRequestReviewsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewRequesterRequestReviewsCall wrap *gomock.Call
|
|
type MockGiteaReviewRequesterRequestReviewsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewRequesterRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewRequesterRequestReviewsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewRequesterRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewRequesterRequestReviewsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewRequesterRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewRequesterRequestReviewsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaReviewUnrequester is a mock of GiteaReviewUnrequester interface.
|
|
type MockGiteaReviewUnrequester struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaReviewUnrequesterMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaReviewUnrequesterMockRecorder is the mock recorder for MockGiteaReviewUnrequester.
|
|
type MockGiteaReviewUnrequesterMockRecorder struct {
|
|
mock *MockGiteaReviewUnrequester
|
|
}
|
|
|
|
// NewMockGiteaReviewUnrequester creates a new mock instance.
|
|
func NewMockGiteaReviewUnrequester(ctrl *gomock.Controller) *MockGiteaReviewUnrequester {
|
|
mock := &MockGiteaReviewUnrequester{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaReviewUnrequesterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaReviewUnrequester) EXPECT() *MockGiteaReviewUnrequesterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// UnrequestReview mocks base method.
|
|
func (m *MockGiteaReviewUnrequester) UnrequestReview(org, repo string, id int64, reviwers ...string) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{org, repo, id}
|
|
for _, a := range reviwers {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "UnrequestReview", varargs...)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UnrequestReview indicates an expected call of UnrequestReview.
|
|
func (mr *MockGiteaReviewUnrequesterMockRecorder) UnrequestReview(org, repo, id any, reviwers ...any) *MockGiteaReviewUnrequesterUnrequestReviewCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{org, repo, id}, reviwers...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrequestReview", reflect.TypeOf((*MockGiteaReviewUnrequester)(nil).UnrequestReview), varargs...)
|
|
return &MockGiteaReviewUnrequesterUnrequestReviewCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewUnrequesterUnrequestReviewCall wrap *gomock.Call
|
|
type MockGiteaReviewUnrequesterUnrequestReviewCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) Return(arg0 error) *MockGiteaReviewUnrequesterUnrequestReviewCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) Do(f func(string, string, int64, ...string) error) *MockGiteaReviewUnrequesterUnrequestReviewCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) DoAndReturn(f func(string, string, int64, ...string) error) *MockGiteaReviewUnrequesterUnrequestReviewCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaReviewer is a mock of GiteaReviewer interface.
|
|
type MockGiteaReviewer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaReviewerMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaReviewerMockRecorder is the mock recorder for MockGiteaReviewer.
|
|
type MockGiteaReviewerMockRecorder struct {
|
|
mock *MockGiteaReviewer
|
|
}
|
|
|
|
// NewMockGiteaReviewer creates a new mock instance.
|
|
func NewMockGiteaReviewer(ctrl *gomock.Controller) *MockGiteaReviewer {
|
|
mock := &MockGiteaReviewer{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaReviewerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaReviewer) EXPECT() *MockGiteaReviewerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddReviewComment mocks base method.
|
|
func (m *MockGiteaReviewer) AddReviewComment(pr *models.PullRequest, state models.ReviewStateType, comment string) (*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddReviewComment", pr, state, comment)
|
|
ret0, _ := ret[0].(*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddReviewComment indicates an expected call of AddReviewComment.
|
|
func (mr *MockGiteaReviewerMockRecorder) AddReviewComment(pr, state, comment any) *MockGiteaReviewerAddReviewCommentCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReviewComment", reflect.TypeOf((*MockGiteaReviewer)(nil).AddReviewComment), pr, state, comment)
|
|
return &MockGiteaReviewerAddReviewCommentCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaReviewerAddReviewCommentCall wrap *gomock.Call
|
|
type MockGiteaReviewerAddReviewCommentCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaReviewerAddReviewCommentCall) Return(arg0 *models.PullReview, arg1 error) *MockGiteaReviewerAddReviewCommentCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaReviewerAddReviewCommentCall) Do(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaReviewerAddReviewCommentCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaReviewerAddReviewCommentCall) DoAndReturn(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaReviewerAddReviewCommentCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaRepoFetcher is a mock of GiteaRepoFetcher interface.
|
|
type MockGiteaRepoFetcher struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaRepoFetcherMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaRepoFetcherMockRecorder is the mock recorder for MockGiteaRepoFetcher.
|
|
type MockGiteaRepoFetcherMockRecorder struct {
|
|
mock *MockGiteaRepoFetcher
|
|
}
|
|
|
|
// NewMockGiteaRepoFetcher creates a new mock instance.
|
|
func NewMockGiteaRepoFetcher(ctrl *gomock.Controller) *MockGiteaRepoFetcher {
|
|
mock := &MockGiteaRepoFetcher{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaRepoFetcherMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaRepoFetcher) EXPECT() *MockGiteaRepoFetcherMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetRepository mocks base method.
|
|
func (m *MockGiteaRepoFetcher) GetRepository(org, repo string) (*models.Repository, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRepository", org, repo)
|
|
ret0, _ := ret[0].(*models.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetRepository indicates an expected call of GetRepository.
|
|
func (mr *MockGiteaRepoFetcherMockRecorder) GetRepository(org, repo any) *MockGiteaRepoFetcherGetRepositoryCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGiteaRepoFetcher)(nil).GetRepository), org, repo)
|
|
return &MockGiteaRepoFetcherGetRepositoryCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaRepoFetcherGetRepositoryCall wrap *gomock.Call
|
|
type MockGiteaRepoFetcherGetRepositoryCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaRepoFetcherGetRepositoryCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaRepoFetcherGetRepositoryCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaRepoFetcherGetRepositoryCall) Do(f func(string, string) (*models.Repository, error)) *MockGiteaRepoFetcherGetRepositoryCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaRepoFetcherGetRepositoryCall) DoAndReturn(f func(string, string) (*models.Repository, error)) *MockGiteaRepoFetcherGetRepositoryCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaFileContentReader is a mock of GiteaFileContentReader interface.
|
|
type MockGiteaFileContentReader struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaFileContentReaderMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaFileContentReaderMockRecorder is the mock recorder for MockGiteaFileContentReader.
|
|
type MockGiteaFileContentReaderMockRecorder struct {
|
|
mock *MockGiteaFileContentReader
|
|
}
|
|
|
|
// NewMockGiteaFileContentReader creates a new mock instance.
|
|
func NewMockGiteaFileContentReader(ctrl *gomock.Controller) *MockGiteaFileContentReader {
|
|
mock := &MockGiteaFileContentReader{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaFileContentReaderMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaFileContentReader) EXPECT() *MockGiteaFileContentReaderMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetRepositoryFileContent mocks base method.
|
|
func (m *MockGiteaFileContentReader) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRepositoryFileContent", org, repo, hash, path)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetRepositoryFileContent indicates an expected call of GetRepositoryFileContent.
|
|
func (mr *MockGiteaFileContentReaderMockRecorder) GetRepositoryFileContent(org, repo, hash, path any) *MockGiteaFileContentReaderGetRepositoryFileContentCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryFileContent", reflect.TypeOf((*MockGiteaFileContentReader)(nil).GetRepositoryFileContent), org, repo, hash, path)
|
|
return &MockGiteaFileContentReaderGetRepositoryFileContentCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaFileContentReaderGetRepositoryFileContentCall wrap *gomock.Call
|
|
type MockGiteaFileContentReaderGetRepositoryFileContentCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFileContentReaderGetRepositoryFileContentCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentReaderGetRepositoryFileContentCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentReaderGetRepositoryFileContentCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaCommitStatusSetter is a mock of GiteaCommitStatusSetter interface.
|
|
type MockGiteaCommitStatusSetter struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaCommitStatusSetterMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaCommitStatusSetterMockRecorder is the mock recorder for MockGiteaCommitStatusSetter.
|
|
type MockGiteaCommitStatusSetterMockRecorder struct {
|
|
mock *MockGiteaCommitStatusSetter
|
|
}
|
|
|
|
// NewMockGiteaCommitStatusSetter creates a new mock instance.
|
|
func NewMockGiteaCommitStatusSetter(ctrl *gomock.Controller) *MockGiteaCommitStatusSetter {
|
|
mock := &MockGiteaCommitStatusSetter{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaCommitStatusSetterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaCommitStatusSetter) EXPECT() *MockGiteaCommitStatusSetterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// SetCommitStatus mocks base method.
|
|
func (m *MockGiteaCommitStatusSetter) SetCommitStatus(org, repo, hash string, status *models.CommitStatus) (*models.CommitStatus, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetCommitStatus", org, repo, hash, status)
|
|
ret0, _ := ret[0].(*models.CommitStatus)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetCommitStatus indicates an expected call of SetCommitStatus.
|
|
func (mr *MockGiteaCommitStatusSetterMockRecorder) SetCommitStatus(org, repo, hash, status any) *MockGiteaCommitStatusSetterSetCommitStatusCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCommitStatus", reflect.TypeOf((*MockGiteaCommitStatusSetter)(nil).SetCommitStatus), org, repo, hash, status)
|
|
return &MockGiteaCommitStatusSetterSetCommitStatusCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaCommitStatusSetterSetCommitStatusCall wrap *gomock.Call
|
|
type MockGiteaCommitStatusSetterSetCommitStatusCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) Return(arg0 *models.CommitStatus, arg1 error) *MockGiteaCommitStatusSetterSetCommitStatusCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) Do(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaCommitStatusSetterSetCommitStatusCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) DoAndReturn(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaCommitStatusSetterSetCommitStatusCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaCommitStatusGetter is a mock of GiteaCommitStatusGetter interface.
|
|
type MockGiteaCommitStatusGetter struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaCommitStatusGetterMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaCommitStatusGetterMockRecorder is the mock recorder for MockGiteaCommitStatusGetter.
|
|
type MockGiteaCommitStatusGetterMockRecorder struct {
|
|
mock *MockGiteaCommitStatusGetter
|
|
}
|
|
|
|
// NewMockGiteaCommitStatusGetter creates a new mock instance.
|
|
func NewMockGiteaCommitStatusGetter(ctrl *gomock.Controller) *MockGiteaCommitStatusGetter {
|
|
mock := &MockGiteaCommitStatusGetter{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaCommitStatusGetterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaCommitStatusGetter) EXPECT() *MockGiteaCommitStatusGetterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetCommitStatus mocks base method.
|
|
func (m *MockGiteaCommitStatusGetter) GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCommitStatus", org, repo, hash)
|
|
ret0, _ := ret[0].([]*models.CommitStatus)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetCommitStatus indicates an expected call of GetCommitStatus.
|
|
func (mr *MockGiteaCommitStatusGetterMockRecorder) GetCommitStatus(org, repo, hash any) *MockGiteaCommitStatusGetterGetCommitStatusCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitStatus", reflect.TypeOf((*MockGiteaCommitStatusGetter)(nil).GetCommitStatus), org, repo, hash)
|
|
return &MockGiteaCommitStatusGetterGetCommitStatusCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaCommitStatusGetterGetCommitStatusCall wrap *gomock.Call
|
|
type MockGiteaCommitStatusGetterGetCommitStatusCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) Return(arg0 []*models.CommitStatus, arg1 error) *MockGiteaCommitStatusGetterGetCommitStatusCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) Do(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaCommitStatusGetterGetCommitStatusCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) DoAndReturn(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaCommitStatusGetterGetCommitStatusCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGiteaMerger is a mock of GiteaMerger interface.
|
|
type MockGiteaMerger struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaMergerMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaMergerMockRecorder is the mock recorder for MockGiteaMerger.
|
|
type MockGiteaMergerMockRecorder struct {
|
|
mock *MockGiteaMerger
|
|
}
|
|
|
|
// NewMockGiteaMerger creates a new mock instance.
|
|
func NewMockGiteaMerger(ctrl *gomock.Controller) *MockGiteaMerger {
|
|
mock := &MockGiteaMerger{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaMergerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGiteaMerger) EXPECT() *MockGiteaMergerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// ManualMergePR mocks base method.
|
|
func (m *MockGiteaMerger) ManualMergePR(org, repo string, id int64, commitid string, delBranch bool) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ManualMergePR", org, repo, id, commitid, delBranch)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ManualMergePR indicates an expected call of ManualMergePR.
|
|
func (mr *MockGiteaMergerMockRecorder) ManualMergePR(org, repo, id, commitid, delBranch any) *MockGiteaMergerManualMergePRCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManualMergePR", reflect.TypeOf((*MockGiteaMerger)(nil).ManualMergePR), org, repo, id, commitid, delBranch)
|
|
return &MockGiteaMergerManualMergePRCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaMergerManualMergePRCall wrap *gomock.Call
|
|
type MockGiteaMergerManualMergePRCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaMergerManualMergePRCall) Return(arg0 error) *MockGiteaMergerManualMergePRCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaMergerManualMergePRCall) Do(f func(string, string, int64, string, bool) error) *MockGiteaMergerManualMergePRCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaMergerManualMergePRCall) DoAndReturn(f func(string, string, int64, string, bool) error) *MockGiteaMergerManualMergePRCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGitea is a mock of Gitea interface.
|
|
type MockGitea struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGiteaMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGiteaMockRecorder is the mock recorder for MockGitea.
|
|
type MockGiteaMockRecorder struct {
|
|
mock *MockGitea
|
|
}
|
|
|
|
// NewMockGitea creates a new mock instance.
|
|
func NewMockGitea(ctrl *gomock.Controller) *MockGitea {
|
|
mock := &MockGitea{ctrl: ctrl}
|
|
mock.recorder = &MockGiteaMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGitea) EXPECT() *MockGiteaMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddComment mocks base method.
|
|
func (m *MockGitea) AddComment(pr *models.PullRequest, comment string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddComment", pr, comment)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AddComment indicates an expected call of AddComment.
|
|
func (mr *MockGiteaMockRecorder) AddComment(pr, comment any) *MockGiteaAddCommentCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddComment", reflect.TypeOf((*MockGitea)(nil).AddComment), pr, comment)
|
|
return &MockGiteaAddCommentCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaAddCommentCall wrap *gomock.Call
|
|
type MockGiteaAddCommentCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaAddCommentCall) Return(arg0 error) *MockGiteaAddCommentCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaAddCommentCall) Do(f func(*models.PullRequest, string) error) *MockGiteaAddCommentCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaAddCommentCall) DoAndReturn(f func(*models.PullRequest, string) error) *MockGiteaAddCommentCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// AddReviewComment mocks base method.
|
|
func (m *MockGitea) AddReviewComment(pr *models.PullRequest, state models.ReviewStateType, comment string) (*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddReviewComment", pr, state, comment)
|
|
ret0, _ := ret[0].(*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddReviewComment indicates an expected call of AddReviewComment.
|
|
func (mr *MockGiteaMockRecorder) AddReviewComment(pr, state, comment any) *MockGiteaAddReviewCommentCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReviewComment", reflect.TypeOf((*MockGitea)(nil).AddReviewComment), pr, state, comment)
|
|
return &MockGiteaAddReviewCommentCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaAddReviewCommentCall wrap *gomock.Call
|
|
type MockGiteaAddReviewCommentCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaAddReviewCommentCall) Return(arg0 *models.PullReview, arg1 error) *MockGiteaAddReviewCommentCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaAddReviewCommentCall) Do(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaAddReviewCommentCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaAddReviewCommentCall) DoAndReturn(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaAddReviewCommentCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// CreatePullRequestIfNotExist mocks base method.
|
|
func (m *MockGitea) CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreatePullRequestIfNotExist", repo, srcId, targetId, title, body)
|
|
ret0, _ := ret[0].(*models.PullRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreatePullRequestIfNotExist indicates an expected call of CreatePullRequestIfNotExist.
|
|
func (mr *MockGiteaMockRecorder) CreatePullRequestIfNotExist(repo, srcId, targetId, title, body any) *MockGiteaCreatePullRequestIfNotExistCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequestIfNotExist", reflect.TypeOf((*MockGitea)(nil).CreatePullRequestIfNotExist), repo, srcId, targetId, title, body)
|
|
return &MockGiteaCreatePullRequestIfNotExistCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaCreatePullRequestIfNotExistCall wrap *gomock.Call
|
|
type MockGiteaCreatePullRequestIfNotExistCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaCreatePullRequestIfNotExistCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaCreatePullRequestIfNotExistCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaCreatePullRequestIfNotExistCall) Do(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error)) *MockGiteaCreatePullRequestIfNotExistCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaCreatePullRequestIfNotExistCall) DoAndReturn(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error)) *MockGiteaCreatePullRequestIfNotExistCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// CreateRepositoryIfNotExist mocks base method.
|
|
func (m *MockGitea) CreateRepositoryIfNotExist(git common.Git, org, repoName string) (*models.Repository, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateRepositoryIfNotExist", git, org, repoName)
|
|
ret0, _ := ret[0].(*models.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateRepositoryIfNotExist indicates an expected call of CreateRepositoryIfNotExist.
|
|
func (mr *MockGiteaMockRecorder) CreateRepositoryIfNotExist(git, org, repoName any) *MockGiteaCreateRepositoryIfNotExistCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepositoryIfNotExist", reflect.TypeOf((*MockGitea)(nil).CreateRepositoryIfNotExist), git, org, repoName)
|
|
return &MockGiteaCreateRepositoryIfNotExistCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaCreateRepositoryIfNotExistCall wrap *gomock.Call
|
|
type MockGiteaCreateRepositoryIfNotExistCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaCreateRepositoryIfNotExistCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaCreateRepositoryIfNotExistCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaCreateRepositoryIfNotExistCall) Do(f func(common.Git, string, string) (*models.Repository, error)) *MockGiteaCreateRepositoryIfNotExistCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaCreateRepositoryIfNotExistCall) DoAndReturn(f func(common.Git, string, string) (*models.Repository, error)) *MockGiteaCreateRepositoryIfNotExistCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// FetchMaintainershipDirFile mocks base method.
|
|
func (m *MockGitea) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile.
|
|
func (mr *MockGiteaMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaFetchMaintainershipDirFileCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGitea)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg)
|
|
return &MockGiteaFetchMaintainershipDirFileCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaFetchMaintainershipDirFileCall wrap *gomock.Call
|
|
type MockGiteaFetchMaintainershipDirFileCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipDirFileCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// FetchMaintainershipFile mocks base method.
|
|
func (m *MockGitea) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile.
|
|
func (mr *MockGiteaMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaFetchMaintainershipFileCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGitea)(nil).FetchMaintainershipFile), org, prjGit, branch)
|
|
return &MockGiteaFetchMaintainershipFileCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaFetchMaintainershipFileCall wrap *gomock.Call
|
|
type MockGiteaFetchMaintainershipFileCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFetchMaintainershipFileCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipFileCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipFileCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetCommit mocks base method.
|
|
func (m *MockGitea) GetCommit(org, repo, sha string) (*models.Commit, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCommit", org, repo, sha)
|
|
ret0, _ := ret[0].(*models.Commit)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetCommit indicates an expected call of GetCommit.
|
|
func (mr *MockGiteaMockRecorder) GetCommit(org, repo, sha any) *MockGiteaGetCommitCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockGitea)(nil).GetCommit), org, repo, sha)
|
|
return &MockGiteaGetCommitCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetCommitCall wrap *gomock.Call
|
|
type MockGiteaGetCommitCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetCommitCall) Return(arg0 *models.Commit, arg1 error) *MockGiteaGetCommitCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetCommitCall) Do(f func(string, string, string) (*models.Commit, error)) *MockGiteaGetCommitCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetCommitCall) DoAndReturn(f func(string, string, string) (*models.Commit, error)) *MockGiteaGetCommitCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetCommitStatus mocks base method.
|
|
func (m *MockGitea) GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCommitStatus", org, repo, hash)
|
|
ret0, _ := ret[0].([]*models.CommitStatus)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetCommitStatus indicates an expected call of GetCommitStatus.
|
|
func (mr *MockGiteaMockRecorder) GetCommitStatus(org, repo, hash any) *MockGiteaGetCommitStatusCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitStatus", reflect.TypeOf((*MockGitea)(nil).GetCommitStatus), org, repo, hash)
|
|
return &MockGiteaGetCommitStatusCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetCommitStatusCall wrap *gomock.Call
|
|
type MockGiteaGetCommitStatusCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetCommitStatusCall) Return(arg0 []*models.CommitStatus, arg1 error) *MockGiteaGetCommitStatusCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetCommitStatusCall) Do(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaGetCommitStatusCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetCommitStatusCall) DoAndReturn(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaGetCommitStatusCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetCurrentUser mocks base method.
|
|
func (m *MockGitea) GetCurrentUser() (*models.User, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCurrentUser")
|
|
ret0, _ := ret[0].(*models.User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetCurrentUser indicates an expected call of GetCurrentUser.
|
|
func (mr *MockGiteaMockRecorder) GetCurrentUser() *MockGiteaGetCurrentUserCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentUser", reflect.TypeOf((*MockGitea)(nil).GetCurrentUser))
|
|
return &MockGiteaGetCurrentUserCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetCurrentUserCall wrap *gomock.Call
|
|
type MockGiteaGetCurrentUserCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetCurrentUserCall) Return(arg0 *models.User, arg1 error) *MockGiteaGetCurrentUserCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetCurrentUserCall) Do(f func() (*models.User, error)) *MockGiteaGetCurrentUserCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetCurrentUserCall) DoAndReturn(f func() (*models.User, error)) *MockGiteaGetCurrentUserCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetDoneNotifications mocks base method.
|
|
func (m *MockGitea) GetDoneNotifications(Type string, page int64) ([]*models.NotificationThread, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDoneNotifications", Type, page)
|
|
ret0, _ := ret[0].([]*models.NotificationThread)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetDoneNotifications indicates an expected call of GetDoneNotifications.
|
|
func (mr *MockGiteaMockRecorder) GetDoneNotifications(Type, page any) *MockGiteaGetDoneNotificationsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDoneNotifications", reflect.TypeOf((*MockGitea)(nil).GetDoneNotifications), Type, page)
|
|
return &MockGiteaGetDoneNotificationsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetDoneNotificationsCall wrap *gomock.Call
|
|
type MockGiteaGetDoneNotificationsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetDoneNotificationsCall) Return(arg0 []*models.NotificationThread, arg1 error) *MockGiteaGetDoneNotificationsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetDoneNotificationsCall) Do(f func(string, int64) ([]*models.NotificationThread, error)) *MockGiteaGetDoneNotificationsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetDoneNotificationsCall) DoAndReturn(f func(string, int64) ([]*models.NotificationThread, error)) *MockGiteaGetDoneNotificationsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetIssueComments mocks base method.
|
|
func (m *MockGitea) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo)
|
|
ret0, _ := ret[0].([]*models.Comment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetIssueComments indicates an expected call of GetIssueComments.
|
|
func (mr *MockGiteaMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaGetIssueCommentsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGitea)(nil).GetIssueComments), org, project, issueNo)
|
|
return &MockGiteaGetIssueCommentsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetIssueCommentsCall wrap *gomock.Call
|
|
type MockGiteaGetIssueCommentsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaGetIssueCommentsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaGetIssueCommentsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaGetIssueCommentsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetNotifications mocks base method.
|
|
func (m *MockGitea) GetNotifications(Type string, since *time.Time) ([]*models.NotificationThread, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNotifications", Type, since)
|
|
ret0, _ := ret[0].([]*models.NotificationThread)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetNotifications indicates an expected call of GetNotifications.
|
|
func (mr *MockGiteaMockRecorder) GetNotifications(Type, since any) *MockGiteaGetNotificationsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotifications", reflect.TypeOf((*MockGitea)(nil).GetNotifications), Type, since)
|
|
return &MockGiteaGetNotificationsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetNotificationsCall wrap *gomock.Call
|
|
type MockGiteaGetNotificationsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetNotificationsCall) Return(arg0 []*models.NotificationThread, arg1 error) *MockGiteaGetNotificationsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetNotificationsCall) Do(f func(string, *time.Time) ([]*models.NotificationThread, error)) *MockGiteaGetNotificationsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetNotificationsCall) DoAndReturn(f func(string, *time.Time) ([]*models.NotificationThread, error)) *MockGiteaGetNotificationsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetOrganization mocks base method.
|
|
func (m *MockGitea) GetOrganization(orgName string) (*models.Organization, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOrganization", orgName)
|
|
ret0, _ := ret[0].(*models.Organization)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetOrganization indicates an expected call of GetOrganization.
|
|
func (mr *MockGiteaMockRecorder) GetOrganization(orgName any) *MockGiteaGetOrganizationCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganization", reflect.TypeOf((*MockGitea)(nil).GetOrganization), orgName)
|
|
return &MockGiteaGetOrganizationCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetOrganizationCall wrap *gomock.Call
|
|
type MockGiteaGetOrganizationCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetOrganizationCall) Return(arg0 *models.Organization, arg1 error) *MockGiteaGetOrganizationCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetOrganizationCall) Do(f func(string) (*models.Organization, error)) *MockGiteaGetOrganizationCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetOrganizationCall) DoAndReturn(f func(string) (*models.Organization, error)) *MockGiteaGetOrganizationCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetOrganizationRepositories mocks base method.
|
|
func (m *MockGitea) GetOrganizationRepositories(orgName string) ([]*models.Repository, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOrganizationRepositories", orgName)
|
|
ret0, _ := ret[0].([]*models.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetOrganizationRepositories indicates an expected call of GetOrganizationRepositories.
|
|
func (mr *MockGiteaMockRecorder) GetOrganizationRepositories(orgName any) *MockGiteaGetOrganizationRepositoriesCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationRepositories", reflect.TypeOf((*MockGitea)(nil).GetOrganizationRepositories), orgName)
|
|
return &MockGiteaGetOrganizationRepositoriesCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetOrganizationRepositoriesCall wrap *gomock.Call
|
|
type MockGiteaGetOrganizationRepositoriesCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetOrganizationRepositoriesCall) Return(arg0 []*models.Repository, arg1 error) *MockGiteaGetOrganizationRepositoriesCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetOrganizationRepositoriesCall) Do(f func(string) ([]*models.Repository, error)) *MockGiteaGetOrganizationRepositoriesCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetOrganizationRepositoriesCall) DoAndReturn(f func(string) ([]*models.Repository, error)) *MockGiteaGetOrganizationRepositoriesCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetPullRequest mocks base method.
|
|
func (m *MockGitea) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequest", org, project, num)
|
|
ret0, _ := ret[0].(*models.PullRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequest indicates an expected call of GetPullRequest.
|
|
func (mr *MockGiteaMockRecorder) GetPullRequest(org, project, num any) *MockGiteaGetPullRequestCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGitea)(nil).GetPullRequest), org, project, num)
|
|
return &MockGiteaGetPullRequestCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetPullRequestCall wrap *gomock.Call
|
|
type MockGiteaGetPullRequestCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaGetPullRequestCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaGetPullRequestCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaGetPullRequestCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetPullRequestFileContent mocks base method.
|
|
func (m *MockGitea) GetPullRequestFileContent(pr *models.PullRequest, path string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequestFileContent", pr, path)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetPullRequestFileContent indicates an expected call of GetPullRequestFileContent.
|
|
func (mr *MockGiteaMockRecorder) GetPullRequestFileContent(pr, path any) *MockGiteaGetPullRequestFileContentCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestFileContent", reflect.TypeOf((*MockGitea)(nil).GetPullRequestFileContent), pr, path)
|
|
return &MockGiteaGetPullRequestFileContentCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetPullRequestFileContentCall wrap *gomock.Call
|
|
type MockGiteaGetPullRequestFileContentCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetPullRequestFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaGetPullRequestFileContentCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetPullRequestFileContentCall) Do(f func(*models.PullRequest, string) ([]byte, string, error)) *MockGiteaGetPullRequestFileContentCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetPullRequestFileContentCall) DoAndReturn(f func(*models.PullRequest, string) ([]byte, string, error)) *MockGiteaGetPullRequestFileContentCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetPullRequestReviews mocks base method.
|
|
func (m *MockGitea) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum)
|
|
ret0, _ := ret[0].([]*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequestReviews indicates an expected call of GetPullRequestReviews.
|
|
func (mr *MockGiteaMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaGetPullRequestReviewsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGitea)(nil).GetPullRequestReviews), org, project, PRnum)
|
|
return &MockGiteaGetPullRequestReviewsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetPullRequestReviewsCall wrap *gomock.Call
|
|
type MockGiteaGetPullRequestReviewsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaGetPullRequestReviewsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaGetPullRequestReviewsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetPullRequests mocks base method.
|
|
func (m *MockGitea) GetPullRequests(org, project string) ([]*models.PullRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPullRequests", org, project)
|
|
ret0, _ := ret[0].([]*models.PullRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetPullRequests indicates an expected call of GetPullRequests.
|
|
func (mr *MockGiteaMockRecorder) GetPullRequests(org, project any) *MockGiteaGetPullRequestsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequests", reflect.TypeOf((*MockGitea)(nil).GetPullRequests), org, project)
|
|
return &MockGiteaGetPullRequestsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetPullRequestsCall wrap *gomock.Call
|
|
type MockGiteaGetPullRequestsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetPullRequestsCall) Return(arg0 []*models.PullRequest, arg1 error) *MockGiteaGetPullRequestsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetPullRequestsCall) Do(f func(string, string) ([]*models.PullRequest, error)) *MockGiteaGetPullRequestsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetPullRequestsCall) DoAndReturn(f func(string, string) ([]*models.PullRequest, error)) *MockGiteaGetPullRequestsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetRecentCommits mocks base method.
|
|
func (m *MockGitea) GetRecentCommits(org, repo, branch string, commitNo int64) ([]*models.Commit, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRecentCommits", org, repo, branch, commitNo)
|
|
ret0, _ := ret[0].([]*models.Commit)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetRecentCommits indicates an expected call of GetRecentCommits.
|
|
func (mr *MockGiteaMockRecorder) GetRecentCommits(org, repo, branch, commitNo any) *MockGiteaGetRecentCommitsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecentCommits", reflect.TypeOf((*MockGitea)(nil).GetRecentCommits), org, repo, branch, commitNo)
|
|
return &MockGiteaGetRecentCommitsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetRecentCommitsCall wrap *gomock.Call
|
|
type MockGiteaGetRecentCommitsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetRecentCommitsCall) Return(arg0 []*models.Commit, arg1 error) *MockGiteaGetRecentCommitsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetRecentCommitsCall) Do(f func(string, string, string, int64) ([]*models.Commit, error)) *MockGiteaGetRecentCommitsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetRecentCommitsCall) DoAndReturn(f func(string, string, string, int64) ([]*models.Commit, error)) *MockGiteaGetRecentCommitsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetRecentPullRequests mocks base method.
|
|
func (m *MockGitea) GetRecentPullRequests(org, repo, branch string) ([]*models.PullRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRecentPullRequests", org, repo, branch)
|
|
ret0, _ := ret[0].([]*models.PullRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetRecentPullRequests indicates an expected call of GetRecentPullRequests.
|
|
func (mr *MockGiteaMockRecorder) GetRecentPullRequests(org, repo, branch any) *MockGiteaGetRecentPullRequestsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecentPullRequests", reflect.TypeOf((*MockGitea)(nil).GetRecentPullRequests), org, repo, branch)
|
|
return &MockGiteaGetRecentPullRequestsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetRecentPullRequestsCall wrap *gomock.Call
|
|
type MockGiteaGetRecentPullRequestsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetRecentPullRequestsCall) Return(arg0 []*models.PullRequest, arg1 error) *MockGiteaGetRecentPullRequestsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetRecentPullRequestsCall) Do(f func(string, string, string) ([]*models.PullRequest, error)) *MockGiteaGetRecentPullRequestsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetRecentPullRequestsCall) DoAndReturn(f func(string, string, string) ([]*models.PullRequest, error)) *MockGiteaGetRecentPullRequestsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetRepository mocks base method.
|
|
func (m *MockGitea) GetRepository(org, repo string) (*models.Repository, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRepository", org, repo)
|
|
ret0, _ := ret[0].(*models.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetRepository indicates an expected call of GetRepository.
|
|
func (mr *MockGiteaMockRecorder) GetRepository(org, repo any) *MockGiteaGetRepositoryCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGitea)(nil).GetRepository), org, repo)
|
|
return &MockGiteaGetRepositoryCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetRepositoryCall wrap *gomock.Call
|
|
type MockGiteaGetRepositoryCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetRepositoryCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaGetRepositoryCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetRepositoryCall) Do(f func(string, string) (*models.Repository, error)) *MockGiteaGetRepositoryCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetRepositoryCall) DoAndReturn(f func(string, string) (*models.Repository, error)) *MockGiteaGetRepositoryCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetRepositoryFileContent mocks base method.
|
|
func (m *MockGitea) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRepositoryFileContent", org, repo, hash, path)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetRepositoryFileContent indicates an expected call of GetRepositoryFileContent.
|
|
func (mr *MockGiteaMockRecorder) GetRepositoryFileContent(org, repo, hash, path any) *MockGiteaGetRepositoryFileContentCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryFileContent", reflect.TypeOf((*MockGitea)(nil).GetRepositoryFileContent), org, repo, hash, path)
|
|
return &MockGiteaGetRepositoryFileContentCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetRepositoryFileContentCall wrap *gomock.Call
|
|
type MockGiteaGetRepositoryFileContentCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetRepositoryFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaGetRepositoryFileContentCall {
|
|
c.Call = c.Call.Return(arg0, arg1, arg2)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetRepositoryFileContentCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaGetRepositoryFileContentCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetRepositoryFileContentCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaGetRepositoryFileContentCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetTimeline mocks base method.
|
|
func (m *MockGitea) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx)
|
|
ret0, _ := ret[0].([]*models.TimelineComment)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTimeline indicates an expected call of GetTimeline.
|
|
func (mr *MockGiteaMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaGetTimelineCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGitea)(nil).GetTimeline), org, repo, idx)
|
|
return &MockGiteaGetTimelineCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaGetTimelineCall wrap *gomock.Call
|
|
type MockGiteaGetTimelineCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaGetTimelineCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaGetTimelineCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaGetTimelineCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// ManualMergePR mocks base method.
|
|
func (m *MockGitea) ManualMergePR(org, repo string, id int64, commitid string, delBranch bool) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ManualMergePR", org, repo, id, commitid, delBranch)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ManualMergePR indicates an expected call of ManualMergePR.
|
|
func (mr *MockGiteaMockRecorder) ManualMergePR(org, repo, id, commitid, delBranch any) *MockGiteaManualMergePRCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManualMergePR", reflect.TypeOf((*MockGitea)(nil).ManualMergePR), org, repo, id, commitid, delBranch)
|
|
return &MockGiteaManualMergePRCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaManualMergePRCall wrap *gomock.Call
|
|
type MockGiteaManualMergePRCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaManualMergePRCall) Return(arg0 error) *MockGiteaManualMergePRCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaManualMergePRCall) Do(f func(string, string, int64, string, bool) error) *MockGiteaManualMergePRCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaManualMergePRCall) DoAndReturn(f func(string, string, int64, string, bool) error) *MockGiteaManualMergePRCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// RequestReviews mocks base method.
|
|
func (m *MockGitea) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{pr}
|
|
for _, a := range reviewer {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RequestReviews", varargs...)
|
|
ret0, _ := ret[0].([]*models.PullReview)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RequestReviews indicates an expected call of RequestReviews.
|
|
func (mr *MockGiteaMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaRequestReviewsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{pr}, reviewer...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGitea)(nil).RequestReviews), varargs...)
|
|
return &MockGiteaRequestReviewsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaRequestReviewsCall wrap *gomock.Call
|
|
type MockGiteaRequestReviewsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaRequestReviewsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaRequestReviewsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaRequestReviewsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// SetCommitStatus mocks base method.
|
|
func (m *MockGitea) SetCommitStatus(org, repo, hash string, status *models.CommitStatus) (*models.CommitStatus, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetCommitStatus", org, repo, hash, status)
|
|
ret0, _ := ret[0].(*models.CommitStatus)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetCommitStatus indicates an expected call of SetCommitStatus.
|
|
func (mr *MockGiteaMockRecorder) SetCommitStatus(org, repo, hash, status any) *MockGiteaSetCommitStatusCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCommitStatus", reflect.TypeOf((*MockGitea)(nil).SetCommitStatus), org, repo, hash, status)
|
|
return &MockGiteaSetCommitStatusCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaSetCommitStatusCall wrap *gomock.Call
|
|
type MockGiteaSetCommitStatusCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaSetCommitStatusCall) Return(arg0 *models.CommitStatus, arg1 error) *MockGiteaSetCommitStatusCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaSetCommitStatusCall) Do(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaSetCommitStatusCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaSetCommitStatusCall) DoAndReturn(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaSetCommitStatusCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// SetNotificationRead mocks base method.
|
|
func (m *MockGitea) SetNotificationRead(notificationId int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetNotificationRead", notificationId)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetNotificationRead indicates an expected call of SetNotificationRead.
|
|
func (mr *MockGiteaMockRecorder) SetNotificationRead(notificationId any) *MockGiteaSetNotificationReadCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNotificationRead", reflect.TypeOf((*MockGitea)(nil).SetNotificationRead), notificationId)
|
|
return &MockGiteaSetNotificationReadCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaSetNotificationReadCall wrap *gomock.Call
|
|
type MockGiteaSetNotificationReadCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaSetNotificationReadCall) Return(arg0 error) *MockGiteaSetNotificationReadCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaSetNotificationReadCall) Do(f func(int64) error) *MockGiteaSetNotificationReadCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaSetNotificationReadCall) DoAndReturn(f func(int64) error) *MockGiteaSetNotificationReadCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// SetRepoOptions mocks base method.
|
|
func (m *MockGitea) SetRepoOptions(owner, repo string, manual_merge bool) (*models.Repository, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetRepoOptions", owner, repo, manual_merge)
|
|
ret0, _ := ret[0].(*models.Repository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetRepoOptions indicates an expected call of SetRepoOptions.
|
|
func (mr *MockGiteaMockRecorder) SetRepoOptions(owner, repo, manual_merge any) *MockGiteaSetRepoOptionsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepoOptions", reflect.TypeOf((*MockGitea)(nil).SetRepoOptions), owner, repo, manual_merge)
|
|
return &MockGiteaSetRepoOptionsCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaSetRepoOptionsCall wrap *gomock.Call
|
|
type MockGiteaSetRepoOptionsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaSetRepoOptionsCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaSetRepoOptionsCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaSetRepoOptionsCall) Do(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaSetRepoOptionsCall) DoAndReturn(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// UnrequestReview mocks base method.
|
|
func (m *MockGitea) UnrequestReview(org, repo string, id int64, reviwers ...string) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{org, repo, id}
|
|
for _, a := range reviwers {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "UnrequestReview", varargs...)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UnrequestReview indicates an expected call of UnrequestReview.
|
|
func (mr *MockGiteaMockRecorder) UnrequestReview(org, repo, id any, reviwers ...any) *MockGiteaUnrequestReviewCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{org, repo, id}, reviwers...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrequestReview", reflect.TypeOf((*MockGitea)(nil).UnrequestReview), varargs...)
|
|
return &MockGiteaUnrequestReviewCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaUnrequestReviewCall wrap *gomock.Call
|
|
type MockGiteaUnrequestReviewCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaUnrequestReviewCall) Return(arg0 error) *MockGiteaUnrequestReviewCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaUnrequestReviewCall) Do(f func(string, string, int64, ...string) error) *MockGiteaUnrequestReviewCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaUnrequestReviewCall) DoAndReturn(f func(string, string, int64, ...string) error) *MockGiteaUnrequestReviewCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// UpdatePullRequest mocks base method.
|
|
func (m *MockGitea) UpdatePullRequest(org, repo string, num int64, options *models.EditPullRequestOption) (*models.PullRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdatePullRequest", org, repo, num, options)
|
|
ret0, _ := ret[0].(*models.PullRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdatePullRequest indicates an expected call of UpdatePullRequest.
|
|
func (mr *MockGiteaMockRecorder) UpdatePullRequest(org, repo, num, options any) *MockGiteaUpdatePullRequestCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequest", reflect.TypeOf((*MockGitea)(nil).UpdatePullRequest), org, repo, num, options)
|
|
return &MockGiteaUpdatePullRequestCall{Call: call}
|
|
}
|
|
|
|
// MockGiteaUpdatePullRequestCall wrap *gomock.Call
|
|
type MockGiteaUpdatePullRequestCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGiteaUpdatePullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaUpdatePullRequestCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGiteaUpdatePullRequestCall) Do(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaUpdatePullRequestCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGiteaUpdatePullRequestCall) DoAndReturn(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaUpdatePullRequestCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|