mock_repository.go

// Copyright The Linux Foundation and each contributor to CommunityBridge.
// SPDX-License-Identifier: MIT
//

// Code generated by MockGen. DO NOT EDIT.
// Source: repositories/repository.go

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

import (
	context "context"
	reflect "reflect"

	models "github.com/communitybridge/easycla/cla-backend-go/gen/v1/models"
	gomock "github.com/golang/mock/gomock"
)

// MockRepositoryInterface is a mock of RepositoryInterface interface.
type MockRepositoryInterface struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryInterfaceMockRecorder
}

// GitHubDisableRepositoriesOfOrganizationParent implements repositories.RepositoryInterface.
func (*MockRepositoryInterface) GitHubDisableRepositoriesOfOrganizationParent(ctx context.Context, parentProjectSFID string, githubOrgName string) error {
	panic("unimplemented")
}

// MockRepositoryInterfaceMockRecorder is the mock recorder for MockRepositoryInterface.
type MockRepositoryInterfaceMockRecorder struct {
	mock *MockRepositoryInterface
}

// NewMockRepositoryInterface creates a new mock instance.
func NewMockRepositoryInterface(ctrl *gomock.Controller) *MockRepositoryInterface {
	mock := &MockRepositoryInterface{ctrl: ctrl}
	mock.recorder = &MockRepositoryInterfaceMockRecorder{mock}
	return mock
}

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

// GitHubAddRepository mocks base method.
func (m *MockRepositoryInterface) GitHubAddRepository(ctx context.Context, externalProjectID, projectSFID string, input *models.GithubRepositoryInput) (*models.GithubRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubAddRepository", ctx, externalProjectID, projectSFID, input)
	ret0, _ := ret[0].(*models.GithubRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubAddRepository indicates an expected call of GitHubAddRepository.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubAddRepository(ctx, externalProjectID, projectSFID, input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubAddRepository", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubAddRepository), ctx, externalProjectID, projectSFID, input)
}

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

// GitHubDisableRepositoriesByProjectID indicates an expected call of GitHubDisableRepositoriesByProjectID.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubDisableRepositoriesByProjectID(ctx, projectID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubDisableRepositoriesByProjectID", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubDisableRepositoriesByProjectID), ctx, projectID)
}

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

// GitHubDisableRepositoriesOfOrganization indicates an expected call of GitHubDisableRepositoriesOfOrganization.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubDisableRepositoriesOfOrganization(ctx, externalProjectID, githubOrgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubDisableRepositoriesOfOrganization", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubDisableRepositoriesOfOrganization), ctx, externalProjectID, githubOrgName)
}

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

// GitHubDisableRepository indicates an expected call of GitHubDisableRepository.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubDisableRepository(ctx, repositoryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubDisableRepository", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubDisableRepository), ctx, repositoryID)
}

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

// GitHubEnableRepository indicates an expected call of GitHubEnableRepository.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubEnableRepository(ctx, repositoryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubEnableRepository", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubEnableRepository), ctx, repositoryID)
}

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

// GitHubEnableRepositoryWithCLAGroupID indicates an expected call of GitHubEnableRepositoryWithCLAGroupID.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubEnableRepositoryWithCLAGroupID(ctx, repositoryID, claGroupID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubEnableRepositoryWithCLAGroupID", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubEnableRepositoryWithCLAGroupID), ctx, repositoryID, claGroupID)
}

