gitmock

package
v0.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 10, 2025 License: MIT Imports: 9 Imported by: 0

Documentation

Overview

Package gitmock is a generated GoMock package.

Package gitmock mocks go-git concrete type custom interfaces.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockRepository 

type MockRepository struct {
	// contains filtered or unexported fields
}

MockRepository is a mock of Repository interface.

func NewMockRepository 

func NewMockRepository(ctrl *gomock.Controller) *MockRepository

NewMockRepository creates a new mock instance.

func (*MockRepository) BlobObject 

func (m *MockRepository) BlobObject(h plumbing.Hash) (*object.Blob, error)

BlobObject mocks base method.

func (*MockRepository) BlobObjects 

func (m *MockRepository) BlobObjects() (*object.BlobIter, error)

BlobObjects mocks base method.

func (*MockRepository) Branch 

func (m *MockRepository) Branch(name string) (*config.Branch, error)

Branch mocks base method.

func (*MockRepository) Branches 

func (m *MockRepository) Branches() (storer.ReferenceIter, error)

Branches mocks base method.

func (*MockRepository) CommitObject 

func (m *MockRepository) CommitObject(h plumbing.Hash) (*object.Commit, error)

CommitObject mocks base method.

func (*MockRepository) CommitObjects 

func (m *MockRepository) CommitObjects() (object.CommitIter, error)

CommitObjects mocks base method.

func (*MockRepository) Config 

func (m *MockRepository) Config() (*config.Config, error)

Config mocks base method.

func (*MockRepository) ConfigScoped 

func (m *MockRepository) ConfigScoped(scope config.Scope) (*config.Config, error)

ConfigScoped mocks base method.

func (*MockRepository) CreateBranch 

func (m *MockRepository) CreateBranch(c *config.Branch) error

CreateBranch mocks base method.

func (*MockRepository) CreateRemote 

func (m *MockRepository) CreateRemote(c *config.RemoteConfig) (*git.Remote, error)

CreateRemote mocks base method.

func (*MockRepository) CreateRemoteAnonymous 

func (m *MockRepository) CreateRemoteAnonymous(c *config.RemoteConfig) (*git.Remote, error)

CreateRemoteAnonymous mocks base method.

func (*MockRepository) CreateTag 

func (m *MockRepository) CreateTag(name string, hash plumbing.Hash, opts *git.CreateTagOptions) (*plumbing.Reference, error)

CreateTag mocks base method.

func (*MockRepository) DeleteBranch 

func (m *MockRepository) DeleteBranch(name string) error

DeleteBranch mocks base method.

func (*MockRepository) DeleteObject 

func (m *MockRepository) DeleteObject(hash plumbing.Hash) error

DeleteObject mocks base method.

func (*MockRepository) DeleteRemote 

func (m *MockRepository) DeleteRemote(name string) error

DeleteRemote mocks base method.

func (*MockRepository) DeleteTag 

func (m *MockRepository) DeleteTag(name string) error

DeleteTag mocks base method.

func (*MockRepository) EXPECT 

func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockRepository) Fetch 

func (m *MockRepository) Fetch(o *git.FetchOptions) error

Fetch mocks base method.

func (*MockRepository) FetchContext 

func (m *MockRepository) FetchContext(ctx context.Context, o *git.FetchOptions) error

FetchContext mocks base method.

func (*MockRepository) Grep 

func (m *MockRepository) Grep(opts *git.GrepOptions) ([]git.GrepResult, error)

Grep mocks base method.

func (*MockRepository) Head 

func (m *MockRepository) Head() (*plumbing.Reference, error)

Head mocks base method.

func (*MockRepository) Log 

func (m *MockRepository) Log(o *git.LogOptions) (object.CommitIter, error)

Log mocks base method.

func (*MockRepository) Merge 

func (m *MockRepository) Merge(ref plumbing.Reference, opts git.MergeOptions) error

Merge mocks base method.

func (*MockRepository) Notes 

func (m *MockRepository) Notes() (storer.ReferenceIter, error)

Notes mocks base method.

func (*MockRepository) Object 

func (m *MockRepository) Object(t plumbing.ObjectType, h plumbing.Hash) (object.Object, error)

Object mocks base method.

func (*MockRepository) Objects 

func (m *MockRepository) Objects() (*object.ObjectIter, error)

Objects mocks base method.

func (*MockRepository) Prune 

func (m *MockRepository) Prune(opt git.PruneOptions) error

Prune mocks base method.

func (*MockRepository) Push 

func (m *MockRepository) Push(o *git.PushOptions) error

Push mocks base method.

func (*MockRepository) PushContext 

func (m *MockRepository) PushContext(ctx context.Context, o *git.PushOptions) error

PushContext mocks base method.

func (*MockRepository) Reference 

func (m *MockRepository) Reference(name plumbing.ReferenceName, resolved bool) (*plumbing.Reference, error)

Reference mocks base method.

func (*MockRepository) References 

func (m *MockRepository) References() (storer.ReferenceIter, error)

References mocks base method.

func (*MockRepository) Remote 

func (m *MockRepository) Remote(name string) (*git.Remote, error)

Remote mocks base method.

func (*MockRepository) Remotes 

func (m *MockRepository) Remotes() ([]*git.Remote, error)

Remotes mocks base method.

func (*MockRepository) RepackObjects 

func (m *MockRepository) RepackObjects(cfg *git.RepackConfig) error

RepackObjects mocks base method.

func (*MockRepository) ResolveRevision 

func (m *MockRepository) ResolveRevision(in plumbing.Revision) (*plumbing.Hash, error)

ResolveRevision mocks base method.

func (*MockRepository) SetConfig 

func (m *MockRepository) SetConfig(cfg *config.Config) error

SetConfig mocks base method.

func (*MockRepository) Storer 

func (m *MockRepository) Storer() storage.Storer

Storer mocks base method.

func (*MockRepository) Tag 

func (m *MockRepository) Tag(name string) (*plumbing.Reference, error)

Tag mocks base method.

func (*MockRepository) TagObject 

func (m *MockRepository) TagObject(h plumbing.Hash) (*object.Tag, error)

TagObject mocks base method.

func (*MockRepository) TagObjects 

func (m *MockRepository) TagObjects() (*object.TagIter, error)

