mirror of
https://github.com/grafana/grafana.git
synced 2025-08-02 03:12:13 +08:00
a438b192d3
* Add unit tests IsAuthenticated * Add unit tests RepoExists * Add unit tests GetContents * Add initial unit tests GetTree * Add unit tests for CreateFile * Add unit test UpdateFile * Add unit tests DeleteFile * Add unit tests for Commits * Add unit tests for helpers * Add unit test CompareCommits * Add GetBranch tests * Add unit tests BranchExists and CreateBranch * Add unit tests Webhooks * Remove unused code * Add unit tests CommentPullRequest * Add more cases for GetTree * Complete coverage * Fix linting
1118 lines
40 KiB
Go
1118 lines
40 KiB
Go
// Code generated by mockery v2.52.4. DO NOT EDIT.
|
|
|
|
package github
|
|
|
|
import (
|
|
context "context"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// MockClient is an autogenerated mock type for the Client type
|
|
type MockClient struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockClient_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockClient) EXPECT() *MockClient_Expecter {
|
|
return &MockClient_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// BranchExists provides a mock function with given fields: ctx, owner, repository, branchName
|
|
func (_m *MockClient) BranchExists(ctx context.Context, owner string, repository string, branchName string) (bool, error) {
|
|
ret := _m.Called(ctx, owner, repository, branchName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for BranchExists")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) (bool, error)); ok {
|
|
return rf(ctx, owner, repository, branchName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) bool); ok {
|
|
r0 = rf(ctx, owner, repository, branchName)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
|
|
r1 = rf(ctx, owner, repository, branchName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_BranchExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BranchExists'
|
|
type MockClient_BranchExists_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// BranchExists is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - branchName string
|
|
func (_e *MockClient_Expecter) BranchExists(ctx interface{}, owner interface{}, repository interface{}, branchName interface{}) *MockClient_BranchExists_Call {
|
|
return &MockClient_BranchExists_Call{Call: _e.mock.On("BranchExists", ctx, owner, repository, branchName)}
|
|
}
|
|
|
|
func (_c *MockClient_BranchExists_Call) Run(run func(ctx context.Context, owner string, repository string, branchName string)) *MockClient_BranchExists_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_BranchExists_Call) Return(_a0 bool, _a1 error) *MockClient_BranchExists_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_BranchExists_Call) RunAndReturn(run func(context.Context, string, string, string) (bool, error)) *MockClient_BranchExists_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Commits provides a mock function with given fields: ctx, owner, repository, path, branch
|
|
func (_m *MockClient) Commits(ctx context.Context, owner string, repository string, path string, branch string) ([]Commit, error) {
|
|
ret := _m.Called(ctx, owner, repository, path, branch)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Commits")
|
|
}
|
|
|
|
var r0 []Commit
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) ([]Commit, error)); ok {
|
|
return rf(ctx, owner, repository, path, branch)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) []Commit); ok {
|
|
r0 = rf(ctx, owner, repository, path, branch)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]Commit)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
|
|
r1 = rf(ctx, owner, repository, path, branch)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_Commits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Commits'
|
|
type MockClient_Commits_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Commits is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - path string
|
|
// - branch string
|
|
func (_e *MockClient_Expecter) Commits(ctx interface{}, owner interface{}, repository interface{}, path interface{}, branch interface{}) *MockClient_Commits_Call {
|
|
return &MockClient_Commits_Call{Call: _e.mock.On("Commits", ctx, owner, repository, path, branch)}
|
|
}
|
|
|
|
func (_c *MockClient_Commits_Call) Run(run func(ctx context.Context, owner string, repository string, path string, branch string)) *MockClient_Commits_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_Commits_Call) Return(_a0 []Commit, _a1 error) *MockClient_Commits_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_Commits_Call) RunAndReturn(run func(context.Context, string, string, string, string) ([]Commit, error)) *MockClient_Commits_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CompareCommits provides a mock function with given fields: ctx, owner, repository, base, head
|
|
func (_m *MockClient) CompareCommits(ctx context.Context, owner string, repository string, base string, head string) ([]CommitFile, error) {
|
|
ret := _m.Called(ctx, owner, repository, base, head)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CompareCommits")
|
|
}
|
|
|
|
var r0 []CommitFile
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) ([]CommitFile, error)); ok {
|
|
return rf(ctx, owner, repository, base, head)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) []CommitFile); ok {
|
|
r0 = rf(ctx, owner, repository, base, head)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]CommitFile)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
|
|
r1 = rf(ctx, owner, repository, base, head)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_CompareCommits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompareCommits'
|
|
type MockClient_CompareCommits_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CompareCommits is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - base string
|
|
// - head string
|
|
func (_e *MockClient_Expecter) CompareCommits(ctx interface{}, owner interface{}, repository interface{}, base interface{}, head interface{}) *MockClient_CompareCommits_Call {
|
|
return &MockClient_CompareCommits_Call{Call: _e.mock.On("CompareCommits", ctx, owner, repository, base, head)}
|
|
}
|
|
|
|
func (_c *MockClient_CompareCommits_Call) Run(run func(ctx context.Context, owner string, repository string, base string, head string)) *MockClient_CompareCommits_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CompareCommits_Call) Return(_a0 []CommitFile, _a1 error) *MockClient_CompareCommits_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CompareCommits_Call) RunAndReturn(run func(context.Context, string, string, string, string) ([]CommitFile, error)) *MockClient_CompareCommits_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateBranch provides a mock function with given fields: ctx, owner, repository, sourceBranch, branchName
|
|
func (_m *MockClient) CreateBranch(ctx context.Context, owner string, repository string, sourceBranch string, branchName string) error {
|
|
ret := _m.Called(ctx, owner, repository, sourceBranch, branchName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateBranch")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) error); ok {
|
|
r0 = rf(ctx, owner, repository, sourceBranch, branchName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockClient_CreateBranch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBranch'
|
|
type MockClient_CreateBranch_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateBranch is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - sourceBranch string
|
|
// - branchName string
|
|
func (_e *MockClient_Expecter) CreateBranch(ctx interface{}, owner interface{}, repository interface{}, sourceBranch interface{}, branchName interface{}) *MockClient_CreateBranch_Call {
|
|
return &MockClient_CreateBranch_Call{Call: _e.mock.On("CreateBranch", ctx, owner, repository, sourceBranch, branchName)}
|
|
}
|
|
|
|
func (_c *MockClient_CreateBranch_Call) Run(run func(ctx context.Context, owner string, repository string, sourceBranch string, branchName string)) *MockClient_CreateBranch_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CreateBranch_Call) Return(_a0 error) *MockClient_CreateBranch_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CreateBranch_Call) RunAndReturn(run func(context.Context, string, string, string, string) error) *MockClient_CreateBranch_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateFile provides a mock function with given fields: ctx, owner, repository, path, branch, message, content
|
|
func (_m *MockClient) CreateFile(ctx context.Context, owner string, repository string, path string, branch string, message string, content []byte) error {
|
|
ret := _m.Called(ctx, owner, repository, path, branch, message, content)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateFile")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, string, []byte) error); ok {
|
|
r0 = rf(ctx, owner, repository, path, branch, message, content)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockClient_CreateFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFile'
|
|
type MockClient_CreateFile_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateFile is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - path string
|
|
// - branch string
|
|
// - message string
|
|
// - content []byte
|
|
func (_e *MockClient_Expecter) CreateFile(ctx interface{}, owner interface{}, repository interface{}, path interface{}, branch interface{}, message interface{}, content interface{}) *MockClient_CreateFile_Call {
|
|
return &MockClient_CreateFile_Call{Call: _e.mock.On("CreateFile", ctx, owner, repository, path, branch, message, content)}
|
|
}
|
|
|
|
func (_c *MockClient_CreateFile_Call) Run(run func(ctx context.Context, owner string, repository string, path string, branch string, message string, content []byte)) *MockClient_CreateFile_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string), args[6].([]byte))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CreateFile_Call) Return(_a0 error) *MockClient_CreateFile_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CreateFile_Call) RunAndReturn(run func(context.Context, string, string, string, string, string, []byte) error) *MockClient_CreateFile_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreatePullRequestComment provides a mock function with given fields: ctx, owner, repository, number, body
|
|
func (_m *MockClient) CreatePullRequestComment(ctx context.Context, owner string, repository string, number int, body string) error {
|
|
ret := _m.Called(ctx, owner, repository, number, body)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreatePullRequestComment")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, int, string) error); ok {
|
|
r0 = rf(ctx, owner, repository, number, body)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockClient_CreatePullRequestComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePullRequestComment'
|
|
type MockClient_CreatePullRequestComment_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreatePullRequestComment is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - number int
|
|
// - body string
|
|
func (_e *MockClient_Expecter) CreatePullRequestComment(ctx interface{}, owner interface{}, repository interface{}, number interface{}, body interface{}) *MockClient_CreatePullRequestComment_Call {
|
|
return &MockClient_CreatePullRequestComment_Call{Call: _e.mock.On("CreatePullRequestComment", ctx, owner, repository, number, body)}
|
|
}
|
|
|
|
func (_c *MockClient_CreatePullRequestComment_Call) Run(run func(ctx context.Context, owner string, repository string, number int, body string)) *MockClient_CreatePullRequestComment_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int), args[4].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CreatePullRequestComment_Call) Return(_a0 error) *MockClient_CreatePullRequestComment_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CreatePullRequestComment_Call) RunAndReturn(run func(context.Context, string, string, int, string) error) *MockClient_CreatePullRequestComment_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateWebhook provides a mock function with given fields: ctx, owner, repository, cfg
|
|
func (_m *MockClient) CreateWebhook(ctx context.Context, owner string, repository string, cfg WebhookConfig) (WebhookConfig, error) {
|
|
ret := _m.Called(ctx, owner, repository, cfg)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateWebhook")
|
|
}
|
|
|
|
var r0 WebhookConfig
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, WebhookConfig) (WebhookConfig, error)); ok {
|
|
return rf(ctx, owner, repository, cfg)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, WebhookConfig) WebhookConfig); ok {
|
|
r0 = rf(ctx, owner, repository, cfg)
|
|
} else {
|
|
r0 = ret.Get(0).(WebhookConfig)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, WebhookConfig) error); ok {
|
|
r1 = rf(ctx, owner, repository, cfg)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_CreateWebhook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateWebhook'
|
|
type MockClient_CreateWebhook_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateWebhook is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - cfg WebhookConfig
|
|
func (_e *MockClient_Expecter) CreateWebhook(ctx interface{}, owner interface{}, repository interface{}, cfg interface{}) *MockClient_CreateWebhook_Call {
|
|
return &MockClient_CreateWebhook_Call{Call: _e.mock.On("CreateWebhook", ctx, owner, repository, cfg)}
|
|
}
|
|
|
|
func (_c *MockClient_CreateWebhook_Call) Run(run func(ctx context.Context, owner string, repository string, cfg WebhookConfig)) *MockClient_CreateWebhook_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(WebhookConfig))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CreateWebhook_Call) Return(_a0 WebhookConfig, _a1 error) *MockClient_CreateWebhook_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_CreateWebhook_Call) RunAndReturn(run func(context.Context, string, string, WebhookConfig) (WebhookConfig, error)) *MockClient_CreateWebhook_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteFile provides a mock function with given fields: ctx, owner, repository, path, branch, message, hash
|
|
func (_m *MockClient) DeleteFile(ctx context.Context, owner string, repository string, path string, branch string, message string, hash string) error {
|
|
ret := _m.Called(ctx, owner, repository, path, branch, message, hash)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteFile")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, string, string) error); ok {
|
|
r0 = rf(ctx, owner, repository, path, branch, message, hash)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockClient_DeleteFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFile'
|
|
type MockClient_DeleteFile_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteFile is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - path string
|
|
// - branch string
|
|
// - message string
|
|
// - hash string
|
|
func (_e *MockClient_Expecter) DeleteFile(ctx interface{}, owner interface{}, repository interface{}, path interface{}, branch interface{}, message interface{}, hash interface{}) *MockClient_DeleteFile_Call {
|
|
return &MockClient_DeleteFile_Call{Call: _e.mock.On("DeleteFile", ctx, owner, repository, path, branch, message, hash)}
|
|
}
|
|
|
|
func (_c *MockClient_DeleteFile_Call) Run(run func(ctx context.Context, owner string, repository string, path string, branch string, message string, hash string)) *MockClient_DeleteFile_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string), args[6].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_DeleteFile_Call) Return(_a0 error) *MockClient_DeleteFile_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_DeleteFile_Call) RunAndReturn(run func(context.Context, string, string, string, string, string, string) error) *MockClient_DeleteFile_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteWebhook provides a mock function with given fields: ctx, owner, repository, webhookID
|
|
func (_m *MockClient) DeleteWebhook(ctx context.Context, owner string, repository string, webhookID int64) error {
|
|
ret := _m.Called(ctx, owner, repository, webhookID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteWebhook")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) error); ok {
|
|
r0 = rf(ctx, owner, repository, webhookID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockClient_DeleteWebhook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteWebhook'
|
|
type MockClient_DeleteWebhook_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteWebhook is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - webhookID int64
|
|
func (_e *MockClient_Expecter) DeleteWebhook(ctx interface{}, owner interface{}, repository interface{}, webhookID interface{}) *MockClient_DeleteWebhook_Call {
|
|
return &MockClient_DeleteWebhook_Call{Call: _e.mock.On("DeleteWebhook", ctx, owner, repository, webhookID)}
|
|
}
|
|
|
|
func (_c *MockClient_DeleteWebhook_Call) Run(run func(ctx context.Context, owner string, repository string, webhookID int64)) *MockClient_DeleteWebhook_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_DeleteWebhook_Call) Return(_a0 error) *MockClient_DeleteWebhook_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_DeleteWebhook_Call) RunAndReturn(run func(context.Context, string, string, int64) error) *MockClient_DeleteWebhook_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// EditWebhook provides a mock function with given fields: ctx, owner, repository, cfg
|
|
func (_m *MockClient) EditWebhook(ctx context.Context, owner string, repository string, cfg WebhookConfig) error {
|
|
ret := _m.Called(ctx, owner, repository, cfg)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for EditWebhook")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, WebhookConfig) error); ok {
|
|
r0 = rf(ctx, owner, repository, cfg)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockClient_EditWebhook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EditWebhook'
|
|
type MockClient_EditWebhook_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// EditWebhook is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - cfg WebhookConfig
|
|
func (_e *MockClient_Expecter) EditWebhook(ctx interface{}, owner interface{}, repository interface{}, cfg interface{}) *MockClient_EditWebhook_Call {
|
|
return &MockClient_EditWebhook_Call{Call: _e.mock.On("EditWebhook", ctx, owner, repository, cfg)}
|
|
}
|
|
|
|
func (_c *MockClient_EditWebhook_Call) Run(run func(ctx context.Context, owner string, repository string, cfg WebhookConfig)) *MockClient_EditWebhook_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(WebhookConfig))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_EditWebhook_Call) Return(_a0 error) *MockClient_EditWebhook_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_EditWebhook_Call) RunAndReturn(run func(context.Context, string, string, WebhookConfig) error) *MockClient_EditWebhook_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetBranch provides a mock function with given fields: ctx, owner, repository, branchName
|
|
func (_m *MockClient) GetBranch(ctx context.Context, owner string, repository string, branchName string) (Branch, error) {
|
|
ret := _m.Called(ctx, owner, repository, branchName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetBranch")
|
|
}
|
|
|
|
var r0 Branch
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) (Branch, error)); ok {
|
|
return rf(ctx, owner, repository, branchName)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string) Branch); ok {
|
|
r0 = rf(ctx, owner, repository, branchName)
|
|
} else {
|
|
r0 = ret.Get(0).(Branch)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
|
|
r1 = rf(ctx, owner, repository, branchName)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_GetBranch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBranch'
|
|
type MockClient_GetBranch_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetBranch is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - branchName string
|
|
func (_e *MockClient_Expecter) GetBranch(ctx interface{}, owner interface{}, repository interface{}, branchName interface{}) *MockClient_GetBranch_Call {
|
|
return &MockClient_GetBranch_Call{Call: _e.mock.On("GetBranch", ctx, owner, repository, branchName)}
|
|
}
|
|
|
|
func (_c *MockClient_GetBranch_Call) Run(run func(ctx context.Context, owner string, repository string, branchName string)) *MockClient_GetBranch_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_GetBranch_Call) Return(_a0 Branch, _a1 error) *MockClient_GetBranch_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_GetBranch_Call) RunAndReturn(run func(context.Context, string, string, string) (Branch, error)) *MockClient_GetBranch_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetContents provides a mock function with given fields: ctx, owner, repository, path, ref
|
|
func (_m *MockClient) GetContents(ctx context.Context, owner string, repository string, path string, ref string) (RepositoryContent, []RepositoryContent, error) {
|
|
ret := _m.Called(ctx, owner, repository, path, ref)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetContents")
|
|
}
|
|
|
|
var r0 RepositoryContent
|
|
var r1 []RepositoryContent
|
|
var r2 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) (RepositoryContent, []RepositoryContent, error)); ok {
|
|
return rf(ctx, owner, repository, path, ref)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) RepositoryContent); ok {
|
|
r0 = rf(ctx, owner, repository, path, ref)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(RepositoryContent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string) []RepositoryContent); ok {
|
|
r1 = rf(ctx, owner, repository, path, ref)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).([]RepositoryContent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(2).(func(context.Context, string, string, string, string) error); ok {
|
|
r2 = rf(ctx, owner, repository, path, ref)
|
|
} else {
|
|
r2 = ret.Error(2)
|
|
}
|
|
|
|
return r0, r1, r2
|
|
}
|
|
|
|
// MockClient_GetContents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContents'
|
|
type MockClient_GetContents_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetContents is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - path string
|
|
// - ref string
|
|
func (_e *MockClient_Expecter) GetContents(ctx interface{}, owner interface{}, repository interface{}, path interface{}, ref interface{}) *MockClient_GetContents_Call {
|
|
return &MockClient_GetContents_Call{Call: _e.mock.On("GetContents", ctx, owner, repository, path, ref)}
|
|
}
|
|
|
|
func (_c *MockClient_GetContents_Call) Run(run func(ctx context.Context, owner string, repository string, path string, ref string)) *MockClient_GetContents_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_GetContents_Call) Return(fileContents RepositoryContent, dirContents []RepositoryContent, err error) *MockClient_GetContents_Call {
|
|
_c.Call.Return(fileContents, dirContents, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_GetContents_Call) RunAndReturn(run func(context.Context, string, string, string, string) (RepositoryContent, []RepositoryContent, error)) *MockClient_GetContents_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTree provides a mock function with given fields: ctx, owner, repository, basePath, ref, recursive
|
|
func (_m *MockClient) GetTree(ctx context.Context, owner string, repository string, basePath string, ref string, recursive bool) ([]RepositoryContent, bool, error) {
|
|
ret := _m.Called(ctx, owner, repository, basePath, ref, recursive)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTree")
|
|
}
|
|
|
|
var r0 []RepositoryContent
|
|
var r1 bool
|
|
var r2 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, bool) ([]RepositoryContent, bool, error)); ok {
|
|
return rf(ctx, owner, repository, basePath, ref, recursive)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, bool) []RepositoryContent); ok {
|
|
r0 = rf(ctx, owner, repository, basePath, ref, recursive)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]RepositoryContent)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, bool) bool); ok {
|
|
r1 = rf(ctx, owner, repository, basePath, ref, recursive)
|
|
} else {
|
|
r1 = ret.Get(1).(bool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(2).(func(context.Context, string, string, string, string, bool) error); ok {
|
|
r2 = rf(ctx, owner, repository, basePath, ref, recursive)
|
|
} else {
|
|
r2 = ret.Error(2)
|
|
}
|
|
|
|
return r0, r1, r2
|
|
}
|
|
|
|
// MockClient_GetTree_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTree'
|
|
type MockClient_GetTree_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTree is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - basePath string
|
|
// - ref string
|
|
// - recursive bool
|
|
func (_e *MockClient_Expecter) GetTree(ctx interface{}, owner interface{}, repository interface{}, basePath interface{}, ref interface{}, recursive interface{}) *MockClient_GetTree_Call {
|
|
return &MockClient_GetTree_Call{Call: _e.mock.On("GetTree", ctx, owner, repository, basePath, ref, recursive)}
|
|
}
|
|
|
|
func (_c *MockClient_GetTree_Call) Run(run func(ctx context.Context, owner string, repository string, basePath string, ref string, recursive bool)) *MockClient_GetTree_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_GetTree_Call) Return(entries []RepositoryContent, truncated bool, err error) *MockClient_GetTree_Call {
|
|
_c.Call.Return(entries, truncated, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_GetTree_Call) RunAndReturn(run func(context.Context, string, string, string, string, bool) ([]RepositoryContent, bool, error)) *MockClient_GetTree_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetWebhook provides a mock function with given fields: ctx, owner, repository, webhookID
|
|
func (_m *MockClient) GetWebhook(ctx context.Context, owner string, repository string, webhookID int64) (WebhookConfig, error) {
|
|
ret := _m.Called(ctx, owner, repository, webhookID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetWebhook")
|
|
}
|
|
|
|
var r0 WebhookConfig
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) (WebhookConfig, error)); ok {
|
|
return rf(ctx, owner, repository, webhookID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) WebhookConfig); ok {
|
|
r0 = rf(ctx, owner, repository, webhookID)
|
|
} else {
|
|
r0 = ret.Get(0).(WebhookConfig)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, int64) error); ok {
|
|
r1 = rf(ctx, owner, repository, webhookID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_GetWebhook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWebhook'
|
|
type MockClient_GetWebhook_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetWebhook is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - webhookID int64
|
|
func (_e *MockClient_Expecter) GetWebhook(ctx interface{}, owner interface{}, repository interface{}, webhookID interface{}) *MockClient_GetWebhook_Call {
|
|
return &MockClient_GetWebhook_Call{Call: _e.mock.On("GetWebhook", ctx, owner, repository, webhookID)}
|
|
}
|
|
|
|
func (_c *MockClient_GetWebhook_Call) Run(run func(ctx context.Context, owner string, repository string, webhookID int64)) *MockClient_GetWebhook_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_GetWebhook_Call) Return(_a0 WebhookConfig, _a1 error) *MockClient_GetWebhook_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_GetWebhook_Call) RunAndReturn(run func(context.Context, string, string, int64) (WebhookConfig, error)) *MockClient_GetWebhook_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// IsAuthenticated provides a mock function with given fields: ctx
|
|
func (_m *MockClient) IsAuthenticated(ctx context.Context) error {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for IsAuthenticated")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) error); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockClient_IsAuthenticated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAuthenticated'
|
|
type MockClient_IsAuthenticated_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// IsAuthenticated is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *MockClient_Expecter) IsAuthenticated(ctx interface{}) *MockClient_IsAuthenticated_Call {
|
|
return &MockClient_IsAuthenticated_Call{Call: _e.mock.On("IsAuthenticated", ctx)}
|
|
}
|
|
|
|
func (_c *MockClient_IsAuthenticated_Call) Run(run func(ctx context.Context)) *MockClient_IsAuthenticated_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_IsAuthenticated_Call) Return(_a0 error) *MockClient_IsAuthenticated_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_IsAuthenticated_Call) RunAndReturn(run func(context.Context) error) *MockClient_IsAuthenticated_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListPullRequestFiles provides a mock function with given fields: ctx, owner, repository, number
|
|
func (_m *MockClient) ListPullRequestFiles(ctx context.Context, owner string, repository string, number int) ([]CommitFile, error) {
|
|
ret := _m.Called(ctx, owner, repository, number)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListPullRequestFiles")
|
|
}
|
|
|
|
var r0 []CommitFile
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, int) ([]CommitFile, error)); ok {
|
|
return rf(ctx, owner, repository, number)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, int) []CommitFile); ok {
|
|
r0 = rf(ctx, owner, repository, number)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]CommitFile)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string, int) error); ok {
|
|
r1 = rf(ctx, owner, repository, number)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_ListPullRequestFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPullRequestFiles'
|
|
type MockClient_ListPullRequestFiles_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListPullRequestFiles is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - number int
|
|
func (_e *MockClient_Expecter) ListPullRequestFiles(ctx interface{}, owner interface{}, repository interface{}, number interface{}) *MockClient_ListPullRequestFiles_Call {
|
|
return &MockClient_ListPullRequestFiles_Call{Call: _e.mock.On("ListPullRequestFiles", ctx, owner, repository, number)}
|
|
}
|
|
|
|
func (_c *MockClient_ListPullRequestFiles_Call) Run(run func(ctx context.Context, owner string, repository string, number int)) *MockClient_ListPullRequestFiles_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_ListPullRequestFiles_Call) Return(_a0 []CommitFile, _a1 error) *MockClient_ListPullRequestFiles_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_ListPullRequestFiles_Call) RunAndReturn(run func(context.Context, string, string, int) ([]CommitFile, error)) *MockClient_ListPullRequestFiles_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListWebhooks provides a mock function with given fields: ctx, owner, repository
|
|
func (_m *MockClient) ListWebhooks(ctx context.Context, owner string, repository string) ([]WebhookConfig, error) {
|
|
ret := _m.Called(ctx, owner, repository)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListWebhooks")
|
|
}
|
|
|
|
var r0 []WebhookConfig
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) ([]WebhookConfig, error)); ok {
|
|
return rf(ctx, owner, repository)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) []WebhookConfig); ok {
|
|
r0 = rf(ctx, owner, repository)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]WebhookConfig)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, owner, repository)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_ListWebhooks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWebhooks'
|
|
type MockClient_ListWebhooks_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListWebhooks is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
func (_e *MockClient_Expecter) ListWebhooks(ctx interface{}, owner interface{}, repository interface{}) *MockClient_ListWebhooks_Call {
|
|
return &MockClient_ListWebhooks_Call{Call: _e.mock.On("ListWebhooks", ctx, owner, repository)}
|
|
}
|
|
|
|
func (_c *MockClient_ListWebhooks_Call) Run(run func(ctx context.Context, owner string, repository string)) *MockClient_ListWebhooks_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_ListWebhooks_Call) Return(_a0 []WebhookConfig, _a1 error) *MockClient_ListWebhooks_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_ListWebhooks_Call) RunAndReturn(run func(context.Context, string, string) ([]WebhookConfig, error)) *MockClient_ListWebhooks_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RepoExists provides a mock function with given fields: ctx, owner, repository
|
|
func (_m *MockClient) RepoExists(ctx context.Context, owner string, repository string) (bool, error) {
|
|
ret := _m.Called(ctx, owner, repository)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RepoExists")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok {
|
|
return rf(ctx, owner, repository)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) bool); ok {
|
|
r0 = rf(ctx, owner, repository)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
|
|
r1 = rf(ctx, owner, repository)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockClient_RepoExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RepoExists'
|
|
type MockClient_RepoExists_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RepoExists is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
func (_e *MockClient_Expecter) RepoExists(ctx interface{}, owner interface{}, repository interface{}) *MockClient_RepoExists_Call {
|
|
return &MockClient_RepoExists_Call{Call: _e.mock.On("RepoExists", ctx, owner, repository)}
|
|
}
|
|
|
|
func (_c *MockClient_RepoExists_Call) Run(run func(ctx context.Context, owner string, repository string)) *MockClient_RepoExists_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_RepoExists_Call) Return(_a0 bool, _a1 error) *MockClient_RepoExists_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_RepoExists_Call) RunAndReturn(run func(context.Context, string, string) (bool, error)) *MockClient_RepoExists_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateFile provides a mock function with given fields: ctx, owner, repository, path, branch, message, hash, content
|
|
func (_m *MockClient) UpdateFile(ctx context.Context, owner string, repository string, path string, branch string, message string, hash string, content []byte) error {
|
|
ret := _m.Called(ctx, owner, repository, path, branch, message, hash, content)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateFile")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, string, string, []byte) error); ok {
|
|
r0 = rf(ctx, owner, repository, path, branch, message, hash, content)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockClient_UpdateFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFile'
|
|
type MockClient_UpdateFile_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateFile is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner string
|
|
// - repository string
|
|
// - path string
|
|
// - branch string
|
|
// - message string
|
|
// - hash string
|
|
// - content []byte
|
|
func (_e *MockClient_Expecter) UpdateFile(ctx interface{}, owner interface{}, repository interface{}, path interface{}, branch interface{}, message interface{}, hash interface{}, content interface{}) *MockClient_UpdateFile_Call {
|
|
return &MockClient_UpdateFile_Call{Call: _e.mock.On("UpdateFile", ctx, owner, repository, path, branch, message, hash, content)}
|
|
}
|
|
|
|
func (_c *MockClient_UpdateFile_Call) Run(run func(ctx context.Context, owner string, repository string, path string, branch string, message string, hash string, content []byte)) *MockClient_UpdateFile_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string), args[6].(string), args[7].([]byte))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_UpdateFile_Call) Return(_a0 error) *MockClient_UpdateFile_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockClient_UpdateFile_Call) RunAndReturn(run func(context.Context, string, string, string, string, string, string, []byte) error) *MockClient_UpdateFile_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockClient(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockClient {
|
|
mock := &MockClient{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|