source.dussan.org Git - sonarqube.git/blob

   1 /*
   2  * SonarQube
   3  * Copyright (C) 2009-2023 SonarSource SA
   4  * mailto:info AT sonarsource DOT com
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 package org.sonar.server.almintegration.ws.gitlab;
  21
  22 import java.util.List;
  23 import java.util.Optional;
  24 import org.assertj.core.api.Assertions;
  25 import org.junit.Before;
  26 import org.junit.Rule;
  27 import org.junit.Test;
  28 import org.sonar.alm.client.gitlab.GitLabBranch;
  29 import org.sonar.alm.client.gitlab.GitlabHttpClient;
  30 import org.sonar.alm.client.gitlab.Project;
  31 import org.sonar.api.utils.System2;
  32 import org.sonar.core.i18n.I18n;
  33 import org.sonar.core.platform.EditionProvider;
  34 import org.sonar.core.platform.PlatformEditionProvider;
  35 import org.sonar.core.util.SequenceUuidFactory;
  36 import org.sonar.db.DbTester;
  37 import org.sonar.db.alm.setting.AlmSettingDto;
  38 import org.sonar.db.component.BranchDto;
  39 import org.sonar.db.newcodeperiod.NewCodePeriodDto;
  40 import org.sonar.db.project.CreationMethod;
  41 import org.sonar.db.project.ProjectDto;
  42 import org.sonar.db.user.UserDto;
  43 import org.sonar.server.almintegration.ws.ImportHelper;
  44 import org.sonar.server.almintegration.ws.ProjectKeyGenerator;
  45 import org.sonar.server.component.ComponentUpdater;
  46 import org.sonar.server.es.TestIndexers;
  47 import org.sonar.server.favorite.FavoriteUpdater;
  48 import org.sonar.server.newcodeperiod.NewCodeDefinitionResolver;
  49 import org.sonar.server.permission.PermissionService;
  50 import org.sonar.server.permission.PermissionTemplateService;
  51 import org.sonar.server.permission.PermissionUpdater;
  52 import org.sonar.server.project.DefaultBranchNameResolver;
  53 import org.sonar.server.project.ProjectDefaultVisibility;
  54 import org.sonar.server.project.Visibility;
  55 import org.sonar.server.tester.UserSessionRule;
  56 import org.sonar.server.ws.WsActionTester;
  57 import org.sonarqube.ws.Projects;
  58
  59 import static java.util.Collections.emptyList;
  60 import static java.util.Collections.singletonList;
  61 import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
  62 import static org.assertj.core.api.Assertions.assertThat;
  63 import static org.assertj.core.api.Assertions.tuple;
  64 import static org.mockito.ArgumentMatchers.any;
  65 import static org.mockito.Mockito.mock;
  66 import static org.mockito.Mockito.verify;
  67 import static org.mockito.Mockito.when;
  68 import static org.sonar.db.component.BranchDto.DEFAULT_MAIN_BRANCH_NAME;
  69 import static org.sonar.db.newcodeperiod.NewCodePeriodType.NUMBER_OF_DAYS;
  70 import static org.sonar.db.permission.GlobalPermission.PROVISION_PROJECTS;
  71 import static org.sonar.server.tester.UserSessionRule.standalone;
  72 import static org.sonarqube.ws.client.project.ProjectsWsParameters.PARAM_NEW_CODE_DEFINITION_TYPE;
  73 import static org.sonarqube.ws.client.project.ProjectsWsParameters.PARAM_NEW_CODE_DEFINITION_VALUE;
  74
  75 public class ImportGitLabProjectActionIT {
  76
  77   private static final String PROJECT_KEY_NAME = "PROJECT_NAME";
  78
  79   private final System2 system2 = mock(System2.class);
  80
  81   @Rule
  82   public UserSessionRule userSession = standalone();
  83
  84   @Rule
  85   public DbTester db = DbTester.create(system2);
  86
  87   DefaultBranchNameResolver defaultBranchNameResolver = mock(DefaultBranchNameResolver.class);
  88
  89   private final ComponentUpdater componentUpdater = new ComponentUpdater(db.getDbClient(), mock(I18n.class), System2.INSTANCE,
  90     mock(PermissionTemplateService.class), new FavoriteUpdater(db.getDbClient()), new TestIndexers(), new SequenceUuidFactory(),
  91     defaultBranchNameResolver, mock(PermissionUpdater.class), mock(PermissionService.class));
  92
  93   private final GitlabHttpClient gitlabHttpClient = mock(GitlabHttpClient.class);
  94   private final ImportHelper importHelper = new ImportHelper(db.getDbClient(), userSession);
  95   private final ProjectDefaultVisibility projectDefaultVisibility = mock(ProjectDefaultVisibility.class);
  96   private final ProjectKeyGenerator projectKeyGenerator = mock(ProjectKeyGenerator.class);
  97   private PlatformEditionProvider editionProvider = mock(PlatformEditionProvider.class);
  98   private NewCodeDefinitionResolver newCodeDefinitionResolver = new NewCodeDefinitionResolver(db.getDbClient(), editionProvider);
  99   private final ImportGitLabProjectAction importGitLabProjectAction = new ImportGitLabProjectAction(
 100     db.getDbClient(), userSession, projectDefaultVisibility, gitlabHttpClient, componentUpdater, importHelper, projectKeyGenerator, newCodeDefinitionResolver,
 101     defaultBranchNameResolver);
 102   private final WsActionTester ws = new WsActionTester(importGitLabProjectAction);
 103
 104   @Before
 105   public void before() {
 106     when(projectDefaultVisibility.get(any())).thenReturn(Visibility.PRIVATE);
 107     when(defaultBranchNameResolver.getEffectiveMainBranchName()).thenReturn(DEFAULT_MAIN_BRANCH_NAME);
 108   }
 109
 110   @Test
 111   public void import_project_developer_edition() {
 112     when(editionProvider.get()).thenReturn(Optional.of(EditionProvider.Edition.DEVELOPER));
 113
 114     AlmSettingDto almSetting = configureUserAndPatAndAlmSettings();
 115     Project project = mockGitlabProject(singletonList(new GitLabBranch("master", true)));
 116
 117     Projects.CreateWsResponse response = ws.newRequest()
 118       .setParam("almSetting", almSetting.getKey())
 119       .setParam("gitlabProjectId", "12345")
 120       .setParam(PARAM_NEW_CODE_DEFINITION_TYPE, "NUMBER_OF_DAYS")
 121       .setParam(PARAM_NEW_CODE_DEFINITION_VALUE, "30")
 122       .executeProtobuf(Projects.CreateWsResponse.class);
 123
 124     verify(gitlabHttpClient).getProject(almSetting.getUrl(), "PAT", 12345L);
 125
 126     Projects.CreateWsResponse.Project result = response.getProject();
 127     assertThat(result.getKey()).isEqualTo(PROJECT_KEY_NAME);
 128     assertThat(result.getName()).isEqualTo(project.getName());
 129
 130     Optional<ProjectDto> projectDto = db.getDbClient().projectDao().selectProjectByKey(db.getSession(), result.getKey());
 131     assertThat(projectDto).isPresent();
 132     assertThat(db.getDbClient().projectAlmSettingDao().selectByProject(db.getSession(), projectDto.get())).isPresent();
 133
 134     assertThat(db.getDbClient().newCodePeriodDao().selectByProject(db.getSession(), projectDto.get().getUuid()))
 135       .isPresent()
 136       .get()
 137       .extracting(NewCodePeriodDto::getType, NewCodePeriodDto::getValue, NewCodePeriodDto::getBranchUuid)
 138       .containsExactly(NUMBER_OF_DAYS, "30", null);
 139   }
 140
 141   @Test
 142   public void import_project_community_edition() {
 143     when(editionProvider.get()).thenReturn(Optional.of(EditionProvider.Edition.COMMUNITY));
 144
 145     AlmSettingDto almSetting = configureUserAndPatAndAlmSettings();
 146     mockGitlabProject(singletonList(new GitLabBranch("master", true)));
 147
 148     Projects.CreateWsResponse response = ws.newRequest()
 149       .setParam("almSetting", almSetting.getKey())
 150       .setParam("gitlabProjectId", "12345")
 151       .setParam(PARAM_NEW_CODE_DEFINITION_TYPE, "NUMBER_OF_DAYS")
 152       .setParam(PARAM_NEW_CODE_DEFINITION_VALUE, "30")
 153       .executeProtobuf(Projects.CreateWsResponse.class);
 154
 155     Projects.CreateWsResponse.Project result = response.getProject();
 156
 157     Optional<ProjectDto> projectDto = db.getDbClient().projectDao().selectProjectByKey(db.getSession(), result.getKey());
 158     BranchDto branchDto = db.getDbClient().branchDao().selectMainBranchByProjectUuid(db.getSession(), projectDto.get().getUuid()).orElseThrow();
 159
 160     String projectUuid = projectDto.get().getUuid();
 161     assertThat(db.getDbClient().newCodePeriodDao().selectByBranch(db.getSession(), projectUuid, branchDto.getUuid()))
 162       .isPresent()
 163       .get()
 164       .extracting(NewCodePeriodDto::getType, NewCodePeriodDto::getValue, NewCodePeriodDto::getBranchUuid)
 165       .containsExactly(NUMBER_OF_DAYS, "30", branchDto.getUuid());
 166   }
 167
 168   @Test
 169   public void import_project_with_specific_different_default_branch() {
 170     AlmSettingDto almSetting = configureUserAndPatAndAlmSettings();
 171     Project project = mockGitlabProject(singletonList(new GitLabBranch("main", true)));
 172
 173     Projects.CreateWsResponse response = ws.newRequest()
 174       .setParam("almSetting", almSetting.getKey())
 175       .setParam("gitlabProjectId", "12345")
 176       .executeProtobuf(Projects.CreateWsResponse.class);
 177
 178     verify(gitlabHttpClient).getProject(almSetting.getUrl(), "PAT", 12345L);
 179     verify(gitlabHttpClient).getBranches(almSetting.getUrl(), "PAT", 12345L);
 180
 181     Projects.CreateWsResponse.Project result = response.getProject();
 182     assertThat(result.getKey()).isEqualTo(PROJECT_KEY_NAME);
 183     assertThat(result.getName()).isEqualTo(project.getName());
 184
 185     Optional<ProjectDto> projectDto = db.getDbClient().projectDao().selectProjectByKey(db.getSession(), result.getKey());
 186     assertThat(projectDto).isPresent();
 187     assertThat(db.getDbClient().projectAlmSettingDao().selectByProject(db.getSession(), projectDto.get())).isPresent();
 188
 189     Assertions.assertThat(db.getDbClient().branchDao().selectByProject(db.getSession(), projectDto.get()))
 190       .extracting(BranchDto::getKey, BranchDto::isMain)
 191       .containsExactlyInAnyOrder(tuple("main", true));
 192   }
 193
 194   @Test
 195   public void import_project_no_gitlab_default_branch() {
 196     AlmSettingDto almSetting = configureUserAndPatAndAlmSettings();
 197     Project project = mockGitlabProject(emptyList());
 198
 199     Projects.CreateWsResponse response = ws.newRequest()
 200       .setParam("almSetting", almSetting.getKey())
 201       .setParam("gitlabProjectId", "12345")
 202       .executeProtobuf(Projects.CreateWsResponse.class);
 203
 204     verify(gitlabHttpClient).getProject(almSetting.getUrl(), "PAT", 12345L);
 205     verify(gitlabHttpClient).getBranches(almSetting.getUrl(), "PAT", 12345L);
 206
 207     Projects.CreateWsResponse.Project result = response.getProject();
 208     assertThat(result.getKey()).isEqualTo(PROJECT_KEY_NAME);
 209     assertThat(result.getName()).isEqualTo(project.getName());
 210
 211     Optional<ProjectDto> projectDto = db.getDbClient().projectDao().selectProjectByKey(db.getSession(), result.getKey());
 212     assertThat(projectDto).isPresent();
 213     assertThat(db.getDbClient().projectAlmSettingDao().selectByProject(db.getSession(), projectDto.get())).isPresent();
 214
 215     Assertions.assertThat(db.getDbClient().branchDao().selectByProject(db.getSession(), projectDto.get()))
 216       .extracting(BranchDto::getKey, BranchDto::isMain)
 217       .containsExactlyInAnyOrder(tuple(DEFAULT_MAIN_BRANCH_NAME, true));
 218   }
 219
 220   @Test
 221   public void import_project_without_NCD() {
 222     AlmSettingDto almSetting = configureUserAndPatAndAlmSettings();
 223     Project project = mockGitlabProject(singletonList(new GitLabBranch("master", true)));
 224
 225     Projects.CreateWsResponse response = ws.newRequest()
 226       .setParam("almSetting", almSetting.getKey())
 227       .setParam("gitlabProjectId", "12345")
 228       .executeProtobuf(Projects.CreateWsResponse.class);
 229
 230     verify(gitlabHttpClient).getProject(almSetting.getUrl(), "PAT", 12345L);
 231
 232     Projects.CreateWsResponse.Project result = response.getProject();
 233     assertThat(result.getKey()).isEqualTo(PROJECT_KEY_NAME);
 234     assertThat(result.getName()).isEqualTo(project.getName());
 235
 236     Optional<ProjectDto> projectDto = db.getDbClient().projectDao().selectProjectByKey(db.getSession(), result.getKey());
 237     assertThat(projectDto).isPresent();
 238     assertThat(db.getDbClient().projectAlmSettingDao().selectByProject(db.getSession(), projectDto.get())).isPresent();
 239   }
 240
 241   @Test
 242   public void importProject_whenNonBrowserCall_setsCreationMethodToApi() {
 243     AlmSettingDto almSetting = configureUserAndPatAndAlmSettings();
 244     mockGitlabProject(singletonList(new GitLabBranch("master", true)));
 245
 246     Projects.CreateWsResponse response = ws.newRequest()
 247       .setParam("almSetting", almSetting.getKey())
 248       .setParam("gitlabProjectId", "12345")
 249       .executeProtobuf(Projects.CreateWsResponse.class);
 250
 251     Optional<ProjectDto> projectDto = db.getDbClient().projectDao().selectProjectByKey(db.getSession(), response.getProject().getKey());
 252     assertThat(projectDto.orElseThrow().getCreationMethod()).isEqualTo(CreationMethod.ALM_IMPORT_API);
 253   }
 254
 255   @Test
 256   public void importProject_whenBrowserCall_setsCreationMethodToBrowser() {
 257     AlmSettingDto almSetting = configureUserAndPatAndAlmSettings();
 258     userSession.flagSessionAsGui();
 259     mockGitlabProject(singletonList(new GitLabBranch("master", true)));
 260
 261     Projects.CreateWsResponse response = ws.newRequest()
 262       .setParam("almSetting", almSetting.getKey())
 263       .setParam("gitlabProjectId", "12345")
 264       .executeProtobuf(Projects.CreateWsResponse.class);
 265
 266     Optional<ProjectDto> projectDto = db.getDbClient().projectDao().selectProjectByKey(db.getSession(), response.getProject().getKey());
 267     assertThat(projectDto.orElseThrow().getCreationMethod()).isEqualTo(CreationMethod.ALM_IMPORT_BROWSER);
 268   }
 269
 270   private AlmSettingDto configureUserAndPatAndAlmSettings() {
 271     UserDto user = db.users().insertUser();
 272     userSession.logIn(user).addPermission(PROVISION_PROJECTS);
 273     return insertGitLabConfigurationAndPat(user);
 274   }
 275
 276   private AlmSettingDto insertGitLabConfigurationAndPat(UserDto user) {
 277     AlmSettingDto almSetting = db.almSettings().insertGitlabAlmSetting();
 278     db.almPats().insert(dto -> {
 279       dto.setAlmSettingUuid(almSetting.getUuid());
 280       dto.setUserUuid(user.getUuid());
 281       dto.setPersonalAccessToken("PAT");
 282     });
 283     return almSetting;
 284   }
 285
 286   private Project mockGitlabProject(List<GitLabBranch> master) {
 287     Project project = new Project(randomAlphanumeric(5), randomAlphanumeric(5));
 288     when(gitlabHttpClient.getProject(any(), any(), any())).thenReturn(project);
 289     when(gitlabHttpClient.getBranches(any(), any(), any())).thenReturn(master);
 290     when(projectKeyGenerator.generateUniqueProjectKey(project.getPathWithNamespace())).thenReturn(PROJECT_KEY_NAME);
 291     return project;
 292   }
 293
 294 }