TagObjects mocks base method.

func (*MockRepository) Tags 

func (m *MockRepository) Tags() (storer.ReferenceIter, error)

Tags mocks base method.

func (*MockRepository) TreeObject 

func (m *MockRepository) TreeObject(h plumbing.Hash) (*object.Tree, error)

TreeObject mocks base method.

func (*MockRepository) TreeObjects 

func (m *MockRepository) TreeObjects() (*object.TreeIter, error)

TreeObjects mocks base method.

func (*MockRepository) Worktree 

func (m *MockRepository) Worktree() (*git.Worktree, error)

Worktree mocks base method.

type MockRepositoryBlobObjectCall 

type MockRepositoryBlobObjectCall struct {
	*gomock.Call
}

MockRepositoryBlobObjectCall wrap *gomock.Call

func (*MockRepositoryBlobObjectCall) Do 

func (c *MockRepositoryBlobObjectCall) Do(f func(plumbing.Hash) (*object.Blob, error)) *MockRepositoryBlobObjectCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryBlobObjectCall) DoAndReturn 

func (c *MockRepositoryBlobObjectCall) DoAndReturn(f func(plumbing.Hash) (*object.Blob, error)) *MockRepositoryBlobObjectCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryBlobObjectCall) Return 

func (c *MockRepositoryBlobObjectCall) Return(arg0 *object.Blob, arg1 error) *MockRepositoryBlobObjectCall

Return rewrite *gomock.Call.Return

type MockRepositoryBlobObjectsCall 

type MockRepositoryBlobObjectsCall struct {
	*gomock.Call
}

MockRepositoryBlobObjectsCall wrap *gomock.Call

func (*MockRepositoryBlobObjectsCall) Do 

func (c *MockRepositoryBlobObjectsCall) Do(f func() (*object.BlobIter, error)) *MockRepositoryBlobObjectsCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryBlobObjectsCall) DoAndReturn 

func (c *MockRepositoryBlobObjectsCall) DoAndReturn(f func() (*object.BlobIter, error)) *MockRepositoryBlobObjectsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryBlobObjectsCall) Return 

func (c *MockRepositoryBlobObjectsCall) Return(arg0 *object.BlobIter, arg1 error) *MockRepositoryBlobObjectsCall

Return rewrite *gomock.Call.Return

type MockRepositoryBranchCall 

type MockRepositoryBranchCall struct {
	*gomock.Call
}

MockRepositoryBranchCall wrap *gomock.Call

func (*MockRepositoryBranchCall) Do 

func (c *MockRepositoryBranchCall) Do(f func(string) (*config.Branch, error)) *MockRepositoryBranchCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryBranchCall) DoAndReturn 

func (c *MockRepositoryBranchCall) DoAndReturn(f func(string) (*config.Branch, error)) *MockRepositoryBranchCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryBranchCall) Return 

func (c *MockRepositoryBranchCall) Return(arg0 *config.Branch, arg1 error) *MockRepositoryBranchCall

Return rewrite *gomock.Call.Return

type MockRepositoryBranchesCall 

type MockRepositoryBranchesCall struct {
	*gomock.Call
}

MockRepositoryBranchesCall wrap *gomock.Call

func (*MockRepositoryBranchesCall) Do 

func (c *MockRepositoryBranchesCall) Do(f func() (storer.ReferenceIter, error)) *MockRepositoryBranchesCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryBranchesCall) DoAndReturn 

func (c *MockRepositoryBranchesCall) DoAndReturn(f func() (storer.ReferenceIter, error)) *MockRepositoryBranchesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryBranchesCall) Return 

func (c *MockRepositoryBranchesCall) Return(arg0 storer.ReferenceIter, arg1 error) *MockRepositoryBranchesCall

Return rewrite *gomock.Call.Return

type MockRepositoryCommitObjectCall 

type MockRepositoryCommitObjectCall struct {
	*gomock.Call
}

MockRepositoryCommitObjectCall wrap *gomock.Call

func (*MockRepositoryCommitObjectCall) Do 

func (c *MockRepositoryCommitObjectCall) Do(f func(plumbing.Hash) (*object.Commit, error)) *MockRepositoryCommitObjectCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryCommitObjectCall) DoAndReturn 

func (c *MockRepositoryCommitObjectCall) DoAndReturn(f func(plumbing.Hash) (*object.Commit, error)) *MockRepositoryCommitObjectCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryCommitObjectCall) Return 

func (c *MockRepositoryCommitObjectCall) Return(arg0 *object.Commit, arg1 error) *MockRepositoryCommitObjectCall

Return rewrite *gomock.Call.Return

type MockRepositoryCommitObjectsCall 

type MockRepositoryCommitObjectsCall struct {
	*gomock.Call
}

MockRepositoryCommitObjectsCall wrap *gomock.Call

func (*MockRepositoryCommitObjectsCall) Do 

func (c *MockRepositoryCommitObjectsCall) Do(f func() (object.CommitIter, error)) *MockRepositoryCommitObjectsCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryCommitObjectsCall) DoAndReturn 

func (c *MockRepositoryCommitObjectsCall) DoAndReturn(f func() (object.CommitIter, error)) *MockRepositoryCommitObjectsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryCommitObjectsCall) Return 

func (c *MockRepositoryCommitObjectsCall) Return(arg0 object.CommitIter, arg1 error) *MockRepositoryCommitObjectsCall

Return rewrite *gomock.Call.Return

type MockRepositoryConfigCall 

type MockRepositoryConfigCall struct {
	*gomock.Call
}

MockRepositoryConfigCall wrap *gomock.Call

func (*MockRepositoryConfigCall) Do 

func (c *MockRepositoryConfigCall) Do(f func() (*config.Config, error)) *MockRepositoryConfigCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryConfigCall) DoAndReturn 

func (c *MockRepositoryConfigCall) DoAndReturn(f func() (*config.Config, error)) *MockRepositoryConfigCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryConfigCall) Return 

func (c *MockRepositoryConfigCall) Return(arg0 *config.Config, arg1 error) *MockRepositoryConfigCall

Return rewrite *gomock.Call.Return

type MockRepositoryConfigScopedCall 

