// Code generated by mockery v2.53.4. DO NOT EDIT.

package github

import (
	context "context"

	repository "github.com/grafana/grafana/apps/provisioning/pkg/repository"
	mock "github.com/stretchr/testify/mock"

	v0alpha1 "github.com/grafana/grafana/apps/provisioning/pkg/apis/provisioning/v0alpha1"
)

// MockGithubRepository is an autogenerated mock type for the GithubRepository type
type MockGithubRepository struct {
	mock.Mock
}

type MockGithubRepository_Expecter struct {
	mock *mock.Mock
}

func (_m *MockGithubRepository) EXPECT() *MockGithubRepository_Expecter {
	return &MockGithubRepository_Expecter{mock: &_m.Mock}
}

// Client provides a mock function with no fields
func (_m *MockGithubRepository) Client() Client {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Client")
	}

	var r0 Client
	if rf, ok := ret.Get(0).(func() Client); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(Client)
		}
	}

	return r0
}

// MockGithubRepository_Client_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Client'
type MockGithubRepository_Client_Call struct {
	*mock.Call
}

// Client is a helper method to define mock.On call
func (_e *MockGithubRepository_Expecter) Client() *MockGithubRepository_Client_Call {
	return &MockGithubRepository_Client_Call{Call: _e.mock.On("Client")}
}

func (_c *MockGithubRepository_Client_Call) Run(run func()) *MockGithubRepository_Client_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockGithubRepository_Client_Call) Return(_a0 Client) *MockGithubRepository_Client_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Client_Call) RunAndReturn(run func() Client) *MockGithubRepository_Client_Call {
	_c.Call.Return(run)
	return _c
}

// CompareFiles provides a mock function with given fields: ctx, base, ref
func (_m *MockGithubRepository) CompareFiles(ctx context.Context, base string, ref string) ([]repository.VersionedFileChange, error) {
	ret := _m.Called(ctx, base, ref)

	if len(ret) == 0 {
		panic("no return value specified for CompareFiles")
	}

	var r0 []repository.VersionedFileChange
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) ([]repository.VersionedFileChange, error)); ok {
		return rf(ctx, base, ref)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) []repository.VersionedFileChange); ok {
		r0 = rf(ctx, base, ref)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]repository.VersionedFileChange)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, base, ref)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_CompareFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompareFiles'
type MockGithubRepository_CompareFiles_Call struct {
	*mock.Call
}

// CompareFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - base string
//   - ref string
func (_e *MockGithubRepository_Expecter) CompareFiles(ctx interface{}, base interface{}, ref interface{}) *MockGithubRepository_CompareFiles_Call {
	return &MockGithubRepository_CompareFiles_Call{Call: _e.mock.On("CompareFiles", ctx, base, ref)}
}

func (_c *MockGithubRepository_CompareFiles_Call) Run(run func(ctx context.Context, base string, ref string)) *MockGithubRepository_CompareFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockGithubRepository_CompareFiles_Call) Return(_a0 []repository.VersionedFileChange, _a1 error) *MockGithubRepository_CompareFiles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_CompareFiles_Call) RunAndReturn(run func(context.Context, string, string) ([]repository.VersionedFileChange, error)) *MockGithubRepository_CompareFiles_Call {
	_c.Call.Return(run)
	return _c
}

// Config provides a mock function with no fields
func (_m *MockGithubRepository) Config() *v0alpha1.Repository {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Config")
	}

	var r0 *v0alpha1.Repository
	if rf, ok := ret.Get(0).(func() *v0alpha1.Repository); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v0alpha1.Repository)
		}
	}

	return r0
}

// MockGithubRepository_Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Config'
type MockGithubRepository_Config_Call struct {
	*mock.Call
}

// Config is a helper method to define mock.On call
func (_e *MockGithubRepository_Expecter) Config() *MockGithubRepository_Config_Call {
	return &MockGithubRepository_Config_Call{Call: _e.mock.On("Config")}
}

