// Code generated by MockGen. DO NOT EDIT.
// Source: go.abhg.dev/gs/internal/handler/squash (interfaces: GitRepository,GitWorktree,Store,Service,RestackHandler)
//
// Generated by this command:
//
//	mockgen -package squash -destination mocks_test.go . GitRepository,GitWorktree,Store,Service,RestackHandler
//

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

import (
	context "context"
	reflect "reflect"

	git "go.abhg.dev/gs/internal/git"
	restack "go.abhg.dev/gs/internal/handler/restack"
	spice "go.abhg.dev/gs/internal/spice"
	gomock "go.uber.org/mock/gomock"
)

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

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

// CommitMessageRange mocks base method.
func (m *MockGitRepository) CommitMessageRange(ctx context.Context, start, stop string) ([]git.CommitMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitMessageRange", ctx, start, stop)
	ret0, _ := ret[0].([]git.CommitMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetRef mocks base method.
func (m *MockGitRepository) SetRef(ctx context.Context, req git.SetRefRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRef", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockGitWorktree is a mock of GitWorktree interface.
type MockGitWorktree struct {
	ctrl     *gomock.Controller
	recorder *MockGitWorktreeMockRecorder
	isgomock struct{}
}

// MockGitWorktreeMockRecorder is the mock recorder for MockGitWorktree.
type MockGitWorktreeMockRecorder struct {
	mock *MockGitWorktree
}

// NewMockGitWorktree creates a new mock instance.
func NewMockGitWorktree(ctrl *gomock.Controller) *MockGitWorktree {
	mock := &MockGitWorktree{ctrl: ctrl}
	mock.recorder = &MockGitWorktreeMockRecorder{mock}
	return mock
}

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

// CheckoutBranch mocks base method.
func (m *MockGitWorktree) CheckoutBranch(ctx context.Context, branch string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckoutBranch", ctx, branch)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckoutBranch indicates an expected call of CheckoutBranch.
func (mr *MockGitWorktreeMockRecorder) CheckoutBranch(ctx, branch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckoutBranch", reflect.TypeOf((*MockGitWorktree)(nil).CheckoutBranch), ctx, branch)
}

// Commit mocks base method.
func (m *MockGitWorktree) Commit(ctx context.Context, req git.CommitRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit.
func (mr *MockGitWorktreeMockRecorder) Commit(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockGitWorktree)(nil).Commit), ctx, req)
}

// DetachHead mocks base method.
func (m *MockGitWorktree) DetachHead(ctx context.Context, commitish string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachHead", ctx, commitish)
	ret0, _ := ret[0].(error)
	return ret0
}

// DetachHead indicates an expected call of DetachHead.
func (mr *MockGitWorktreeMockRecorder) DetachHead(ctx, commitish any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachHead", reflect.TypeOf((*MockGitWorktree)(nil).DetachHead), ctx, commitish)
}

// Head mocks base method.
func (m *MockGitWorktree) Head(ctx context.Context) (git.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Head", ctx)
	ret0, _ := ret[0].(git.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Head indicates an expected call of Head.
func (mr *MockGitWorktreeMockRecorder) Head(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockGitWorktree)(nil).Head), ctx)
}

// Reset mocks base method.
func (m *MockGitWorktree) Reset(ctx context.Context, commit string, opts git.ResetOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reset", ctx, commit, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// Reset indicates an expected call of Reset.
func (mr *MockGitWorktreeMockRecorder) Reset(ctx, commit, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockGitWorktree)(nil).Reset), ctx, commit, opts)
}

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

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

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

// MockService is a mock of Service interface.
type MockService struct {
	ctrl     *gomock.Controller
	recorder *MockServiceMockRecorder
	isgomock struct{}
}

// MockServiceMockRecorder is the mock recorder for MockService.
type MockServiceMockRecorder struct {
	mock *MockService
}

// NewMockService creates a new mock instance.
func NewMockService(ctrl *gomock.Controller) *MockService {
	mock := &MockService{ctrl: ctrl}
	mock.recorder = &MockServiceMockRecorder{mock}
	return mock
}

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

// LookupBranch mocks base method.
func (m *MockService) LookupBranch(ctx context.Context, name string) (*spice.LookupBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupBranch", ctx, name)
	ret0, _ := ret[0].(*spice.LookupBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupBranch indicates an expected call of LookupBranch.
func (mr *MockServiceMockRecorder) LookupBranch(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupBranch", reflect.TypeOf((*MockService)(nil).LookupBranch), ctx, name)
}

// VerifyRestacked mocks base method.
func (m *MockService) VerifyRestacked(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyRestacked", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyRestacked indicates an expected call of VerifyRestacked.
func (mr *MockServiceMockRecorder) VerifyRestacked(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyRestacked", reflect.TypeOf((*MockService)(nil).VerifyRestacked), ctx, name)
}

// MockRestackHandler is a mock of RestackHandler interface.
type MockRestackHandler struct {
	ctrl     *gomock.Controller
	recorder *MockRestackHandlerMockRecorder
	isgomock struct{}
}

// MockRestackHandlerMockRecorder is the mock recorder for MockRestackHandler.
type MockRestackHandlerMockRecorder struct {
	mock *MockRestackHandler
}

// NewMockRestackHandler creates a new mock instance.
func NewMockRestackHandler(ctrl *gomock.Controller) *MockRestackHandler {
	mock := &MockRestackHandler{ctrl: ctrl}
	mock.recorder = &MockRestackHandlerMockRecorder{mock}
	return mock
}

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

// RestackUpstack mocks base method.
func (m *MockRestackHandler) RestackUpstack(ctx context.Context, branch string, opts *restack.UpstackOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestackUpstack", ctx, branch, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// RestackUpstack indicates an expected call of RestackUpstack.
func (mr *MockRestackHandlerMockRecorder) RestackUpstack(ctx, branch, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestackUpstack", reflect.TypeOf((*MockRestackHandler)(nil).RestackUpstack), ctx, branch, opts)
}