type MockRepositoryConfigScopedCall struct {
	*gomock.Call
}

MockRepositoryConfigScopedCall wrap *gomock.Call

func (*MockRepositoryConfigScopedCall) Do 

func (c *MockRepositoryConfigScopedCall) Do(f func(config.Scope) (*config.Config, error)) *MockRepositoryConfigScopedCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryConfigScopedCall) DoAndReturn 

func (c *MockRepositoryConfigScopedCall) DoAndReturn(f func(config.Scope) (*config.Config, error)) *MockRepositoryConfigScopedCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryConfigScopedCall) Return 

func (c *MockRepositoryConfigScopedCall) Return(arg0 *config.Config, arg1 error) *MockRepositoryConfigScopedCall

Return rewrite *gomock.Call.Return

type MockRepositoryCreateBranchCall 

type MockRepositoryCreateBranchCall struct {
	*gomock.Call
}

MockRepositoryCreateBranchCall wrap *gomock.Call

func (*MockRepositoryCreateBranchCall) Do 

func (c_2 *MockRepositoryCreateBranchCall) Do(f func(*config.Branch) error) *MockRepositoryCreateBranchCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryCreateBranchCall) DoAndReturn 

func (c_2 *MockRepositoryCreateBranchCall) DoAndReturn(f func(*config.Branch) error) *MockRepositoryCreateBranchCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryCreateBranchCall) Return 

func (c_2 *MockRepositoryCreateBranchCall) Return(arg0 error) *MockRepositoryCreateBranchCall

Return rewrite *gomock.Call.Return

type MockRepositoryCreateRemoteAnonymousCall 

type MockRepositoryCreateRemoteAnonymousCall struct {
	*gomock.Call
}

MockRepositoryCreateRemoteAnonymousCall wrap *gomock.Call

func (*MockRepositoryCreateRemoteAnonymousCall) Do 

func (c_2 *MockRepositoryCreateRemoteAnonymousCall) Do(f func(*config.RemoteConfig) (*git.Remote, error)) *MockRepositoryCreateRemoteAnonymousCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryCreateRemoteAnonymousCall) DoAndReturn 

func (c_2 *MockRepositoryCreateRemoteAnonymousCall) DoAndReturn(f func(*config.RemoteConfig) (*git.Remote, error)) *MockRepositoryCreateRemoteAnonymousCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryCreateRemoteAnonymousCall) Return 

func (c_2 *MockRepositoryCreateRemoteAnonymousCall) Return(arg0 *git.Remote, arg1 error) *MockRepositoryCreateRemoteAnonymousCall

Return rewrite *gomock.Call.Return

type MockRepositoryCreateRemoteCall 

type MockRepositoryCreateRemoteCall struct {
	*gomock.Call
}

MockRepositoryCreateRemoteCall wrap *gomock.Call

func (*MockRepositoryCreateRemoteCall) Do 

func (c_2 *MockRepositoryCreateRemoteCall) Do(f func(*config.RemoteConfig) (*git.Remote, error)) *MockRepositoryCreateRemoteCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryCreateRemoteCall) DoAndReturn 

func (c_2 *MockRepositoryCreateRemoteCall) DoAndReturn(f func(*config.RemoteConfig) (*git.Remote, error)) *MockRepositoryCreateRemoteCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryCreateRemoteCall) Return 

func (c_2 *MockRepositoryCreateRemoteCall) Return(arg0 *git.Remote, arg1 error) *MockRepositoryCreateRemoteCall

Return rewrite *gomock.Call.Return

type MockRepositoryCreateTagCall 

type MockRepositoryCreateTagCall struct {
	*gomock.Call
}

MockRepositoryCreateTagCall wrap *gomock.Call

func (*MockRepositoryCreateTagCall) Do 

func (c *MockRepositoryCreateTagCall) Do(f func(string, plumbing.Hash, *git.CreateTagOptions) (*plumbing.Reference, error)) *MockRepositoryCreateTagCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryCreateTagCall) DoAndReturn 

func (c *MockRepositoryCreateTagCall) DoAndReturn(f func(string, plumbing.Hash, *git.CreateTagOptions) (*plumbing.Reference, error)) *MockRepositoryCreateTagCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryCreateTagCall) Return 

func (c *MockRepositoryCreateTagCall) Return(arg0 *plumbing.Reference, arg1 error) *MockRepositoryCreateTagCall

Return rewrite *gomock.Call.Return

type MockRepositoryDeleteBranchCall 

type MockRepositoryDeleteBranchCall struct {
	*gomock.Call
}

MockRepositoryDeleteBranchCall wrap *gomock.Call

func (*MockRepositoryDeleteBranchCall) Do 

func (c *MockRepositoryDeleteBranchCall) Do(f func(string) error) *MockRepositoryDeleteBranchCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryDeleteBranchCall) DoAndReturn 

func (c *MockRepositoryDeleteBranchCall) DoAndReturn(f func(string) error) *MockRepositoryDeleteBranchCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryDeleteBranchCall) Return 

func (c *MockRepositoryDeleteBranchCall) Return(arg0 error) *MockRepositoryDeleteBranchCall

Return rewrite *gomock.Call.Return

type MockRepositoryDeleteObjectCall 

type MockRepositoryDeleteObjectCall struct {
	*gomock.Call
}

MockRepositoryDeleteObjectCall wrap *gomock.Call

func (*MockRepositoryDeleteObjectCall) Do 

func (c *MockRepositoryDeleteObjectCall) Do(f func(plumbing.Hash) error) *MockRepositoryDeleteObjectCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryDeleteObjectCall) DoAndReturn 

func (c *MockRepositoryDeleteObjectCall) DoAndReturn(f func(plumbing.Hash) error) *MockRepositoryDeleteObjectCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryDeleteObjectCall) Return 

func (c *MockRepositoryDeleteObjectCall) Return(arg0 error) *MockRepositoryDeleteObjectCall

Return rewrite *gomock.Call.Return

type MockRepositoryDeleteRemoteCall 

type MockRepositoryDeleteRemoteCall struct {
	*gomock.Call
}

MockRepositoryDeleteRemoteCall wrap *gomock.Call

func (*MockRepositoryDeleteRemoteCall) Do 