func (_c *MockGithubRepository_Config_Call) Run(run func()) *MockGithubRepository_Config_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockGithubRepository_Config_Call) Return(_a0 *v0alpha1.Repository) *MockGithubRepository_Config_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Config_Call) RunAndReturn(run func() *v0alpha1.Repository) *MockGithubRepository_Config_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function with given fields: ctx, path, ref, data, message
func (_m *MockGithubRepository) Create(ctx context.Context, path string, ref string, data []byte, message string) error {
	ret := _m.Called(ctx, path, ref, data, message)

	if len(ret) == 0 {
		panic("no return value specified for Create")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []byte, string) error); ok {
		r0 = rf(ctx, path, ref, data, message)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockGithubRepository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
type MockGithubRepository_Create_Call struct {
	*mock.Call
}

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
//   - ref string
//   - data []byte
//   - message string
func (_e *MockGithubRepository_Expecter) Create(ctx interface{}, path interface{}, ref interface{}, data interface{}, message interface{}) *MockGithubRepository_Create_Call {
	return &MockGithubRepository_Create_Call{Call: _e.mock.On("Create", ctx, path, ref, data, message)}
}

func (_c *MockGithubRepository_Create_Call) Run(run func(ctx context.Context, path string, ref string, data []byte, message string)) *MockGithubRepository_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]byte), args[4].(string))
	})
	return _c
}

func (_c *MockGithubRepository_Create_Call) Return(_a0 error) *MockGithubRepository_Create_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Create_Call) RunAndReturn(run func(context.Context, string, string, []byte, string) error) *MockGithubRepository_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: ctx, path, ref, message
func (_m *MockGithubRepository) Delete(ctx context.Context, path string, ref string, message string) error {
	ret := _m.Called(ctx, path, ref, message)

	if len(ret) == 0 {
		panic("no return value specified for Delete")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = rf(ctx, path, ref, message)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockGithubRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
type MockGithubRepository_Delete_Call struct {
	*mock.Call
}

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
//   - ref string
//   - message string
func (_e *MockGithubRepository_Expecter) Delete(ctx interface{}, path interface{}, ref interface{}, message interface{}) *MockGithubRepository_Delete_Call {
	return &MockGithubRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, path, ref, message)}
}

func (_c *MockGithubRepository_Delete_Call) Run(run func(ctx context.Context, path string, ref string, message string)) *MockGithubRepository_Delete_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 *MockGithubRepository_Delete_Call) Return(_a0 error) *MockGithubRepository_Delete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Delete_Call) RunAndReturn(run func(context.Context, string, string, string) error) *MockGithubRepository_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// GetCurrentBranch provides a mock function with no fields
func (_m *MockGithubRepository) GetCurrentBranch() string {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetCurrentBranch")
	}

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

// MockGithubRepository_GetCurrentBranch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentBranch'
type MockGithubRepository_GetCurrentBranch_Call struct {
	*mock.Call
}

// GetCurrentBranch is a helper method to define mock.On call
func (_e *MockGithubRepository_Expecter) GetCurrentBranch() *MockGithubRepository_GetCurrentBranch_Call {
	return &MockGithubRepository_GetCurrentBranch_Call{Call: _e.mock.On("GetCurrentBranch")}
}

func (_c *MockGithubRepository_GetCurrentBranch_Call) Run(run func()) *MockGithubRepository_GetCurrentBranch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockGithubRepository_GetCurrentBranch_Call) Return(_a0 string) *MockGithubRepository_GetCurrentBranch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_GetCurrentBranch_Call) RunAndReturn(run func() string) *MockGithubRepository_GetCurrentBranch_Call {
	_c.Call.Return(run)
	return _c
}

// GetDefaultBranch provides a mock function with given fields: ctx
func (_m *MockGithubRepository) GetDefaultBranch(ctx context.Context) (string, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetDefaultBranch")
	}

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) string); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_GetDefaultBranch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultBranch'
type MockGithubRepository_GetDefaultBranch_Call struct {
	*mock.Call
}

// GetDefaultBranch is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockGithubRepository_Expecter) GetDefaultBranch(ctx interface{}) *MockGithubRepository_GetDefaultBranch_Call {
	return &MockGithubRepository_GetDefaultBranch_Call{Call: _e.mock.On("GetDefaultBranch", ctx)}
}

