forked from git-workflow/autogits
1149 lines
38 KiB
Go
1149 lines
38 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: git_utils.go
|
|
//
|
|
// Generated by this command:
|
|
//
|
|
// mockgen -source=git_utils.go -destination=mock/git_utils.go -typed
|
|
//
|
|
|
|
// Package mock_common is a generated GoMock package.
|
|
package mock_common
|
|
|
|
import (
|
|
reflect "reflect"
|
|
|
|
gomock "go.uber.org/mock/gomock"
|
|
common "src.opensuse.org/autogits/common"
|
|
)
|
|
|
|
// MockGitSubmoduleLister is a mock of GitSubmoduleLister interface.
|
|
type MockGitSubmoduleLister struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGitSubmoduleListerMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGitSubmoduleListerMockRecorder is the mock recorder for MockGitSubmoduleLister.
|
|
type MockGitSubmoduleListerMockRecorder struct {
|
|
mock *MockGitSubmoduleLister
|
|
}
|
|
|
|
// NewMockGitSubmoduleLister creates a new mock instance.
|
|
func NewMockGitSubmoduleLister(ctrl *gomock.Controller) *MockGitSubmoduleLister {
|
|
mock := &MockGitSubmoduleLister{ctrl: ctrl}
|
|
mock.recorder = &MockGitSubmoduleListerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGitSubmoduleLister) EXPECT() *MockGitSubmoduleListerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GitSubmoduleCommitId mocks base method.
|
|
func (m *MockGitSubmoduleLister) GitSubmoduleCommitId(cwd, packageName, commitId string) (string, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitSubmoduleCommitId", cwd, packageName, commitId)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitSubmoduleCommitId indicates an expected call of GitSubmoduleCommitId.
|
|
func (mr *MockGitSubmoduleListerMockRecorder) GitSubmoduleCommitId(cwd, packageName, commitId any) *MockGitSubmoduleListerGitSubmoduleCommitIdCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleCommitId", reflect.TypeOf((*MockGitSubmoduleLister)(nil).GitSubmoduleCommitId), cwd, packageName, commitId)
|
|
return &MockGitSubmoduleListerGitSubmoduleCommitIdCall{Call: call}
|
|
}
|
|
|
|
// MockGitSubmoduleListerGitSubmoduleCommitIdCall wrap *gomock.Call
|
|
type MockGitSubmoduleListerGitSubmoduleCommitIdCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) Return(subCommitId string, valid bool) *MockGitSubmoduleListerGitSubmoduleCommitIdCall {
|
|
c.Call = c.Call.Return(subCommitId, valid)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) Do(f func(string, string, string) (string, bool)) *MockGitSubmoduleListerGitSubmoduleCommitIdCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) DoAndReturn(f func(string, string, string) (string, bool)) *MockGitSubmoduleListerGitSubmoduleCommitIdCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitSubmoduleList mocks base method.
|
|
func (m *MockGitSubmoduleLister) GitSubmoduleList(gitPath, commitId string) (map[string]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitSubmoduleList", gitPath, commitId)
|
|
ret0, _ := ret[0].(map[string]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitSubmoduleList indicates an expected call of GitSubmoduleList.
|
|
func (mr *MockGitSubmoduleListerMockRecorder) GitSubmoduleList(gitPath, commitId any) *MockGitSubmoduleListerGitSubmoduleListCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleList", reflect.TypeOf((*MockGitSubmoduleLister)(nil).GitSubmoduleList), gitPath, commitId)
|
|
return &MockGitSubmoduleListerGitSubmoduleListCall{Call: call}
|
|
}
|
|
|
|
// MockGitSubmoduleListerGitSubmoduleListCall wrap *gomock.Call
|
|
type MockGitSubmoduleListerGitSubmoduleListCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitSubmoduleListerGitSubmoduleListCall) Return(submoduleList map[string]string, err error) *MockGitSubmoduleListerGitSubmoduleListCall {
|
|
c.Call = c.Call.Return(submoduleList, err)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitSubmoduleListerGitSubmoduleListCall) Do(f func(string, string) (map[string]string, error)) *MockGitSubmoduleListerGitSubmoduleListCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitSubmoduleListerGitSubmoduleListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitSubmoduleListerGitSubmoduleListCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGitDirectoryLister is a mock of GitDirectoryLister interface.
|
|
type MockGitDirectoryLister struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGitDirectoryListerMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGitDirectoryListerMockRecorder is the mock recorder for MockGitDirectoryLister.
|
|
type MockGitDirectoryListerMockRecorder struct {
|
|
mock *MockGitDirectoryLister
|
|
}
|
|
|
|
// NewMockGitDirectoryLister creates a new mock instance.
|
|
func NewMockGitDirectoryLister(ctrl *gomock.Controller) *MockGitDirectoryLister {
|
|
mock := &MockGitDirectoryLister{ctrl: ctrl}
|
|
mock.recorder = &MockGitDirectoryListerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGitDirectoryLister) EXPECT() *MockGitDirectoryListerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GitDirectoryList mocks base method.
|
|
func (m *MockGitDirectoryLister) GitDirectoryList(gitPath, commitId string) (map[string]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitDirectoryList", gitPath, commitId)
|
|
ret0, _ := ret[0].(map[string]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitDirectoryList indicates an expected call of GitDirectoryList.
|
|
func (mr *MockGitDirectoryListerMockRecorder) GitDirectoryList(gitPath, commitId any) *MockGitDirectoryListerGitDirectoryListCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDirectoryList", reflect.TypeOf((*MockGitDirectoryLister)(nil).GitDirectoryList), gitPath, commitId)
|
|
return &MockGitDirectoryListerGitDirectoryListCall{Call: call}
|
|
}
|
|
|
|
// MockGitDirectoryListerGitDirectoryListCall wrap *gomock.Call
|
|
type MockGitDirectoryListerGitDirectoryListCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitDirectoryListerGitDirectoryListCall) Return(dirlist map[string]string, err error) *MockGitDirectoryListerGitDirectoryListCall {
|
|
c.Call = c.Call.Return(dirlist, err)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitDirectoryListerGitDirectoryListCall) Do(f func(string, string) (map[string]string, error)) *MockGitDirectoryListerGitDirectoryListCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitDirectoryListerGitDirectoryListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitDirectoryListerGitDirectoryListCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGitStatusLister is a mock of GitStatusLister interface.
|
|
type MockGitStatusLister struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGitStatusListerMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGitStatusListerMockRecorder is the mock recorder for MockGitStatusLister.
|
|
type MockGitStatusListerMockRecorder struct {
|
|
mock *MockGitStatusLister
|
|
}
|
|
|
|
// NewMockGitStatusLister creates a new mock instance.
|
|
func NewMockGitStatusLister(ctrl *gomock.Controller) *MockGitStatusLister {
|
|
mock := &MockGitStatusLister{ctrl: ctrl}
|
|
mock.recorder = &MockGitStatusListerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGitStatusLister) EXPECT() *MockGitStatusListerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GitStatus mocks base method.
|
|
func (m *MockGitStatusLister) GitStatus(cwd string) ([]common.GitStatusData, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitStatus", cwd)
|
|
ret0, _ := ret[0].([]common.GitStatusData)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitStatus indicates an expected call of GitStatus.
|
|
func (mr *MockGitStatusListerMockRecorder) GitStatus(cwd any) *MockGitStatusListerGitStatusCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitStatus", reflect.TypeOf((*MockGitStatusLister)(nil).GitStatus), cwd)
|
|
return &MockGitStatusListerGitStatusCall{Call: call}
|
|
}
|
|
|
|
// MockGitStatusListerGitStatusCall wrap *gomock.Call
|
|
type MockGitStatusListerGitStatusCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitStatusListerGitStatusCall) Return(arg0 []common.GitStatusData, arg1 error) *MockGitStatusListerGitStatusCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitStatusListerGitStatusCall) Do(f func(string) ([]common.GitStatusData, error)) *MockGitStatusListerGitStatusCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitStatusListerGitStatusCall) DoAndReturn(f func(string) ([]common.GitStatusData, error)) *MockGitStatusListerGitStatusCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGitDiffLister is a mock of GitDiffLister interface.
|
|
type MockGitDiffLister struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGitDiffListerMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGitDiffListerMockRecorder is the mock recorder for MockGitDiffLister.
|
|
type MockGitDiffListerMockRecorder struct {
|
|
mock *MockGitDiffLister
|
|
}
|
|
|
|
// NewMockGitDiffLister creates a new mock instance.
|
|
func NewMockGitDiffLister(ctrl *gomock.Controller) *MockGitDiffLister {
|
|
mock := &MockGitDiffLister{ctrl: ctrl}
|
|
mock.recorder = &MockGitDiffListerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGitDiffLister) EXPECT() *MockGitDiffListerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GitDiff mocks base method.
|
|
func (m *MockGitDiffLister) GitDiff(cwd, base, head string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitDiff", cwd, base, head)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitDiff indicates an expected call of GitDiff.
|
|
func (mr *MockGitDiffListerMockRecorder) GitDiff(cwd, base, head any) *MockGitDiffListerGitDiffCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDiff", reflect.TypeOf((*MockGitDiffLister)(nil).GitDiff), cwd, base, head)
|
|
return &MockGitDiffListerGitDiffCall{Call: call}
|
|
}
|
|
|
|
// MockGitDiffListerGitDiffCall wrap *gomock.Call
|
|
type MockGitDiffListerGitDiffCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitDiffListerGitDiffCall) Return(arg0 string, arg1 error) *MockGitDiffListerGitDiffCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitDiffListerGitDiffCall) Do(f func(string, string, string) (string, error)) *MockGitDiffListerGitDiffCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitDiffListerGitDiffCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitDiffListerGitDiffCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGit is a mock of Git interface.
|
|
type MockGit struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGitMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGitMockRecorder is the mock recorder for MockGit.
|
|
type MockGitMockRecorder struct {
|
|
mock *MockGit
|
|
}
|
|
|
|
// NewMockGit creates a new mock instance.
|
|
func NewMockGit(ctrl *gomock.Controller) *MockGit {
|
|
mock := &MockGit{ctrl: ctrl}
|
|
mock.recorder = &MockGitMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGit) EXPECT() *MockGitMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Close mocks base method.
|
|
func (m *MockGit) Close() error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Close")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Close indicates an expected call of Close.
|
|
func (mr *MockGitMockRecorder) Close() *MockGitCloseCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockGit)(nil).Close))
|
|
return &MockGitCloseCall{Call: call}
|
|
}
|
|
|
|
// MockGitCloseCall wrap *gomock.Call
|
|
type MockGitCloseCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitCloseCall) Return(arg0 error) *MockGitCloseCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitCloseCall) Do(f func() error) *MockGitCloseCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitCloseCall) DoAndReturn(f func() error) *MockGitCloseCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GetPath mocks base method.
|
|
func (m *MockGit) GetPath() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPath")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetPath indicates an expected call of GetPath.
|
|
func (mr *MockGitMockRecorder) GetPath() *MockGitGetPathCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPath", reflect.TypeOf((*MockGit)(nil).GetPath))
|
|
return &MockGitGetPathCall{Call: call}
|
|
}
|
|
|
|
// MockGitGetPathCall wrap *gomock.Call
|
|
type MockGitGetPathCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGetPathCall) Return(arg0 string) *MockGitGetPathCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGetPathCall) Do(f func() string) *MockGitGetPathCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGetPathCall) DoAndReturn(f func() string) *MockGitGetPathCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitBranchHead mocks base method.
|
|
func (m *MockGit) GitBranchHead(gitDir, branchName string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitBranchHead", gitDir, branchName)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitBranchHead indicates an expected call of GitBranchHead.
|
|
func (mr *MockGitMockRecorder) GitBranchHead(gitDir, branchName any) *MockGitGitBranchHeadCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitBranchHead", reflect.TypeOf((*MockGit)(nil).GitBranchHead), gitDir, branchName)
|
|
return &MockGitGitBranchHeadCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitBranchHeadCall wrap *gomock.Call
|
|
type MockGitGitBranchHeadCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitBranchHeadCall) Return(arg0 string, arg1 error) *MockGitGitBranchHeadCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitBranchHeadCall) Do(f func(string, string) (string, error)) *MockGitGitBranchHeadCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitBranchHeadCall) DoAndReturn(f func(string, string) (string, error)) *MockGitGitBranchHeadCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitCatFile mocks base method.
|
|
func (m *MockGit) GitCatFile(cwd, commitId, filename string) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitCatFile", cwd, commitId, filename)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitCatFile indicates an expected call of GitCatFile.
|
|
func (mr *MockGitMockRecorder) GitCatFile(cwd, commitId, filename any) *MockGitGitCatFileCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitCatFile", reflect.TypeOf((*MockGit)(nil).GitCatFile), cwd, commitId, filename)
|
|
return &MockGitGitCatFileCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitCatFileCall wrap *gomock.Call
|
|
type MockGitGitCatFileCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitCatFileCall) Return(data []byte, err error) *MockGitGitCatFileCall {
|
|
c.Call = c.Call.Return(data, err)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitCatFileCall) Do(f func(string, string, string) ([]byte, error)) *MockGitGitCatFileCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitCatFileCall) DoAndReturn(f func(string, string, string) ([]byte, error)) *MockGitGitCatFileCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitClone mocks base method.
|
|
func (m *MockGit) GitClone(repo, branch, remoteUrl string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitClone", repo, branch, remoteUrl)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitClone indicates an expected call of GitClone.
|
|
func (mr *MockGitMockRecorder) GitClone(repo, branch, remoteUrl any) *MockGitGitCloneCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitClone", reflect.TypeOf((*MockGit)(nil).GitClone), repo, branch, remoteUrl)
|
|
return &MockGitGitCloneCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitCloneCall wrap *gomock.Call
|
|
type MockGitGitCloneCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitCloneCall) Return(arg0 string, arg1 error) *MockGitGitCloneCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitCloneCall) Do(f func(string, string, string) (string, error)) *MockGitGitCloneCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitCloneCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitCloneCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitDiff mocks base method.
|
|
func (m *MockGit) GitDiff(cwd, base, head string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitDiff", cwd, base, head)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitDiff indicates an expected call of GitDiff.
|
|
func (mr *MockGitMockRecorder) GitDiff(cwd, base, head any) *MockGitGitDiffCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDiff", reflect.TypeOf((*MockGit)(nil).GitDiff), cwd, base, head)
|
|
return &MockGitGitDiffCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitDiffCall wrap *gomock.Call
|
|
type MockGitGitDiffCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitDiffCall) Return(arg0 string, arg1 error) *MockGitGitDiffCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitDiffCall) Do(f func(string, string, string) (string, error)) *MockGitGitDiffCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitDiffCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitDiffCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitDirectoryList mocks base method.
|
|
func (m *MockGit) GitDirectoryList(gitPath, commitId string) (map[string]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitDirectoryList", gitPath, commitId)
|
|
ret0, _ := ret[0].(map[string]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitDirectoryList indicates an expected call of GitDirectoryList.
|
|
func (mr *MockGitMockRecorder) GitDirectoryList(gitPath, commitId any) *MockGitGitDirectoryListCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDirectoryList", reflect.TypeOf((*MockGit)(nil).GitDirectoryList), gitPath, commitId)
|
|
return &MockGitGitDirectoryListCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitDirectoryListCall wrap *gomock.Call
|
|
type MockGitGitDirectoryListCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitDirectoryListCall) Return(dirlist map[string]string, err error) *MockGitGitDirectoryListCall {
|
|
c.Call = c.Call.Return(dirlist, err)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitDirectoryListCall) Do(f func(string, string) (map[string]string, error)) *MockGitGitDirectoryListCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitDirectoryListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitGitDirectoryListCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitExec mocks base method.
|
|
func (m *MockGit) GitExec(cwd string, params ...string) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{cwd}
|
|
for _, a := range params {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GitExec", varargs...)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// GitExec indicates an expected call of GitExec.
|
|
func (mr *MockGitMockRecorder) GitExec(cwd any, params ...any) *MockGitGitExecCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{cwd}, params...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExec", reflect.TypeOf((*MockGit)(nil).GitExec), varargs...)
|
|
return &MockGitGitExecCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitExecCall wrap *gomock.Call
|
|
type MockGitGitExecCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitExecCall) Return(arg0 error) *MockGitGitExecCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitExecCall) Do(f func(string, ...string) error) *MockGitGitExecCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitExecCall) DoAndReturn(f func(string, ...string) error) *MockGitGitExecCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitExecOrPanic mocks base method.
|
|
func (m *MockGit) GitExecOrPanic(cwd string, params ...string) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{cwd}
|
|
for _, a := range params {
|
|
varargs = append(varargs, a)
|
|
}
|
|
m.ctrl.Call(m, "GitExecOrPanic", varargs...)
|
|
}
|
|
|
|
// GitExecOrPanic indicates an expected call of GitExecOrPanic.
|
|
func (mr *MockGitMockRecorder) GitExecOrPanic(cwd any, params ...any) *MockGitGitExecOrPanicCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{cwd}, params...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecOrPanic), varargs...)
|
|
return &MockGitGitExecOrPanicCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitExecOrPanicCall wrap *gomock.Call
|
|
type MockGitGitExecOrPanicCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitExecOrPanicCall) Return() *MockGitGitExecOrPanicCall {
|
|
c.Call = c.Call.Return()
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitExecOrPanicCall) Do(f func(string, ...string)) *MockGitGitExecOrPanicCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitExecOrPanicCall) DoAndReturn(f func(string, ...string)) *MockGitGitExecOrPanicCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitExecQuietOrPanic mocks base method.
|
|
func (m *MockGit) GitExecQuietOrPanic(cwd string, params ...string) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{cwd}
|
|
for _, a := range params {
|
|
varargs = append(varargs, a)
|
|
}
|
|
m.ctrl.Call(m, "GitExecQuietOrPanic", varargs...)
|
|
}
|
|
|
|
// GitExecQuietOrPanic indicates an expected call of GitExecQuietOrPanic.
|
|
func (mr *MockGitMockRecorder) GitExecQuietOrPanic(cwd any, params ...any) *MockGitGitExecQuietOrPanicCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{cwd}, params...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecQuietOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecQuietOrPanic), varargs...)
|
|
return &MockGitGitExecQuietOrPanicCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitExecQuietOrPanicCall wrap *gomock.Call
|
|
type MockGitGitExecQuietOrPanicCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitExecQuietOrPanicCall) Return() *MockGitGitExecQuietOrPanicCall {
|
|
c.Call = c.Call.Return()
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitExecQuietOrPanicCall) Do(f func(string, ...string)) *MockGitGitExecQuietOrPanicCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitExecQuietOrPanicCall) DoAndReturn(f func(string, ...string)) *MockGitGitExecQuietOrPanicCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitExecWithOutput mocks base method.
|
|
func (m *MockGit) GitExecWithOutput(cwd string, params ...string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{cwd}
|
|
for _, a := range params {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GitExecWithOutput", varargs...)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitExecWithOutput indicates an expected call of GitExecWithOutput.
|
|
func (mr *MockGitMockRecorder) GitExecWithOutput(cwd any, params ...any) *MockGitGitExecWithOutputCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{cwd}, params...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecWithOutput", reflect.TypeOf((*MockGit)(nil).GitExecWithOutput), varargs...)
|
|
return &MockGitGitExecWithOutputCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitExecWithOutputCall wrap *gomock.Call
|
|
type MockGitGitExecWithOutputCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitExecWithOutputCall) Return(arg0 string, arg1 error) *MockGitGitExecWithOutputCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitExecWithOutputCall) Do(f func(string, ...string) (string, error)) *MockGitGitExecWithOutputCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitExecWithOutputCall) DoAndReturn(f func(string, ...string) (string, error)) *MockGitGitExecWithOutputCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitExecWithOutputOrPanic mocks base method.
|
|
func (m *MockGit) GitExecWithOutputOrPanic(cwd string, params ...string) string {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{cwd}
|
|
for _, a := range params {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GitExecWithOutputOrPanic", varargs...)
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GitExecWithOutputOrPanic indicates an expected call of GitExecWithOutputOrPanic.
|
|
func (mr *MockGitMockRecorder) GitExecWithOutputOrPanic(cwd any, params ...any) *MockGitGitExecWithOutputOrPanicCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{cwd}, params...)
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecWithOutputOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecWithOutputOrPanic), varargs...)
|
|
return &MockGitGitExecWithOutputOrPanicCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitExecWithOutputOrPanicCall wrap *gomock.Call
|
|
type MockGitGitExecWithOutputOrPanicCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitExecWithOutputOrPanicCall) Return(arg0 string) *MockGitGitExecWithOutputOrPanicCall {
|
|
c.Call = c.Call.Return(arg0)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitExecWithOutputOrPanicCall) Do(f func(string, ...string) string) *MockGitGitExecWithOutputOrPanicCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitExecWithOutputOrPanicCall) DoAndReturn(f func(string, ...string) string) *MockGitGitExecWithOutputOrPanicCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitParseCommits mocks base method.
|
|
func (m *MockGit) GitParseCommits(cwd string, commitIDs []string) ([]common.GitCommit, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitParseCommits", cwd, commitIDs)
|
|
ret0, _ := ret[0].([]common.GitCommit)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitParseCommits indicates an expected call of GitParseCommits.
|
|
func (mr *MockGitMockRecorder) GitParseCommits(cwd, commitIDs any) *MockGitGitParseCommitsCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitParseCommits", reflect.TypeOf((*MockGit)(nil).GitParseCommits), cwd, commitIDs)
|
|
return &MockGitGitParseCommitsCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitParseCommitsCall wrap *gomock.Call
|
|
type MockGitGitParseCommitsCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitParseCommitsCall) Return(parsedCommits []common.GitCommit, err error) *MockGitGitParseCommitsCall {
|
|
c.Call = c.Call.Return(parsedCommits, err)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitParseCommitsCall) Do(f func(string, []string) ([]common.GitCommit, error)) *MockGitGitParseCommitsCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitParseCommitsCall) DoAndReturn(f func(string, []string) ([]common.GitCommit, error)) *MockGitGitParseCommitsCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitRemoteHead mocks base method.
|
|
func (m *MockGit) GitRemoteHead(gitDir, remoteName, branchName string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitRemoteHead", gitDir, remoteName, branchName)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitRemoteHead indicates an expected call of GitRemoteHead.
|
|
func (mr *MockGitMockRecorder) GitRemoteHead(gitDir, remoteName, branchName any) *MockGitGitRemoteHeadCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitRemoteHead", reflect.TypeOf((*MockGit)(nil).GitRemoteHead), gitDir, remoteName, branchName)
|
|
return &MockGitGitRemoteHeadCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitRemoteHeadCall wrap *gomock.Call
|
|
type MockGitGitRemoteHeadCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitRemoteHeadCall) Return(arg0 string, arg1 error) *MockGitGitRemoteHeadCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitRemoteHeadCall) Do(f func(string, string, string) (string, error)) *MockGitGitRemoteHeadCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitRemoteHeadCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitRemoteHeadCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitStatus mocks base method.
|
|
func (m *MockGit) GitStatus(cwd string) ([]common.GitStatusData, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitStatus", cwd)
|
|
ret0, _ := ret[0].([]common.GitStatusData)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitStatus indicates an expected call of GitStatus.
|
|
func (mr *MockGitMockRecorder) GitStatus(cwd any) *MockGitGitStatusCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitStatus", reflect.TypeOf((*MockGit)(nil).GitStatus), cwd)
|
|
return &MockGitGitStatusCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitStatusCall wrap *gomock.Call
|
|
type MockGitGitStatusCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitStatusCall) Return(arg0 []common.GitStatusData, arg1 error) *MockGitGitStatusCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitStatusCall) Do(f func(string) ([]common.GitStatusData, error)) *MockGitGitStatusCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitStatusCall) DoAndReturn(f func(string) ([]common.GitStatusData, error)) *MockGitGitStatusCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitSubmoduleCommitId mocks base method.
|
|
func (m *MockGit) GitSubmoduleCommitId(cwd, packageName, commitId string) (string, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitSubmoduleCommitId", cwd, packageName, commitId)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitSubmoduleCommitId indicates an expected call of GitSubmoduleCommitId.
|
|
func (mr *MockGitMockRecorder) GitSubmoduleCommitId(cwd, packageName, commitId any) *MockGitGitSubmoduleCommitIdCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleCommitId", reflect.TypeOf((*MockGit)(nil).GitSubmoduleCommitId), cwd, packageName, commitId)
|
|
return &MockGitGitSubmoduleCommitIdCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitSubmoduleCommitIdCall wrap *gomock.Call
|
|
type MockGitGitSubmoduleCommitIdCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitSubmoduleCommitIdCall) Return(subCommitId string, valid bool) *MockGitGitSubmoduleCommitIdCall {
|
|
c.Call = c.Call.Return(subCommitId, valid)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitSubmoduleCommitIdCall) Do(f func(string, string, string) (string, bool)) *MockGitGitSubmoduleCommitIdCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitSubmoduleCommitIdCall) DoAndReturn(f func(string, string, string) (string, bool)) *MockGitGitSubmoduleCommitIdCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// GitSubmoduleList mocks base method.
|
|
func (m *MockGit) GitSubmoduleList(gitPath, commitId string) (map[string]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GitSubmoduleList", gitPath, commitId)
|
|
ret0, _ := ret[0].(map[string]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GitSubmoduleList indicates an expected call of GitSubmoduleList.
|
|
func (mr *MockGitMockRecorder) GitSubmoduleList(gitPath, commitId any) *MockGitGitSubmoduleListCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleList", reflect.TypeOf((*MockGit)(nil).GitSubmoduleList), gitPath, commitId)
|
|
return &MockGitGitSubmoduleListCall{Call: call}
|
|
}
|
|
|
|
// MockGitGitSubmoduleListCall wrap *gomock.Call
|
|
type MockGitGitSubmoduleListCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitGitSubmoduleListCall) Return(submoduleList map[string]string, err error) *MockGitGitSubmoduleListCall {
|
|
c.Call = c.Call.Return(submoduleList, err)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitGitSubmoduleListCall) Do(f func(string, string) (map[string]string, error)) *MockGitGitSubmoduleListCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitGitSubmoduleListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitGitSubmoduleListCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// MockGitHandlerGenerator is a mock of GitHandlerGenerator interface.
|
|
type MockGitHandlerGenerator struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockGitHandlerGeneratorMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockGitHandlerGeneratorMockRecorder is the mock recorder for MockGitHandlerGenerator.
|
|
type MockGitHandlerGeneratorMockRecorder struct {
|
|
mock *MockGitHandlerGenerator
|
|
}
|
|
|
|
// NewMockGitHandlerGenerator creates a new mock instance.
|
|
func NewMockGitHandlerGenerator(ctrl *gomock.Controller) *MockGitHandlerGenerator {
|
|
mock := &MockGitHandlerGenerator{ctrl: ctrl}
|
|
mock.recorder = &MockGitHandlerGeneratorMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockGitHandlerGenerator) EXPECT() *MockGitHandlerGeneratorMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CreateGitHandler mocks base method.
|
|
func (m *MockGitHandlerGenerator) CreateGitHandler(org string) (common.Git, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateGitHandler", org)
|
|
ret0, _ := ret[0].(common.Git)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateGitHandler indicates an expected call of CreateGitHandler.
|
|
func (mr *MockGitHandlerGeneratorMockRecorder) CreateGitHandler(org any) *MockGitHandlerGeneratorCreateGitHandlerCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGitHandler", reflect.TypeOf((*MockGitHandlerGenerator)(nil).CreateGitHandler), org)
|
|
return &MockGitHandlerGeneratorCreateGitHandlerCall{Call: call}
|
|
}
|
|
|
|
// MockGitHandlerGeneratorCreateGitHandlerCall wrap *gomock.Call
|
|
type MockGitHandlerGeneratorCreateGitHandlerCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitHandlerGeneratorCreateGitHandlerCall) Return(arg0 common.Git, arg1 error) *MockGitHandlerGeneratorCreateGitHandlerCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitHandlerGeneratorCreateGitHandlerCall) Do(f func(string) (common.Git, error)) *MockGitHandlerGeneratorCreateGitHandlerCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitHandlerGeneratorCreateGitHandlerCall) DoAndReturn(f func(string) (common.Git, error)) *MockGitHandlerGeneratorCreateGitHandlerCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// ReadExistingPath mocks base method.
|
|
func (m *MockGitHandlerGenerator) ReadExistingPath(org string) (common.Git, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ReadExistingPath", org)
|
|
ret0, _ := ret[0].(common.Git)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ReadExistingPath indicates an expected call of ReadExistingPath.
|
|
func (mr *MockGitHandlerGeneratorMockRecorder) ReadExistingPath(org any) *MockGitHandlerGeneratorReadExistingPathCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadExistingPath", reflect.TypeOf((*MockGitHandlerGenerator)(nil).ReadExistingPath), org)
|
|
return &MockGitHandlerGeneratorReadExistingPathCall{Call: call}
|
|
}
|
|
|
|
// MockGitHandlerGeneratorReadExistingPathCall wrap *gomock.Call
|
|
type MockGitHandlerGeneratorReadExistingPathCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitHandlerGeneratorReadExistingPathCall) Return(arg0 common.Git, arg1 error) *MockGitHandlerGeneratorReadExistingPathCall {
|
|
c.Call = c.Call.Return(arg0, arg1)
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitHandlerGeneratorReadExistingPathCall) Do(f func(string) (common.Git, error)) *MockGitHandlerGeneratorReadExistingPathCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitHandlerGeneratorReadExistingPathCall) DoAndReturn(f func(string) (common.Git, error)) *MockGitHandlerGeneratorReadExistingPathCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|
|
|
|
// ReleaseLock mocks base method.
|
|
func (m *MockGitHandlerGenerator) ReleaseLock(path string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "ReleaseLock", path)
|
|
}
|
|
|
|
// ReleaseLock indicates an expected call of ReleaseLock.
|
|
func (mr *MockGitHandlerGeneratorMockRecorder) ReleaseLock(path any) *MockGitHandlerGeneratorReleaseLockCall {
|
|
mr.mock.ctrl.T.Helper()
|
|
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseLock", reflect.TypeOf((*MockGitHandlerGenerator)(nil).ReleaseLock), path)
|
|
return &MockGitHandlerGeneratorReleaseLockCall{Call: call}
|
|
}
|
|
|
|
// MockGitHandlerGeneratorReleaseLockCall wrap *gomock.Call
|
|
type MockGitHandlerGeneratorReleaseLockCall struct {
|
|
*gomock.Call
|
|
}
|
|
|
|
// Return rewrite *gomock.Call.Return
|
|
func (c *MockGitHandlerGeneratorReleaseLockCall) Return() *MockGitHandlerGeneratorReleaseLockCall {
|
|
c.Call = c.Call.Return()
|
|
return c
|
|
}
|
|
|
|
// Do rewrite *gomock.Call.Do
|
|
func (c *MockGitHandlerGeneratorReleaseLockCall) Do(f func(string)) *MockGitHandlerGeneratorReleaseLockCall {
|
|
c.Call = c.Call.Do(f)
|
|
return c
|
|
}
|
|
|
|
// DoAndReturn rewrite *gomock.Call.DoAndReturn
|
|
func (c *MockGitHandlerGeneratorReleaseLockCall) DoAndReturn(f func(string)) *MockGitHandlerGeneratorReleaseLockCall {
|
|
c.Call = c.Call.DoAndReturn(f)
|
|
return c
|
|
}
|