func (c *MockRepositoryDeleteRemoteCall) Do(f func(string) error) *MockRepositoryDeleteRemoteCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryDeleteRemoteCall) DoAndReturn 

func (c *MockRepositoryDeleteRemoteCall) DoAndReturn(f func(string) error) *MockRepositoryDeleteRemoteCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryDeleteRemoteCall) Return 

func (c *MockRepositoryDeleteRemoteCall) Return(arg0 error) *MockRepositoryDeleteRemoteCall

Return rewrite *gomock.Call.Return

type MockRepositoryDeleteTagCall 

type MockRepositoryDeleteTagCall struct {
	*gomock.Call
}

MockRepositoryDeleteTagCall wrap *gomock.Call

func (*MockRepositoryDeleteTagCall) Do 

func (c *MockRepositoryDeleteTagCall) Do(f func(string) error) *MockRepositoryDeleteTagCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryDeleteTagCall) DoAndReturn 

func (c *MockRepositoryDeleteTagCall) DoAndReturn(f func(string) error) *MockRepositoryDeleteTagCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryDeleteTagCall) Return 

func (c *MockRepositoryDeleteTagCall) Return(arg0 error) *MockRepositoryDeleteTagCall

Return rewrite *gomock.Call.Return

type MockRepositoryFetchCall 

type MockRepositoryFetchCall struct {
	*gomock.Call
}

MockRepositoryFetchCall wrap *gomock.Call

func (*MockRepositoryFetchCall) Do 

func (c *MockRepositoryFetchCall) Do(f func(*git.FetchOptions) error) *MockRepositoryFetchCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryFetchCall) DoAndReturn 

func (c *MockRepositoryFetchCall) DoAndReturn(f func(*git.FetchOptions) error) *MockRepositoryFetchCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryFetchCall) Return 

func (c *MockRepositoryFetchCall) Return(arg0 error) *MockRepositoryFetchCall

Return rewrite *gomock.Call.Return

type MockRepositoryFetchContextCall 

type MockRepositoryFetchContextCall struct {
	*gomock.Call
}

MockRepositoryFetchContextCall wrap *gomock.Call

func (*MockRepositoryFetchContextCall) Do 

func (c *MockRepositoryFetchContextCall) Do(f func(context.Context, *git.FetchOptions) error) *MockRepositoryFetchContextCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryFetchContextCall) DoAndReturn 

func (c *MockRepositoryFetchContextCall) DoAndReturn(f func(context.Context, *git.FetchOptions) error) *MockRepositoryFetchContextCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryFetchContextCall) Return 

func (c *MockRepositoryFetchContextCall) Return(arg0 error) *MockRepositoryFetchContextCall

Return rewrite *gomock.Call.Return

type MockRepositoryGrepCall 

type MockRepositoryGrepCall struct {
	*gomock.Call
}

MockRepositoryGrepCall wrap *gomock.Call

func (*MockRepositoryGrepCall) Do 

func (c *MockRepositoryGrepCall) Do(f func(*git.GrepOptions) ([]git.GrepResult, error)) *MockRepositoryGrepCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryGrepCall) DoAndReturn 

func (c *MockRepositoryGrepCall) DoAndReturn(f func(*git.GrepOptions) ([]git.GrepResult, error)) *MockRepositoryGrepCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryGrepCall) Return 

func (c *MockRepositoryGrepCall) Return(arg0 []git.GrepResult, arg1 error) *MockRepositoryGrepCall

Return rewrite *gomock.Call.Return

type MockRepositoryHeadCall 

type MockRepositoryHeadCall struct {
	*gomock.Call
}

MockRepositoryHeadCall wrap *gomock.Call

func (*MockRepositoryHeadCall) Do 

func (c *MockRepositoryHeadCall) Do(f func() (*plumbing.Reference, error)) *MockRepositoryHeadCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryHeadCall) DoAndReturn 

func (c *MockRepositoryHeadCall) DoAndReturn(f func() (*plumbing.Reference, error)) *MockRepositoryHeadCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryHeadCall) Return 

func (c *MockRepositoryHeadCall) Return(arg0 *plumbing.Reference, arg1 error) *MockRepositoryHeadCall

Return rewrite *gomock.Call.Return

type MockRepositoryLogCall 

type MockRepositoryLogCall struct {
	*gomock.Call
}

MockRepositoryLogCall wrap *gomock.Call

func (*MockRepositoryLogCall) Do 

func (c *MockRepositoryLogCall) Do(f func(*git.LogOptions) (object.CommitIter, error)) *MockRepositoryLogCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryLogCall) DoAndReturn 

func (c *MockRepositoryLogCall) DoAndReturn(f func(*git.LogOptions) (object.CommitIter, error)) *MockRepositoryLogCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryLogCall) Return 

func (c *MockRepositoryLogCall) Return(arg0 object.CommitIter, arg1 error) *MockRepositoryLogCall

Return rewrite *gomock.Call.Return

type MockRepositoryMergeCall 

type MockRepositoryMergeCall struct {
	*gomock.Call
}

MockRepositoryMergeCall wrap *gomock.Call

func (*MockRepositoryMergeCall) Do 

func (c *MockRepositoryMergeCall) Do(f func(plumbing.Reference, git.MergeOptions) error) *MockRepositoryMergeCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryMergeCall) DoAndReturn 

func (c *MockRepositoryMergeCall) DoAndReturn(f func(plumbing.Reference, git.MergeOptions) error) *MockRepositoryMergeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryMergeCall) Return 

func (c *MockRepositoryMergeCall) Return(arg0 error) *MockRepositoryMergeCall

Return rewrite *gomock.Call.Return

type MockRepositoryMockRecorder 

type MockRepositoryMockRecorder struct {
	// contains filtered or unexported fields
}

MockRepositoryMockRecorder is the mock recorder for MockRepository.

func (*MockRepositoryMockRecorder) BlobObject 

func (mr *MockRepositoryMockRecorder) BlobObject(h any) *MockRepositoryBlobObjectCall

BlobObject indicates an expected call of BlobObject.

func (*MockRepositoryMockRecorder) BlobObjects 

func (mr *MockRepositoryMockRecorder) BlobObjects() *MockRepositoryBlobObjectsCall