func (_c *MockGithubRepository_GetDefaultBranch_Call) Run(run func(ctx context.Context)) *MockGithubRepository_GetDefaultBranch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockGithubRepository_GetDefaultBranch_Call) Return(_a0 string, _a1 error) *MockGithubRepository_GetDefaultBranch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_GetDefaultBranch_Call) RunAndReturn(run func(context.Context) (string, error)) *MockGithubRepository_GetDefaultBranch_Call {
	_c.Call.Return(run)
	return _c
}

// History provides a mock function with given fields: ctx, path, ref
func (_m *MockGithubRepository) History(ctx context.Context, path string, ref string) ([]v0alpha1.HistoryItem, error) {
	ret := _m.Called(ctx, path, ref)

	if len(ret) == 0 {
		panic("no return value specified for History")
	}

	var r0 []v0alpha1.HistoryItem
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) ([]v0alpha1.HistoryItem, error)); ok {
		return rf(ctx, path, ref)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) []v0alpha1.HistoryItem); ok {
		r0 = rf(ctx, path, ref)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v0alpha1.HistoryItem)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, path, ref)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_History_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'History'
type MockGithubRepository_History_Call struct {
	*mock.Call
}

// History is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
//   - ref string
func (_e *MockGithubRepository_Expecter) History(ctx interface{}, path interface{}, ref interface{}) *MockGithubRepository_History_Call {
	return &MockGithubRepository_History_Call{Call: _e.mock.On("History", ctx, path, ref)}
}

func (_c *MockGithubRepository_History_Call) Run(run func(ctx context.Context, path string, ref string)) *MockGithubRepository_History_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockGithubRepository_History_Call) Return(_a0 []v0alpha1.HistoryItem, _a1 error) *MockGithubRepository_History_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_History_Call) RunAndReturn(run func(context.Context, string, string) ([]v0alpha1.HistoryItem, error)) *MockGithubRepository_History_Call {
	_c.Call.Return(run)
	return _c
}

// LatestRef provides a mock function with given fields: ctx
func (_m *MockGithubRepository) LatestRef(ctx context.Context) (string, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for LatestRef")
	}

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) string); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_LatestRef_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LatestRef'
type MockGithubRepository_LatestRef_Call struct {
	*mock.Call
}

// LatestRef is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockGithubRepository_Expecter) LatestRef(ctx interface{}) *MockGithubRepository_LatestRef_Call {
	return &MockGithubRepository_LatestRef_Call{Call: _e.mock.On("LatestRef", ctx)}
}

func (_c *MockGithubRepository_LatestRef_Call) Run(run func(ctx context.Context)) *MockGithubRepository_LatestRef_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockGithubRepository_LatestRef_Call) Return(_a0 string, _a1 error) *MockGithubRepository_LatestRef_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_LatestRef_Call) RunAndReturn(run func(context.Context) (string, error)) *MockGithubRepository_LatestRef_Call {
	_c.Call.Return(run)
	return _c
}

// ListRefs provides a mock function with given fields: ctx
func (_m *MockGithubRepository) ListRefs(ctx context.Context) ([]v0alpha1.RefItem, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListRefs")
	}

	var r0 []v0alpha1.RefItem
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]v0alpha1.RefItem, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []v0alpha1.RefItem); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v0alpha1.RefItem)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_ListRefs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRefs'
type MockGithubRepository_ListRefs_Call struct {
	*mock.Call
}

// ListRefs is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockGithubRepository_Expecter) ListRefs(ctx interface{}) *MockGithubRepository_ListRefs_Call {
	return &MockGithubRepository_ListRefs_Call{Call: _e.mock.On("ListRefs", ctx)}
}

func (_c *MockGithubRepository_ListRefs_Call) Run(run func(ctx context.Context)) *MockGithubRepository_ListRefs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockGithubRepository_ListRefs_Call) Return(_a0 []v0alpha1.RefItem, _a1 error) *MockGithubRepository_ListRefs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_ListRefs_Call) RunAndReturn(run func(context.Context) ([]v0alpha1.RefItem, error)) *MockGithubRepository_ListRefs_Call {
	_c.Call.Return(run)
	return _c
}