// GitHubGetCLAGroupRepositoriesGroupByOrgs mocks base method.
func (m *MockRepositoryInterface) GitHubGetCLAGroupRepositoriesGroupByOrgs(ctx context.Context, projectID string, enabled bool) ([]*models.GithubRepositoriesGroupByOrgs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubGetCLAGroupRepositoriesGroupByOrgs", ctx, projectID, enabled)
	ret0, _ := ret[0].([]*models.GithubRepositoriesGroupByOrgs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubGetCLAGroupRepositoriesGroupByOrgs indicates an expected call of GitHubGetCLAGroupRepositoriesGroupByOrgs.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubGetCLAGroupRepositoriesGroupByOrgs(ctx, projectID, enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubGetCLAGroupRepositoriesGroupByOrgs", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubGetCLAGroupRepositoriesGroupByOrgs), ctx, projectID, enabled)
}

// GitHubGetRepositoriesByCLAGroup mocks base method.
func (m *MockRepositoryInterface) GitHubGetRepositoriesByCLAGroup(ctx context.Context, claGroup string, enabled bool) ([]*models.GithubRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubGetRepositoriesByCLAGroup", ctx, claGroup, enabled)
	ret0, _ := ret[0].([]*models.GithubRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubGetRepositoriesByCLAGroup indicates an expected call of GitHubGetRepositoriesByCLAGroup.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubGetRepositoriesByCLAGroup(ctx, claGroup, enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubGetRepositoriesByCLAGroup", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubGetRepositoriesByCLAGroup), ctx, claGroup, enabled)
}

// GitHubGetRepositoriesByOrganizationName mocks base method.
func (m *MockRepositoryInterface) GitHubGetRepositoriesByOrganizationName(ctx context.Context, gitHubOrgName string) ([]*models.GithubRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubGetRepositoriesByOrganizationName", ctx, gitHubOrgName)
	ret0, _ := ret[0].([]*models.GithubRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubGetRepositoriesByOrganizationName indicates an expected call of GitHubGetRepositoriesByOrganizationName.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubGetRepositoriesByOrganizationName(ctx, gitHubOrgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubGetRepositoriesByOrganizationName", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubGetRepositoriesByOrganizationName), ctx, gitHubOrgName)
}

// GitHubGetRepository mocks base method.
func (m *MockRepositoryInterface) GitHubGetRepository(ctx context.Context, repositoryID string) (*models.GithubRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubGetRepository", ctx, repositoryID)
	ret0, _ := ret[0].(*models.GithubRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubGetRepository indicates an expected call of GitHubGetRepository.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubGetRepository(ctx, repositoryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubGetRepository", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubGetRepository), ctx, repositoryID)
}

// GitHubGetRepositoryByExternalID mocks base method.
func (m *MockRepositoryInterface) GitHubGetRepositoryByExternalID(ctx context.Context, repositoryExternalID string) (*models.GithubRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubGetRepositoryByExternalID", ctx, repositoryExternalID)
	ret0, _ := ret[0].(*models.GithubRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubGetRepositoryByExternalID indicates an expected call of GitHubGetRepositoryByExternalID.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubGetRepositoryByExternalID(ctx, repositoryExternalID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubGetRepositoryByExternalID", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubGetRepositoryByExternalID), ctx, repositoryExternalID)
}

// GitHubGetRepositoryByGithubID mocks base method.
func (m *MockRepositoryInterface) GitHubGetRepositoryByGithubID(ctx context.Context, externalID string, enabled bool) (*models.GithubRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubGetRepositoryByGithubID", ctx, externalID, enabled)
	ret0, _ := ret[0].(*models.GithubRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubGetRepositoryByGithubID indicates an expected call of GitHubGetRepositoryByGithubID.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubGetRepositoryByGithubID(ctx, externalID, enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubGetRepositoryByGithubID", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubGetRepositoryByGithubID), ctx, externalID, enabled)
}

// GitHubGetRepositoryByName mocks base method.
func (m *MockRepositoryInterface) GitHubGetRepositoryByName(ctx context.Context, repositoryName string) (*models.GithubRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubGetRepositoryByName", ctx, repositoryName)
	ret0, _ := ret[0].(*models.GithubRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubGetRepositoryByName indicates an expected call of GitHubGetRepositoryByName.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubGetRepositoryByName(ctx, repositoryName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubGetRepositoryByName", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubGetRepositoryByName), ctx, repositoryName)
}

// GitHubListProjectRepositories mocks base method.
func (m *MockRepositoryInterface) GitHubListProjectRepositories(ctx context.Context, projectSFID string, enabled *bool) (*models.GithubListRepositories, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubListProjectRepositories", ctx, projectSFID, enabled)
	ret0, _ := ret[0].(*models.GithubListRepositories)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubListProjectRepositories indicates an expected call of GitHubListProjectRepositories.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubListProjectRepositories(ctx, projectSFID, enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubListProjectRepositories", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubListProjectRepositories), ctx, projectSFID, enabled)
}

// GitHubSetRemoteDeletedRepository mocks base method.
func (m *MockRepositoryInterface) GitHubSetRemoteDeletedRepository(ctx context.Context, repositoryID string, isDeleted, wasCLAEnforced bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubSetRemoteDeletedRepository", ctx, repositoryID, isDeleted, wasCLAEnforced)
	ret0, _ := ret[0].(error)
	return ret0
}

// GitHubSetRemoteDeletedRepository indicates an expected call of GitHubSetRemoteDeletedRepository.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubSetRemoteDeletedRepository(ctx, repositoryID, isDeleted, wasCLAEnforced interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubSetRemoteDeletedRepository", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubSetRemoteDeletedRepository), ctx, repositoryID, isDeleted, wasCLAEnforced)
}

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

// GitHubUpdateClaGroupID indicates an expected call of GitHubUpdateClaGroupID.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubUpdateClaGroupID(ctx, repositoryID, claGroupID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubUpdateClaGroupID", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubUpdateClaGroupID), ctx, repositoryID, claGroupID)
}

// GitHubUpdateRepository mocks base method.
func (m *MockRepositoryInterface) GitHubUpdateRepository(ctx context.Context, repositoryID, projectSFID, parentProjectSFID string, input *models.GithubRepositoryInput) (*models.GithubRepository, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitHubUpdateRepository", ctx, repositoryID, projectSFID, parentProjectSFID, input)
	ret0, _ := ret[0].(*models.GithubRepository)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitHubUpdateRepository indicates an expected call of GitHubUpdateRepository.
func (mr *MockRepositoryInterfaceMockRecorder) GitHubUpdateRepository(ctx, repositoryID, projectSFID, parentProjectSFID, input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitHubUpdateRepository", reflect.TypeOf((*MockRepositoryInterface)(nil).GitHubUpdateRepository), ctx, repositoryID, projectSFID, parentProjectSFID, input)
}