BlobObjects indicates an expected call of BlobObjects.

func (*MockRepositoryMockRecorder) Branch 

func (mr *MockRepositoryMockRecorder) Branch(name any) *MockRepositoryBranchCall

Branch indicates an expected call of Branch.

func (*MockRepositoryMockRecorder) Branches 

func (mr *MockRepositoryMockRecorder) Branches() *MockRepositoryBranchesCall

Branches indicates an expected call of Branches.

func (*MockRepositoryMockRecorder) CommitObject 

func (mr *MockRepositoryMockRecorder) CommitObject(h any) *MockRepositoryCommitObjectCall

CommitObject indicates an expected call of CommitObject.

func (*MockRepositoryMockRecorder) CommitObjects 

func (mr *MockRepositoryMockRecorder) CommitObjects() *MockRepositoryCommitObjectsCall

CommitObjects indicates an expected call of CommitObjects.

func (*MockRepositoryMockRecorder) Config 

func (mr *MockRepositoryMockRecorder) Config() *MockRepositoryConfigCall

Config indicates an expected call of Config.

func (*MockRepositoryMockRecorder) ConfigScoped 

func (mr *MockRepositoryMockRecorder) ConfigScoped(scope any) *MockRepositoryConfigScopedCall

ConfigScoped indicates an expected call of ConfigScoped.

func (*MockRepositoryMockRecorder) CreateBranch 

func (mr *MockRepositoryMockRecorder) CreateBranch(c any) *MockRepositoryCreateBranchCall

CreateBranch indicates an expected call of CreateBranch.

func (*MockRepositoryMockRecorder) CreateRemote 

func (mr *MockRepositoryMockRecorder) CreateRemote(c any) *MockRepositoryCreateRemoteCall

CreateRemote indicates an expected call of CreateRemote.

func (*MockRepositoryMockRecorder) CreateRemoteAnonymous 

func (mr *MockRepositoryMockRecorder) CreateRemoteAnonymous(c any) *MockRepositoryCreateRemoteAnonymousCall

CreateRemoteAnonymous indicates an expected call of CreateRemoteAnonymous.

func (*MockRepositoryMockRecorder) CreateTag 

func (mr *MockRepositoryMockRecorder) CreateTag(name, hash, opts any) *MockRepositoryCreateTagCall

CreateTag indicates an expected call of CreateTag.

func (*MockRepositoryMockRecorder) DeleteBranch 

func (mr *MockRepositoryMockRecorder) DeleteBranch(name any) *MockRepositoryDeleteBranchCall

DeleteBranch indicates an expected call of DeleteBranch.

func (*MockRepositoryMockRecorder) DeleteObject 

func (mr *MockRepositoryMockRecorder) DeleteObject(hash any) *MockRepositoryDeleteObjectCall

DeleteObject indicates an expected call of DeleteObject.

func (*MockRepositoryMockRecorder) DeleteRemote 

func (mr *MockRepositoryMockRecorder) DeleteRemote(name any) *MockRepositoryDeleteRemoteCall

DeleteRemote indicates an expected call of DeleteRemote.

func (*MockRepositoryMockRecorder) DeleteTag 

func (mr *MockRepositoryMockRecorder) DeleteTag(name any) *MockRepositoryDeleteTagCall

DeleteTag indicates an expected call of DeleteTag.

func (*MockRepositoryMockRecorder) Fetch 

func (mr *MockRepositoryMockRecorder) Fetch(o any) *MockRepositoryFetchCall

Fetch indicates an expected call of Fetch.

func (*MockRepositoryMockRecorder) FetchContext 

func (mr *MockRepositoryMockRecorder) FetchContext(ctx, o any) *MockRepositoryFetchContextCall

FetchContext indicates an expected call of FetchContext.

func (*MockRepositoryMockRecorder) Grep 

func (mr *MockRepositoryMockRecorder) Grep(opts any) *MockRepositoryGrepCall

Grep indicates an expected call of Grep.

func (*MockRepositoryMockRecorder) Head 

func (mr *MockRepositoryMockRecorder) Head() *MockRepositoryHeadCall

Head indicates an expected call of Head.

func (*MockRepositoryMockRecorder) Log 

func (mr *MockRepositoryMockRecorder) Log(o any) *MockRepositoryLogCall

Log indicates an expected call of Log.

func (*MockRepositoryMockRecorder) Merge 

func (mr *MockRepositoryMockRecorder) Merge(ref, opts any) *MockRepositoryMergeCall

Merge indicates an expected call of Merge.

func (*MockRepositoryMockRecorder) Notes 

func (mr *MockRepositoryMockRecorder) Notes() *MockRepositoryNotesCall

Notes indicates an expected call of Notes.

func (*MockRepositoryMockRecorder) Object 

func (mr *MockRepositoryMockRecorder) Object(t, h any) *MockRepositoryObjectCall

Object indicates an expected call of Object.

func (*MockRepositoryMockRecorder) Objects 

func (mr *MockRepositoryMockRecorder) Objects() *MockRepositoryObjectsCall

Objects indicates an expected call of Objects.

func (*MockRepositoryMockRecorder) Prune 

func (mr *MockRepositoryMockRecorder) Prune(opt any) *MockRepositoryPruneCall

Prune indicates an expected call of Prune.

func (*MockRepositoryMockRecorder) Push 

func (mr *MockRepositoryMockRecorder) Push(o any) *MockRepositoryPushCall

Push indicates an expected call of Push.

func (*MockRepositoryMockRecorder) PushContext 

func (mr *MockRepositoryMockRecorder) PushContext(ctx, o any) *MockRepositoryPushContextCall

PushContext indicates an expected call of PushContext.

func (*MockRepositoryMockRecorder) Reference 

func (mr *MockRepositoryMockRecorder) Reference(name, resolved any) *MockRepositoryReferenceCall

Reference indicates an expected call of Reference.

func (*MockRepositoryMockRecorder) References 

func (mr *MockRepositoryMockRecorder) References() *MockRepositoryReferencesCall

References indicates an expected call of References.

func (*MockRepositoryMockRecorder) Remote 

func (mr *MockRepositoryMockRecorder) Remote(name any) *MockRepositoryRemoteCall

Remote indicates an expected call of Remote.