// Move provides a mock function with given fields: ctx, oldPath, newPath, ref, message
func (_m *MockGithubRepository) Move(ctx context.Context, oldPath string, newPath string, ref string, message string) error {
	ret := _m.Called(ctx, oldPath, newPath, ref, message)

	if len(ret) == 0 {
		panic("no return value specified for Move")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) error); ok {
		r0 = rf(ctx, oldPath, newPath, ref, message)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockGithubRepository_Move_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Move'
type MockGithubRepository_Move_Call struct {
	*mock.Call
}

// Move is a helper method to define mock.On call
//   - ctx context.Context
//   - oldPath string
//   - newPath string
//   - ref string
//   - message string
func (_e *MockGithubRepository_Expecter) Move(ctx interface{}, oldPath interface{}, newPath interface{}, ref interface{}, message interface{}) *MockGithubRepository_Move_Call {
	return &MockGithubRepository_Move_Call{Call: _e.mock.On("Move", ctx, oldPath, newPath, ref, message)}
}

func (_c *MockGithubRepository_Move_Call) Run(run func(ctx context.Context, oldPath string, newPath string, ref string, message string)) *MockGithubRepository_Move_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 *MockGithubRepository_Move_Call) Return(_a0 error) *MockGithubRepository_Move_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Move_Call) RunAndReturn(run func(context.Context, string, string, string, string) error) *MockGithubRepository_Move_Call {
	_c.Call.Return(run)
	return _c
}

// Owner provides a mock function with no fields
func (_m *MockGithubRepository) Owner() string {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Owner")
	}

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

// MockGithubRepository_Owner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Owner'
type MockGithubRepository_Owner_Call struct {
	*mock.Call
}

// Owner is a helper method to define mock.On call
func (_e *MockGithubRepository_Expecter) Owner() *MockGithubRepository_Owner_Call {
	return &MockGithubRepository_Owner_Call{Call: _e.mock.On("Owner")}
}

func (_c *MockGithubRepository_Owner_Call) Run(run func()) *MockGithubRepository_Owner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockGithubRepository_Owner_Call) Return(_a0 string) *MockGithubRepository_Owner_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Owner_Call) RunAndReturn(run func() string) *MockGithubRepository_Owner_Call {
	_c.Call.Return(run)
	return _c
}

// Read provides a mock function with given fields: ctx, path, ref
func (_m *MockGithubRepository) Read(ctx context.Context, path string, ref string) (*repository.FileInfo, error) {
	ret := _m.Called(ctx, path, ref)

	if len(ret) == 0 {
		panic("no return value specified for Read")
	}

	var r0 *repository.FileInfo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (*repository.FileInfo, error)); ok {
		return rf(ctx, path, ref)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) *repository.FileInfo); ok {
		r0 = rf(ctx, path, ref)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*repository.FileInfo)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, path, ref)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
type MockGithubRepository_Read_Call struct {
	*mock.Call
}

// Read is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
//   - ref string
func (_e *MockGithubRepository_Expecter) Read(ctx interface{}, path interface{}, ref interface{}) *MockGithubRepository_Read_Call {
	return &MockGithubRepository_Read_Call{Call: _e.mock.On("Read", ctx, path, ref)}
}

func (_c *MockGithubRepository_Read_Call) Run(run func(ctx context.Context, path string, ref string)) *MockGithubRepository_Read_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockGithubRepository_Read_Call) Return(_a0 *repository.FileInfo, _a1 error) *MockGithubRepository_Read_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_Read_Call) RunAndReturn(run func(context.Context, string, string) (*repository.FileInfo, error)) *MockGithubRepository_Read_Call {
	_c.Call.Return(run)
	return _c
}

