github.com/covergates/covergates@v0.2.2-0.20201009050117-42ef8a19fb95/mock/git_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/covergates/covergates/core (interfaces: GitRepository,Git,GitCommit)

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	core "github.com/covergates/covergates/core"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockGitRepository is a mock of GitRepository interface
type MockGitRepository struct {
	ctrl     *gomock.Controller
	recorder *MockGitRepositoryMockRecorder
}

// MockGitRepositoryMockRecorder is the mock recorder for MockGitRepository
type MockGitRepositoryMockRecorder struct {
	mock *MockGitRepository
}

// NewMockGitRepository creates a new mock instance
func NewMockGitRepository(ctrl *gomock.Controller) *MockGitRepository {
	mock := &MockGitRepository{ctrl: ctrl}
	mock.recorder = &MockGitRepositoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockGitRepository) EXPECT() *MockGitRepositoryMockRecorder {
	return m.recorder
}

// Branch mocks base method
func (m *MockGitRepository) Branch() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Branch")
	ret0, _ := ret[0].(string)
	return ret0
}

// Branch indicates an expected call of Branch
func (mr *MockGitRepositoryMockRecorder) Branch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Branch", reflect.TypeOf((*MockGitRepository)(nil).Branch))
}

// Commit mocks base method
func (m *MockGitRepository) Commit(arg0 string) (core.GitCommit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", arg0)
	ret0, _ := ret[0].(core.GitCommit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Commit indicates an expected call of Commit
func (mr *MockGitRepositoryMockRecorder) Commit(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockGitRepository)(nil).Commit), arg0)
}

// HeadCommit mocks base method
func (m *MockGitRepository) HeadCommit() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeadCommit")
	ret0, _ := ret[0].(string)
	return ret0
}

// HeadCommit indicates an expected call of HeadCommit
func (mr *MockGitRepositoryMockRecorder) HeadCommit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadCommit", reflect.TypeOf((*MockGitRepository)(nil).HeadCommit))
}

// ListAllFiles mocks base method
func (m *MockGitRepository) ListAllFiles(arg0 string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllFiles", arg0)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllFiles indicates an expected call of ListAllFiles
func (mr *MockGitRepositoryMockRecorder) ListAllFiles(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllFiles", reflect.TypeOf((*MockGitRepository)(nil).ListAllFiles), arg0)
}

// Root mocks base method
func (m *MockGitRepository) Root() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Root")
	ret0, _ := ret[0].(string)
	return ret0
}

// Root indicates an expected call of Root
func (mr *MockGitRepositoryMockRecorder) Root() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockGitRepository)(nil).Root))
}

// MockGit is a mock of Git interface
type MockGit struct {
	ctrl     *gomock.Controller
	recorder *MockGitMockRecorder
}

// 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
}

// Clone mocks base method
func (m *MockGit) Clone(arg0 context.Context, arg1, arg2 string) (core.GitRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clone", arg0, arg1, arg2)
	ret0, _ := ret[0].(core.GitRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Clone indicates an expected call of Clone
func (mr *MockGitMockRecorder) Clone(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockGit)(nil).Clone), arg0, arg1, arg2)
}

// PlainOpen mocks base method
func (m *MockGit) PlainOpen(arg0 context.Context, arg1 string) (core.GitRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PlainOpen", arg0, arg1)
	ret0, _ := ret[0].(core.GitRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PlainOpen indicates an expected call of PlainOpen
func (mr *MockGitMockRecorder) PlainOpen(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PlainOpen", reflect.TypeOf((*MockGit)(nil).PlainOpen), arg0, arg1)
}

// MockGitCommit is a mock of GitCommit interface
type MockGitCommit struct {
	ctrl     *gomock.Controller
	recorder *MockGitCommitMockRecorder
}

// MockGitCommitMockRecorder is the mock recorder for MockGitCommit
type MockGitCommitMockRecorder struct {
	mock *MockGitCommit
}

// NewMockGitCommit creates a new mock instance
func NewMockGitCommit(ctrl *gomock.Controller) *MockGitCommit {
	mock := &MockGitCommit{ctrl: ctrl}
	mock.recorder = &MockGitCommitMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockGitCommit) EXPECT() *MockGitCommitMockRecorder {
	return m.recorder
}

// InDefaultBranch mocks base method
func (m *MockGitCommit) InDefaultBranch() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InDefaultBranch")
	ret0, _ := ret[0].(bool)
	return ret0
}

// InDefaultBranch indicates an expected call of InDefaultBranch
func (mr *MockGitCommitMockRecorder) InDefaultBranch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InDefaultBranch", reflect.TypeOf((*MockGitCommit)(nil).InDefaultBranch))
}