func (*MockRepositoryMockRecorder) Remotes 

func (mr *MockRepositoryMockRecorder) Remotes() *MockRepositoryRemotesCall

Remotes indicates an expected call of Remotes.

func (*MockRepositoryMockRecorder) RepackObjects 

func (mr *MockRepositoryMockRecorder) RepackObjects(cfg any) *MockRepositoryRepackObjectsCall

RepackObjects indicates an expected call of RepackObjects.

func (*MockRepositoryMockRecorder) ResolveRevision 

func (mr *MockRepositoryMockRecorder) ResolveRevision(in any) *MockRepositoryResolveRevisionCall

ResolveRevision indicates an expected call of ResolveRevision.

func (*MockRepositoryMockRecorder) SetConfig 

func (mr *MockRepositoryMockRecorder) SetConfig(cfg any) *MockRepositorySetConfigCall

SetConfig indicates an expected call of SetConfig.

func (*MockRepositoryMockRecorder) Storer 

func (mr *MockRepositoryMockRecorder) Storer() *MockRepositoryStorerCall

Storer indicates an expected call of Storer.

func (*MockRepositoryMockRecorder) Tag 

func (mr *MockRepositoryMockRecorder) Tag(name any) *MockRepositoryTagCall

Tag indicates an expected call of Tag.

func (*MockRepositoryMockRecorder) TagObject 

func (mr *MockRepositoryMockRecorder) TagObject(h any) *MockRepositoryTagObjectCall

TagObject indicates an expected call of TagObject.

func (*MockRepositoryMockRecorder) TagObjects 

func (mr *MockRepositoryMockRecorder) TagObjects() *MockRepositoryTagObjectsCall

TagObjects indicates an expected call of TagObjects.

func (*MockRepositoryMockRecorder) Tags 

func (mr *MockRepositoryMockRecorder) Tags() *MockRepositoryTagsCall

Tags indicates an expected call of Tags.

func (*MockRepositoryMockRecorder) TreeObject 

func (mr *MockRepositoryMockRecorder) TreeObject(h any) *MockRepositoryTreeObjectCall

TreeObject indicates an expected call of TreeObject.

func (*MockRepositoryMockRecorder) TreeObjects 

func (mr *MockRepositoryMockRecorder) TreeObjects() *MockRepositoryTreeObjectsCall

TreeObjects indicates an expected call of TreeObjects.

func (*MockRepositoryMockRecorder) Worktree 

func (mr *MockRepositoryMockRecorder) Worktree() *MockRepositoryWorktreeCall

Worktree indicates an expected call of Worktree.

type MockRepositoryNotesCall 

type MockRepositoryNotesCall struct {
	*gomock.Call
}

MockRepositoryNotesCall wrap *gomock.Call

func (*MockRepositoryNotesCall) Do 

func (c *MockRepositoryNotesCall) Do(f func() (storer.ReferenceIter, error)) *MockRepositoryNotesCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryNotesCall) DoAndReturn 

func (c *MockRepositoryNotesCall) DoAndReturn(f func() (storer.ReferenceIter, error)) *MockRepositoryNotesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryNotesCall) Return 

func (c *MockRepositoryNotesCall) Return(arg0 storer.ReferenceIter, arg1 error) *MockRepositoryNotesCall

Return rewrite *gomock.Call.Return

type MockRepositoryObjectCall 

type MockRepositoryObjectCall struct {
	*gomock.Call
}

MockRepositoryObjectCall wrap *gomock.Call

func (*MockRepositoryObjectCall) Do 

func (c *MockRepositoryObjectCall) Do(f func(plumbing.ObjectType, plumbing.Hash) (object.Object, error)) *MockRepositoryObjectCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryObjectCall) DoAndReturn 

func (c *MockRepositoryObjectCall) DoAndReturn(f func(plumbing.ObjectType, plumbing.Hash) (object.Object, error)) *MockRepositoryObjectCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryObjectCall) Return 

func (c *MockRepositoryObjectCall) Return(arg0 object.Object, arg1 error) *MockRepositoryObjectCall

Return rewrite *gomock.Call.Return

type MockRepositoryObjectsCall 

type MockRepositoryObjectsCall struct {
	*gomock.Call
}

MockRepositoryObjectsCall wrap *gomock.Call

func (*MockRepositoryObjectsCall) Do 

func (c *MockRepositoryObjectsCall) Do(f func() (*object.ObjectIter, error)) *MockRepositoryObjectsCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryObjectsCall) DoAndReturn 

func (c *MockRepositoryObjectsCall) DoAndReturn(f func() (*object.ObjectIter, error)) *MockRepositoryObjectsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryObjectsCall) Return 

func (c *MockRepositoryObjectsCall) Return(arg0 *object.ObjectIter, arg1 error) *MockRepositoryObjectsCall

Return rewrite *gomock.Call.Return

type MockRepositoryPruneCall 

type MockRepositoryPruneCall struct {
	*gomock.Call
}

MockRepositoryPruneCall wrap *gomock.Call

func (*MockRepositoryPruneCall) Do 

func (c *MockRepositoryPruneCall) Do(f func(git.PruneOptions) error) *MockRepositoryPruneCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryPruneCall) DoAndReturn 

func (c *MockRepositoryPruneCall) DoAndReturn(f func(git.PruneOptions) error) *MockRepositoryPruneCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryPruneCall) Return 

func (c *MockRepositoryPruneCall) Return(arg0 error) *MockRepositoryPruneCall

Return rewrite *gomock.Call.Return

type MockRepositoryPushCall 

type MockRepositoryPushCall struct {
	*gomock.Call
}

MockRepositoryPushCall wrap *gomock.Call

func (*MockRepositoryPushCall) Do 

func (c *MockRepositoryPushCall) Do(f func(*git.PushOptions) error) *MockRepositoryPushCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryPushCall) DoAndReturn 

func (c *MockRepositoryPushCall) DoAndReturn(f func(*git.PushOptions) error) *MockRepositoryPushCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryPushCall) Return 

func (c *MockRepositoryPushCall) Return(arg0 error) *MockRepositoryPushCall

Return rewrite *gomock.Call.Return

type MockRepositoryPushContextCall 