// ReadTree provides a mock function with given fields: ctx, ref
func (_m *MockGithubRepository) ReadTree(ctx context.Context, ref string) ([]repository.FileTreeEntry, error) {
	ret := _m.Called(ctx, ref)

	if len(ret) == 0 {
		panic("no return value specified for ReadTree")
	}

	var r0 []repository.FileTreeEntry
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]repository.FileTreeEntry, error)); ok {
		return rf(ctx, ref)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []repository.FileTreeEntry); ok {
		r0 = rf(ctx, ref)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]repository.FileTreeEntry)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, ref)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_ReadTree_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadTree'
type MockGithubRepository_ReadTree_Call struct {
	*mock.Call
}

// ReadTree is a helper method to define mock.On call
//   - ctx context.Context
//   - ref string
func (_e *MockGithubRepository_Expecter) ReadTree(ctx interface{}, ref interface{}) *MockGithubRepository_ReadTree_Call {
	return &MockGithubRepository_ReadTree_Call{Call: _e.mock.On("ReadTree", ctx, ref)}
}

func (_c *MockGithubRepository_ReadTree_Call) Run(run func(ctx context.Context, ref string)) *MockGithubRepository_ReadTree_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockGithubRepository_ReadTree_Call) Return(_a0 []repository.FileTreeEntry, _a1 error) *MockGithubRepository_ReadTree_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_ReadTree_Call) RunAndReturn(run func(context.Context, string) ([]repository.FileTreeEntry, error)) *MockGithubRepository_ReadTree_Call {
	_c.Call.Return(run)
	return _c
}

// RefURLs provides a mock function with given fields: ctx, ref
func (_m *MockGithubRepository) RefURLs(ctx context.Context, ref string) (*v0alpha1.RepositoryURLs, error) {
	ret := _m.Called(ctx, ref)

	if len(ret) == 0 {
		panic("no return value specified for RefURLs")
	}

	var r0 *v0alpha1.RepositoryURLs
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*v0alpha1.RepositoryURLs, error)); ok {
		return rf(ctx, ref)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *v0alpha1.RepositoryURLs); ok {
		r0 = rf(ctx, ref)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v0alpha1.RepositoryURLs)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, ref)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_RefURLs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefURLs'
type MockGithubRepository_RefURLs_Call struct {
	*mock.Call
}

// RefURLs is a helper method to define mock.On call
//   - ctx context.Context
//   - ref string
func (_e *MockGithubRepository_Expecter) RefURLs(ctx interface{}, ref interface{}) *MockGithubRepository_RefURLs_Call {
	return &MockGithubRepository_RefURLs_Call{Call: _e.mock.On("RefURLs", ctx, ref)}
}

func (_c *MockGithubRepository_RefURLs_Call) Run(run func(ctx context.Context, ref string)) *MockGithubRepository_RefURLs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockGithubRepository_RefURLs_Call) Return(_a0 *v0alpha1.RepositoryURLs, _a1 error) *MockGithubRepository_RefURLs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_RefURLs_Call) RunAndReturn(run func(context.Context, string) (*v0alpha1.RepositoryURLs, error)) *MockGithubRepository_RefURLs_Call {
	_c.Call.Return(run)
	return _c
}

// Repo provides a mock function with no fields
func (_m *MockGithubRepository) Repo() string {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Repo")
	}

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

// MockGithubRepository_Repo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Repo'
type MockGithubRepository_Repo_Call struct {
	*mock.Call
}

// Repo is a helper method to define mock.On call
func (_e *MockGithubRepository_Expecter) Repo() *MockGithubRepository_Repo_Call {
	return &MockGithubRepository_Repo_Call{Call: _e.mock.On("Repo")}
}

