diff --git a/cla-backend-go/company/mocks/mock_repo.go b/cla-backend-go/company/mocks/mock_repo.go new file mode 100644 index 000000000..a9a2421ff --- /dev/null +++ b/cla-backend-go/company/mocks/mock_repo.go @@ -0,0 +1,351 @@ +// Copyright The Linux Foundation and each contributor to CommunityBridge. +// SPDX-License-Identifier: MIT + +// Code generated by MockGen. DO NOT EDIT. +// Source: company/repository.go + +// Package mock_company is a generated GoMock package. +package mock_company + +import ( + context "context" + reflect "reflect" + + company "github.com/communitybridge/easycla/cla-backend-go/company" + models "github.com/communitybridge/easycla/cla-backend-go/gen/v1/models" + user "github.com/communitybridge/easycla/cla-backend-go/user" + gomock "github.com/golang/mock/gomock" +) + +// MockIRepository is a mock of IRepository interface. +type MockIRepository struct { + ctrl *gomock.Controller + recorder *MockIRepositoryMockRecorder +} + +// MockIRepositoryMockRecorder is the mock recorder for MockIRepository. +type MockIRepositoryMockRecorder struct { + mock *MockIRepository +} + +// NewMockIRepository creates a new mock instance. +func NewMockIRepository(ctrl *gomock.Controller) *MockIRepository { + mock := &MockIRepository{ctrl: ctrl} + mock.recorder = &MockIRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIRepository) EXPECT() *MockIRepositoryMockRecorder { + return m.recorder +} + +// AddPendingCompanyInviteRequest mocks base method. +func (m *MockIRepository) AddPendingCompanyInviteRequest(ctx context.Context, companyID string, userModel user.User) (*company.Invite, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddPendingCompanyInviteRequest", ctx, companyID, userModel) + ret0, _ := ret[0].(*company.Invite) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddPendingCompanyInviteRequest indicates an expected call of AddPendingCompanyInviteRequest. +func (mr *MockIRepositoryMockRecorder) AddPendingCompanyInviteRequest(ctx, companyID, userModel interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPendingCompanyInviteRequest", reflect.TypeOf((*MockIRepository)(nil).AddPendingCompanyInviteRequest), ctx, companyID, userModel) +} + +// ApproveCompanyAccessRequest mocks base method. +func (m *MockIRepository) ApproveCompanyAccessRequest(ctx context.Context, companyInviteID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ApproveCompanyAccessRequest", ctx, companyInviteID) + ret0, _ := ret[0].(error) + return ret0 +} + +// ApproveCompanyAccessRequest indicates an expected call of ApproveCompanyAccessRequest. +func (mr *MockIRepositoryMockRecorder) ApproveCompanyAccessRequest(ctx, companyInviteID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveCompanyAccessRequest", reflect.TypeOf((*MockIRepository)(nil).ApproveCompanyAccessRequest), ctx, companyInviteID) +} + +// CreateCompany mocks base method. +func (m *MockIRepository) CreateCompany(ctx context.Context, in *models.Company) (*models.Company, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCompany", ctx, in) + ret0, _ := ret[0].(*models.Company) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCompany indicates an expected call of CreateCompany. +func (mr *MockIRepositoryMockRecorder) CreateCompany(ctx, in interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCompany", reflect.TypeOf((*MockIRepository)(nil).CreateCompany), ctx, in) +} + +// DeleteCompanyByID mocks base method. +func (m *MockIRepository) DeleteCompanyByID(ctx context.Context, companyID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCompanyByID", ctx, companyID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteCompanyByID indicates an expected call of DeleteCompanyByID. +func (mr *MockIRepositoryMockRecorder) DeleteCompanyByID(ctx, companyID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCompanyByID", reflect.TypeOf((*MockIRepository)(nil).DeleteCompanyByID), ctx, companyID) +} + +// DeleteCompanyBySFID mocks base method. +func (m *MockIRepository) DeleteCompanyBySFID(ctx context.Context, companySFID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCompanyBySFID", ctx, companySFID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteCompanyBySFID indicates an expected call of DeleteCompanyBySFID. +func (mr *MockIRepositoryMockRecorder) DeleteCompanyBySFID(ctx, companySFID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCompanyBySFID", reflect.TypeOf((*MockIRepository)(nil).DeleteCompanyBySFID), ctx, companySFID) +} + +// GetCompanies mocks base method. +func (m *MockIRepository) GetCompanies(ctx context.Context) (*models.Companies, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanies", ctx) + ret0, _ := ret[0].(*models.Companies) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanies indicates an expected call of GetCompanies. +func (mr *MockIRepositoryMockRecorder) GetCompanies(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanies", reflect.TypeOf((*MockIRepository)(nil).GetCompanies), ctx) +} + +// GetCompaniesByExternalID mocks base method. +func (m *MockIRepository) GetCompaniesByExternalID(ctx context.Context, companySFID string, includeChildCompanies bool) ([]*models.Company, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompaniesByExternalID", ctx, companySFID, includeChildCompanies) + ret0, _ := ret[0].([]*models.Company) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompaniesByExternalID indicates an expected call of GetCompaniesByExternalID. +func (mr *MockIRepositoryMockRecorder) GetCompaniesByExternalID(ctx, companySFID, includeChildCompanies interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompaniesByExternalID", reflect.TypeOf((*MockIRepository)(nil).GetCompaniesByExternalID), ctx, companySFID, includeChildCompanies) +} + +// GetCompaniesByUserManager mocks base method. +func (m *MockIRepository) GetCompaniesByUserManager(ctx context.Context, userID string, userModel user.User) (*models.Companies, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompaniesByUserManager", ctx, userID, userModel) + ret0, _ := ret[0].(*models.Companies) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompaniesByUserManager indicates an expected call of GetCompaniesByUserManager. +func (mr *MockIRepositoryMockRecorder) GetCompaniesByUserManager(ctx, userID, userModel interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompaniesByUserManager", reflect.TypeOf((*MockIRepository)(nil).GetCompaniesByUserManager), ctx, userID, userModel) +} + +// GetCompaniesByUserManagerWithInvites mocks base method. +func (m *MockIRepository) GetCompaniesByUserManagerWithInvites(ctx context.Context, userID string, userModel user.User) (*models.CompaniesWithInvites, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompaniesByUserManagerWithInvites", ctx, userID, userModel) + ret0, _ := ret[0].(*models.CompaniesWithInvites) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompaniesByUserManagerWithInvites indicates an expected call of GetCompaniesByUserManagerWithInvites. +func (mr *MockIRepositoryMockRecorder) GetCompaniesByUserManagerWithInvites(ctx, userID, userModel interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompaniesByUserManagerWithInvites", reflect.TypeOf((*MockIRepository)(nil).GetCompaniesByUserManagerWithInvites), ctx, userID, userModel) +} + +// GetCompany mocks base method. +func (m *MockIRepository) GetCompany(ctx context.Context, companyID string) (*models.Company, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompany", ctx, companyID) + ret0, _ := ret[0].(*models.Company) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompany indicates an expected call of GetCompany. +func (mr *MockIRepositoryMockRecorder) GetCompany(ctx, companyID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompany", reflect.TypeOf((*MockIRepository)(nil).GetCompany), ctx, companyID) +} + +// GetCompanyByExternalID mocks base method. +func (m *MockIRepository) GetCompanyByExternalID(ctx context.Context, companySFID string) (*models.Company, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanyByExternalID", ctx, companySFID) + ret0, _ := ret[0].(*models.Company) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanyByExternalID indicates an expected call of GetCompanyByExternalID. +func (mr *MockIRepositoryMockRecorder) GetCompanyByExternalID(ctx, companySFID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanyByExternalID", reflect.TypeOf((*MockIRepository)(nil).GetCompanyByExternalID), ctx, companySFID) +} + +// GetCompanyByName mocks base method. +func (m *MockIRepository) GetCompanyByName(ctx context.Context, companyName string) (*models.Company, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanyByName", ctx, companyName) + ret0, _ := ret[0].(*models.Company) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanyByName indicates an expected call of GetCompanyByName. +func (mr *MockIRepositoryMockRecorder) GetCompanyByName(ctx, companyName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanyByName", reflect.TypeOf((*MockIRepository)(nil).GetCompanyByName), ctx, companyName) +} + +// GetCompanyBySigningEntityName mocks base method. +func (m *MockIRepository) GetCompanyBySigningEntityName(ctx context.Context, signingEntityName string) (*models.Company, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanyBySigningEntityName", ctx, signingEntityName) + ret0, _ := ret[0].(*models.Company) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanyBySigningEntityName indicates an expected call of GetCompanyBySigningEntityName. +func (mr *MockIRepositoryMockRecorder) GetCompanyBySigningEntityName(ctx, signingEntityName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanyBySigningEntityName", reflect.TypeOf((*MockIRepository)(nil).GetCompanyBySigningEntityName), ctx, signingEntityName) +} + +// GetCompanyInviteRequest mocks base method. +func (m *MockIRepository) GetCompanyInviteRequest(ctx context.Context, companyInviteID string) (*company.Invite, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanyInviteRequest", ctx, companyInviteID) + ret0, _ := ret[0].(*company.Invite) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanyInviteRequest indicates an expected call of GetCompanyInviteRequest. +func (mr *MockIRepositoryMockRecorder) GetCompanyInviteRequest(ctx, companyInviteID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanyInviteRequest", reflect.TypeOf((*MockIRepository)(nil).GetCompanyInviteRequest), ctx, companyInviteID) +} + +// GetCompanyInviteRequests mocks base method. +func (m *MockIRepository) GetCompanyInviteRequests(ctx context.Context, companyID string, status *string) ([]company.Invite, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanyInviteRequests", ctx, companyID, status) + ret0, _ := ret[0].([]company.Invite) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanyInviteRequests indicates an expected call of GetCompanyInviteRequests. +func (mr *MockIRepositoryMockRecorder) GetCompanyInviteRequests(ctx, companyID, status interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanyInviteRequests", reflect.TypeOf((*MockIRepository)(nil).GetCompanyInviteRequests), ctx, companyID, status) +} + +// GetCompanyUserInviteRequests mocks base method. +func (m *MockIRepository) GetCompanyUserInviteRequests(ctx context.Context, companyID, userID string) (*company.Invite, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanyUserInviteRequests", ctx, companyID, userID) + ret0, _ := ret[0].(*company.Invite) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanyUserInviteRequests indicates an expected call of GetCompanyUserInviteRequests. +func (mr *MockIRepositoryMockRecorder) GetCompanyUserInviteRequests(ctx, companyID, userID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanyUserInviteRequests", reflect.TypeOf((*MockIRepository)(nil).GetCompanyUserInviteRequests), ctx, companyID, userID) +} + +// GetUserInviteRequests mocks base method. +func (m *MockIRepository) GetUserInviteRequests(ctx context.Context, userID string) ([]company.Invite, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserInviteRequests", ctx, userID) + ret0, _ := ret[0].([]company.Invite) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserInviteRequests indicates an expected call of GetUserInviteRequests. +func (mr *MockIRepositoryMockRecorder) GetUserInviteRequests(ctx, userID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserInviteRequests", reflect.TypeOf((*MockIRepository)(nil).GetUserInviteRequests), ctx, userID) +} + +// IsCCLAEnabledForCompany mocks base method. +func (m *MockIRepository) IsCCLAEnabledForCompany(ctx context.Context, companyID string) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsCCLAEnabledForCompany", ctx, companyID) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// IsCCLAEnabledForCompany indicates an expected call of IsCCLAEnabledForCompany. +func (mr *MockIRepositoryMockRecorder) IsCCLAEnabledForCompany(ctx, companyID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCCLAEnabledForCompany", reflect.TypeOf((*MockIRepository)(nil).IsCCLAEnabledForCompany), ctx, companyID) +} + +// RejectCompanyAccessRequest mocks base method. +func (m *MockIRepository) RejectCompanyAccessRequest(ctx context.Context, companyInviteID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectCompanyAccessRequest", ctx, companyInviteID) + ret0, _ := ret[0].(error) + return ret0 +} + +// RejectCompanyAccessRequest indicates an expected call of RejectCompanyAccessRequest. +func (mr *MockIRepositoryMockRecorder) RejectCompanyAccessRequest(ctx, companyInviteID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectCompanyAccessRequest", reflect.TypeOf((*MockIRepository)(nil).RejectCompanyAccessRequest), ctx, companyInviteID) +} + +// SearchCompanyByName mocks base method. +func (m *MockIRepository) SearchCompanyByName(ctx context.Context, companyName, nextKey string) (*models.Companies, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchCompanyByName", ctx, companyName, nextKey) + ret0, _ := ret[0].(*models.Companies) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchCompanyByName indicates an expected call of SearchCompanyByName. +func (mr *MockIRepositoryMockRecorder) SearchCompanyByName(ctx, companyName, nextKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCompanyByName", reflect.TypeOf((*MockIRepository)(nil).SearchCompanyByName), ctx, companyName, nextKey) +} + +// UpdateCompanyAccessList mocks base method. +func (m *MockIRepository) UpdateCompanyAccessList(ctx context.Context, companyID string, companyACL []string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateCompanyAccessList", ctx, companyID, companyACL) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateCompanyAccessList indicates an expected call of UpdateCompanyAccessList. +func (mr *MockIRepositoryMockRecorder) UpdateCompanyAccessList(ctx, companyID, companyACL interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCompanyAccessList", reflect.TypeOf((*MockIRepository)(nil).UpdateCompanyAccessList), ctx, companyID, companyACL) +} diff --git a/cla-backend-go/project/mocks/mock_repo.go b/cla-backend-go/project/mocks/mock_repo.go new file mode 100644 index 000000000..bb3328820 --- /dev/null +++ b/cla-backend-go/project/mocks/mock_repo.go @@ -0,0 +1,203 @@ +// Copyright The Linux Foundation and each contributor to CommunityBridge. +// SPDX-License-Identifier: MIT + +// Code generated by MockGen. DO NOT EDIT. +// Source: project/repository/repository.go + +// Package mock_repository is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + models "github.com/communitybridge/easycla/cla-backend-go/gen/v1/models" + project "github.com/communitybridge/easycla/cla-backend-go/gen/v1/restapi/operations/project" + gomock "github.com/golang/mock/gomock" +) + +// MockProjectRepository is a mock of ProjectRepository interface. +type MockProjectRepository struct { + ctrl *gomock.Controller + recorder *MockProjectRepositoryMockRecorder +} + +// MockProjectRepositoryMockRecorder is the mock recorder for MockProjectRepository. +type MockProjectRepositoryMockRecorder struct { + mock *MockProjectRepository +} + +// NewMockProjectRepository creates a new mock instance. +func NewMockProjectRepository(ctrl *gomock.Controller) *MockProjectRepository { + mock := &MockProjectRepository{ctrl: ctrl} + mock.recorder = &MockProjectRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProjectRepository) EXPECT() *MockProjectRepositoryMockRecorder { + return m.recorder +} + +// CreateCLAGroup mocks base method. +func (m *MockProjectRepository) CreateCLAGroup(ctx context.Context, claGroupModel *models.ClaGroup) (*models.ClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCLAGroup", ctx, claGroupModel) + ret0, _ := ret[0].(*models.ClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCLAGroup indicates an expected call of CreateCLAGroup. +func (mr *MockProjectRepositoryMockRecorder) CreateCLAGroup(ctx, claGroupModel interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCLAGroup", reflect.TypeOf((*MockProjectRepository)(nil).CreateCLAGroup), ctx, claGroupModel) +} + +// DeleteCLAGroup mocks base method. +func (m *MockProjectRepository) DeleteCLAGroup(ctx context.Context, claGroupID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCLAGroup", ctx, claGroupID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteCLAGroup indicates an expected call of DeleteCLAGroup. +func (mr *MockProjectRepositoryMockRecorder) DeleteCLAGroup(ctx, claGroupID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCLAGroup", reflect.TypeOf((*MockProjectRepository)(nil).DeleteCLAGroup), ctx, claGroupID) +} + +// GetCLAGroupByID mocks base method. +func (m *MockProjectRepository) GetCLAGroupByID(ctx context.Context, claGroupID string, loadRepoDetails bool) (*models.ClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCLAGroupByID", ctx, claGroupID, loadRepoDetails) + ret0, _ := ret[0].(*models.ClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCLAGroupByID indicates an expected call of GetCLAGroupByID. +func (mr *MockProjectRepositoryMockRecorder) GetCLAGroupByID(ctx, claGroupID, loadRepoDetails interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCLAGroupByID", reflect.TypeOf((*MockProjectRepository)(nil).GetCLAGroupByID), ctx, claGroupID, loadRepoDetails) +} + +// GetCLAGroupByName mocks base method. +func (m *MockProjectRepository) GetCLAGroupByName(ctx context.Context, claGroupName string) (*models.ClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCLAGroupByName", ctx, claGroupName) + ret0, _ := ret[0].(*models.ClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCLAGroupByName indicates an expected call of GetCLAGroupByName. +func (mr *MockProjectRepositoryMockRecorder) GetCLAGroupByName(ctx, claGroupName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCLAGroupByName", reflect.TypeOf((*MockProjectRepository)(nil).GetCLAGroupByName), ctx, claGroupName) +} + +// GetCLAGroups mocks base method. +func (m *MockProjectRepository) GetCLAGroups(ctx context.Context, params *project.GetProjectsParams) (*models.ClaGroups, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCLAGroups", ctx, params) + ret0, _ := ret[0].(*models.ClaGroups) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCLAGroups indicates an expected call of GetCLAGroups. +func (mr *MockProjectRepositoryMockRecorder) GetCLAGroups(ctx, params interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCLAGroups", reflect.TypeOf((*MockProjectRepository)(nil).GetCLAGroups), ctx, params) +} + +// GetCLAGroupsByExternalID mocks base method. +func (m *MockProjectRepository) GetCLAGroupsByExternalID(ctx context.Context, params *project.GetProjectsByExternalIDParams, loadRepoDetails bool) (*models.ClaGroups, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCLAGroupsByExternalID", ctx, params, loadRepoDetails) + ret0, _ := ret[0].(*models.ClaGroups) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCLAGroupsByExternalID indicates an expected call of GetCLAGroupsByExternalID. +func (mr *MockProjectRepositoryMockRecorder) GetCLAGroupsByExternalID(ctx, params, loadRepoDetails interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCLAGroupsByExternalID", reflect.TypeOf((*MockProjectRepository)(nil).GetCLAGroupsByExternalID), ctx, params, loadRepoDetails) +} + +// GetClaGroupByProjectSFID mocks base method. +func (m *MockProjectRepository) GetClaGroupByProjectSFID(ctx context.Context, projectSFID string, loadRepoDetails bool) (*models.ClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClaGroupByProjectSFID", ctx, projectSFID, loadRepoDetails) + ret0, _ := ret[0].(*models.ClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClaGroupByProjectSFID indicates an expected call of GetClaGroupByProjectSFID. +func (mr *MockProjectRepositoryMockRecorder) GetClaGroupByProjectSFID(ctx, projectSFID, loadRepoDetails interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClaGroupByProjectSFID", reflect.TypeOf((*MockProjectRepository)(nil).GetClaGroupByProjectSFID), ctx, projectSFID, loadRepoDetails) +} + +// GetClaGroupsByFoundationSFID mocks base method. +func (m *MockProjectRepository) GetClaGroupsByFoundationSFID(ctx context.Context, foundationSFID string, loadRepoDetails bool) (*models.ClaGroups, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClaGroupsByFoundationSFID", ctx, foundationSFID, loadRepoDetails) + ret0, _ := ret[0].(*models.ClaGroups) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClaGroupsByFoundationSFID indicates an expected call of GetClaGroupsByFoundationSFID. +func (mr *MockProjectRepositoryMockRecorder) GetClaGroupsByFoundationSFID(ctx, foundationSFID, loadRepoDetails interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClaGroupsByFoundationSFID", reflect.TypeOf((*MockProjectRepository)(nil).GetClaGroupsByFoundationSFID), ctx, foundationSFID, loadRepoDetails) +} + +// GetExternalCLAGroup mocks base method. +func (m *MockProjectRepository) GetExternalCLAGroup(ctx context.Context, claGroupExternalID string) (*models.ClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetExternalCLAGroup", ctx, claGroupExternalID) + ret0, _ := ret[0].(*models.ClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetExternalCLAGroup indicates an expected call of GetExternalCLAGroup. +func (mr *MockProjectRepositoryMockRecorder) GetExternalCLAGroup(ctx, claGroupExternalID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExternalCLAGroup", reflect.TypeOf((*MockProjectRepository)(nil).GetExternalCLAGroup), ctx, claGroupExternalID) +} + +// UpdateCLAGroup mocks base method. +func (m *MockProjectRepository) UpdateCLAGroup(ctx context.Context, claGroupModel *models.ClaGroup) (*models.ClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateCLAGroup", ctx, claGroupModel) + ret0, _ := ret[0].(*models.ClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateCLAGroup indicates an expected call of UpdateCLAGroup. +func (mr *MockProjectRepositoryMockRecorder) UpdateCLAGroup(ctx, claGroupModel interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCLAGroup", reflect.TypeOf((*MockProjectRepository)(nil).UpdateCLAGroup), ctx, claGroupModel) +} + +// UpdateRootCLAGroupRepositoriesCount mocks base method. +func (m *MockProjectRepository) UpdateRootCLAGroupRepositoriesCount(ctx context.Context, claGroupID string, diff int64, reset bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRootCLAGroupRepositoriesCount", ctx, claGroupID, diff, reset) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateRootCLAGroupRepositoriesCount indicates an expected call of UpdateRootCLAGroupRepositoriesCount. +func (mr *MockProjectRepositoryMockRecorder) UpdateRootCLAGroupRepositoriesCount(ctx, claGroupID, diff, reset interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRootCLAGroupRepositoriesCount", reflect.TypeOf((*MockProjectRepository)(nil).UpdateRootCLAGroupRepositoriesCount), ctx, claGroupID, diff, reset) +} diff --git a/cla-backend-go/project/mocks/mock_service.go b/cla-backend-go/project/mocks/mock_service.go index ab02a40e1..c8246cdbb 100644 --- a/cla-backend-go/project/mocks/mock_service.go +++ b/cla-backend-go/project/mocks/mock_service.go @@ -5,7 +5,7 @@ // Source: project/service/service.go // Package mock_service is a generated GoMock package. -package mock_service +package mocks import ( context "context" diff --git a/cla-backend-go/projects_cla_groups/mocks/mock_repository.go b/cla-backend-go/projects_cla_groups/mocks/mock_repository.go new file mode 100644 index 000000000..9035fdf63 --- /dev/null +++ b/cla-backend-go/projects_cla_groups/mocks/mock_repository.go @@ -0,0 +1,215 @@ +// Copyright The Linux Foundation and each contributor to CommunityBridge. +// SPDX-License-Identifier: MIT + +// Code generated by MockGen. DO NOT EDIT. +// Source: projects_cla_groups/repository.go + +// Package mock_projects_cla_groups is a generated GoMock package. +package mock_projects_cla_groups + +import ( + context "context" + reflect "reflect" + + projects_cla_groups "github.com/communitybridge/easycla/cla-backend-go/projects_cla_groups" + gomock "github.com/golang/mock/gomock" +) + +// MockRepository is a mock of Repository interface. +type MockRepository struct { + ctrl *gomock.Controller + recorder *MockRepositoryMockRecorder +} + +// MockRepositoryMockRecorder is the mock recorder for MockRepository. +type MockRepositoryMockRecorder struct { + mock *MockRepository +} + +// NewMockRepository creates a new mock instance. +func NewMockRepository(ctrl *gomock.Controller) *MockRepository { + mock := &MockRepository{ctrl: ctrl} + mock.recorder = &MockRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder { + return m.recorder +} + +// AssociateClaGroupWithProject mocks base method. +func (m *MockRepository) AssociateClaGroupWithProject(ctx context.Context, claGroupID, projectSFID, foundationSFID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateClaGroupWithProject", ctx, claGroupID, projectSFID, foundationSFID) + ret0, _ := ret[0].(error) + return ret0 +} + +// AssociateClaGroupWithProject indicates an expected call of AssociateClaGroupWithProject. +func (mr *MockRepositoryMockRecorder) AssociateClaGroupWithProject(ctx, claGroupID, projectSFID, foundationSFID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClaGroupWithProject", reflect.TypeOf((*MockRepository)(nil).AssociateClaGroupWithProject), ctx, claGroupID, projectSFID, foundationSFID) +} + +// GetCLAGroup mocks base method. +func (m *MockRepository) GetCLAGroup(ctx context.Context, claGroupID string) (*projects_cla_groups.ProjectClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCLAGroup", ctx, claGroupID) + ret0, _ := ret[0].(*projects_cla_groups.ProjectClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCLAGroup indicates an expected call of GetCLAGroup. +func (mr *MockRepositoryMockRecorder) GetCLAGroup(ctx, claGroupID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCLAGroup", reflect.TypeOf((*MockRepository)(nil).GetCLAGroup), ctx, claGroupID) +} + +// GetCLAGroupNameByID mocks base method. +func (m *MockRepository) GetCLAGroupNameByID(ctx context.Context, claGroupID string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCLAGroupNameByID", ctx, claGroupID) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCLAGroupNameByID indicates an expected call of GetCLAGroupNameByID. +func (mr *MockRepositoryMockRecorder) GetCLAGroupNameByID(ctx, claGroupID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCLAGroupNameByID", reflect.TypeOf((*MockRepository)(nil).GetCLAGroupNameByID), ctx, claGroupID) +} + +// GetClaGroupIDForProject mocks base method. +func (m *MockRepository) GetClaGroupIDForProject(ctx context.Context, projectSFID string) (*projects_cla_groups.ProjectClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClaGroupIDForProject", ctx, projectSFID) + ret0, _ := ret[0].(*projects_cla_groups.ProjectClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClaGroupIDForProject indicates an expected call of GetClaGroupIDForProject. +func (mr *MockRepositoryMockRecorder) GetClaGroupIDForProject(ctx, projectSFID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClaGroupIDForProject", reflect.TypeOf((*MockRepository)(nil).GetClaGroupIDForProject), ctx, projectSFID) +} + +// GetProjectsIdsForAllFoundation mocks base method. +func (m *MockRepository) GetProjectsIdsForAllFoundation(ctx context.Context) ([]*projects_cla_groups.ProjectClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProjectsIdsForAllFoundation", ctx) + ret0, _ := ret[0].([]*projects_cla_groups.ProjectClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectsIdsForAllFoundation indicates an expected call of GetProjectsIdsForAllFoundation. +func (mr *MockRepositoryMockRecorder) GetProjectsIdsForAllFoundation(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectsIdsForAllFoundation", reflect.TypeOf((*MockRepository)(nil).GetProjectsIdsForAllFoundation), ctx) +} + +// GetProjectsIdsForClaGroup mocks base method. +func (m *MockRepository) GetProjectsIdsForClaGroup(ctx context.Context, claGroupID string) ([]*projects_cla_groups.ProjectClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProjectsIdsForClaGroup", ctx, claGroupID) + ret0, _ := ret[0].([]*projects_cla_groups.ProjectClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectsIdsForClaGroup indicates an expected call of GetProjectsIdsForClaGroup. +func (mr *MockRepositoryMockRecorder) GetProjectsIdsForClaGroup(ctx, claGroupID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectsIdsForClaGroup", reflect.TypeOf((*MockRepository)(nil).GetProjectsIdsForClaGroup), ctx, claGroupID) +} + +// GetProjectsIdsForFoundation mocks base method. +func (m *MockRepository) GetProjectsIdsForFoundation(ctx context.Context, foundationSFID string) ([]*projects_cla_groups.ProjectClaGroup, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProjectsIdsForFoundation", ctx, foundationSFID) + ret0, _ := ret[0].([]*projects_cla_groups.ProjectClaGroup) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectsIdsForFoundation indicates an expected call of GetProjectsIdsForFoundation. +func (mr *MockRepositoryMockRecorder) GetProjectsIdsForFoundation(ctx, foundationSFID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectsIdsForFoundation", reflect.TypeOf((*MockRepository)(nil).GetProjectsIdsForFoundation), ctx, foundationSFID) +} + +// IsAssociated mocks base method. +func (m *MockRepository) IsAssociated(ctx context.Context, projectSFID, claGroupID string) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsAssociated", ctx, projectSFID, claGroupID) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// IsAssociated indicates an expected call of IsAssociated. +func (mr *MockRepositoryMockRecorder) IsAssociated(ctx, projectSFID, claGroupID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAssociated", reflect.TypeOf((*MockRepository)(nil).IsAssociated), ctx, projectSFID, claGroupID) +} + +// IsExistingFoundationLevelCLAGroup mocks base method. +func (m *MockRepository) IsExistingFoundationLevelCLAGroup(ctx context.Context, foundationSFID string) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsExistingFoundationLevelCLAGroup", ctx, foundationSFID) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// IsExistingFoundationLevelCLAGroup indicates an expected call of IsExistingFoundationLevelCLAGroup. +func (mr *MockRepositoryMockRecorder) IsExistingFoundationLevelCLAGroup(ctx, foundationSFID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsExistingFoundationLevelCLAGroup", reflect.TypeOf((*MockRepository)(nil).IsExistingFoundationLevelCLAGroup), ctx, foundationSFID) +} + +// RemoveProjectAssociatedWithClaGroup mocks base method. +func (m *MockRepository) RemoveProjectAssociatedWithClaGroup(ctx context.Context, claGroupID string, projectSFIDList []string, all bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveProjectAssociatedWithClaGroup", ctx, claGroupID, projectSFIDList, all) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveProjectAssociatedWithClaGroup indicates an expected call of RemoveProjectAssociatedWithClaGroup. +func (mr *MockRepositoryMockRecorder) RemoveProjectAssociatedWithClaGroup(ctx, claGroupID, projectSFIDList, all interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProjectAssociatedWithClaGroup", reflect.TypeOf((*MockRepository)(nil).RemoveProjectAssociatedWithClaGroup), ctx, claGroupID, projectSFIDList, all) +} + +// UpdateClaGroupName mocks base method. +func (m *MockRepository) UpdateClaGroupName(ctx context.Context, projectSFID, claGroupName string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateClaGroupName", ctx, projectSFID, claGroupName) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateClaGroupName indicates an expected call of UpdateClaGroupName. +func (mr *MockRepositoryMockRecorder) UpdateClaGroupName(ctx, projectSFID, claGroupName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClaGroupName", reflect.TypeOf((*MockRepository)(nil).UpdateClaGroupName), ctx, projectSFID, claGroupName) +} + +// UpdateRepositoriesCount mocks base method. +func (m *MockRepository) UpdateRepositoriesCount(ctx context.Context, projectSFID string, diff int64, reset bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRepositoriesCount", ctx, projectSFID, diff, reset) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateRepositoriesCount indicates an expected call of UpdateRepositoriesCount. +func (mr *MockRepositoryMockRecorder) UpdateRepositoriesCount(ctx, projectSFID, diff, reset interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRepositoriesCount", reflect.TypeOf((*MockRepository)(nil).UpdateRepositoriesCount), ctx, projectSFID, diff, reset) +} diff --git a/cla-backend-go/signatures/mocks/mock_repo.go b/cla-backend-go/signatures/mocks/mock_repo.go new file mode 100644 index 000000000..8ebe7653d --- /dev/null +++ b/cla-backend-go/signatures/mocks/mock_repo.go @@ -0,0 +1,629 @@ +// Copyright The Linux Foundation and each contributor to CommunityBridge. +// SPDX-License-Identifier: MIT + +// Code generated by MockGen. DO NOT EDIT. +// Source: signatures/repository.go + +// Package mock_signatures is a generated GoMock package. +package mock_signatures + +import ( + context "context" + reflect "reflect" + sync "sync" + + events "github.com/communitybridge/easycla/cla-backend-go/events" + models "github.com/communitybridge/easycla/cla-backend-go/gen/v1/models" + signatures "github.com/communitybridge/easycla/cla-backend-go/gen/v1/restapi/operations/signatures" + signatures0 "github.com/communitybridge/easycla/cla-backend-go/signatures" + gomock "github.com/golang/mock/gomock" +) + +// MockSignatureRepository is a mock of SignatureRepository interface. +type MockSignatureRepository struct { + ctrl *gomock.Controller + recorder *MockSignatureRepositoryMockRecorder +} + +// MockSignatureRepositoryMockRecorder is the mock recorder for MockSignatureRepository. +type MockSignatureRepositoryMockRecorder struct { + mock *MockSignatureRepository +} + +// NewMockSignatureRepository creates a new mock instance. +func NewMockSignatureRepository(ctrl *gomock.Controller) *MockSignatureRepository { + mock := &MockSignatureRepository{ctrl: ctrl} + mock.recorder = &MockSignatureRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSignatureRepository) EXPECT() *MockSignatureRepositoryMockRecorder { + return m.recorder +} + +// ActivateSignature mocks base method. +func (m *MockSignatureRepository) ActivateSignature(ctx context.Context, signatureID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ActivateSignature", ctx, signatureID) + ret0, _ := ret[0].(error) + return ret0 +} + +// ActivateSignature indicates an expected call of ActivateSignature. +func (mr *MockSignatureRepositoryMockRecorder) ActivateSignature(ctx, signatureID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateSignature", reflect.TypeOf((*MockSignatureRepository)(nil).ActivateSignature), ctx, signatureID) +} + +// AddCLAManager mocks base method. +func (m *MockSignatureRepository) AddCLAManager(ctx context.Context, signatureID, claManagerID string) (*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddCLAManager", ctx, signatureID, claManagerID) + ret0, _ := ret[0].(*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddCLAManager indicates an expected call of AddCLAManager. +func (mr *MockSignatureRepositoryMockRecorder) AddCLAManager(ctx, signatureID, claManagerID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCLAManager", reflect.TypeOf((*MockSignatureRepository)(nil).AddCLAManager), ctx, signatureID, claManagerID) +} + +// AddGithubOrganizationToApprovalList mocks base method. +func (m *MockSignatureRepository) AddGithubOrganizationToApprovalList(ctx context.Context, signatureID, githubOrganizationID string) ([]models.GithubOrg, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddGithubOrganizationToApprovalList", ctx, signatureID, githubOrganizationID) + ret0, _ := ret[0].([]models.GithubOrg) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddGithubOrganizationToApprovalList indicates an expected call of AddGithubOrganizationToApprovalList. +func (mr *MockSignatureRepositoryMockRecorder) AddGithubOrganizationToApprovalList(ctx, signatureID, githubOrganizationID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGithubOrganizationToApprovalList", reflect.TypeOf((*MockSignatureRepository)(nil).AddGithubOrganizationToApprovalList), ctx, signatureID, githubOrganizationID) +} + +// AddSigTypeSignedApprovedID mocks base method. +func (m *MockSignatureRepository) AddSigTypeSignedApprovedID(ctx context.Context, signatureID, val string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddSigTypeSignedApprovedID", ctx, signatureID, val) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddSigTypeSignedApprovedID indicates an expected call of AddSigTypeSignedApprovedID. +func (mr *MockSignatureRepositoryMockRecorder) AddSigTypeSignedApprovedID(ctx, signatureID, val interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSigTypeSignedApprovedID", reflect.TypeOf((*MockSignatureRepository)(nil).AddSigTypeSignedApprovedID), ctx, signatureID, val) +} + +// AddSignedOn mocks base method. +func (m *MockSignatureRepository) AddSignedOn(ctx context.Context, signatureID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddSignedOn", ctx, signatureID) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddSignedOn indicates an expected call of AddSignedOn. +func (mr *MockSignatureRepositoryMockRecorder) AddSignedOn(ctx, signatureID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSignedOn", reflect.TypeOf((*MockSignatureRepository)(nil).AddSignedOn), ctx, signatureID) +} + +// AddUsersDetails mocks base method. +func (m *MockSignatureRepository) AddUsersDetails(ctx context.Context, signatureID, userID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddUsersDetails", ctx, signatureID, userID) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddUsersDetails indicates an expected call of AddUsersDetails. +func (mr *MockSignatureRepositoryMockRecorder) AddUsersDetails(ctx, signatureID, userID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUsersDetails", reflect.TypeOf((*MockSignatureRepository)(nil).AddUsersDetails), ctx, signatureID, userID) +} + +// CreateProjectCompanyEmployeeSignature mocks base method. +func (m *MockSignatureRepository) CreateProjectCompanyEmployeeSignature(ctx context.Context, companyModel *models.Company, claGroupModel *models.ClaGroup, employeeUserModel *models.User) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateProjectCompanyEmployeeSignature", ctx, companyModel, claGroupModel, employeeUserModel) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateProjectCompanyEmployeeSignature indicates an expected call of CreateProjectCompanyEmployeeSignature. +func (mr *MockSignatureRepositoryMockRecorder) CreateProjectCompanyEmployeeSignature(ctx, companyModel, claGroupModel, employeeUserModel interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProjectCompanyEmployeeSignature", reflect.TypeOf((*MockSignatureRepository)(nil).CreateProjectCompanyEmployeeSignature), ctx, companyModel, claGroupModel, employeeUserModel) +} + +// CreateProjectSummaryReport mocks base method. +func (m *MockSignatureRepository) CreateProjectSummaryReport(ctx context.Context, params signatures.CreateProjectSummaryReportParams) (*models.SignatureReport, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateProjectSummaryReport", ctx, params) + ret0, _ := ret[0].(*models.SignatureReport) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateProjectSummaryReport indicates an expected call of CreateProjectSummaryReport. +func (mr *MockSignatureRepositoryMockRecorder) CreateProjectSummaryReport(ctx, params interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProjectSummaryReport", reflect.TypeOf((*MockSignatureRepository)(nil).CreateProjectSummaryReport), ctx, params) +} + +// CreateSignature mocks base method. +func (m *MockSignatureRepository) CreateSignature(ctx context.Context, signature *signatures0.ItemSignature) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSignature", ctx, signature) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateSignature indicates an expected call of CreateSignature. +func (mr *MockSignatureRepositoryMockRecorder) CreateSignature(ctx, signature interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSignature", reflect.TypeOf((*MockSignatureRepository)(nil).CreateSignature), ctx, signature) +} + +// DeleteGithubOrganizationFromApprovalList mocks base method. +func (m *MockSignatureRepository) DeleteGithubOrganizationFromApprovalList(ctx context.Context, signatureID, githubOrganizationID string) ([]models.GithubOrg, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGithubOrganizationFromApprovalList", ctx, signatureID, githubOrganizationID) + ret0, _ := ret[0].([]models.GithubOrg) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGithubOrganizationFromApprovalList indicates an expected call of DeleteGithubOrganizationFromApprovalList. +func (mr *MockSignatureRepositoryMockRecorder) DeleteGithubOrganizationFromApprovalList(ctx, signatureID, githubOrganizationID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGithubOrganizationFromApprovalList", reflect.TypeOf((*MockSignatureRepository)(nil).DeleteGithubOrganizationFromApprovalList), ctx, signatureID, githubOrganizationID) +} + +// EclaAutoCreate mocks base method. +func (m *MockSignatureRepository) EclaAutoCreate(ctx context.Context, signatureID string, autoCreateECLA bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EclaAutoCreate", ctx, signatureID, autoCreateECLA) + ret0, _ := ret[0].(error) + return ret0 +} + +// EclaAutoCreate indicates an expected call of EclaAutoCreate. +func (mr *MockSignatureRepositoryMockRecorder) EclaAutoCreate(ctx, signatureID, autoCreateECLA interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EclaAutoCreate", reflect.TypeOf((*MockSignatureRepository)(nil).EclaAutoCreate), ctx, signatureID, autoCreateECLA) +} + +// GetActivePullRequestMetadata mocks base method. +func (m *MockSignatureRepository) GetActivePullRequestMetadata(ctx context.Context, gitHubAuthorUsername, gitHubAuthorEmail string) (*signatures0.ActivePullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetActivePullRequestMetadata", ctx, gitHubAuthorUsername, gitHubAuthorEmail) + ret0, _ := ret[0].(*signatures0.ActivePullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetActivePullRequestMetadata indicates an expected call of GetActivePullRequestMetadata. +func (mr *MockSignatureRepositoryMockRecorder) GetActivePullRequestMetadata(ctx, gitHubAuthorUsername, gitHubAuthorEmail interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivePullRequestMetadata", reflect.TypeOf((*MockSignatureRepository)(nil).GetActivePullRequestMetadata), ctx, gitHubAuthorUsername, gitHubAuthorEmail) +} + +// GetCCLASignatures mocks base method. +func (m *MockSignatureRepository) GetCCLASignatures(ctx context.Context, signed, approved *bool) ([]*signatures0.ItemSignature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCCLASignatures", ctx, signed, approved) + ret0, _ := ret[0].([]*signatures0.ItemSignature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCCLASignatures indicates an expected call of GetCCLASignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetCCLASignatures(ctx, signed, approved interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCCLASignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetCCLASignatures), ctx, signed, approved) +} + +// GetClaGroupCorporateContributors mocks base method. +func (m *MockSignatureRepository) GetClaGroupCorporateContributors(ctx context.Context, claGroupID string, companyID *string, pageSize *int64, nextKey, searchTerm *string) (*models.CorporateContributorList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClaGroupCorporateContributors", ctx, claGroupID, companyID, pageSize, nextKey, searchTerm) + ret0, _ := ret[0].(*models.CorporateContributorList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClaGroupCorporateContributors indicates an expected call of GetClaGroupCorporateContributors. +func (mr *MockSignatureRepositoryMockRecorder) GetClaGroupCorporateContributors(ctx, claGroupID, companyID, pageSize, nextKey, searchTerm interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClaGroupCorporateContributors", reflect.TypeOf((*MockSignatureRepository)(nil).GetClaGroupCorporateContributors), ctx, claGroupID, companyID, pageSize, nextKey, searchTerm) +} + +// GetClaGroupICLASignatures mocks base method. +func (m *MockSignatureRepository) GetClaGroupICLASignatures(ctx context.Context, claGroupID string, searchTerm *string, approved, signed *bool, pageSize int64, nextKey string, withExtraDetails bool) (*models.IclaSignatures, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClaGroupICLASignatures", ctx, claGroupID, searchTerm, approved, signed, pageSize, nextKey, withExtraDetails) + ret0, _ := ret[0].(*models.IclaSignatures) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClaGroupICLASignatures indicates an expected call of GetClaGroupICLASignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetClaGroupICLASignatures(ctx, claGroupID, searchTerm, approved, signed, pageSize, nextKey, withExtraDetails interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClaGroupICLASignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetClaGroupICLASignatures), ctx, claGroupID, searchTerm, approved, signed, pageSize, nextKey, withExtraDetails) +} + +// GetCompanyIDsWithSignedCorporateSignatures mocks base method. +func (m *MockSignatureRepository) GetCompanyIDsWithSignedCorporateSignatures(ctx context.Context, claGroupID string) ([]signatures0.SignatureCompanyID, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanyIDsWithSignedCorporateSignatures", ctx, claGroupID) + ret0, _ := ret[0].([]signatures0.SignatureCompanyID) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanyIDsWithSignedCorporateSignatures indicates an expected call of GetCompanyIDsWithSignedCorporateSignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetCompanyIDsWithSignedCorporateSignatures(ctx, claGroupID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanyIDsWithSignedCorporateSignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetCompanyIDsWithSignedCorporateSignatures), ctx, claGroupID) +} + +// GetCompanySignatures mocks base method. +func (m *MockSignatureRepository) GetCompanySignatures(ctx context.Context, params signatures.GetCompanySignaturesParams, pageSize int64, loadACL bool) (*models.Signatures, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCompanySignatures", ctx, params, pageSize, loadACL) + ret0, _ := ret[0].(*models.Signatures) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCompanySignatures indicates an expected call of GetCompanySignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetCompanySignatures(ctx, params, pageSize, loadACL interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompanySignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetCompanySignatures), ctx, params, pageSize, loadACL) +} + +// GetCorporateSignature mocks base method. +func (m *MockSignatureRepository) GetCorporateSignature(ctx context.Context, claGroupID, companyID string, approved, signed *bool) (*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCorporateSignature", ctx, claGroupID, companyID, approved, signed) + ret0, _ := ret[0].(*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCorporateSignature indicates an expected call of GetCorporateSignature. +func (mr *MockSignatureRepositoryMockRecorder) GetCorporateSignature(ctx, claGroupID, companyID, approved, signed interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCorporateSignature", reflect.TypeOf((*MockSignatureRepository)(nil).GetCorporateSignature), ctx, claGroupID, companyID, approved, signed) +} + +// GetCorporateSignatures mocks base method. +func (m *MockSignatureRepository) GetCorporateSignatures(ctx context.Context, claGroupID, companyID string, approved, signed *bool) ([]*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCorporateSignatures", ctx, claGroupID, companyID, approved, signed) + ret0, _ := ret[0].([]*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCorporateSignatures indicates an expected call of GetCorporateSignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetCorporateSignatures(ctx, claGroupID, companyID, approved, signed interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCorporateSignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetCorporateSignatures), ctx, claGroupID, companyID, approved, signed) +} + +// GetGithubOrganizationsFromApprovalList mocks base method. +func (m *MockSignatureRepository) GetGithubOrganizationsFromApprovalList(ctx context.Context, signatureID string) ([]models.GithubOrg, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGithubOrganizationsFromApprovalList", ctx, signatureID) + ret0, _ := ret[0].([]models.GithubOrg) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGithubOrganizationsFromApprovalList indicates an expected call of GetGithubOrganizationsFromApprovalList. +func (mr *MockSignatureRepositoryMockRecorder) GetGithubOrganizationsFromApprovalList(ctx, signatureID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGithubOrganizationsFromApprovalList", reflect.TypeOf((*MockSignatureRepository)(nil).GetGithubOrganizationsFromApprovalList), ctx, signatureID) +} + +// GetICLAByDate mocks base method. +func (m *MockSignatureRepository) GetICLAByDate(ctx context.Context, startDate string) ([]signatures0.ItemSignature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetICLAByDate", ctx, startDate) + ret0, _ := ret[0].([]signatures0.ItemSignature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetICLAByDate indicates an expected call of GetICLAByDate. +func (mr *MockSignatureRepositoryMockRecorder) GetICLAByDate(ctx, startDate interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetICLAByDate", reflect.TypeOf((*MockSignatureRepository)(nil).GetICLAByDate), ctx, startDate) +} + +// GetIndividualSignature mocks base method. +func (m *MockSignatureRepository) GetIndividualSignature(ctx context.Context, claGroupID, userID string, approved, signed *bool) (*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIndividualSignature", ctx, claGroupID, userID, approved, signed) + ret0, _ := ret[0].(*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIndividualSignature indicates an expected call of GetIndividualSignature. +func (mr *MockSignatureRepositoryMockRecorder) GetIndividualSignature(ctx, claGroupID, userID, approved, signed interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndividualSignature", reflect.TypeOf((*MockSignatureRepository)(nil).GetIndividualSignature), ctx, claGroupID, userID, approved, signed) +} + +// GetIndividualSignatures mocks base method. +func (m *MockSignatureRepository) GetIndividualSignatures(ctx context.Context, claGroupID, userID string, approved, signed *bool) ([]*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIndividualSignatures", ctx, claGroupID, userID, approved, signed) + ret0, _ := ret[0].([]*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIndividualSignatures indicates an expected call of GetIndividualSignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetIndividualSignatures(ctx, claGroupID, userID, approved, signed interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndividualSignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetIndividualSignatures), ctx, claGroupID, userID, approved, signed) +} + +// GetItemSignature mocks base method. +func (m *MockSignatureRepository) GetItemSignature(ctx context.Context, signatureID string) (*signatures0.ItemSignature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetItemSignature", ctx, signatureID) + ret0, _ := ret[0].(*signatures0.ItemSignature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetItemSignature indicates an expected call of GetItemSignature. +func (mr *MockSignatureRepositoryMockRecorder) GetItemSignature(ctx, signatureID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemSignature", reflect.TypeOf((*MockSignatureRepository)(nil).GetItemSignature), ctx, signatureID) +} + +// GetProjectCompanyEmployeeSignature mocks base method. +func (m *MockSignatureRepository) GetProjectCompanyEmployeeSignature(ctx context.Context, companyModel *models.Company, claGroupModel *models.ClaGroup, employeeUserModel *models.User, wg *sync.WaitGroup, resultChannel chan<- *signatures0.EmployeeModel, errorChannel chan<- error) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "GetProjectCompanyEmployeeSignature", ctx, companyModel, claGroupModel, employeeUserModel, wg, resultChannel, errorChannel) +} + +// GetProjectCompanyEmployeeSignature indicates an expected call of GetProjectCompanyEmployeeSignature. +func (mr *MockSignatureRepositoryMockRecorder) GetProjectCompanyEmployeeSignature(ctx, companyModel, claGroupModel, employeeUserModel, wg, resultChannel, errorChannel interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectCompanyEmployeeSignature", reflect.TypeOf((*MockSignatureRepository)(nil).GetProjectCompanyEmployeeSignature), ctx, companyModel, claGroupModel, employeeUserModel, wg, resultChannel, errorChannel) +} + +// GetProjectCompanyEmployeeSignatures mocks base method. +func (m *MockSignatureRepository) GetProjectCompanyEmployeeSignatures(ctx context.Context, params signatures.GetProjectCompanyEmployeeSignaturesParams, criteria *signatures0.ApprovalCriteria) (*models.Signatures, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProjectCompanyEmployeeSignatures", ctx, params, criteria) + ret0, _ := ret[0].(*models.Signatures) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectCompanyEmployeeSignatures indicates an expected call of GetProjectCompanyEmployeeSignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetProjectCompanyEmployeeSignatures(ctx, params, criteria interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectCompanyEmployeeSignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetProjectCompanyEmployeeSignatures), ctx, params, criteria) +} + +// GetProjectCompanySignature mocks base method. +func (m *MockSignatureRepository) GetProjectCompanySignature(ctx context.Context, companyID, projectID string, approved, signed *bool, nextKey *string, pageSize *int64) (*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProjectCompanySignature", ctx, companyID, projectID, approved, signed, nextKey, pageSize) + ret0, _ := ret[0].(*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectCompanySignature indicates an expected call of GetProjectCompanySignature. +func (mr *MockSignatureRepositoryMockRecorder) GetProjectCompanySignature(ctx, companyID, projectID, approved, signed, nextKey, pageSize interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectCompanySignature", reflect.TypeOf((*MockSignatureRepository)(nil).GetProjectCompanySignature), ctx, companyID, projectID, approved, signed, nextKey, pageSize) +} + +// GetProjectCompanySignatures mocks base method. +func (m *MockSignatureRepository) GetProjectCompanySignatures(ctx context.Context, companyID, projectID string, approved, signed *bool, nextKey, sortOrder *string, pageSize *int64) (*models.Signatures, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProjectCompanySignatures", ctx, companyID, projectID, approved, signed, nextKey, sortOrder, pageSize) + ret0, _ := ret[0].(*models.Signatures) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectCompanySignatures indicates an expected call of GetProjectCompanySignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetProjectCompanySignatures(ctx, companyID, projectID, approved, signed, nextKey, sortOrder, pageSize interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectCompanySignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetProjectCompanySignatures), ctx, companyID, projectID, approved, signed, nextKey, sortOrder, pageSize) +} + +// GetProjectSignatures mocks base method. +func (m *MockSignatureRepository) GetProjectSignatures(ctx context.Context, params signatures.GetProjectSignaturesParams) (*models.Signatures, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProjectSignatures", ctx, params) + ret0, _ := ret[0].(*models.Signatures) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectSignatures indicates an expected call of GetProjectSignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetProjectSignatures(ctx, params interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectSignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetProjectSignatures), ctx, params) +} + +// GetSignature mocks base method. +func (m *MockSignatureRepository) GetSignature(ctx context.Context, signatureID string) (*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSignature", ctx, signatureID) + ret0, _ := ret[0].(*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSignature indicates an expected call of GetSignature. +func (mr *MockSignatureRepositoryMockRecorder) GetSignature(ctx, signatureID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignature", reflect.TypeOf((*MockSignatureRepository)(nil).GetSignature), ctx, signatureID) +} + +// GetSignatureACL mocks base method. +func (m *MockSignatureRepository) GetSignatureACL(ctx context.Context, signatureID string) ([]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSignatureACL", ctx, signatureID) + ret0, _ := ret[0].([]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSignatureACL indicates an expected call of GetSignatureACL. +func (mr *MockSignatureRepositoryMockRecorder) GetSignatureACL(ctx, signatureID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignatureACL", reflect.TypeOf((*MockSignatureRepository)(nil).GetSignatureACL), ctx, signatureID) +} + +// GetUserSignatures mocks base method. +func (m *MockSignatureRepository) GetUserSignatures(ctx context.Context, params signatures.GetUserSignaturesParams, pageSize int64, projectID *string) (*models.Signatures, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserSignatures", ctx, params, pageSize, projectID) + ret0, _ := ret[0].(*models.Signatures) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserSignatures indicates an expected call of GetUserSignatures. +func (mr *MockSignatureRepositoryMockRecorder) GetUserSignatures(ctx, params, pageSize, projectID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserSignatures", reflect.TypeOf((*MockSignatureRepository)(nil).GetUserSignatures), ctx, params, pageSize, projectID) +} + +// InvalidateProjectRecord mocks base method. +func (m *MockSignatureRepository) InvalidateProjectRecord(ctx context.Context, signatureID, note string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InvalidateProjectRecord", ctx, signatureID, note) + ret0, _ := ret[0].(error) + return ret0 +} + +// InvalidateProjectRecord indicates an expected call of InvalidateProjectRecord. +func (mr *MockSignatureRepositoryMockRecorder) InvalidateProjectRecord(ctx, signatureID, note interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateProjectRecord", reflect.TypeOf((*MockSignatureRepository)(nil).InvalidateProjectRecord), ctx, signatureID, note) +} + +// ProjectSignatures mocks base method. +func (m *MockSignatureRepository) ProjectSignatures(ctx context.Context, projectID string) (*models.Signatures, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProjectSignatures", ctx, projectID) + ret0, _ := ret[0].(*models.Signatures) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProjectSignatures indicates an expected call of ProjectSignatures. +func (mr *MockSignatureRepositoryMockRecorder) ProjectSignatures(ctx, projectID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectSignatures", reflect.TypeOf((*MockSignatureRepository)(nil).ProjectSignatures), ctx, projectID) +} + +// RemoveCLAManager mocks base method. +func (m *MockSignatureRepository) RemoveCLAManager(ctx context.Context, signatureID, claManagerID string) (*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveCLAManager", ctx, signatureID, claManagerID) + ret0, _ := ret[0].(*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveCLAManager indicates an expected call of RemoveCLAManager. +func (mr *MockSignatureRepositoryMockRecorder) RemoveCLAManager(ctx, signatureID, claManagerID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveCLAManager", reflect.TypeOf((*MockSignatureRepository)(nil).RemoveCLAManager), ctx, signatureID, claManagerID) +} + +// SaveOrUpdateSignature mocks base method. +func (m *MockSignatureRepository) SaveOrUpdateSignature(ctx context.Context, signature *signatures0.ItemSignature) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveOrUpdateSignature", ctx, signature) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveOrUpdateSignature indicates an expected call of SaveOrUpdateSignature. +func (mr *MockSignatureRepositoryMockRecorder) SaveOrUpdateSignature(ctx, signature interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveOrUpdateSignature", reflect.TypeOf((*MockSignatureRepository)(nil).SaveOrUpdateSignature), ctx, signature) +} + +// UpdateApprovalList mocks base method. +func (m *MockSignatureRepository) UpdateApprovalList(ctx context.Context, claManager *models.User, claGroupModel *models.ClaGroup, companyID string, params *models.ApprovalList, eventArgs *events.LogEventArgs) (*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateApprovalList", ctx, claManager, claGroupModel, companyID, params, eventArgs) + ret0, _ := ret[0].(*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateApprovalList indicates an expected call of UpdateApprovalList. +func (mr *MockSignatureRepositoryMockRecorder) UpdateApprovalList(ctx, claManager, claGroupModel, companyID, params, eventArgs interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApprovalList", reflect.TypeOf((*MockSignatureRepository)(nil).UpdateApprovalList), ctx, claManager, claGroupModel, companyID, params, eventArgs) +} + +// UpdateEnvelopeDetails mocks base method. +func (m *MockSignatureRepository) UpdateEnvelopeDetails(ctx context.Context, signatureID, envelopeID string, signURL *string) (*models.Signature, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateEnvelopeDetails", ctx, signatureID, envelopeID, signURL) + ret0, _ := ret[0].(*models.Signature) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateEnvelopeDetails indicates an expected call of UpdateEnvelopeDetails. +func (mr *MockSignatureRepositoryMockRecorder) UpdateEnvelopeDetails(ctx, signatureID, envelopeID, signURL interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEnvelopeDetails", reflect.TypeOf((*MockSignatureRepository)(nil).UpdateEnvelopeDetails), ctx, signatureID, envelopeID, signURL) +} + +// UpdateSignature mocks base method. +func (m *MockSignatureRepository) UpdateSignature(ctx context.Context, signatureID string, updates map[string]interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSignature", ctx, signatureID, updates) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateSignature indicates an expected call of UpdateSignature. +func (mr *MockSignatureRepositoryMockRecorder) UpdateSignature(ctx, signatureID, updates interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSignature", reflect.TypeOf((*MockSignatureRepository)(nil).UpdateSignature), ctx, signatureID, updates) +} + +// ValidateProjectRecord mocks base method. +func (m *MockSignatureRepository) ValidateProjectRecord(ctx context.Context, signatureID, note string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ValidateProjectRecord", ctx, signatureID, note) + ret0, _ := ret[0].(error) + return ret0 +} + +// ValidateProjectRecord indicates an expected call of ValidateProjectRecord. +func (mr *MockSignatureRepositoryMockRecorder) ValidateProjectRecord(ctx, signatureID, note interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateProjectRecord", reflect.TypeOf((*MockSignatureRepository)(nil).ValidateProjectRecord), ctx, signatureID, note) +} diff --git a/cla-backend-go/users/mocks/mock_repo.go b/cla-backend-go/users/mocks/mock_repo.go new file mode 100644 index 000000000..3a603a729 --- /dev/null +++ b/cla-backend-go/users/mocks/mock_repo.go @@ -0,0 +1,276 @@ +// Copyright The Linux Foundation and each contributor to CommunityBridge. +// SPDX-License-Identifier: MIT + +// Code generated by MockGen. DO NOT EDIT. +// Source: users/repository.go + +// Package mock_users is a generated GoMock package. +package mock_users + +import ( + reflect "reflect" + + models "github.com/communitybridge/easycla/cla-backend-go/gen/v1/models" + gomock "github.com/golang/mock/gomock" +) + +// MockUserRepository is a mock of UserRepository interface. +type MockUserRepository struct { + ctrl *gomock.Controller + recorder *MockUserRepositoryMockRecorder +} + +// MockUserRepositoryMockRecorder is the mock recorder for MockUserRepository. +type MockUserRepositoryMockRecorder struct { + mock *MockUserRepository +} + +// NewMockUserRepository creates a new mock instance. +func NewMockUserRepository(ctrl *gomock.Controller) *MockUserRepository { + mock := &MockUserRepository{ctrl: ctrl} + mock.recorder = &MockUserRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockUserRepository) EXPECT() *MockUserRepositoryMockRecorder { + return m.recorder +} + +// CreateUser mocks base method. +func (m *MockUserRepository) CreateUser(user *models.User) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateUser", user) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateUser indicates an expected call of CreateUser. +func (mr *MockUserRepositoryMockRecorder) CreateUser(user interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUser", reflect.TypeOf((*MockUserRepository)(nil).CreateUser), user) +} + +// Delete mocks base method. +func (m *MockUserRepository) Delete(userID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", userID) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockUserRepositoryMockRecorder) Delete(userID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockUserRepository)(nil).Delete), userID) +} + +// GetUser mocks base method. +func (m *MockUserRepository) GetUser(userID string) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUser", userID) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUser indicates an expected call of GetUser. +func (mr *MockUserRepositoryMockRecorder) GetUser(userID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockUserRepository)(nil).GetUser), userID) +} + +// GetUserByEmail mocks base method. +func (m *MockUserRepository) GetUserByEmail(userEmail string) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserByEmail", userEmail) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByEmail indicates an expected call of GetUserByEmail. +func (mr *MockUserRepositoryMockRecorder) GetUserByEmail(userEmail interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByEmail", reflect.TypeOf((*MockUserRepository)(nil).GetUserByEmail), userEmail) +} + +// GetUserByExternalID mocks base method. +func (m *MockUserRepository) GetUserByExternalID(userExternalID string) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserByExternalID", userExternalID) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByExternalID indicates an expected call of GetUserByExternalID. +func (mr *MockUserRepositoryMockRecorder) GetUserByExternalID(userExternalID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByExternalID", reflect.TypeOf((*MockUserRepository)(nil).GetUserByExternalID), userExternalID) +} + +// GetUserByGitHubID mocks base method. +func (m *MockUserRepository) GetUserByGitHubID(gitHubID string) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserByGitHubID", gitHubID) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByGitHubID indicates an expected call of GetUserByGitHubID. +func (mr *MockUserRepositoryMockRecorder) GetUserByGitHubID(gitHubID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByGitHubID", reflect.TypeOf((*MockUserRepository)(nil).GetUserByGitHubID), gitHubID) +} + +// GetUserByGitHubUsername mocks base method. +func (m *MockUserRepository) GetUserByGitHubUsername(gitHubUsername string) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserByGitHubUsername", gitHubUsername) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByGitHubUsername indicates an expected call of GetUserByGitHubUsername. +func (mr *MockUserRepositoryMockRecorder) GetUserByGitHubUsername(gitHubUsername interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByGitHubUsername", reflect.TypeOf((*MockUserRepository)(nil).GetUserByGitHubUsername), gitHubUsername) +} + +// GetUserByGitLabUsername mocks base method. +func (m *MockUserRepository) GetUserByGitLabUsername(gitlabUsername string) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserByGitLabUsername", gitlabUsername) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByGitLabUsername indicates an expected call of GetUserByGitLabUsername. +func (mr *MockUserRepositoryMockRecorder) GetUserByGitLabUsername(gitlabUsername interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByGitLabUsername", reflect.TypeOf((*MockUserRepository)(nil).GetUserByGitLabUsername), gitlabUsername) +} + +// GetUserByGitlabID mocks base method. +func (m *MockUserRepository) GetUserByGitlabID(gitlabID int) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserByGitlabID", gitlabID) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByGitlabID indicates an expected call of GetUserByGitlabID. +func (mr *MockUserRepositoryMockRecorder) GetUserByGitlabID(gitlabID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByGitlabID", reflect.TypeOf((*MockUserRepository)(nil).GetUserByGitlabID), gitlabID) +} + +// GetUserByLFUserName mocks base method. +func (m *MockUserRepository) GetUserByLFUserName(lfUserName string) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserByLFUserName", lfUserName) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByLFUserName indicates an expected call of GetUserByLFUserName. +func (mr *MockUserRepositoryMockRecorder) GetUserByLFUserName(lfUserName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByLFUserName", reflect.TypeOf((*MockUserRepository)(nil).GetUserByLFUserName), lfUserName) +} + +// GetUserByUserName mocks base method. +func (m *MockUserRepository) GetUserByUserName(userName string, fullMatch bool) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserByUserName", userName, fullMatch) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByUserName indicates an expected call of GetUserByUserName. +func (mr *MockUserRepositoryMockRecorder) GetUserByUserName(userName, fullMatch interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByUserName", reflect.TypeOf((*MockUserRepository)(nil).GetUserByUserName), userName, fullMatch) +} + +// GetUsersByEmail mocks base method. +func (m *MockUserRepository) GetUsersByEmail(userEmail string) ([]*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUsersByEmail", userEmail) + ret0, _ := ret[0].([]*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUsersByEmail indicates an expected call of GetUsersByEmail. +func (mr *MockUserRepositoryMockRecorder) GetUsersByEmail(userEmail interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsersByEmail", reflect.TypeOf((*MockUserRepository)(nil).GetUsersByEmail), userEmail) +} + +// Save mocks base method. +func (m *MockUserRepository) Save(user *models.UserUpdate) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", user) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Save indicates an expected call of Save. +func (mr *MockUserRepositoryMockRecorder) Save(user interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockUserRepository)(nil).Save), user) +} + +// SearchUsers mocks base method. +func (m *MockUserRepository) SearchUsers(searchField, searchTerm string, fullMatch bool) (*models.Users, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchUsers", searchField, searchTerm, fullMatch) + ret0, _ := ret[0].(*models.Users) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchUsers indicates an expected call of SearchUsers. +func (mr *MockUserRepositoryMockRecorder) SearchUsers(searchField, searchTerm, fullMatch interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchUsers", reflect.TypeOf((*MockUserRepository)(nil).SearchUsers), searchField, searchTerm, fullMatch) +} + +// UpdateUser mocks base method. +func (m *MockUserRepository) UpdateUser(userID string, updates map[string]interface{}) (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateUser", userID, updates) + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateUser indicates an expected call of UpdateUser. +func (mr *MockUserRepositoryMockRecorder) UpdateUser(userID, updates interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockUserRepository)(nil).UpdateUser), userID, updates) +} + +// UpdateUserCompanyID mocks base method. +func (m *MockUserRepository) UpdateUserCompanyID(userID, companyID, note string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateUserCompanyID", userID, companyID, note) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateUserCompanyID indicates an expected call of UpdateUserCompanyID. +func (mr *MockUserRepositoryMockRecorder) UpdateUserCompanyID(userID, companyID, note interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserCompanyID", reflect.TypeOf((*MockUserRepository)(nil).UpdateUserCompanyID), userID, companyID, note) +} diff --git a/cla-backend-go/v2/company/service.go b/cla-backend-go/v2/company/service.go index d06269792..2f292bd92 100644 --- a/cla-backend-go/v2/company/service.go +++ b/cla-backend-go/v2/company/service.go @@ -384,6 +384,11 @@ func (s *service) GetCompanyProjectContributors(ctx context.Context, params *v2O list = append(list, corpContributor) } + // sort the list based on timestamp in descending order + sort.Slice(list, func(i, j int) bool { + return list[i].Timestamp > list[j].Timestamp + }) + return &models.CorporateContributorList{ List: list, NextKey: sigResponse.LastKeyScanned, diff --git a/cla-backend-go/v2/company/service_test.go b/cla-backend-go/v2/company/service_test.go new file mode 100644 index 000000000..de5cea1d4 --- /dev/null +++ b/cla-backend-go/v2/company/service_test.go @@ -0,0 +1,182 @@ +// Copyright The Linux Foundation and each contributor to CommunityBridge. +// SPDX-License-Identifier: MIT +package company + +import ( + "context" + "fmt" + "testing" + + v1Models "github.com/communitybridge/easycla/cla-backend-go/gen/v1/models" + v1SignatureParams "github.com/communitybridge/easycla/cla-backend-go/gen/v1/restapi/operations/signatures" + v2Ops "github.com/communitybridge/easycla/cla-backend-go/gen/v2/restapi/operations/company" + + mock_company_repo "github.com/communitybridge/easycla/cla-backend-go/company/mocks" + mock_project_repo "github.com/communitybridge/easycla/cla-backend-go/project/mocks" + "github.com/communitybridge/easycla/cla-backend-go/projects_cla_groups" + mock_pcg_repo "github.com/communitybridge/easycla/cla-backend-go/projects_cla_groups/mocks" + mock_signature_repo "github.com/communitybridge/easycla/cla-backend-go/signatures/mocks" + mock_user_repo "github.com/communitybridge/easycla/cla-backend-go/users/mocks" + + "github.com/golang/mock/gomock" + + "github.com/stretchr/testify/assert" +) + +func TestGetCompanyProjectContributors(t *testing.T) { + ctx := context.Background() + + testCases := []struct { + name string + signatures []*v1Models.Signature + expectedOrder []string + }{ + { + name: "With all timestamps", + signatures: []*v1Models.Signature{ + { + SignatureID: "signature-id-2", + SignatureCreated: "2021-09-13T11:59:00.981612+0000", + SignatureApproved: true, + SignatureSigned: true, + SignatureMajorVersion: "1", + SignatureMinorVersion: "0", + SignatureReferenceID: "signature_reference_id", + }, + { + SignatureID: "signature-id", + SignatureCreated: "2021-09-15T11:59:00.981612+0000", + SignatureApproved: true, + SignatureSigned: true, + SignatureMajorVersion: "1", + SignatureMinorVersion: "0", + SignatureReferenceID: "signature_reference_id", + }, + { + SignatureID: "signature-id-3", + SignatureCreated: "2021-09-14T11:59:00.981612+0000", + SignatureApproved: true, + SignatureSigned: true, + SignatureMajorVersion: "1", + SignatureMinorVersion: "0", + SignatureReferenceID: "signature_reference_id", + }, + }, + expectedOrder: []string{ + "2021-09-15T11:59:00Z", + "2021-09-14T11:59:00Z", + "2021-09-13T11:59:00Z", + }, + }, + { + name: "With empty timestamp", + signatures: []*v1Models.Signature{ + { + SignatureID: "signature-id-2", + SignatureCreated: "2021-09-13T11:59:00.981612+0000", + SignatureApproved: true, + SignatureSigned: true, + SignatureMajorVersion: "1", + SignatureMinorVersion: "0", + SignatureReferenceID: "signature_reference_id", + }, + { + SignatureID: "signature-id", + SignatureCreated: "2021-09-15T11:59:00.981612+0000", + SignatureApproved: true, + SignatureSigned: true, + SignatureMajorVersion: "1", + SignatureMinorVersion: "0", + SignatureReferenceID: "signature_reference_id", + }, + { + SignatureID: "signature-id-3", + SignatureCreated: "2021-09-14T11:59:00.981612+0000", + SignatureApproved: true, + SignatureSigned: true, + SignatureMajorVersion: "1", + SignatureMinorVersion: "0", + SignatureReferenceID: "signature_reference_id", + }, + { + SignatureID: "signature-id-4", + SignatureCreated: "", + SignatureApproved: true, + SignatureSigned: true, + SignatureMajorVersion: "1", + SignatureMinorVersion: "0", + SignatureReferenceID: "signature_reference_id_empty", + }, + }, + expectedOrder: []string{ + "2021-09-15T11:59:00Z", + "2021-09-14T11:59:00Z", + "2021-09-13T11:59:00Z", + "", + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + params := v2Ops.GetCompanyProjectContributorsParams{ + CompanyID: "company-id", + ProjectSFID: "project-sfid", + } + empParams := v1SignatureParams.GetProjectCompanyEmployeeSignaturesParams{ + CompanyID: "company-id", + ProjectID: "project-id", + HTTPRequest: nil, + } + + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockProjectClaGroupRepo := mock_pcg_repo.NewMockRepository(ctrl) + mockProjectClaGroupRepo.EXPECT().GetClaGroupIDForProject(ctx, params.ProjectSFID).Return(&projects_cla_groups.ProjectClaGroup{ + ProjectSFID: "project-sfid", + ClaGroupID: "cla-group-id", + }, nil) + + mockCompanyRepo := mock_company_repo.NewMockIRepository(ctrl) + mockCompanyRepo.EXPECT().GetCompany(ctx, params.CompanyID).Return(&v1Models.Company{ + CompanyID: "company-id", + }, nil) + + mock_signature_repo := mock_signature_repo.NewMockSignatureRepository(ctrl) + mock_signature_repo.EXPECT().GetProjectCompanyEmployeeSignatures(ctx, empParams, nil).Return(&v1Models.Signatures{ + Signatures: tc.signatures, + }, nil) + + mockUserRepo := mock_user_repo.NewMockUserRepository(ctrl) + for _, sig := range tc.signatures { + mockUserRepo.EXPECT().GetUser(sig.SignatureReferenceID).Return(&v1Models.User{ + Username: "username", + GithubUsername: "github-username", + LfUsername: "lf-username", + UserID: sig.SignatureReferenceID, + }, nil) + } + + mockProjectRepo := mock_project_repo.NewMockProjectRepository(ctrl) + mockProjectRepo.EXPECT().GetCLAGroupByID(ctx, "cla-group-id", false).Return(&v1Models.ClaGroup{ + ProjectID: "project-id", + }, nil) + + service := NewService(nil, mock_signature_repo, mockProjectRepo, mockUserRepo, mockCompanyRepo, mockProjectClaGroupRepo, nil) + + response, err := service.GetCompanyProjectContributors(ctx, ¶ms) + + assert.Nil(t, err) + + fmt.Printf("response: %+v\n", response) + + assert.Equal(t, len(tc.expectedOrder), len(response.List)) + + // check the timestamp order + for i, expected := range tc.expectedOrder { + assert.Equal(t, expected, response.List[i].Timestamp) + } + }) + } +}