type MockRepositoryPushContextCall struct {
	*gomock.Call
}

MockRepositoryPushContextCall wrap *gomock.Call

func (*MockRepositoryPushContextCall) Do 

func (c *MockRepositoryPushContextCall) Do(f func(context.Context, *git.PushOptions) error) *MockRepositoryPushContextCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryPushContextCall) DoAndReturn 

func (c *MockRepositoryPushContextCall) DoAndReturn(f func(context.Context, *git.PushOptions) error) *MockRepositoryPushContextCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryPushContextCall) Return 

func (c *MockRepositoryPushContextCall) Return(arg0 error) *MockRepositoryPushContextCall

Return rewrite *gomock.Call.Return

type MockRepositoryReferenceCall 

type MockRepositoryReferenceCall struct {
	*gomock.Call
}

MockRepositoryReferenceCall wrap *gomock.Call

func (*MockRepositoryReferenceCall) Do 

func (c *MockRepositoryReferenceCall) Do(f func(plumbing.ReferenceName, bool) (*plumbing.Reference, error)) *MockRepositoryReferenceCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryReferenceCall) DoAndReturn 

func (c *MockRepositoryReferenceCall) DoAndReturn(f func(plumbing.ReferenceName, bool) (*plumbing.Reference, error)) *MockRepositoryReferenceCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryReferenceCall) Return 

func (c *MockRepositoryReferenceCall) Return(arg0 *plumbing.Reference, arg1 error) *MockRepositoryReferenceCall

Return rewrite *gomock.Call.Return

type MockRepositoryReferencesCall 

type MockRepositoryReferencesCall struct {
	*gomock.Call
}

MockRepositoryReferencesCall wrap *gomock.Call

func (*MockRepositoryReferencesCall) Do 

func (c *MockRepositoryReferencesCall) Do(f func() (storer.ReferenceIter, error)) *MockRepositoryReferencesCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryReferencesCall) DoAndReturn 

func (c *MockRepositoryReferencesCall) DoAndReturn(f func() (storer.ReferenceIter, error)) *MockRepositoryReferencesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryReferencesCall) Return 

func (c *MockRepositoryReferencesCall) Return(arg0 storer.ReferenceIter, arg1 error) *MockRepositoryReferencesCall

Return rewrite *gomock.Call.Return

type MockRepositoryRemoteCall 

type MockRepositoryRemoteCall struct {
	*gomock.Call
}

MockRepositoryRemoteCall wrap *gomock.Call

func (*MockRepositoryRemoteCall) Do 

func (c *MockRepositoryRemoteCall) Do(f func(string) (*git.Remote, error)) *MockRepositoryRemoteCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryRemoteCall) DoAndReturn 

func (c *MockRepositoryRemoteCall) DoAndReturn(f func(string) (*git.Remote, error)) *MockRepositoryRemoteCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryRemoteCall) Return 

func (c *MockRepositoryRemoteCall) Return(arg0 *git.Remote, arg1 error) *MockRepositoryRemoteCall

Return rewrite *gomock.Call.Return

type MockRepositoryRemotesCall 

type MockRepositoryRemotesCall struct {
	*gomock.Call
}

MockRepositoryRemotesCall wrap *gomock.Call

func (*MockRepositoryRemotesCall) Do 

func (c *MockRepositoryRemotesCall) Do(f func() ([]*git.Remote, error)) *MockRepositoryRemotesCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryRemotesCall) DoAndReturn 

func (c *MockRepositoryRemotesCall) DoAndReturn(f func() ([]*git.Remote, error)) *MockRepositoryRemotesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryRemotesCall) Return 

func (c *MockRepositoryRemotesCall) Return(arg0 []*git.Remote, arg1 error) *MockRepositoryRemotesCall

Return rewrite *gomock.Call.Return

type MockRepositoryRepackObjectsCall 

type MockRepositoryRepackObjectsCall struct {
	*gomock.Call
}

MockRepositoryRepackObjectsCall wrap *gomock.Call

func (*MockRepositoryRepackObjectsCall) Do 

func (c *MockRepositoryRepackObjectsCall) Do(f func(*git.RepackConfig) error) *MockRepositoryRepackObjectsCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryRepackObjectsCall) DoAndReturn 

func (c *MockRepositoryRepackObjectsCall) DoAndReturn(f func(*git.RepackConfig) error) *MockRepositoryRepackObjectsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryRepackObjectsCall) Return 

func (c *MockRepositoryRepackObjectsCall) Return(err error) *MockRepositoryRepackObjectsCall

Return rewrite *gomock.Call.Return

type MockRepositoryResolveRevisionCall 

type MockRepositoryResolveRevisionCall struct {
	*gomock.Call
}

MockRepositoryResolveRevisionCall wrap *gomock.Call

func (*MockRepositoryResolveRevisionCall) Do 

func (c *MockRepositoryResolveRevisionCall) Do(f func(plumbing.Revision) (*plumbing.Hash, error)) *MockRepositoryResolveRevisionCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryResolveRevisionCall) DoAndReturn 

func (c *MockRepositoryResolveRevisionCall) DoAndReturn(f func(plumbing.Revision) (*plumbing.Hash, error)) *MockRepositoryResolveRevisionCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryResolveRevisionCall) Return 

func (c *MockRepositoryResolveRevisionCall) Return(arg0 *plumbing.Hash, arg1 error) *MockRepositoryResolveRevisionCall

Return rewrite *gomock.Call.Return

type MockRepositorySetConfigCall 

type MockRepositorySetConfigCall struct {
	*gomock.Call
}

MockRepositorySetConfigCall wrap *gomock.Call

func (*MockRepositorySetConfigCall) Do 

func (c *MockRepositorySetConfigCall) Do(f func(*config.Config) error) *MockRepositorySetConfigCall

Do rewrite *gomock.Call.Do

func (*MockRepositorySetConfigCall) DoAndReturn 

func (c *MockRepositorySetConfigCall) DoAndReturn(f func(*config.Config) error) *MockRepositorySetConfigCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositorySetConfigCall) Return 

func (c *MockRepositorySetConfigCall) Return(arg0 error) *MockRepositorySetConfigCall

Return rewrite *gomock.Call.Return