func (_c *MockGithubRepository_Repo_Call) Run(run func()) *MockGithubRepository_Repo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockGithubRepository_Repo_Call) Return(_a0 string) *MockGithubRepository_Repo_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Repo_Call) RunAndReturn(run func() string) *MockGithubRepository_Repo_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceURLs provides a mock function with given fields: ctx, file
func (_m *MockGithubRepository) ResourceURLs(ctx context.Context, file *repository.FileInfo) (*v0alpha1.RepositoryURLs, error) {
	ret := _m.Called(ctx, file)

	if len(ret) == 0 {
		panic("no return value specified for ResourceURLs")
	}

	var r0 *v0alpha1.RepositoryURLs
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *repository.FileInfo) (*v0alpha1.RepositoryURLs, error)); ok {
		return rf(ctx, file)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *repository.FileInfo) *v0alpha1.RepositoryURLs); ok {
		r0 = rf(ctx, file)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v0alpha1.RepositoryURLs)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *repository.FileInfo) error); ok {
		r1 = rf(ctx, file)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_ResourceURLs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceURLs'
type MockGithubRepository_ResourceURLs_Call struct {
	*mock.Call
}

// ResourceURLs is a helper method to define mock.On call
//   - ctx context.Context
//   - file *repository.FileInfo
func (_e *MockGithubRepository_Expecter) ResourceURLs(ctx interface{}, file interface{}) *MockGithubRepository_ResourceURLs_Call {
	return &MockGithubRepository_ResourceURLs_Call{Call: _e.mock.On("ResourceURLs", ctx, file)}
}

func (_c *MockGithubRepository_ResourceURLs_Call) Run(run func(ctx context.Context, file *repository.FileInfo)) *MockGithubRepository_ResourceURLs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*repository.FileInfo))
	})
	return _c
}

func (_c *MockGithubRepository_ResourceURLs_Call) Return(_a0 *v0alpha1.RepositoryURLs, _a1 error) *MockGithubRepository_ResourceURLs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_ResourceURLs_Call) RunAndReturn(run func(context.Context, *repository.FileInfo) (*v0alpha1.RepositoryURLs, error)) *MockGithubRepository_ResourceURLs_Call {
	_c.Call.Return(run)
	return _c
}

// SetBranch provides a mock function with given fields: branch
func (_m *MockGithubRepository) SetBranch(branch string) {
	_m.Called(branch)
}

// MockGithubRepository_SetBranch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBranch'
type MockGithubRepository_SetBranch_Call struct {
	*mock.Call
}

// SetBranch is a helper method to define mock.On call
//   - branch string
func (_e *MockGithubRepository_Expecter) SetBranch(branch interface{}) *MockGithubRepository_SetBranch_Call {
	return &MockGithubRepository_SetBranch_Call{Call: _e.mock.On("SetBranch", branch)}
}

func (_c *MockGithubRepository_SetBranch_Call) Run(run func(branch string)) *MockGithubRepository_SetBranch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockGithubRepository_SetBranch_Call) Return() *MockGithubRepository_SetBranch_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockGithubRepository_SetBranch_Call) RunAndReturn(run func(string)) *MockGithubRepository_SetBranch_Call {
	_c.Run(run)
	return _c
}

// Stage provides a mock function with given fields: ctx, opts
func (_m *MockGithubRepository) Stage(ctx context.Context, opts repository.StageOptions) (repository.StagedRepository, error) {
	ret := _m.Called(ctx, opts)

	if len(ret) == 0 {
		panic("no return value specified for Stage")
	}

	var r0 repository.StagedRepository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, repository.StageOptions) (repository.StagedRepository, error)); ok {
		return rf(ctx, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, repository.StageOptions) repository.StagedRepository); ok {
		r0 = rf(ctx, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(repository.StagedRepository)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, repository.StageOptions) error); ok {
		r1 = rf(ctx, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_Stage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stage'
type MockGithubRepository_Stage_Call struct {
	*mock.Call
}

// Stage is a helper method to define mock.On call
//   - ctx context.Context
//   - opts repository.StageOptions
func (_e *MockGithubRepository_Expecter) Stage(ctx interface{}, opts interface{}) *MockGithubRepository_Stage_Call {
	return &MockGithubRepository_Stage_Call{Call: _e.mock.On("Stage", ctx, opts)}
}

func (_c *MockGithubRepository_Stage_Call) Run(run func(ctx context.Context, opts repository.StageOptions)) *MockGithubRepository_Stage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(repository.StageOptions))
	})
	return _c
}

func (_c *MockGithubRepository_Stage_Call) Return(_a0 repository.StagedRepository, _a1 error) *MockGithubRepository_Stage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_Stage_Call) RunAndReturn(run func(context.Context, repository.StageOptions) (repository.StagedRepository, error)) *MockGithubRepository_Stage_Call {
	_c.Call.Return(run)
	return _c
}

// Test provides a mock function with given fields: ctx
func (_m *MockGithubRepository) Test(ctx context.Context) (*v0alpha1.TestResults, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Test")
	}

	var r0 *v0alpha1.TestResults
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*v0alpha1.TestResults, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *v0alpha1.TestResults); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v0alpha1.TestResults)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockGithubRepository_Test_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Test'
type MockGithubRepository_Test_Call struct {
	*mock.Call
}

// Test is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockGithubRepository_Expecter) Test(ctx interface{}) *MockGithubRepository_Test_Call {
	return &MockGithubRepository_Test_Call{Call: _e.mock.On("Test", ctx)}
}

func (_c *MockGithubRepository_Test_Call) Run(run func(ctx context.Context)) *MockGithubRepository_Test_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockGithubRepository_Test_Call) Return(_a0 *v0alpha1.TestResults, _a1 error) *MockGithubRepository_Test_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGithubRepository_Test_Call) RunAndReturn(run func(context.Context) (*v0alpha1.TestResults, error)) *MockGithubRepository_Test_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function with given fields: ctx, path, ref, data, message
func (_m *MockGithubRepository) Update(ctx context.Context, path string, ref string, data []byte, message string) error {
	ret := _m.Called(ctx, path, ref, data, message)

	if len(ret) == 0 {
		panic("no return value specified for Update")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []byte, string) error); ok {
		r0 = rf(ctx, path, ref, data, message)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockGithubRepository_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
type MockGithubRepository_Update_Call struct {
	*mock.Call
}

// Update is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
//   - ref string
//   - data []byte
//   - message string
func (_e *MockGithubRepository_Expecter) Update(ctx interface{}, path interface{}, ref interface{}, data interface{}, message interface{}) *MockGithubRepository_Update_Call {
	return &MockGithubRepository_Update_Call{Call: _e.mock.On("Update", ctx, path, ref, data, message)}
}

func (_c *MockGithubRepository_Update_Call) Run(run func(ctx context.Context, path string, ref string, data []byte, message string)) *MockGithubRepository_Update_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]byte), args[4].(string))
	})
	return _c
}

func (_c *MockGithubRepository_Update_Call) Return(_a0 error) *MockGithubRepository_Update_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Update_Call) RunAndReturn(run func(context.Context, string, string, []byte, string) error) *MockGithubRepository_Update_Call {
	_c.Call.Return(run)
	return _c
}

// Write provides a mock function with given fields: ctx, path, ref, data, message
func (_m *MockGithubRepository) Write(ctx context.Context, path string, ref string, data []byte, message string) error {
	ret := _m.Called(ctx, path, ref, data, message)

	if len(ret) == 0 {
		panic("no return value specified for Write")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []byte, string) error); ok {
		r0 = rf(ctx, path, ref, data, message)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockGithubRepository_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
type MockGithubRepository_Write_Call struct {
	*mock.Call
}

// Write is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
//   - ref string
//   - data []byte
//   - message string
func (_e *MockGithubRepository_Expecter) Write(ctx interface{}, path interface{}, ref interface{}, data interface{}, message interface{}) *MockGithubRepository_Write_Call {
	return &MockGithubRepository_Write_Call{Call: _e.mock.On("Write", ctx, path, ref, data, message)}
}

func (_c *MockGithubRepository_Write_Call) Run(run func(ctx context.Context, path string, ref string, data []byte, message string)) *MockGithubRepository_Write_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]byte), args[4].(string))
	})
	return _c
}

func (_c *MockGithubRepository_Write_Call) Return(_a0 error) *MockGithubRepository_Write_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGithubRepository_Write_Call) RunAndReturn(run func(context.Context, string, string, []byte, string) error) *MockGithubRepository_Write_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockGithubRepository creates a new instance of MockGithubRepository. 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 NewMockGithubRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGithubRepository {
	mock := &MockGithubRepository{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