type MockRepositoryStorerCall 

type MockRepositoryStorerCall struct {
	*gomock.Call
}

MockRepositoryStorerCall wrap *gomock.Call

func (*MockRepositoryStorerCall) Do 

func (c *MockRepositoryStorerCall) Do(f func() storage.Storer) *MockRepositoryStorerCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryStorerCall) DoAndReturn 

func (c *MockRepositoryStorerCall) DoAndReturn(f func() storage.Storer) *MockRepositoryStorerCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryStorerCall) Return 

func (c *MockRepositoryStorerCall) Return(arg0 storage.Storer) *MockRepositoryStorerCall

Return rewrite *gomock.Call.Return

type MockRepositoryTagCall 

type MockRepositoryTagCall struct {
	*gomock.Call
}

MockRepositoryTagCall wrap *gomock.Call

func (*MockRepositoryTagCall) Do 

func (c *MockRepositoryTagCall) Do(f func(string) (*plumbing.Reference, error)) *MockRepositoryTagCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryTagCall) DoAndReturn 

func (c *MockRepositoryTagCall) DoAndReturn(f func(string) (*plumbing.Reference, error)) *MockRepositoryTagCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryTagCall) Return 

func (c *MockRepositoryTagCall) Return(arg0 *plumbing.Reference, arg1 error) *MockRepositoryTagCall

Return rewrite *gomock.Call.Return

type MockRepositoryTagObjectCall 

type MockRepositoryTagObjectCall struct {
	*gomock.Call
}

MockRepositoryTagObjectCall wrap *gomock.Call

func (*MockRepositoryTagObjectCall) Do 

func (c *MockRepositoryTagObjectCall) Do(f func(plumbing.Hash) (*object.Tag, error)) *MockRepositoryTagObjectCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryTagObjectCall) DoAndReturn 

func (c *MockRepositoryTagObjectCall) DoAndReturn(f func(plumbing.Hash) (*object.Tag, error)) *MockRepositoryTagObjectCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryTagObjectCall) Return 

func (c *MockRepositoryTagObjectCall) Return(arg0 *object.Tag, arg1 error) *MockRepositoryTagObjectCall

Return rewrite *gomock.Call.Return

type MockRepositoryTagObjectsCall 

type MockRepositoryTagObjectsCall struct {
	*gomock.Call
}

MockRepositoryTagObjectsCall wrap *gomock.Call

func (*MockRepositoryTagObjectsCall) Do 

func (c *MockRepositoryTagObjectsCall) Do(f func() (*object.TagIter, error)) *MockRepositoryTagObjectsCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryTagObjectsCall) DoAndReturn 

func (c *MockRepositoryTagObjectsCall) DoAndReturn(f func() (*object.TagIter, error)) *MockRepositoryTagObjectsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryTagObjectsCall) Return 

func (c *MockRepositoryTagObjectsCall) Return(arg0 *object.TagIter, arg1 error) *MockRepositoryTagObjectsCall

Return rewrite *gomock.Call.Return

type MockRepositoryTagsCall 

type MockRepositoryTagsCall struct {
	*gomock.Call
}

MockRepositoryTagsCall wrap *gomock.Call

func (*MockRepositoryTagsCall) Do 

func (c *MockRepositoryTagsCall) Do(f func() (storer.ReferenceIter, error)) *MockRepositoryTagsCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryTagsCall) DoAndReturn 

func (c *MockRepositoryTagsCall) DoAndReturn(f func() (storer.ReferenceIter, error)) *MockRepositoryTagsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryTagsCall) Return 

func (c *MockRepositoryTagsCall) Return(arg0 storer.ReferenceIter, arg1 error) *MockRepositoryTagsCall

Return rewrite *gomock.Call.Return

type MockRepositoryTreeObjectCall 

type MockRepositoryTreeObjectCall struct {
	*gomock.Call
}

MockRepositoryTreeObjectCall wrap *gomock.Call

func (*MockRepositoryTreeObjectCall) Do 

func (c *MockRepositoryTreeObjectCall) Do(f func(plumbing.Hash) (*object.Tree, error)) *MockRepositoryTreeObjectCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryTreeObjectCall) DoAndReturn 

func (c *MockRepositoryTreeObjectCall) DoAndReturn(f func(plumbing.Hash) (*object.Tree, error)) *MockRepositoryTreeObjectCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryTreeObjectCall) Return 

func (c *MockRepositoryTreeObjectCall) Return(arg0 *object.Tree, arg1 error) *MockRepositoryTreeObjectCall

Return rewrite *gomock.Call.Return

type MockRepositoryTreeObjectsCall 

type MockRepositoryTreeObjectsCall struct {
	*gomock.Call
}

MockRepositoryTreeObjectsCall wrap *gomock.Call

func (*MockRepositoryTreeObjectsCall) Do 

func (c *MockRepositoryTreeObjectsCall) Do(f func() (*object.TreeIter, error)) *MockRepositoryTreeObjectsCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryTreeObjectsCall) DoAndReturn 

func (c *MockRepositoryTreeObjectsCall) DoAndReturn(f func() (*object.TreeIter, error)) *MockRepositoryTreeObjectsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryTreeObjectsCall) Return 

func (c *MockRepositoryTreeObjectsCall) Return(arg0 *object.TreeIter, arg1 error) *MockRepositoryTreeObjectsCall

Return rewrite *gomock.Call.Return

type MockRepositoryWorktreeCall 

type MockRepositoryWorktreeCall struct {
	*gomock.Call
}

MockRepositoryWorktreeCall wrap *gomock.Call

func (*MockRepositoryWorktreeCall) Do 

func (c *MockRepositoryWorktreeCall) Do(f func() (*git.Worktree, error)) *MockRepositoryWorktreeCall

Do rewrite *gomock.Call.Do

func (*MockRepositoryWorktreeCall) DoAndReturn 

func (c *MockRepositoryWorktreeCall) DoAndReturn(f func() (*git.Worktree, error)) *MockRepositoryWorktreeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockRepositoryWorktreeCall) Return 

func (c *MockRepositoryWorktreeCall) Return(arg0 *git.Worktree, arg1 error) *MockRepositoryWorktreeCall

Return rewrite *gomock.Call.Return

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.